PHP Classes
elePHPant
Icontem

File: FrontEndScripts/libs/angular-bootstrap-switch.js

Recommend this page to a friend!
  Classes of Aleksey Nemiro  >  PHP Small Server Administrator  >  FrontEndScripts/libs/angular-bootstrap-switch.js  >  Download  
File: FrontEndScripts/libs/angular-bootstrap-switch.js
Role: Auxiliary data
Content type: text/plain
Description: Auxiliary data
Class: PHP Small Server Administrator
Web panel for small Debian and Ubuntu servers
Author: By
Last change:
Date: 3 years ago
Size: 9,561 bytes
 

 

Contents

Class file image Download
/**
 * angular-bootstrap-switch
 * @version v0.5.0 - 2016-03-10
 * @author Francesco Pontillo (francescopontillo@gmail.com)
 * @link https://github.com/frapontillo/angular-bootstrap-switch
 * @license Apache License 2.0(http://www.apache.org/licenses/LICENSE-2.0.html)
**/

(function () {
	'use strict';

	// Source: common/module.js
	angular.module('frapontillo.bootstrap-switch', []);

	// Source: dist/.temp/directives/bsSwitch.js
	angular.module('frapontillo.bootstrap-switch')
		.directive('bsSwitch', ["$parse", "$timeout", function ($parse, $timeout) {
			return {
				restrict: 'A',
				require: 'ngModel',
				link: function link(scope, element, attrs, controller) {
					var isInit = false;

					/**
					 * Return the true value for this specific checkbox.
					 * @returns {Object} representing the true view value; if undefined, returns true.
					 */
					var getTrueValue = function () {
						if (attrs.type === 'radio') {
							return attrs.value || $parse(attrs.ngValue)(scope) || true;
						}
						var trueValue = ($parse(attrs.ngTrueValue)(scope));
						if (angular.isUndefined(trueValue)) {
							trueValue = true;
						}
						return trueValue;
					};

					/**
					 * Get a boolean value from a boolean-like string, evaluating it on the current scope.
					 * @param value The input object
					 * @returns {boolean} A boolean value
					 */
					var getBooleanFromString = function (value) {
						return scope.$eval(value) === true;
					};

					/**
					 * Get a boolean value from a boolean-like string, defaulting to true if undefined.
					 * @param value The input object
					 * @returns {boolean} A boolean value
					 */
					var getBooleanFromStringDefTrue = function (value) {
						return (value === true || value === 'true' || !value);
					};

					/**
					 * Returns the value if it is truthy, or undefined.
					 *
					 * @param value The value to check.
					 * @returns the original value if it is truthy, {@link undefined} otherwise.
					 */
					var getValueOrUndefined = function (value) {
						return (value ? value : undefined);
					};

					/**
					 * Returns a function that executes the provided expression
					 *
					 * @param value The string expression
					 * @return a function that evaluates the expression
					 */
					var getExprFromString = function (value) {
						if (angular.isUndefined(value)) {
							return angular.noop;
						}
						return function () {
							scope.$evalAsync(value);
						};
					};

					/**
					 * Get the value of the angular-bound attribute, given its name.
					 * The returned value may or may not equal the attribute value, as it may be transformed by a function.
					 *
					 * @param attrName  The angular-bound attribute name to get the value for
					 * @returns {*}     The attribute value
					 */
					var getSwitchAttrValue = function (attrName) {
						var map = {
							'switchRadioOff': getBooleanFromStringDefTrue,
							'switchActive': function (value) {
								return !getBooleanFromStringDefTrue(value);
							},
							'switchAnimate': getBooleanFromStringDefTrue,
							'switchLabel': function (value) {
								return value ? value : ' ';
							},
							'switchIcon': function (value) {
								if (value) {
									return '<span class=\'' + value + '\'></span>';
								}
							},
							'switchWrapper': function (value) {
								return value || 'wrapper';
							},
							'switchInverse': getBooleanFromString,
							'switchReadonly': getBooleanFromString,
							'switchChange': getExprFromString
						};
						var transFn = map[attrName] || getValueOrUndefined;
						return transFn(attrs[attrName]);
					};

					/**
					 * Set a bootstrapSwitch parameter according to the angular-bound attribute.
					 * The parameter will be changed only if the switch has already been initialized
					 * (to avoid creating it before the model is ready).
					 *
					 * @param element   The switch to apply the parameter modification to
					 * @param attr      The name of the switch parameter
					 * @param modelAttr The name of the angular-bound parameter
					 */
					var setSwitchParamMaybe = function (element, attr, modelAttr) {
						if (!isInit) {
							return;
						}
						var newValue = getSwitchAttrValue(modelAttr);
						element.bootstrapSwitch(attr, newValue);
					};

					var setActive = function () {
						setSwitchParamMaybe(element, 'disabled', 'switchActive');
					};

					/**
					 * If the directive has not been initialized yet, do so.
					 */
					var initMaybe = function () {
						// if it's the first initialization
						if (!isInit) {
							var viewValue = (controller.$modelValue === getTrueValue());
							isInit = !isInit;
							// Bootstrap the switch plugin
							element.bootstrapSwitch({
								radioAllOff: getSwitchAttrValue('switchRadioOff'),
								disabled: getSwitchAttrValue('switchActive'),
								state: viewValue,
								onText: getSwitchAttrValue('switchOnText'),
								offText: getSwitchAttrValue('switchOffText'),
								onColor: getSwitchAttrValue('switchOnColor'),
								offColor: getSwitchAttrValue('switchOffColor'),
								animate: getSwitchAttrValue('switchAnimate'),
								size: getSwitchAttrValue('switchSize'),
								labelText: attrs.switchLabel ? getSwitchAttrValue('switchLabel') : getSwitchAttrValue('switchIcon'),
								wrapperClass: getSwitchAttrValue('switchWrapper'),
								handleWidth: getSwitchAttrValue('switchHandleWidth'),
								labelWidth: getSwitchAttrValue('switchLabelWidth'),
								inverse: getSwitchAttrValue('switchInverse'),
								readonly: getSwitchAttrValue('switchReadonly')
							});
							if (attrs.type === 'radio') {
								controller.$setViewValue(controller.$modelValue);
							} else {
								controller.$setViewValue(viewValue);
							}
						}
					};

					/**
					 * Listen to model changes.
					 */
					var listenToModel = function () {

						attrs.$observe('switchActive', function (newValue) {
							var active = getBooleanFromStringDefTrue(newValue);
							// if we are disabling the switch, delay the deactivation so that the toggle can be switched
							if (!active) {
								$timeout(function () {
									setActive(active);
								});
							} else {
								// if we are enabling the switch, set active right away
								setActive(active);
							}
						});

						function modelValue() {
							return controller.$modelValue;
						}

						// When the model changes
						scope.$watch(modelValue, function (newValue) {
							initMaybe();
							if (newValue !== undefined && newValue !== null) {
								element.bootstrapSwitch('state', newValue === getTrueValue(), false);
							} else {
								element.bootstrapSwitch('toggleIndeterminate', true, false);
							}
						}, true);

						// angular attribute to switch property bindings
						var bindings = {
							'switchRadioOff': 'radioAllOff',
							'switchOnText': 'onText',
							'switchOffText': 'offText',
							'switchOnColor': 'onColor',
							'switchOffColor': 'offColor',
							'switchAnimate': 'animate',
							'switchSize': 'size',
							'switchLabel': 'labelText',
							'switchIcon': 'labelText',
							'switchWrapper': 'wrapperClass',
							'switchHandleWidth': 'handleWidth',
							'switchLabelWidth': 'labelWidth',
							'switchInverse': 'inverse',
							'switchReadonly': 'readonly'
						};

						var observeProp = function (prop, bindings) {
							return function () {
								attrs.$observe(prop, function () {
									setSwitchParamMaybe(element, bindings[prop], prop);
								});
							};
						};

						// for every angular-bound attribute, observe it and trigger the appropriate switch function
						for (var prop in bindings) {
							attrs.$observe(prop, observeProp(prop, bindings));
						}
					};

					/**
					 * Listen to view changes.
					 */
					var listenToView = function () {

						var switchChangeFn = getSwitchAttrValue('switchChange');

						if (attrs.type === 'radio') {
							// when the switch is clicked
							element.on('change.bootstrapSwitch', function (e) {
								// discard not real change events
								if ((controller.$modelValue === controller.$viewValue) && (e.target.checked !== $(e.target).bootstrapSwitch('state'))) {
									// $setViewValue --> $viewValue --> $parsers --> $modelValue
									// if the switch is indeed selected
									if (e.target.checked) {
										// set its value into the view
										controller.$setViewValue(getTrueValue());
									} else if (getTrueValue() === controller.$viewValue) {
										// otherwise if it's been deselected, delete the view value
										controller.$setViewValue(undefined);
									}
									switchChangeFn();
								}
							});
						} else {
							// When the checkbox switch is clicked, set its value into the ngModel
							element.on('switchChange.bootstrapSwitch', function (e) {
								// $setViewValue --> $viewValue --> $parsers --> $modelValue
								controller.$setViewValue(e.target.checked);
								switchChangeFn();
							});
						}
					};

					// Listen and respond to view changes
					listenToView();

					// Listen and respond to model changes
					listenToModel();

					// On destroy, collect ya garbage
					scope.$on('$destroy', function () {
						element.bootstrapSwitch('destroy');
					});
				}
			};
		}])
		.directive('bsSwitch', function () {
			return {
				restrict: 'E',
				require: 'ngModel',
				template: '<input bs-switch>',
				replace: true
			};
		});

	// Source: bsSwitch.suffix
})();