ztfy/ztfy.myams: comparison src/ztfy/myams/resources/js/myams.js

Mercurial Mercurial > ztfy > ztfy.myams / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/ztfy/myams/resources/js/myams.js

changeset 180	172ddcb92995
parent 178	2c3ba8d90123
child 182	681edeb5c6ef

equal deleted inserted replaced

-:a36bac847ea7
+:172ddcb92995
 				}
 			}
 			return -1;
 		};
 	}
+	/**
+	 * JQuery 'hasvalue' expression
+	 * Filter inputs containing value
+	 */
+	$.expr[":"].hasvalue =  function(obj, index, meta /*, stack*/) {
+		return $(obj).val() !== "";
+	};
 	/**
 	 * JQuery 'econtains' expression
 	 * Case insensitive contains expression
 												top: getMenuPosition(e.clientY, 'height', 'scrollTop') - 10
 											})
 											.off('click')
 											.on('click', function (e) {
 												$(this).hide();
-												var $invokedOn = $(this).data("invokedOn");
+												var invokedOn = $(this).data("invokedOn");
-												var $selectedMenu = $(e.target);
+												var selectedMenu = $(e.target);
-												settings.menuSelected.call(this, $invokedOn, $selectedMenu);
+												settings.menuSelected.call(this, invokedOn, selectedMenu);
 												ams.event.stop(e);
 											});
 					return false;
 				});
 			// Assign current element to variable, in this case is UL element
 			var menu = $(this);
 			// Add a mark [+] to a multilevel menu
 			menu.find("LI").each(function() {
-				var menu_item = $(this);
+				var menuItem = $(this);
-				if (menu_item.find("UL").size() > 0) {
+				if (menuItem.find("UL").size() > 0) {
 					// add the multilevel sign next to the link
-					menu_item.find("A:first")
+					menuItem.find("A:first")
 							 .append("<b class='collapse-sign'>" + settings.closedSign + "</b>");
 					// avoid jumping to the top of the page when the href is an #
-					var first_link = menu_item.find("A:first");
+					var firstLink = menuItem.find("A:first");
-					if (first_link.attr('href') === "#") {
+					if (firstLink.attr('href') === "#") {
-						first_link.click(function() {
+						firstLink.click(function() {
 							return false;
 						});
 					}
 				}
 			});
 			// Open active level
 			menu.find("LI.active").each(function() {
-				var active_parent = $(this).parents('UL');
+				var activeParent = $(this).parents('UL');
-				var active_item = active_parent.parent('LI');
+				var activeItem = activeParent.parent('LI');
-				active_parent.slideDown(settings.speed);
+				activeParent.slideDown(settings.speed);
-				active_item.find("b:first").html(settings.openedSign);
+				activeItem.find("b:first").html(settings.openedSign);
-				active_item.addClass("open");
+				activeItem.addClass("open");
 			});
 			menu.find("LI A").on('click', function() {
 				var link = $(this);
 				if (link.hasClass('active')) {
 					return;
 				}
 				var href = link.attr('href').replace(/^#/,'');
-				var parent_ul = link.parent().find("UL");
+				var parentUL = link.parent().find("UL");
 				if (settings.accordion) {
 					var parents = link.parent().parents("UL");
 					var visible = menu.find("UL:visible");
 					visible.each(function(visibleIndex) {
 						var close = true;
 								close = false;
 								return false;
 							}
 						});
 						if (close) {
-							if (parent_ul !== visible[visibleIndex]) {
+							if (parentUL !== visible[visibleIndex]) {
 								var visibleItem = $(visible[visibleIndex]);
 								if (href || !visibleItem.hasClass('active')) {
 									visibleItem.slideUp(settings.speed, function () {
 										$(this).parent("LI")
-											.removeClass('open')
+											   .removeClass('open')
-											.find("B:first")
+											   .find("B:first")
-											.delay(settings.speed)
+											   .delay(settings.speed)
-											.html(settings.closedSign);
+											   .html(settings.closedSign);
 									});
 								}
 							}
 						}
 					});
 				}
-				var first_ul = link.parent().find("UL:first");
+				var firstUL = link.parent().find("UL:first");
-				if (!href && first_ul.is(":visible") && !first_ul.hasClass("active")) {
+				if (!href && firstUL.is(":visible") && !firstUL.hasClass("active")) {
-					first_ul.slideUp(settings.speed, function() {
+					firstUL.slideUp(settings.speed, function() {
 						link.parent("LI")
 							.removeClass("open")
 							.find("B:first")
 							.delay(settings.speed)
 							.html(settings.closedSign);
 					});
 				} else /*if (link.attr('href') !== location.hash)*/ {
-					first_ul.slideDown(settings.speed, function() {
+					firstUL.slideDown(settings.speed, function() {
 						link.parent("LI")
 							.addClass("open")
 							.find("B:first")
 							.delay(settings.speed)
 							.html(settings.openedSign);
 	if (globals.MyAMS === undefined) {
 		globals.MyAMS = {
 			devmode: true,
 			devext: '',
 			lang: 'en',
-			throttle_delay: 350,
+			throttleDelay: 350,
-			menu_speed: 235,
+			menuSpeed: 235,
-			navbar_height: 49,
+			navbarHeight: 49,
-			ajax_nav: true,
+			ajaxNav: true,
-			enable_widgets: true,
+			enableWidgets: true,
-			enable_mobile: false,
+			enableMobile: false,
-			enable_fastclick: false,
+			enableFastclick: false,
-			warn_on_form_change: false,
+			warnOnFormChange: false,
 			ismobile: (/iphone|ipad|ipod|android|blackberry|mini|windows\sce|palm/i.test(navigator.userAgent.toLowerCase()))
 		};
 	}
 	var MyAMS = globals.MyAMS;
 	var ams = MyAMS;
 		 */
 		ajax: function(event, response, request, error) {
 			if (response.statusText === 'OK') {
 				return;
 			}
-			var ajax_response = ams.ajax.getResponse(response);
+			var response = ams.ajax.getResponse(response);
-			if (ajax_response.content_type === 'json') {
+			if (response.contentType === 'json') {
-				ams.ajax.handleJSON(ajax_response.data);
+				ams.ajax.handleJSON(response.data);
 			} else {
 				var title = event.statusText || event.type;
 				var message = response.responseText;
 				ams.skin.messageBox('error', {
 					title: ams.i18n.ERROR_OCCURED,
 		show: function(request, status, error) {
 			if (!error) {
 				return;
 			}
 			var response = ams.ajax.getResponse(request);
-			if (response.content_type === 'json') {
+			if (response.contentType === 'json') {
 				ams.ajax.handleJSON(response.data);
 			} else {
 				ams.skin.messageBox('error', {
 					title: ams.i18n.ERRORS_OCCURED,
 					content: '<h4>' + status + '</h4><p>' + error + '</p>',
 		/**
 		 * Handle AJAX upload and download progress
 		 *
 		 * @param event: the source event
-		 * @param request: the request
-		 * @param options: AJAX options
 		 */
 		progress: function(event) {
 			if (!event.lengthComputable) {
 				return;
 			}
 		/**
 		 * Extract data type and result from response
 		 */
 		getResponse: function(request) {
-			var content_type = request.getResponseHeader('content-type'),
+			var contentType = request.getResponseHeader('content-type'),
-				data_type,
+				dataType,
 				result;
-			if (content_type) {
+			if (contentType) {
 				// Got server response
-				if (content_type.startsWith('application/javascript')) {
+				if (contentType.startsWith('application/javascript')) {
-					data_type = 'script';
+					dataType = 'script';
 					result = request.responseText;
-				} else if (content_type.startsWith('text/html')) {
+				} else if (contentType.startsWith('text/html')) {
-					data_type = 'html';
+					dataType = 'html';
 					result = request.responseText;
-				} else if (content_type.startsWith('text/xml')) {
+				} else if (contentType.startsWith('text/xml')) {
-					data_type = 'xml';
+					dataType = 'xml';
 					result = request.responseText;
 				} else {
 					result = request.responseJSON;
 					if (result) {
-						data_type = 'json';
+						dataType = 'json';
 					} else {
 						try {
 							result = JSON.parse(request.responseText);
-							data_type = 'json';
+							dataType = 'json';
 						} catch (e) {
 							result = request.responseText;
-							data_type = 'text';
+							dataType = 'text';
 						}
 					}
 				}
 			} else {
 				// Probably no response from server...
-				data_type = 'json';
+				dataType = 'json';
 				result = {
 					status: 'alert',
 					alert: {
 						title: ams.i18n.ERROR_OCCURED,
 						content: ams.i18n.NO_SERVER_RESPONSE
 					}
 				};
 			}
-			return {content_type: data_type,
+			return {contentType: dataType,
 					data: result};
 		},
 		/**
 		 * Handle server response in JSON format
 											title: ams.i18n.ERROR_OCCURED,
 											content: message,
 											timeout: 10000
 										});
 				} else {
-					var message_status = message.status || 'info';
+					var messageStatus = message.status || 'info';
-					if (message_status === 'error' && form && target) {
+					if (messageStatus === 'error' && form && target) {
 						ams.executeFunctionByName(form.data('ams-form-submit-error') || 'MyAMS.form.finalizeSubmitOnError', form, target);
 					}
-					ams.skin.messageBox(message_status,
+					ams.skin.messageBox(messageStatus,
 										{title: message.title || ams.i18n.ERROR_OCCURED,
 										 content: message.content,
 										 icon: message.icon,
 										 number: message.number,
 										 timeout: message.timeout === null ? undefined : (message.timeout || 10000)});
 		 * @param element: the parent element
 		 */
 		init: function(element) {
 			// Activate form changes if required
 			var forms;
-			if (ams.warn_on_form_change) {
+			if (ams.warnOnFormChange) {
 				forms = $('FORM[data-ams-warn-on-change!="false"]', element);
 			} else {
 				forms = $('FORM[data-ams-warn-on-change="true"]', element);
 			}
 			forms.each(function() {
 		},
 		/**
 		 * Submit given form
 		 */
-		submit: function(form, handler, submit_options) {
+		submit: function(form, handler, submitOptions) {
 			// Check params
 			form = $(form);
 			if (!form.exists()) {
 				return false;
 			}
 			if (typeof(handler) === 'object') {
-				submit_options = handler;
+				submitOptions = handler;
 				handler = undefined;
 			}
 			// Prevent multiple submits of the same form
 			if (form.data('submitted')) {
 				if (!form.data('ams-form-hide-submitted')) {
 						   function() {
 								function _submitAjaxForm(form, options) {
 									var button,
-										button_data,
+										buttonData,
-										button_target;
+										buttonTarget;
 									var data = form.data();
-									var form_options = data.amsFormOptions;
+									var formOptions = data.amsFormOptions;
-									var form_data;
+									var formData;
-									var form_data_callback;
+									var formDataCallback;
-									var progress_handler;
+									var progressHandler;
-									var progress_interval;
+									var progressInterval;
-									var progress_callback;
+									var progressCallback;
-									var progress_end_callback;
+									var progressEndCallback;
 									// Inner progress status handler
 									function _getProgress(handler, progress_id) {
 										var interval;
 										function _clearProgressStatus() {
 											button.button('reset');
 											clearInterval(interval);
-											ams.executeFunctionByName(progress_end_callback, form, button);
+											ams.executeFunctionByName(progressEndCallback, form, button);
 										}
 										function _getProgressStatus() {
 											ams.ajax.post(handler,
 														  {progress_id: progress_id},
 														  {error: _clearProgressStatus},
-														  ams.getFunctionByName(progress_callback) || function(result, status) {
+														  ams.getFunctionByName(progressCallback) || function(result, status) {
 															if (status == 'success') {
 																if (result.status === 'running') {
 																	if (result.message) {
 																		button.text(result.message);
 																	} else {
 															}
 														  });
 										}
 										button.button('loading');
-										interval = setInterval(_getProgressStatus, progress_interval);
+										interval = setInterval(_getProgressStatus, progressInterval);
 									}
 									// Initialize form data
-									if (submit_options) {
+									if (submitOptions) {
-										form_data_callback = submit_options.formDataInitCallback;
+										formDataCallback = submitOptions.formDataInitCallback;
 									}
-									if (form_data_callback) {
+									if (formDataCallback) {
-										delete submit_options.formDataInitCallback;
+										delete submitOptions.formDataInitCallback;
 									} else {
-										form_data_callback = data.amsFormDataInitCallback;
+										formDataCallback = data.amsFormDataInitCallback;
 									}
-									if (form_data_callback) {
+									if (formDataCallback) {
 										var veto = {};
-										if (typeof(form_data_callback) === 'function') {
+										if (typeof(formDataCallback) === 'function') {
-											form_data = form_data_callback.call(form, veto);
+											formData = formDataCallback.call(form, veto);
 										} else {
-											form_data = ams.executeFunctionByName(form_data_callback, form, veto);
+											formData = ams.executeFunctionByName(formDataCallback, form, veto);
 										}
 										if (veto.veto) {
 											button = form.data('ams-submit-button');
 											if (button) {
 												button.button('reset');
 											}
 											ams.form.finalizeSubmitFooter.call(form);
 											return false;
 										}
 									} else {
-										form_data = data.amsFormData || {};
+										formData = data.amsFormData || {};
 									}
 									// Check submit button for custom action handler and target
 									button = $(form.data('ams-submit-button'));
 									if (button && button.exists()) {
-										button_data = button.data();
+										buttonData = button.data();
-										button_target = button_data.amsFormSubmitTarget;
+										buttonTarget = buttonData.amsFormSubmitTarget;
 									} else {
-										button_data = {};
+										buttonData = {};
 									}
 									// Check action URL
 									var url;
-									var form_handler = handler || button_data.amsFormHandler || data.amsFormHandler || '';
+									var formHandler = handler || buttonData.amsFormHandler || data.amsFormHandler || '';
-									if (form_handler.startsWith(window.location.protocol)) {
+									if (formHandler.startsWith(window.location.protocol)) {
-										url = form_handler;
+										url = formHandler;
 									} else {
-										var action = button_data.amsFormAction || form.attr('action').replace(/#/, '');
+										var action = buttonData.amsFormAction || form.attr('action').replace(/#/, '');
 										if (action.startsWith(window.location.protocol)) {
 											url = action;
 										} else {
 											url = ams.ajax.getAddr() + action;
 										}
-										url += form_handler;
+										url += formHandler;
 									}
-									progress_handler = button_data.amsProgressHandler || data.amsProgressHandler || '';
+									progressHandler = buttonData.amsProgressHandler || data.amsProgressHandler || '';
-									progress_interval = button_data.amsProgressInterval || data.amsProgressInterval || 1000;
+									progressInterval = buttonData.amsProgressInterval || data.amsProgressInterval || 1000;
-									progress_callback = button_data.amsProgressCallback || data.amsProgressCallback;
+									progressCallback = buttonData.amsProgressCallback || data.amsProgressCallback;
-									progress_end_callback = button_data.amsProgressEndCallback || data.amsProgressEndCallback;
+									progressEndCallback = buttonData.amsProgressEndCallback || data.amsProgressEndCallback;
 									// Initialize submit target with AJAX indicator
 									var target = null;
-									if (submit_options && submit_options.initSubmitTarget) {
+									if (submitOptions && submitOptions.initSubmitTarget) {
-										ams.executeFunctionByName(submit_options.initSubmitTarget, form);
+										ams.executeFunctionByName(submitOptions.initSubmitTarget, form);
 									} else {
 										if (data.amsFormInitSubmitTarget) {
-											target = $(button_target || data.amsFormSubmitTarget || '#content');
+											target = $(buttonTarget || data.amsFormSubmitTarget || '#content');
 											ams.executeFunctionByName(data.amsFormInitSubmit || 'MyAMS.form.initSubmit', form, target);
 										} else if (!data.amsFormHideSubmitFooter) {
 											ams.executeFunctionByName(data.amsFormInitSubmit || 'MyAMS.form.initSubmitFooter', form);
 										}
 									}
 									// Complete form data
-									if (submit_options) {
+									if (submitOptions) {
-										form_data = $.extend({}, form_data, submit_options.form_data);
+										formData = $.extend({}, formData, submitOptions.form_data);
 									}
 									// Check progress handler
 									var hasUpload;
-									if (progress_handler) {
+									if (progressHandler) {
-										form_data.progress_id = ams.generateUUID();
+										formData.progress_id = ams.generateUUID();
 									} else {
 										// Check progress meter via Apache progress module
 										hasUpload = typeof(options.uuid) !== 'undefined';
 										if (hasUpload) {
 											if (url.indexOf('X-Progress-ID') < 0) {
 									// Initialize default AJAX settings
 									var defaults = {
 										url: url,
 										type: 'post',
 										cache: false,
-										data: form_data,
+										data: formData,
 										dataType: data.amsFormDatatype,
 										beforeSerialize: function(/*form, options*/) {
 											if (typeof(globals.tinyMCE) !== 'undefined') {
 												globals.tinyMCE.triggerSave();
 											}
 										},
 										iframe: hasUpload
 									};
 									// Initialize IFrame for custom download target
-									var download_target = (submit_options && submit_options.downloadTarget) || data.amsFormDownloadTarget;
+									var downloadTarget = (submitOptions && submitOptions.downloadTarget) || data.amsFormDownloadTarget;
-									if (download_target) {
+									if (downloadTarget) {
-										var iframe = $('iframe[name="' + download_target + '"]');
+										var iframe = $('iframe[name="' + downloadTarget + '"]');
 										if (!iframe.exists()) {
 											iframe = $('<iframe></iframe>').hide()
-																		   .attr('name', download_target)
+																		   .attr('name', downloadTarget)
 																		   .appendTo($('body'));
 										}
 										defaults = $.extend({}, defaults, {
 											iframe: true,
 											iframeTarget: iframe,
 												}
 											},
 											iframe: hasUpload
 										});
 									}
-									var settings = $.extend({}, defaults, options, form_options, submit_options);
+									var settings = $.extend({}, defaults, options, formOptions, submitOptions);
 									// Initialize progress handler
-									if (progress_handler) {
+									if (progressHandler) {
-										_getProgress(progress_handler, form_data.progress_id);
+										_getProgress(progressHandler, formData.progress_id);
 									}
 									// Submit form
 									$(form).ajaxSubmit(settings);
 									// If external download target is specified, reset form submit button and footer
-									if (download_target) {
+									if (downloadTarget) {
 										var modal = $(form).parents('.modal-dialog');
-										var keep_modal = modal.exists() && button.exists() && button.data('ams-keep-modal');
+										var keepModal = modal.exists() && button.exists() && button.data('ams-keep-modal');
-										if (modal.exists() && (keep_modal !== true)) {
+										if (modal.exists() && (keepModal !== true)) {
 											ams.dialog.close(form);
 										} else {
 											setTimeout(function() {
 												ams.form.resetAfterSubmit(form, button);
 												ams.form.resetChanged(form);
 					button.button('reset');
 				}
 			}
 			var data = form.data();
-			var data_type;
+			var dataType;
 			if (data.amsFormDatatype) {
-				data_type = data.amsFormDatatype;
+				dataType = data.amsFormDatatype;
 			} else {
-				var request_data = ams.ajax.getResponse(request);
+				var response = ams.ajax.getResponse(request);
-				data_type = request_data.content_type;
+				dataType = response.contentType;
-				result = request_data.data;
+				result = response.data;
 			}
 			var target;
 			if (button) {
 				target = $(button.data('ams-form-submit-target') || data.amsFormSubmitTarget || '#content');
 			} else {
 				target = $(data.amsFormSubmitTarget || '#content');
 			}
-			switch (data_type) {
+			switch (dataType) {
 				case 'json':
 					ams.ajax.handleJSON(result, form, target);
 					break;
 				case 'script':
 					break;
 		/**
 		 * Get list of custom validators called before submit
 		 */
 		_getSubmitValidators: function(form) {
 			var validators = [];
-			var form_validator = form.data('ams-form-validator');
+			var formValidator = form.data('ams-form-validator');
-			if (form_validator) {
+			if (formValidator) {
-				validators.push([form, form_validator]);
+				validators.push([form, formValidator]);
 			}
 			$('[data-ams-form-validator]', form).each(function() {
 				var source = $(this);
 				validators.push([source, source.data('ams-form-validator')]);
 			});
 			var result = true;
 			for (var index=0; index < validators.length; index++) {
 				var validator = validators[index];
 				var source = validator[0];
 				var handler = validator[1];
-				var validator_result = ams.executeFunctionByName(handler, form, source);
+				var validatorResult = ams.executeFunctionByName(handler, form, source);
-				if (validator_result === false) {
+				if (validatorResult === false) {
 					result = false;
-				} else if (typeof(validator_result) === 'string') {
+				} else if (typeof(validatorResult) === 'string') {
-					output.push(validator_result);
+					output.push(validatorResult);
 				} else if (result.length && (result.length > 0)) {
 					output = output.concat(result);
 				}
 			}
 			if (output.length > 0) {
 					}
 				}
 				if (errors.widgets) {
 					for (index = 0; index < errors.widgets.length; index++) {
 						// set widget status message
-						var widget_data = errors.widgets[index];
+						var widgetData = errors.widgets[index];
-						var widget = $('[name="' + widget_data.name + '"]', form);
+						var widget = $('[name="' + widgetData.name + '"]', form);
 						widget.parents('label:first')
 								.removeClassPrefix('state-')
 								.addClass('state-error')
-								.after('<span for="name" class="state-error">' + widget_data.message + '</span>');
+								.after('<span for="name" class="state-error">' + widgetData.message + '</span>');
 						// complete form alert message
-						if (widget_data.label) {
+						if (widgetData.label) {
-							message.push(widget_data.label + ' : ' + widget_data.message);
+							message.push(widgetData.label + ' : ' + widgetData.message);
 						}
 						// mark parent tab (if any) with error status
-						var tab_index = widget.parents('.tab-pane').index() + 1;
+						var tabIndex = widget.parents('.tab-pane').index() + 1;
-						if (tab_index > 0) {
+						if (tabIndex > 0) {
-							var nav_tabs = $('.nav-tabs', $(widget).parents('.tabforms'));
+							var navTabs = $('.nav-tabs', $(widget).parents('.tabforms'));
-							$('li:nth-child(' + tab_index + ')', nav_tabs).removeClassPrefix('state-')
+							$('li:nth-child(' + tabIndex + ')', navTabs).removeClassPrefix('state-')
-									.addClass('state-error');
+																		.addClass('state-error');
 							$('li.state-error:first a', form).click();
 						}
 					}
 				}
 				ams.skin.alert($('fieldset:first', form), errors.error_level || 'error', header, message, errors.error_message);
 													'<div class="progress-bar" style="width: 100%;"></div>' +
 												'</div>' +
 											'</div>';
 									}
-									var source_data;
+									var sourceData;
 									var url;
 									if (typeof(source) === 'string') {
-										source_data = {};
+										sourceData = {};
 										url = source;
 									} else {
-										source_data = source.data();
+										sourceData = source.data();
-										url = source.attr('href') || source_data.amsUrl;
+										url = source.attr('href') || sourceData.amsUrl;
 										var url_getter = ams.getFunctionByName(url);
 										if (typeof(url_getter) === 'function') {
 											url = url_getter.call(source);
 										}
 									}
 									} else {
 										// Remote URL modal dialog
 										$.ajax({
 											url: url,
 											type: 'get',
-											cache: source_data.amsAllowCache === undefined ? false : source_data.amsAllowCache,
+											cache: sourceData.amsAllowCache === undefined ? false : sourceData.amsAllowCache,
 											data: options,
 											success: function(data, status, request) {
 												$('body').modalmanager('removeLoading');
-												var request_data = ams.ajax.getResponse(request);
+												var response = ams.ajax.getResponse(request);
-												var data_type = request_data.content_type;
+												var dataType = response.contentType;
-												var result = request_data.data;
+												var result = response.data;
-												switch (data_type) {
+												switch (dataType) {
 													case 'json':
 														ams.ajax.handleJSON(result, $($(source).data('ams-json-target') || '#content'));
 														break;
 													case 'script':
 														break;
 													case 'text':
 														/* falls through */
 													default:
 														var content = $(result);
 														var dialog = $('.modal-dialog', content.wrap('<div></div>').parent());
-														var dialog_data = dialog.data();
+														var dialogData = dialog.data();
-														var data_options = {
+														var dataOptions = {
 															backdrop: 'static',
-															overflow: dialog_data.amsModalOverflow || '.modal-viewport',
+															overflow: dialogData.amsModalOverflow || '.modal-viewport',
-															maxHeight: dialog_data.amsModalMaxHeight === undefined ?
+															maxHeight: dialogData.amsModalMaxHeight === undefined ?
 																	function() {
 																		return $(window).height() -
 																					$('.modal-header', content).outerHeight(true) -
 																					$('footer', content).outerHeight(true) - 85;
 																	}
-																	: ams.getFunctionByName(dialog_data.amsModalMaxHeight)
+																	: ams.getFunctionByName(dialogData.amsModalMaxHeight)
 														};
-														var settings = $.extend({}, data_options, dialog_data.amsModalOptions);
+														var settings = $.extend({}, dataOptions, dialogData.amsModalOptions);
-														settings = ams.executeFunctionByName(dialog_data.amsModalInitCallback, dialog, settings) || settings;
+														settings = ams.executeFunctionByName(dialogData.amsModalInitCallback, dialog, settings) || settings;
 														$('<div>').addClass('modal fade')
 																  .append(content)
 																  .modal(settings)
 																  .on('shown', ams.dialog.shown)
 																  .on('hidden', ams.dialog.hidden);
 														ams.initContent(content);
-														if (source_data.amsLogEvent !== false) {
+														if (sourceData.amsLogEvent !== false) {
 															ams.stats.logPageview(url);
 														}
 												}
 											}
 										});
 		 */
 		shown: function(e) {
 			function resetViewport(ev) {
 				var top = $('.scrollmarker.top', viewport);
-				var top_position = viewport.scrollTop();
+				var topPosition = viewport.scrollTop();
-				if (top_position > 0) {
+				if (topPosition > 0) {
 					top.show();
 				} else {
 					top.hide();
 				}
 				var bottom = $('.scrollmarker.bottom', viewport);
-				if (maxHeight + top_position >= viewport.get(0).scrollHeight) {
+				if (maxHeight + topPosition >= viewport.get(0).scrollHeight) {
 					bottom.hide();
 				} else {
 					bottom.show();
 				}
 			}
 			}
 		},
 		/** Context menu handler */
 		contextMenuHandler: function(target, menu) {
-			var menu_data = menu.data();
+			var menuData = menu.data();
-			if (menu_data.toggle === 'modal') {
+			if (menuData.toggle === 'modal') {
 				ams.dialog.open(menu);
 			} else {
-				var href = menu.attr('href') || menu_data.amsUrl;
+				var href = menu.attr('href') || menuData.amsUrl;
 				if (!href || href.startsWith('javascript') || menu.attr('target')) {
 					return;
 				}
 				ams.event.stop();
-				var href_getter = ams.getFunctionByName(href);
+				var hrefGetter = ams.getFunctionByName(href);
-				if (typeof(href_getter) === 'function') {
+				if (typeof(hrefGetter) === 'function') {
-					href = href_getter.call(menu, target);
+					href = hrefGetter.call(menu, target);
 				}
 				if (typeof(href) === 'function') {
 					// Javascript function call
 					href.call(menu, target);
 				} else {
 			}
 			$('[data-ams-plugins]', element).each(function() {
 				var source = $(this);
-				var ams_plugins = source.data('ams-plugins');
+				var amsPlugins = source.data('ams-plugins');
-				if (typeof(ams_plugins) === 'string') {
+				if (typeof(amsPlugins) === 'string') {
 					var names = source.data('ams-plugins').split(/\s+/);
 					for (var index = 0; index < names.length; index++) {
 						name = names[index];
-						var new_plugin = {
+						var newPlugin = {
 							src: source.data('ams-plugin-' + name + '-src'),
 							css: source.data('ams-plugin-' + name + '-css'),
 							callback: source.data('ams-plugin-' + name + '-callback'),
 							register: source.data('ams-plugin-' + name + '-register'),
 							async: source.data('ams-plugin-' + name + '-async')
 						};
-						_registerPlugin(name, new_plugin);
+						_registerPlugin(name, newPlugin);
 					}
 				} else {
-					for (name in ams_plugins) {
+					for (name in amsPlugins) {
-						if (!ams_plugins.hasOwnProperty(name)) {
+						if (!amsPlugins.hasOwnProperty(name)) {
 							continue;
 						}
-						_registerPlugin(name, ams_plugins[name]);
+						_registerPlugin(name, amsPlugins[name]);
 					}
 				}
 			});
 			for (name in plugins) {
 					switch (typeof(callbacks)) {
 						case 'function':
 							callbacks(element);
 							break;
 						default:
-							for (var cb_index = 0; cb_index < callbacks.length; cb_index++) {
+							for (var cbIndex = 0; cbIndex < callbacks.length; cbIndex++) {
-								var callback = callbacks[cb_index];
+								var callback = callbacks[cbIndex];
 								if (typeof(callback) === 'function') {
 									callback(element);
 								}
 							}
 					}
 		 * This way of defining data attributes can be used with HTML templates engines which don't allow you
 		 * to create dynamic attributes easily.
 		 */
 		initData: function(element) {
 			$('[data-ams-data]', element).each(function() {
-				var data_element = $(this);
+				var dataElement = $(this);
-				var data = data_element.data('ams-data');
+				var data = dataElement.data('ams-data');
 				if (data) {
 					for (var name in data) {
 						if (data.hasOwnProperty(name)) {
-							data_element.attr('data-' + name, data[name]);
+							dataElement.attr('data-' + name, data[name]);
 						}
 					}
 				}
 			});
 		},
 									   ams.getCSS(ams.baseURL + '../css/ext/jquery-tipsy' + ams.devext + '.css',
 												  'jquery-tipsy');
 									   hints.each(function () {
 										   var hint = $(this);
 										   var data = hint.data();
-										   var data_options = {
+										   var dataOptions = {
 											   html: data.amsHintHtml,
 											   title: ams.getFunctionByName(data.amsHintTitleGetter) || function () {
 												   var hint = $(this);
 												   return hint.attr('original-title') ||
 														   hint.attr(data.amsHintTitleAttr || 'title') ||
 											   },
 											   opacity: data.amsHintOpacity || 0.95,
 											   gravity: data.amsHintGravity || 'sw',
 											   offset: data.amsHintOffset || 0
 										   };
-										   var settings = $.extend({}, data_options, data.amsHintOptions);
+										   var settings = $.extend({}, dataOptions, data.amsHintOptions);
 										   settings = ams.executeFunctionByName(data.amsHintInitCallback, hint, settings) || settings;
 										   var plugin = hint.tipsy(settings);
 										   ams.executeFunctionByName(data.amsHintAfterInitCallback, hint, plugin, settings);
 									   });
 								   });
 				var menus = $('.context-menu', element);
 				if (menus.length > 0) {
 					menus.each(function() {
 						var menu = $(this);
 						var data = menu.data();
-						var data_options = {
+						var dataOptions = {
 							menuSelector: data.amsContextmenuSelector,
 							menuSelected: ams.helpers.contextMenuHandler
 						};
-						var settings = $.extend({}, data_options, data.amsContextmenuOptions);
+						var settings = $.extend({}, dataOptions, data.amsContextmenuOptions);
 						settings = ams.executeFunctionByName(data.amsContextmenuInitCallback, menu, settings) || settings;
 						var plugin = menu.contextMenu(settings);
 						ams.executeFunctionByName(data.amsContextmenuAfterInitCallback, menu, plugin, settings);
 					});
 				}
 					var fieldset = legend.parent('fieldset');
 					var data = legend.data();
 					if (!data.amsChecker) {
 						var checker = $('<label class="checkbox"></label>');
 						var fieldname = data.amsCheckerFieldname || ('checker_'+ams.generateId());
-						var checkbox_id = fieldname.replace(/\./, '_');
+						var checkboxId = fieldname.replace(/\./, '_');
 						var prefix = data.amsCheckerHiddenPrefix;
 						var hidden = null;
 						var checkedValue = data.amsCheckerHiddenValueOn || 'true';
 						var uncheckedValue = data.amsCheckerHiddenValueOff || 'false';
 						var marker = data.amsCheckerMarker || false;
 							$('<input type="hidden">').attr('name', marker)
 													  .attr('value', 1)
 													  .prependTo(legend);
 						}
 						var input = $('<input type="checkbox">').attr('name', fieldname)
-																.attr('id', checkbox_id)
+																.attr('id', checkboxId)
 																.data('ams-checker-hidden-input', hidden)
 																.data('ams-checker-init', true)
 																.val(data.amsCheckerValue || true)
 																.attr('checked', data.amsCheckerState === 'on' ? 'checked' : null);
 						if (data.amsCheckerReadonly) {
 								   ams.baseURL + 'ext/bootstrap-slider-2.0.0' + ams.devext + '.js',
 								   function() {
 										sliders.each(function() {
 											var slider = $(this);
 											var data = slider.data();
-											var data_options = {};
+											var dataOptions = {};
-											var settings = $.extend({}, data_options, slider.data.amsSliderOptions);
+											var settings = $.extend({}, dataOptions, slider.data.amsSliderOptions);
 											settings = ams.executeFunctionByName(data.amsSliderInitCallback, slider, settings) || settings;
 											var plugin = slider.slider(settings);
 											ams.executeFunctionByName(data.amsSliderAfterInitCallback, slider, plugin, settings);
 										});
 								   });
 				var draggables = $('.draggable', element);
 				if (draggables.length > 0) {
 					draggables.each(function() {
 						var draggable = $(this);
 						var data = draggable.data();
-						var data_options = {
+						var dataOptions = {
 							containment: data.amsDraggableContainment,
 							helper: ams.getFunctionByName(data.amsDraggableHelper) || data.amsDraggableHelper,
 							start: ams.getFunctionByName(data.amsDraggableStart),
 							stop: ams.getFunctionByName(data.amsDraggableStop)
 						};
-						var settings = $.extend({}, data_options, data.amsDraggableOptions);
+						var settings = $.extend({}, dataOptions, data.amsDraggableOptions);
 						settings = ams.executeFunctionByName(data.amsDraggableInitCallback, draggable, settings) || settings;
 						var plugin = draggable.draggable(settings);
 						draggable.disableSelection();
 						ams.executeFunctionByName(data.amsDraggableAfterInitCallback, draggable, plugin, settings);
 					});
 				var sortables = $('.sortable', element);
 				if (sortables.length > 0) {
 					sortables.each(function() {
 						var sortable = $(this);
 						var data = sortable.data();
-						var data_options = {
+						var dataOptions = {
 							items: data.amsSortableItems,
 							handle: data.amsSortableHandle,
 							connectWith: data.amsSortableConnectwith,
 							start: ams.getFunctionByName(data.amsSortableStart),
 							over: ams.getFunctionByName(data.amsSortableOver),
 							containment: data.amsSortableContainment,
 							placeholder: data.amsSortablePlaceholder,
 							stop: ams.getFunctionByName(data.amsSortableStop)
 						};
-						var settings = $.extend({}, data_options, data.amsSortableOptions);
+						var settings = $.extend({}, dataOptions, data.amsSortableOptions);
 						settings = ams.executeFunctionByName(data.amsSortableInitCallback, sortable, settings) || settings;
 						var plugin = sortable.sortable(settings);
 						sortable.disableSelection();
 						ams.executeFunctionByName(data.amsSortableAfterInitCallback, sortable, plugin, settings);
 					});
 				var resizables = $('.resizable', element);
 				if (resizables.length > 0) {
 					resizables.each(function() {
 						var resizable = $(this);
 						var data = resizable.data();
-						var data_options = {
+						var dataOptions = {
 							autoHide: data.amsResizableAutohide === false ? true : data.amsResizableAutohide,
 							containment: data.amsResizableContainment,
 							grid: data.amsResizableGrid,
 							handles: data.amsResizableHandles,
 							start: ams.getFunctionByName(data.amsResizableStart),
 							stop: ams.getFunctionByName(data.amsResizableStop)
 						};
-						var settings = $.extend({}, data_options, data.amsResizableOptions);
+						var settings = $.extend({}, dataOptions, data.amsResizableOptions);
 						settings = ams.executeFunctionByName(data.amsResizableInitCallback, resizable, settings) || settings;
 						var plugin = resizable.resizable(settings);
 						resizable.disableSelection();
 						ams.executeFunctionByName(data.amsResizableAfterInitCallback, resizable, plugin, settings);
 					});
 								   ams.baseURL + 'ext/jquery-typeahead' + ams.devext + '.js',
 								   function() {
 										typeaheads.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options = {};
+											var dataOptions = {};
-											var settings = $.extend({}, data_options, data.amsTypeaheadOptions);
+											var settings = $.extend({}, dataOptions, data.amsTypeaheadOptions);
 											settings = ams.executeFunctionByName(data.amsTypeaheadInitCallback, input, settings) || settings;
 											var plugin = input.typeahead(settings);
 											ams.executeFunctionByName(data.amsTypeaheadAfterInitCallback, input, plugin, settings);
 										});
 								   });
 								   ams.baseURL + 'ext/jquery-select2-3.5.2' + ams.devext + '.js',
 								   function() {
 										selects.each(function() {
 											var select = $(this);
 											var data = select.data();
-											var data_options = {
+											var dataOptions = {
 												placeholder: data.amsSelect2Placeholder,
 												multiple: data.amsSelect2Multiple,
 												minimumInputLength: data.amsSelect2MinimumInputLength || 0,
 												maximumSelectionSize: data.amsSelect2MaximumSelectionSize,
 												openOnEnter: data.amsSelect2EnterOpen === undefined ? true : data.amsSelect2EnterOpen,
 											};
 											switch (select.context.type) {
 												case 'text':
 												case 'hidden':
-													if (!data_options.initSelection) {
+													if (!dataOptions.initSelection) {
-														var values_data = select.data('ams-select2-values');
+														var valuesData = select.data('ams-select2-values');
-														if (values_data) {
+														if (valuesData) {
-															data_options.initSelection = function(element, callback) {
+															dataOptions.initSelection = function(element, callback) {
 																var data = [];
-																$(element.val().split(data_options.separator)).each(function() {
+																$(element.val().split(dataOptions.separator)).each(function() {
 																	data.push({id: this,
-																			   text: values_data[this] || this});
+																			   text: valuesData[this] || this});
 																});
 																callback(data);
 															};
 														}
 													}
 													break;
 											}
 											if (select.attr('readonly')) {
 												if (select.attr('type') === 'hidden') {
-													data_options.query = function () {
+													dataOptions.query = function () {
 														return [];
 													};
 												}
 											} else if (data.amsSelect2Query) {
 												// Custom query method
-												data_options.query = ams.getFunctionByName(data.amsSelect2Query);
+												dataOptions.query = ams.getFunctionByName(data.amsSelect2Query);
-												data_options.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
+												dataOptions.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
 											} else if (data.amsSelect2QueryUrl) {
 												// AJAX query
-												data_options.ajax = {
+												dataOptions.ajax = {
 													url: data.amsSelect2QueryUrl,
 													quietMillis: data.amsSelect2QuietMillis || 200,
 													type: data.amsSelect2QueryType || 'POST',
 													dataType: data.amsSelect2QueryDatatype || 'json',
 													data: function(term, page, context) {
 														options[data.amsSelect2ContextParamName || 'context'] = context;
 														return $.extend({}, options, data.amsSelect2QueryOptions);
 													},
 													results: ams.helpers.select2QueryUrlResultsCallback
 												};
-												data_options.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
+												dataOptions.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
 											} else if (data.amsSelect2QueryMethod) {
 												// JSON-RPC query
-												data_options.query = function(options) {
+												dataOptions.query = function(options) {
 													var settings = {
 														url: data.amsSelect2MethodTarget || ams.jsonrpc.getAddr(),
 														type: data.amsSelect2MethodType || 'POST',
 														cache: false,
 														method: data.amsSelect2QueryMethod,
 													settings.params[data.amsSelect2PageParamName || 'page'] = options.page;
 													settings.params[data.amsSelect2ContextParamName || 'context'] = options.context;
 													settings = $.extend({}, settings, data.amsSelect2QueryOptions);
 													settings = ams.executeFunctionByName(data.amsSelect2QueryInitCallback, select, settings) || settings;
 													ams.ajax.check($.jsonRpc,
-																   ams.baseURL + 'ext/jquery-jsonrpc' + (ams.devmode ? '.js' : '.min.js'),
+																   ams.baseURL + 'ext/jquery-jsonrpc' + ams.devext + '.js',
 																   function() {
 																		$.jsonRpc(settings);
 																   });
 												};
-												data_options.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
+												dataOptions.minimumInputLength = data.amsSelect2MinimumInputLength || 1;
 											} else if (data.amsSelect2Tags) {
 												// Tags mode
-												data_options.tags = data.amsSelect2Tags;
+												dataOptions.tags = data.amsSelect2Tags;
 											} else if (data.amsSelect2Data) {
 												// Provided data mode
-												data_options.data = data.amsSelect2Data;
+												dataOptions.data = data.amsSelect2Data;
 											}
 											if (data.amsSelect2EnableFreeTags) {
-												data_options.createSearchChoice = function(term) {
+												dataOptions.createSearchChoice = function(term) {
 													return {id: term,
 															text: (data.amsSelect2FreeTagsPrefix || ams.i18n.SELECT2_FREETAG_PREFIX) + term};
 												};
 											}
-											var settings = $.extend({}, data_options, data.amsSelect2Options);
+											var settings = $.extend({}, dataOptions, data.amsSelect2Options);
 											settings = ams.executeFunctionByName(data.amsSelect2InitCallback, select, settings) || settings;
 											var plugin = select.select2(settings);
 											ams.executeFunctionByName(data.amsSelect2AfterInitCallback, select, plugin, settings);
 											if (select.hasClass('ordered')) {
 												ams.ajax.check($.fn.select2Sortable,
 								   ams.baseURL + 'ext/jquery-maskedinput-1.4.1' + ams.devext + '.js',
 								   function() {
 										masks.each(function() {
 											var mask = $(this);
 											var data = mask.data();
-											var data_options = {
+											var dataOptions = {
 												placeholder: data.amsMaskeditPlaceholder === undefined ? 'X' : data.amsMaskeditPlaceholder,
 												complete: ams.getFunctionByName(data.amsMaskeditComplete)
 											};
-											var settings = $.extend({}, data_options, data.amsMaskeditOptions);
+											var settings = $.extend({}, dataOptions, data.amsMaskeditOptions);
 											settings = ams.executeFunctionByName(data.amsMaskeditInitCallback, mask, settings) || settings;
 											var plugin = mask.mask(mask.attr('data-mask'), settings);
 											ams.executeFunctionByName(data.amsMaskeditAfterInitCallback, mask, plugin, settings);
 										});
 								   });
 								   ams.baseURL + 'ext/jquery-inputmask-bundle-3.2.8' + ams.devext + '.js',
 								   function() {
 										masks.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options;
+											var dataOptions;
 											if (typeof(data.inputMask) === 'object') {
-												data_options = data.inputMask;
+												dataOptions = data.inputMask;
 											} else {
-												data_options = {
+												dataOptions = {
 													mask: data.inputMask.toString()
 												};
 											}
-											var settings = $.extend({}, data_options, data.amsInputmaskOptions);
+											var settings = $.extend({}, dataOptions, data.amsInputmaskOptions);
 											settings = ams.executeFunctionByName(data.amsInputmaskInitCallback, input, settings) || settings;
 											var plugin = input.inputmask(settings);
 											ams.executeFunctionByName(data.amsInputmaskAfterInitCallback, input, plugin, settings);
 										});
 								   });
 											ams.dialog.registerHideCallback(ams.helpers.datetimepickerDialogHiddenCallback);
 										}
 										datepickers.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options = {
+											var dataOptions = {
 												lang: data.amsDatetimepickerLang || ams.lang,
 												format: data.amsDatetimepickerFormat || 'd/m/y',
 												datepicker: true,
 												dayOfWeekStart: 1,
 												timepicker: false
 											};
-											var settings = $.extend({}, data_options, data.amsDatetimepickerOptions);
+											var settings = $.extend({}, dataOptions, data.amsDatetimepickerOptions);
 											settings = ams.executeFunctionByName(data.amsDatetimepickerInitCallback, input, settings) || settings;
 											var plugin = input.datetimepicker(settings);
 											ams.executeFunctionByName(data.amsDatetimepickerAfterInitCallback, input, plugin, settings);
 										});
 								   });
 											ams.dialog.registerHideCallback(ams.helpers.datetimepickerDialogHiddenCallback);
 										}
 										datetimepickers.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options = {
+											var dataOptions = {
 												lang: data.amsDatetimepickerLang || ams.lang,
 												format: data.amsDatetimepickerFormat || 'd/m/y H:i',
 												datepicker: true,
 												dayOfWeekStart: 1,
 												timepicker: true
 											};
-											var settings = $.extend({}, data_options, data.amsDatetimepickerOptions);
+											var settings = $.extend({}, dataOptions, data.amsDatetimepickerOptions);
 											settings = ams.executeFunctionByName(data.amsDatetimepickerInitCallback, input, settings) || settings;
 											var plugin = input.datetimepicker(settings);
 											ams.executeFunctionByName(data.amsDatetimepickerAfterInitCallback, input, plugin, settings);
 										});
 								   });
 											ams.dialog.registerHideCallback(ams.helpers.datetimepickerDialogHiddenCallback);
 										}
 										timepickers.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options = {
+											var dataOptions = {
 												lang: data.amsDatetimepickerLang || ams.lang,
 												format: data.amsDatetimepickerFormat || 'H:i',
 												datepicker: false,
 												timepicker: true
 											};
-											var settings = $.extend({}, data_options, data.amsDatetimepickerOptions);
+											var settings = $.extend({}, dataOptions, data.amsDatetimepickerOptions);
 											settings = ams.executeFunctionByName(data.amsDatetimepickerInitCallback, input, settings) || settings;
 											var plugin = input.datetimepicker(settings);
 											ams.executeFunctionByName(data.amsDatetimepickerAfterInitCallback, input, plugin, settings);
 										});
 								   });
 											ams.getCSS(ams.baseURL + '../css/ext/jquery-minicolors' + ams.devext + '.css', 'jquery-minicolors');
 										}
 										colorpickers.each(function() {
 											var input = $(this);
 											var data = input.data();
-											var data_options = {
+											var dataOptions = {
 												position: data.amsColorpickerPosition || input.closest('label.input').data('ams-colorpicker-position') || 'bottom left'
 											};
-											var settings = $.extend({}, data_options, data.amsColorpickerOptions);
+											var settings = $.extend({}, dataOptions, data.amsColorpickerOptions);
 											settings = ams.executeFunctionByName(data.amsColorpickerInitCallback, input, settings) || settings;
 											var plugin = input.minicolors(settings);
 											ams.executeFunctionByName(data.amsDatetimepickerAfterInitCallback, input, plugin, settings);
 										});
 								   });
 											}
 										}
 										forms.each(function() {
 											var form = $(this);
 											var data = form.data();
-											var data_options = {
+											var dataOptions = {
 												ignore: null,
 												submitHandler: form.attr('data-async') !== undefined ?
 															   data.amsFormSubmitHandler === undefined ?
 																	function() {
 																		// JQuery-form plug-in must be loaded synchronously!!
 																data.amsFormInvalidHandler === undefined ?
 																	function(event, validator) {
 																		$('.state-error', form).removeClass('state-error');
 																		for (var index=0; index < validator.errorList.length; index++) {
 																			var error = validator.errorList[index];
-																			var tab_index = $(error.element).parents('.tab-pane').index() + 1;
+																			var tabIndex = $(error.element).parents('.tab-pane').index() + 1;
-																			if (tab_index > 0) {
+																			if (tabIndex > 0) {
-																				var nav_tabs = $('.nav-tabs', $(error.element).parents('.tabforms'));
+																				var navTabs = $('.nav-tabs', $(error.element).parents('.tabforms'));
-																				$('li:nth-child(' + tab_index + ')', nav_tabs)
+																				$('li:nth-child(' + tabIndex + ')', navTabs)
 																						.removeClassPrefix('state-')
 																						.addClass('state-error');
-																				$('li.state-error:first a', nav_tabs).click();
+																				$('li.state-error:first a', navTabs).click();
 																			}
 																		}
 																	}
 																	: ams.getFunctionByName(data.amsFormInvalidHandler)
 																: undefined
 											};
 											$('[data-ams-validate-rules]', form).each(function(index) {
 												if (index === 0) {
-													data_options.rules = {};
+													dataOptions.rules = {};
 												}
-												data_options.rules[$(this).attr('name')] = $(this).data('ams-validate-rules');
+												dataOptions.rules[$(this).attr('name')] = $(this).data('ams-validate-rules');
 											});
-											var settings = $.extend({}, data_options, data.amsValidateOptions);
+											var settings = $.extend({}, dataOptions, data.amsValidateOptions);
 											settings = ams.executeFunctionByName(data.amsValidateInitCallback, form, settings) || settings;
 											var plugin = form.validate(settings);
 											ams.executeFunctionByName(data.amsValidateAfterInitCallback, form, plugin, settings);
 										});
 								   });
 											var sorting = data.amsDatatableSorting;
 											if (typeof(sorting) === 'string') {
 												var sortings = sorting.split(';');
 												sorting = [];
 												for (index=0; index < sortings.length; index++) {
-													var col_sorting = sortings[index].split(',');
+													var colSorting = sortings[index].split(',');
-													col_sorting[0] = parseInt(col_sorting[0]);
+													colSorting[0] = parseInt(colSorting[0]);
-													sorting.push(col_sorting);
+													sorting.push(colSorting);
+												}
+											}
+											// Check columns sortings
+											var columns = [];
+											var column;
+											var sortables = $('th', table).listattr('data-ams-datatable-sortable');
+											for (index=0; index < sortables.length; index++) {
+												var sortable = sortables[index];
+												if (sortable !== undefined) {
+													column = columns[index] || {};
+													column.bSortable = sortable;
+													columns[index] = column;
 												}
 											}
 											// Check columns types
-											var columns = [];
+											var sortTypes = $('th', table).listattr('data-ams-datatable-stype');
-											var sort_types = $('th', table).listattr('data-ams-datatable-stype');
+											for (index=0; index < sortTypes.length; index++) {
-											for (index=0; index < sort_types.length; index++) {
+												var sortType = sortTypes[index];
-												var sort_type = sort_types[index];
+												if (sortType) {
-												if (sort_type) {
+													column = columns[index] || {};
-													var column = columns[index] || {};
+													column.sType = sortType;
-													column.sType = sort_type;
 													columns[index] = column;
 												}
 											}
 											// Set options
-											var data_options = {
+											var dataOptions = {
 												bJQueryUI: false,
 												bFilter: data.amsDatatableGlobalFilter !== false || extensions.indexOf('columnfilter') >= 0,
 												bPaginate: data.amsDatatablePagination !== false,
 												bInfo: data.amsDatatableInfo !== false,
 												bSort: data.amsDatatableSort !== false,
 												sPaginationType: data.amsDatatablePaginationType || 'bootstrap_full',
 												sDom: sDom,
 												oLanguage: ams.plugins.i18n.datatables,
 												fnInitComplete: function(oSettings, json) {
 													$('.ColVis_Button').addClass('btn btn-default btn-sm')
-																	   .html((ams.plugins.i18n.datatables.sColumns || "Columns") + ' <i class="fa fa-fw fa-caret-down"></i>');
+																	   .html((ams.plugins.i18n.datatables.sColumns || "Columns") +
+																			 ' <i class="fa fa-fw fa-caret-down"></i>');
 												}
 											};
-											var settings = $.extend({}, data_options, data.amsDatatableOptions);
+											var settings = $.extend({}, dataOptions, data.amsDatatableOptions);
 											if (extensions.length > 0) {
 												for (index=0; index < extensions.length; index++) {
 													switch (extensions[index]) {
 														case 'autofill':
 															ams.ajax.check($.fn.dataTable.AutoFill,
 																		   ams.baseURL + 'ext/jquery-dataTables-colReorderWithResize' + ams.devext + '.js');
 															break;
 														case 'colvis':
 															ams.ajax.check($.fn.dataTable.ColVis,
 																		   ams.baseURL + 'ext/jquery-dataTables-colVis' + ams.devext + '.js');
-															var cv_default = {
+															var cvDefault = {
 																activate: 'click',
 																sAlign: 'right'
 															};
-															settings.oColVis = $.extend({}, cv_default, data.amsDatatableColvisOptions);
+															settings.oColVis = $.extend({}, cvDefault, data.amsDatatableColvisOptions);
 															break;
 														case 'editable':
 															ams.ajax.check($.fn.editable,
 																		   ams.baseURL + 'ext/jquery-jeditable' + ams.devext + '.js');
 															ams.ajax.check($.fn.makeEditable,
 												ams.executeFunctionByName(data.amsDatatableAfterInitCallback, table, plugin, settings);
 												if (extensions.length > 0) {
 													for (index=0; index < extensions.length; index++) {
 														switch (extensions[index]) {
 															case 'autofill':
-																var af_settings = $.extend({}, data.amsDatatableAutofillOptions, settings.autofill);
+																var afSettings = $.extend({}, data.amsDatatableAutofillOptions, settings.autofill);
-																af_settings = ams.executeFunctionByName(data.amsDatatableAutofillInitCallback, table, af_settings) || af_settings;
+																afSettings = ams.executeFunctionByName(data.amsDatatableAutofillInitCallback, table, afSettings) || afSettings;
 																table.data('ams-autofill', data.amsDatatableAutofillConstructor === undefined ?
-																							new $.fn.dataTable.AutoFill(table, af_settings)
+																							new $.fn.dataTable.AutoFill(table, afSettings)
-																							: ams.executeFunctionByName(data.amsDatatableAutofillConstructor, table, plugin, af_settings));
+																							: ams.executeFunctionByName(data.amsDatatableAutofillConstructor, table, plugin, afSettings));
 																break;
 															case 'columnfilter':
-																var cf_default = {
+																var cfDefault = {
 																	sPlaceHolder: 'head:after'
 																};
-																var cf_settings = $.extend({}, cf_default, data.amsDatatableColumnfilterOptions, settings.columnfilter);
+																var cfSettings = $.extend({}, cfDefault, data.amsDatatableColumnfilterOptions, settings.columnfilter);
-																cf_settings = ams.executeFunctionByName(data.amsDatatableColumnfilterInitCallback, table, cf_settings) || cf_settings;
+																cfSettings = ams.executeFunctionByName(data.amsDatatableColumnfilterInitCallback, table, cfSettings) || cfSettings;
 																table.data('ams-columnfilter', data.amsDatatableColumnfilterConstructor === undefined ?
-																							plugin.columnFilter(cf_settings)
+																							plugin.columnFilter(cfSettings)
-																							: ams.executeFunctionByName(data.amsDatatableColumnfilterConstructor, table, plugin, cf_settings));
+																							: ams.executeFunctionByName(data.amsDatatableColumnfilterConstructor, table, plugin, cfSettings));
 																break;
 															case 'editable':
-																var ed_settings = $.extend({}, data.amsDatatableEditableOptions, settings.editable);
+																var edSettings = $.extend({}, data.amsDatatableEditableOptions, settings.editable);
-																ed_settings = ams.executeFunctionByName(data.amsDatatableEditableInitCallback, table, ed_settings) || ed_settings;
+																edSettings = ams.executeFunctionByName(data.amsDatatableEditableInitCallback, table, edSettings) || edSettings;
 																table.data('ams-editable', data.amsDatatableEditableConstructor === undefined ?
-																							table.makeEditable(ed_settings)
+																							table.makeEditable(edSettings)
-																							: ams.executeFunctionByName(data.amsDatatableEditableConstructor, table, plugin, ed_settings));
+																							: ams.executeFunctionByName(data.amsDatatableEditableConstructor, table, plugin, edSettings));
 																break;
 															case 'fixedcolumns':
-																var fc_settings = $.extend({}, data.amsDatatableFixedcolumnsOptions, settings.fixedcolumns);
+																var fcSettings = $.extend({}, data.amsDatatableFixedcolumnsOptions, settings.fixedcolumns);
-																fc_settings = ams.executeFunctionByName(data.amsDatatableFixedcolumnsInitCallback, table, fc_settings) || fc_settings;
+																fcSettings = ams.executeFunctionByName(data.amsDatatableFixedcolumnsInitCallback, table, fcSettings) || fcSettings;
 																table.data('ams-fixedcolumns', data.amsDatatableFixedcolumnsConstructor === undefined ?
-																							new $.fn.dataTable.FixedColumns(table, fc_settings)
+																							new $.fn.dataTable.FixedColumns(table, fcSettings)
-																							: ams.executeFunctionByName(data.amsDatatableFixedcolumnsConstructor, table, plugin, fc_settings));
+																							: ams.executeFunctionByName(data.amsDatatableFixedcolumnsConstructor, table, plugin, fcSettings));
 																break;
 															case 'fixedheader':
-																var fh_settings = $.extend({}, data.amsDatatableFixedheaderOptions, settings.fixedheader);
+																var fhSettings = $.extend({}, data.amsDatatableFixedheaderOptions, settings.fixedheader);
-																fh_settings = ams.executeFunctionByName(data.amsDatatableFixedheadeInitCallback, table, fh_settings) || fh_settings;
+																fhSettings = ams.executeFunctionByName(data.amsDatatableFixedheadeInitCallback, table, fhSettings) || fhSettings;
 																table.data('ams-fixedheader', data.amsDatatableFixedheaderConstructor === undefined ?
-																							new $.fn.dataTable.FixedHeader(table, fh_settings)
+																							new $.fn.dataTable.FixedHeader(table, fhSettings)
-																							: ams.executeFunctionByName(data.amsDatatableFixedheaderConstructor, table, plugin, fh_settings));
+																							: ams.executeFunctionByName(data.amsDatatableFixedheaderConstructor, table, plugin, fhSettings));
 																break;
 															case 'keytable':
-																var kt_default = {
+																var ktDefault = {
 																	table: table.get(0),
 																	datatable: plugin
 																};
-																var kt_settings = $.extend({}, kt_default, data.amsDatatableKeytableOptions, settings.keytable);
+																var ktSettings = $.extend({}, ktDefault, data.amsDatatableKeytableOptions, settings.keytable);
-																kt_settings = ams.executeFunctionByName(data.amsDatatableKeytableInitCallback, table, kt_settings) || kt_settings;
+																ktSettings = ams.executeFunctionByName(data.amsDatatableKeytableInitCallback, table, ktSettings) || ktSettings;
 																table.data('ams-keytable', data.amsDatatableKeytableConstructor === undefined ?
-																							new KeyTable(kt_settings)
+																							new KeyTable(ktSettings)
-																							: ams.executeFunctionByName(data.amsDatatableKeytableConstructor, table, plugin, kt_settings));
+																							: ams.executeFunctionByName(data.amsDatatableKeytableConstructor, table, plugin, ktSettings));
 																break;
 															case 'rowgrouping':
-																var rg_settings = $.extend({}, data.amsDatatableRowgroupingOptions, settings.rowgrouping);
+																var rgSettings = $.extend({}, data.amsDatatableRowgroupingOptions, settings.rowgrouping);
-																rg_settings = ams.executeFunctionByName(data.amsDatatableRowgroupingInitCallback, table, rg_settings) || rg_settings;
+																rgSettings = ams.executeFunctionByName(data.amsDatatableRowgroupingInitCallback, table, rgSettings) || rgSettings;
 																table.data('ams-rowgrouping', data.amsDatatableRowgroupingConstructor === undefined ?
-																							table.rowGrouping(rg_settings)
+																							table.rowGrouping(rgSettings)
-																							: ams.executeFunctionByName(data.amsDatatableRowgroupingConstructor, table, plugin, rg_settings));
+																							: ams.executeFunctionByName(data.amsDatatableRowgroupingConstructor, table, plugin, rgSettings));
 																break;
 															case 'rowreordering':
-																var rr_settings = $.extend({}, data.amsDatatableRowreorderingOptions, settings.rowreordering);
+																var rrSettings = $.extend({}, data.amsDatatableRowreorderingOptions, settings.rowreordering);
-																rr_settings = ams.executeFunctionByName(data.amsDatatableRowreorderingInitCallback, table, rr_settings) || rr_settings;
+																rrSettings = ams.executeFunctionByName(data.amsDatatableRowreorderingInitCallback, table, rrSettings) || rrSettings;
 																table.data('ams-rowreordering', data.amsDatatableRowreorderingConstructor === undefined ?
-																							table.rowReordering(rr_settings)
+																							table.rowReordering(rrSettings)
-																							: ams.executeFunctionByName(data.amsDatatableRowreorderingConstructor, table, plugin, rr_settings));
+																							: ams.executeFunctionByName(data.amsDatatableRowreorderingConstructor, table, plugin, rrSettings));
 																break;
 															default:
 																break;
 														}
 													}
 													$(this.cells[0]).addClass('drag-handle');
 												}).on('mouseout', 'tr', function () {
 													$(this.cells[0]).removeClass('drag-handle');
 												});
 											}
-											var data_options = {
+											var dataOptions = {
 												onDragClass: data.amsTabledndDragClass || 'dragging-row',
 												onDragStart: ams.getFunctionByName(data.amsTabledndDragStart),
 												dragHandle: data.amsTabledndDragHandle,
 												scrollAmount: data.amsTabledndScrollAmount,
 												onAllowDrop: data.amsTabledndAllowDrop,
 													if (target) {
 														// Disable row click handler
 														$(row).data('ams-disabled-handlers', 'click');
 														var rows = [];
 														$(dnd_table.rows).each(function() {
-															var row_id = $(this).data('ams-element-name');
+															var rowId = $(this).data('ams-element-name');
-															if (row_id) {
+															if (rowId) {
-																rows.push(row_id);
+																rows.push(rowId);
 															}
 														});
-														var local_target = ams.getFunctionByName(target);
+														var localTarget = ams.getFunctionByName(target);
-														if (typeof(local_target) === 'function') {
+														if (typeof(localTarget) === 'function') {
-															local_target.call(table, dnd_table, rows);
+															localTarget.call(table, dnd_table, rows);
 														} else {
 															ams.ajax.post(target, {names: JSON.stringify(rows)});
 														}
 														// Restore row click handler
 														setTimeout(function() {
 														}, 50);
 													}
 													return false;
 												}
 											};
-											var settings = $.extend({}, data_options, data.amsTabledndOptions);
+											var settings = $.extend({}, dataOptions, data.amsTabledndOptions);
 											settings = ams.executeFunctionByName(data.amsTabledndInitCallback, table, settings) || settings;
 											var plugin = table.tableDnD(settings);
 											ams.executeFunctionByName(data.amsTabledndAfterInitCallback, table, plugin, settings);
 										});
 								   });
 									   }
 									   images.each(function() {
 										   var image = $(this);
 										   var data = image.data();
 										   var parent = data.amsImgareaselectParent ? image.parents(data.amsImgareaselectParent) : 'body';
-										   var data_options = {
+										   var dataOptions = {
 											   instance: true,
 											   handles: true,
 											   parent: parent,
 											   x1: data.amsImgareaselectX1 || 0,
 											   y1: data.amsImgareaselectY1 || 0,
 												   $('input[name="' + target + 'y1"]', parent).val(selection.y1);
 												   $('input[name="' + target + 'x2"]', parent).val(selection.x2);
 												   $('input[name="' + target + 'y2"]', parent).val(selection.y2);
 											   }
 										   };
-										   var settings = $.extend({}, data_options, data.amsImgareaselectOptions);
+										   var settings = $.extend({}, dataOptions, data.amsImgareaselectOptions);
 										   settings = ams.executeFunctionByName(data.amsImgareaselectInitCallback, image, settings) || settings;
 										   var plugin = image.imgAreaSelect(settings);
 										   ams.executeFunctionByName(data.amsImgareaselectAfterInitCallback, image, plugin, settings);
 										   // Add update timeout when plug-in is displayed into a modal dialog
 										   setTimeout(function() {
 														default:
 															break;
 													}
 												}
 											}
-											var data_options = {
+											var dataOptions = {
 												type: data.amsFancyboxType,
 												padding: data.amsFancyboxPadding || 10,
 												margin: data.amsFancyboxMargin || 10,
 												beforeLoad: ams.getFunctionByName(data.amsFancyboxBeforeLoad) || function() {
 													this.title = ams.executeFunctionByName(data.amsFancyboxTitleGetter, this) || $(this.element).attr('original-title') || $(this.element).attr('title');
 													title: {
 														type: 'inside'
 													}
 												}
 											};
-											var settings = $.extend({}, data_options, data.amsFancyboxOptions);
+											var settings = $.extend({}, dataOptions, data.amsFancyboxOptions);
 											settings = ams.executeFunctionByName(data.amsFancyboxInitCallback, fancybox, settings) || settings;
 											var plugin = fancybox.fancybox(settings);
 											ams.executeFunctionByName(data.amsFancyboxAfterInitCallback, fancybox, plugin, settings);
 										});
 								   });
 																		   'jquery-mCustomScrollbar');
 															}
 															scrollbars.each(function() {
 																var scrollbar = $(this);
 																var data = scrollbar.data();
-																var data_options = {
+																var dataOptions = {
 																	theme: data.amsScrollbarTheme || 'light'
 																};
-																var settings = $.extend({}, data_options, data.amsScrollbarOptions);
+																var settings = $.extend({}, dataOptions, data.amsScrollbarOptions);
 																settings = ams.executeFunctionByName(data.amsScrollbarInitCallback, scrollbar, settings) || settings;
 																var plugin = scrollbar.mCustomScrollbar(settings);
 																ams.executeFunctionByName(data.amsScrollbarAfterInitCallback, scrollbar, plugin, settings);
 															});
 													   });
 		 *   of milliseconds
 		 * - data-ams-messagebox-callback: a callback's name, which will be called when message box is closed
 		 */
 		messageBox: function(options) {
 			var data = $(this).data();
-			var data_options = $.extend({}, options, data.amsMessageboxOptions);
+			var dataOptions = $.extend({}, options, data.amsMessageboxOptions);
-			var settings = $.extend({}, data_options, {
+			var settings = $.extend({}, dataOptions, {
-				title: data.amsMessageboxTitle || data_options.title || '',
+				title: data.amsMessageboxTitle || dataOptions.title || '',
-				content: data.amsMessageboxContent || data_options.content || '',
+				content: data.amsMessageboxContent || dataOptions.content || '',
-				icon: data.amsMessageboxIcon || data_options.icon,
+				icon: data.amsMessageboxIcon || dataOptions.icon,
-				number: data.amsMessageboxNumber || data_options.number,
+				number: data.amsMessageboxNumber || dataOptions.number,
-				timeout: data.amsMessageboxTimeout || data_options.timeout
+				timeout: data.amsMessageboxTimeout || dataOptions.timeout
 			});
-			var status = data.amsMessageboxStatus || data_options.status || 'info';
+			var status = data.amsMessageboxStatus || dataOptions.status || 'info';
-			var callback = ams.getFunctionByName(data.amsMessageboxCallback || data_options.callback);
+			var callback = ams.getFunctionByName(data.amsMessageboxCallback || dataOptions.callback);
 			ams.skin.messageBox(status, settings, callback);
 		},
 		/**
 		 * Standard small box callback
 		 *   of milliseconds
 		 * - data-ams-smallbox-callback: a callback's name, which will be called when message box is closed
 		 */
 		smallBox: function(options) {
 			var data = $(this).data();
-			var data_options = $.extend({}, options, data.amsSmallboxOptions);
+			var dataOptions = $.extend({}, options, data.amsSmallboxOptions);
-			var settings = $.extend({}, data_options, {
+			var settings = $.extend({}, dataOptions, {
-				title: data.amsSmallboxTitle || data_options.title || '',
+				title: data.amsSmallboxTitle || dataOptions.title || '',
-				content: data.amsSmallboxContent || data_options.content || '',
+				content: data.amsSmallboxContent || dataOptions.content || '',
-				icon: data.amsSmallboxIcon || data_options.icon,
+				icon: data.amsSmallboxIcon || dataOptions.icon,
-				iconSmall: data.amsSmallboxIconSmall || data_options.iconSmall,
+				iconSmall: data.amsSmallboxIconSmall || dataOptions.iconSmall,
-				timeout: data.amsSmallboxTimeout || data_options.timeout
+				timeout: data.amsSmallboxTimeout || dataOptions.timeout
 			});
-			var status = data.amsSmallboxStatus || data_options.status || 'info';
+			var status = data.amsSmallboxStatus || dataOptions.status || 'info';
-			var callback = ams.getFunctionByName(data.amsSmallboxCallback || data_options.callback);
+			var callback = ams.getFunctionByName(data.amsSmallboxCallback || dataOptions.callback);
 			ams.skin.smallBox(status, settings, callback);
 		}
 	};
 				}, function(button) {
 					if (button === ams.i18n.BTN_OK) {
 						var table = link.parents('table');
 						var location = table.data('ams-location') || '';
 						var tr = link.parents('tr');
-						var delete_target = tr.data('ams-delete-target') || table.data('ams-delete-target') || 'delete-element.json';
+						var deleteTarget = tr.data('ams-delete-target') || table.data('ams-delete-target') || 'delete-element.json';
-						var object_name = tr.data('ams-element-name');
+						var objectName = tr.data('ams-element-name');
-						MyAMS.ajax.post(location + '/' + delete_target, {'object_name': object_name}, function(result, status) {
+						MyAMS.ajax.post(location + '/' + deleteTarget, {'object_name': objectName}, function(result, status) {
 							if (result.status === 'success') {
 								if (table.hasClass('datatable')) {
 									table.dataTable().fnDeleteRow(tr[0]);
 								} else {
 									tr.remove();
 		/**
 		 * Compute navigation page height
 		 */
 		_setPageHeight: function() {
-			var main_height = $('#main').height();
+			var mainHeight = $('#main').height();
-			var menu_height = ams.left_panel.height();
+			var menuHeight = ams.leftPanel.height();
-			var window_height = $(window).height() - ams.navbar_height;
+			var windowHeight = $(window).height() - ams.navbarHeight;
-			if (main_height > window_height) {
+			if (mainHeight > windowHeight) {
-				ams.left_panel.css('min-height', main_height);
+				ams.leftPanel.css('min-height', mainHeight);
-				ams.root.css('min-height', main_height + ams.navbar_height);
+				ams.root.css('min-height', mainHeight + ams.navbarHeight);
 			} else {
-				ams.left_panel.css('min-height', window_height);
+				ams.leftPanel.css('min-height', windowHeight);
-				ams.root.css('min-height', window_height);
+				ams.root.css('min-height', windowHeight);
 			}
 		},
 		/**
 		 * Check width for mobile devices
 		/**
 		 * Initialize desktop and mobile widgets
 		 */
 		_initDesktopWidgets: function(element) {
-			if (ams.enable_widgets) {
+			if (ams.enableWidgets) {
 				var widgets = $('.ams-widget', element);
 				if (widgets.length > 0) {
 					ams.ajax.check($.fn.MyAMSWidget,
 								   ams.baseURL + 'myams-widgets' + ams.devext + '.js',
 								   function () {
 									   widgets.each(function () {
 										   var widget = $(this);
 										   var data = widget.data();
-										   var data_options = {
+										   var dataOptions = {
 											   deleteSettingsKey: '#deletesettingskey-options',
 											   deletePositionKey: '#deletepositionkey-options'
 										   };
-										   var settings = $.extend({}, data_options, data.amsWidgetOptions);
+										   var settings = $.extend({}, dataOptions, data.amsWidgetOptions);
 										   settings = ams.executeFunctionByName(data.amsWidgetInitcallback, widget, settings) || settings;
 										   widget.MyAMSWidget(settings);
 									   });
 									   globals.MyAMSWidget.initWidgetsGrid($('.ams-widget-grid', element));
 								   });
 				}
 			}
 		},
 		_initMobileWidgets: function(element) {
-			if (ams.enable_mobile && ams.enable_widgets) {
+			if (ams.enableMobile && ams.enableWidgets) {
 				ams.skin._initDesktopWidgets(element);
 			}
 		},
 		/**
 				document.title = (prefix ? prefix + ' > ' : '') +
 								 ($('[data-ams-page-title]:first', container).data('ams-page-title') ||
 								  menu.attr('title') ||
 								  document.title);
 			} else {
-				var active_url = $('[data-ams-active-menu]').data('ams-active-menu');
+				var activeUrl = $('[data-ams-active-menu]').data('ams-active-menu');
-				if (active_url) {
+				if (activeUrl) {
-					menu = $('A[href="' + active_url + '"]', nav);
+					menu = $('A[href="' + activeUrl + '"]', nav);
 				} else {
 					menu = $('>UL >LI >A[href!="#"]', nav).first();
 				}
 				if (menu.exists()) {
 					updateActiveMenus(menu);
-					if (active_url) {
+					if (activeUrl) {
 						ams.skin._drawBreadCrumb();
 					} else {
 						window.location.hash = menu.attr('href');
 					}
 				}
 				},
 				success: function(data, status, request) {
 					if (callback) {
 						ams.executeFunctionByName(callback, this, data, status, request, options);
 					} else {
-						var request_data = ams.ajax.getResponse(request);
+						var response = ams.ajax.getResponse(request);
-						var data_type = request_data.content_type;
+						var dataType = response.contentType;
-						var result = request_data.data;
+						var result = response.data;
 						$('.loading', container).remove();
-						switch (data_type) {
+						switch (dataType) {
 							case 'json':
 								ams.ajax.handleJSON(result, container);
 								break;
 							case 'script':
 								break;
 		/**
 		 * Change user language
 		 */
 		setLanguage: function(options) {
 			var lang = options.lang;
-			var handler_type = options.handler_type || 'json';
+			var handlerType = options.handler_type || 'json';
-			switch (handler_type) {
+			switch (handlerType) {
 				case 'json':
 					var method = options.method || 'setUserLanguage';
 					ams.jsonrpc.post(method, {lang: lang}, function() {
 						window.location.reload(true);
 					});
 		var body = $('body');
 		/* Init main components */
 		ams.root = body;
-		ams.left_panel = $('#left-panel');
+		ams.leftPanel = $('#left-panel');
 		ams.shortcuts = $('#shortcut');
 		ams.plugins.initData(body);
 		// Init main AJAX events
-		var jquery_xhr = $.ajaxSettings.xhr;
+		var xhr = $.ajaxSettings.xhr;
 		$.ajaxSetup({
 			progress: ams.ajax.progress,
 			progressUpload: ams.ajax.progress,
 			xhr: function() {
-				var request = jquery_xhr();
+				var request = xhr();
 				if (request && (typeof(request.addEventListener) === "function")) {
 					var that = this;
 					request.addEventListener("progress", function(evt) {
 						that.progress(evt);
 					}, false);
 			ams.root.addClass('desktop-detected');
 			ams.device = 'desktop';
 		} else {
 			ams.root.addClass('mobile-detected');
 			ams.device = 'mobile';
-			if (ams.enable_fastclick) {
+			if (ams.enableFastclick) {
 				ams.ajax.check($.fn.noClickDelay,
 							   ams.baseURL + '/ext/jquery-smartclick' + ams.devext + '.js',
 							   function() {
 								   $('NAV UL A').noClickDelay();
 								   $('A', '#hide-menu').noClickDelay();
 		$('input[name="activity"]').change(function(e) {
 			var href = $(this).data('ams-url');
 			if (href) {
 				e.preventDefault();
 				e.stopPropagation();
-				var href_getter = ams.getFunctionByName(href);
+				var hrefGetter = ams.getFunctionByName(href);
-				if (typeof(href_getter) === 'function') {
+				if (typeof(hrefGetter) === 'function') {
-					href = href_getter.call(this);
+					href = hrefGetter.call(this);
 				}
 				if (typeof(href) === 'function') {
 					// Javascript function call
 					href.call(this);
 				} else {
 		// Initialize left nav
 		var nav = $('nav');
 		$('UL', nav).myams_menu({
 			accordion : nav.data('ams-menu-accordion') !== false,
-			speed : ams.menu_speed
+			speed : ams.menuSpeed
 		});
 		// Left navigation collapser
 		$('.minifyme').click(function(e) {
 			$('BODY').toggleClass("minified");
 							   ams.skin._setPageHeight();
 						   });
 					   });
 		// Init AJAX navigation
-		if (ams.ajax_nav) {
+		if (ams.ajaxNav) {
 			$(document).on('click', 'a[href="#"]', function(e) {
 				e.preventDefault();
 			});
 			$(document).on('click', 'a[href!="#"]:not([data-toggle]), [data-ams-url]:not([data-toggle])', function(e) {
 				var link = $(e.currentTarget);
 				if (!href || href.startsWith('javascript') || link.attr('target') || (link.data('ams-context-menu') === true)) {
 					return;
 				}
 				e.preventDefault();
 				e.stopPropagation();
-				var href_getter = ams.getFunctionByName(href);
+				var hrefGetter = ams.getFunctionByName(href);
-				if (typeof(href_getter) === 'function') {
+				if (typeof(hrefGetter) === 'function') {
-					href = href_getter.call(link);
+					href = hrefGetter.call(link);
 				}
 				if (typeof(href) === 'function') {
 					// Javascript function call
 					href.call(link);
 				} else {
 			});
 		});
 		// Init page content
 		ams.initContent(document);
-		if (ams.ajax_nav && nav.exists()) {
+		if (ams.ajaxNav && nav.exists()) {
 			ams.skin.checkURL();
 		}
 		ams.form.setFocus(document);
 		// Add unload event listener to check for modified forms

ztfy/ztfy.myams