praiadeseselle/wire/modules/Inputfield/InputfieldToggle/InputfieldToggle.module

<?php namespace ProcessWire;

/**
 * Toggle Inputfield
 * 
 * An Inputfield for handling an on/off toggle that maintains a boolean value (or null when no selection).
 * This provides an alternative to a single checkbox field. 
 * 
 * ProcessWire 3.x, Copyright 2020 by Ryan Cramer
 * https://processwire.com
 * 
 * API usage example
 * ~~~~~~
 * // Default behavior displays toggle of "Yes" and "No":
 * $f = $modules->get('InputfieldToggle');
 * $f->attr('name', 'test_toggle_field');
 * $f->label = 'Do you like toggle fields?';
 * 
 * // Optionally make it show "On" and "Off" (rather than "Yes" and "No"):
 * $f->labelType = InputfieldToggle::labelTypeOn;
 * 
 * // Optionally set custom labels:
 * $f->labelType = InputfieldToggle::labelTypeCustom;
 * $f->yesLabel = 'Yes please';
 * $f->noLabel = 'No thanks';
 *
 * // Optionally add an "other" option with label "Not sure":
 * $f->useOther = true;
 * $f->otherLabel = 'Not sure';
 * 
 * // Set the value: 0=No, 1=Yes, 2=Other, or blank string '' for no selection (Unknown)
 * $f->val(1); 
 * 
 * // Optionally set to use radio buttons rather than toggle buttons:
 * $f->inputfieldClass = 'InputfieldRadios';
 * 
 * // Remember to add to your InputfieldForm, InputfieldWrapper or InputfieldFieldset:
 * $form->add($f); 
 * echo $form->render();
 * ~~~~~~
 *
 * @property int|string $value Integer value when selection is made or blank string when no selection (0=No, 1=Yes, 2=Other, ''=Unknown)
 * @property int $labelType Label type to use, see the labelType constants (default=labelTypeYes)
 * @property int $valueType Type of value for methods that ask for it (use one of the valueType constants)
 * @property string $yesLabel Custom yes/on label
 * @property string $noLabel Custom no/off label 
 * @property string $otherLabel Custom label for optional other value Label to use for "other" option
 * @property int|bool $useReverse Reverse the order of the Yes/No options? (default=false)
 * @property int|bool $useOther Use the "other" option? (default=false)
 * @property bool|int $useVertical Use vertically oriented radio buttons? Applies only if $inputfieldClass is 'InputfieldRadios' (default=false)
 * @property bool|int $useDeselect Allow radios or toggles to be de-selected, enabling possibility of no-selection? (default=false)
 * @property string $defaultOption Default selected value of 'no', 'yes', 'other' or 'none' (default='none')
 * @property string $inputfieldClass Inputfield class to use or blank for this toggle buttons (default='')
 * 
 * @method InputfieldSelect|InputfieldRadios getInputfield()
 *
 */
class InputfieldToggle extends Inputfield {

	public static function getModuleInfo() {
		return array(
			'title' => __('Toggle', __FILE__),
			'summary' => __('A toggle providing similar input capability to a checkbox but much more configurable.', __FILE__),
			'version' => 1,
		);
	}

	// label type constants
	const labelTypeYes = 0;
	const labelTypeTrue = 1;
	const labelTypeOn = 2;
	const labelTypeEnabled = 3;
	const labelTypeCustom = 100;

	// value constants
	const valueNo = 0;
	const valueYes = 1; 
	const valueOther = 2;
	const valueUnknown = '';

	/**
	 * Array of all label types
	 * 
	 * @var array
	 * 
	 */
	protected $labelTypes = array(
		'yes' => self::labelTypeYes,
		'true' => self::labelTypeOn,
		'on' => self::labelTypeTrue,
		'enabled' => self::labelTypeEnabled,
		'custom' => self::labelTypeCustom,
	);
	
	/**
	 * Array of all value types
	 *
	 * @var array
	 *
	 */
	protected $valueTypes = array(
		'no' => self::valueNo,
		'yes' => self::valueYes,
		'other' => self::valueOther,
		'unknown' => self::valueUnknown
	);

	/**
	 * Deleted Inputfield object for rendering (InputfieldRadios, InputfieldSelect, etc.)
	 * 
	 * @var InputfieldSelect|InputfieldRadios Or any that extends them and does not have array value
	 * 
	 */
	protected $inputfield = null;

	/**
	 * Cached result of a getAllLabels() call
	 * 
	 * @var array
	 * 
	 */
	protected $allLabels = array();

	/**
	 * Manually added custom options of [ value => label ]
	 * 
	 * @var array
	 * 
	 */
	protected $customOptions = array();

	/**
	 * Construct and set default settings
	 *
	 */
	public function __construct() {
		
		$this->set('labelType', self::labelTypeYes);
		$this->set('yesLabel', '✓');
		$this->set('noLabel', '✗');
		$this->set('otherLabel', $this->_('?'));
		$this->set('useOther', 0);
		$this->set('useReverse', 0);
		$this->set('useVertical', 0); 
		$this->set('useDeselect', 0); 
		$this->set('defaultOption', 'none');
		$this->set('inputfieldClass', '0');
	
		$this->set('settings', array(
			'inputCheckedClass' => '', 
			'labelCheckedClass' => '',
		));

		$this->attr('value', self::valueUnknown);

		parent::__construct();
	}
	
	public function wired() {
		$languages = $this->wire('languages');
		if($languages) {
			foreach($languages as $language) {
				if($language->isDefault()) continue;
				$this->set("yesLabel$language", '');
				$this->set("noLabel$language", '');
				$this->set("otherLabel$language", '');
			}
		}
		parent::wired();
	}
	
	/**
	 * Is the current value empty? (i.e. no selection)
	 * 
	 * @return bool
	 * 
	 */
	public function isEmpty() {
		$value = $this->val();
		if($value === self::valueUnknown) return true;
		if(is_int($value)) {
			if($this->hasCustomOptions()) {
				if(isset($this->customOptions[$value])) return false;
			} else {
				if($value > -1) return false;
			}
		} else if($value && $value !== 'unknown' && isset($this->valueTypes[$value])) {
			return false;
		}
		if($value === self::valueOther && $this->useOther) return false;
		return true;
	}

	/**
	 * Sanitize the value to be one ofthe constants: valueYes, valueNo, valueOther, valueUnknown
	 * 
	 * @param string|int $value Value to sanitize
	 * @param bool $getName Get internal name of value rather than value? (default=false)
	 * @return int|string
	 * 
	 */
	public function sanitizeValue($value, $getName = false) {
	
		if($value === null) {
			return $getName ? 'unknown' : self::valueUnknown;
		}
		
		if(is_bool($value)) {
			if($getName) return $value ? 'yes' : 'no';
			return $value ? self::valueYes : self::valueNo;
		}
		
		$intValue = strlen("$value") && ctype_digit("$value") ? (int) "$value" : '';
		$strValue = strtolower("$value");
		
		if($this->hasCustomOptions()) { 
			if($intValue !== '') $value = $intValue;
			$value = isset($this->customOptions[$value]) ? $value : self::valueUnknown;
				
		} else if($intValue === self::valueNo || $intValue === self::valueYes) {
			$value = $intValue;
			
		} else if($intValue === self::valueOther) {
			$value = $intValue;

		} else if($strValue === 'yes' || $strValue === 'on' || $strValue === 'true') {
			$value = self::valueYes;
			
		} else if($strValue === 'no' || $strValue === 'off' || $strValue === 'false') {
			$value = self::valueNo;

		} else if($strValue === 'unknown' || $strValue === '') {
			$value = self::valueUnknown;
			
		} else if(is_string($value) && strlen($value)) {
			// attempt to match to a label
			$value = null;
			foreach($this->getAllLabels() as $key => $label) {
				if(strtolower($label) !== $strValue) continue;
				list($labelType, $valueType, $languageName) = explode(':', $key);
				if($labelType || $languageName) {} // ignore
				$value = $this->valueTypes[$valueType]; 
				break;
			}
			if($value === null) $value = self::valueUnknown;
			
		} else {
			$value = self::valueUnknown; // blank string
		}
		
		if($getName && !$this->hasCustomOptions()) {
			if($value === self::valueUnknown) {
				$value = 'unknown';
			} else if($value === self::valueYes) {
				$value = 'yes';
			} else if($value === self::valueNo) {
				$value = 'no';
			} else if($value === self::valueOther) {
				$value = 'other';
			}
		}
		
		return $value;
	}

	/**
	 * Set attribute
	 * 
	 * @param array|string $key
	 * @param array|bool|int|string $value
	 * @return Inputfield
	 * 
	 */
	public function setAttribute($key, $value) {
		if($key === 'value') $value = $this->sanitizeValue($value);
		return parent::setAttribute($key, $value);
	}

	/**
	 * Get the delegated Inputfield that will be used for rendering selectable options
	 * 
	 * @return InputfieldRadios|InputfieldSelect|InputfieldToggle
	 * 
	 */
	public function ___getInputfield() {

		if($this->inputfield) return $this->inputfield;
		
		$class = $this->getSetting('inputfieldClass');
		if(empty($class) || $class === $this->className()) {
			if(false && $this->wire('adminTheme') == 'AdminThemeDefault') {
				// clicking toggles jumps to top of page on AdminThemeDefault for some reason
				// even if JS click events are canceled, so use radios instead
				$class = 'InputfieldRadios'; 
			} else {
				return $this;
			}
		}
		
		$f = $this->wire('modules')->get($class);
		if(!$f || $f === $this) return $this;
		
		$this->addClass($class, 'wrapClass');

		/** @var InputfieldSelect|InputfieldRadios $f */
		$f->attr('name', $this->attr('name'));
		$f->attr('id', $this->attr('id'));
		$f->addClass($this->attr('class'));

		if(!$this->useVertical) {
			$f->set('optionColumns', 1);
		}

		$val = $this->val();
		$options = $this->getOptions();
		$f->addOptions($options);

		if(isset($options[$val]) && method_exists($f, 'addOptionAttributes')) {
			$f->addOptionAttributes($val, array('input.class' => 'InputfieldToggleChecked'));
		}

		$f->val($val);
		
		$this->inputfield = $f;
		
		return $f;
	}

	/**
	 * Render ready
	 * 
	 * @param Inputfield|null $parent
	 * @param bool $renderValueMode
	 * @return bool
	 * 
	 */
	public function renderReady(Inputfield $parent = null, $renderValueMode = false) {
		$f = $this->getInputfield();
		if($f && $f !== $this) $f->renderReady($parent, $renderValueMode);
		if($this->useDeselect && $this->defaultOption === 'none') {
			$this->addClass('InputfieldToggleUseDeselect', 'wrapClass');
		}
		return parent::renderReady($parent, $renderValueMode);
	}

	/**
	 * Render value
	 * 
	 * @return string
	 * 
	 */
	public function ___renderValue() {
		$label = $this->getValueLabel($this->attr('value'));
		$value = $this->formatLabel($label, true); 
		return $value; 
	}

	/**
	 * Render input element(s)
	 *
	 * @return string
	 *
	 */
	public function ___render() {
		
		$value = $this->val();
		$default = $this->getSetting('defaultOption');

		// check if we should assign a default value
		if($default && ("$value" === self::valueUnknown || !strlen("$value"))) {
			if($default === 'yes') {
				$this->val(self::valueYes);
			} else if($default === 'no') {
				$this->val(self::valueNo);
			} else if($default === 'other' && $this->useOther) {
				$this->val(self::valueOther);
			}
		}
		
		$f = $this->getInputfield();

		if($f && $f !== $this) {
			$f->val($this->val());
			$out = $f->render();
		} else {
			$out = $this->renderToggle();
		}

		// hidden input to indicate presence when no selection is made (like with radios)
		
		/** @var InputfieldButton $btn */
		$button = $this->wire('modules')->get('InputfieldButton');
		$button->setSecondary(true);
		$button->val('1');
		$button->removeAttr('name');
		
		$input = $this->wire('modules')->get('InputfieldText');
		$input->attr('name', "_{$this->name}_");
		$input->val(1);
		
		$out .= "<div class='InputfieldToggleHelper'>" . $input->render() . $button->render() . "</div>";

		return $out;
	}
	
	/**
	 * Render default input toggles
	 * 
	 * @return string
	 * 
	 */
	protected function renderToggle() {
		
		$id = $this->attr('id');
		$name = $this->attr('name');
		$checkedValue = $this->val();
		$out = '';
		
		foreach($this->getOptions() as $value => $label) {
			$checked = "$checkedValue" === "$value" ? "checked " : "";
			$inputClass = $checked ? 'InputfieldToggleChecked' : '';
			$labelClass = $checked ? 'InputfieldToggleCurrent' : '';
			$label = $this->formatLabel($label);
			$out .= 
				"<input type='radio' id='{$id}_$value' name='$name' class='$inputClass' value='$value' $checked/>" . 
                "<label for='{$id}_$value' class='$labelClass'><span class='pw-no-select'>$label</span></label>";
		}
	
		return
			"<div class='pw-clearfix ui-helper-clearfix'>" . 
				"<div class='InputfieldToggleGroup'>$out</div>" . 
			"</div>";
	}
	
	/**
	 * Process input
	 *
	 * @param WireInputData $input
	 * @return $this
	 *
	 */
	public function ___processInput(WireInputData $input) {

		$prevValue = $this->val();
		$value = $input[$this->name];
		$intValue = strlen("$value") && ctype_digit("$value") ? (int) $value : null;
		
		if($value === null && $input["_{$this->name}_"] === null) {
			// input was not rendered in the submitted post, so should be ignored

		} else if($this->hasCustomOptions()) {
			// custom options
			if(isset($this->customOptions[$value])) $this->val($value);
			
		} else if($intValue === self::valueYes || $intValue === self::valueNo) {
			// yes or no selected
			$this->val($intValue);

		} else if($intValue === self::valueOther && $this->useOther) {
			// other selected
			$this->val($intValue);

		} else if($value === self::valueUnknown || $value === null) {
			// no selection 
			$this->val(self::valueUnknown); 

		} else {
			// something we don't recognize
		}
		
		if($this->val() !== $prevValue) {
			$this->trackChange('value', $prevValue, $this->val());
		}
		
		return $this;
	}
	
	/**
	 * Get labels for the given label type
	 *
	 * @param int $labelType Specify toggle type constant or omit to use configured toggle type. 
	 * @param Language|int|string|null Language or omit to use current user’s language. (default=null)
	 * @return array Returned array has these indexes: 
	 *  `no` (string): No/Off state label
	 *  `yes` (string): Yes/On state label
	 *  `other` (string): Other state label
	 *  `unknown` (string): No selection label
	 *
	 */
	public function getLabels($labelType = null, $language = null) {
		
		if($labelType === null) $labelType = $this->labelType;

		/** @var Languages $langauges */
		$languages = $this->wire('languages');
		$setLanguage = false;
		$languageId = '';
		$yes = '';
		$no = '';

		if($languages) {
			/** @var User $user */
			$user = $this->wire('user');
			if(empty($language)) {
				// use current user language
				$language = $user->language;
			} else if(is_int($language) || is_string($language)) {
				// get language from specified language ID or name
				$language = $languages->get($language);
			}
			if($language instanceof Page && $language->id != $user->language->id) {
				// use other specified language
				$languages->setLanguage($language);
				$setLanguage = true;
			} else {
				// use current user language
				$language = $user->language;
			}
			$languageId = $language && !$language->isDefault() ? $language->id : '';
		}
		
		switch($labelType) {
			case self::labelTypeTrue:
				$yes = $this->_('True');
				$no = $this->_('False');
				break;
			case self::labelTypeOn:
				$yes = $this->_('On');
				$no = $this->_('Off');
				break;
			case self::labelTypeEnabled:
				$yes = $this->_('Enabled');
				$no = $this->_('Disabled');
				break;
			case self::labelTypeCustom:	
				$yes = $languageId ? $this->get("yesLabel$languageId|yesLabel") : $this->yesLabel;
				$no = $languageId ? $this->get("noLabel$languageId|noLabel") : $this->noLabel;
				break;
		}
	
		// default (labelTypeYes)
		if(!strlen($yes)) $yes = $this->_('Yes');
		if(!strlen($no)) $no = $this->_('No');
	
		// other and unknown labels
		$other = $languageId ? $this->get("otherLabel$languageId|otherLabel") : $this->otherLabel;
		if(empty($other)) $other = $this->_('Other');
		$unknown = $this->_('Unknown');

		if($setLanguage && $languages) $languages->unsetLanguage();
		
		return array(
			'no' => $no, 
			'yes' => $yes, 
			'other' => $other,
			'unknown' => $unknown
		);
	}

	/**
	 * Get all possible labels for all label types and all languages
	 * 
	 * Returned array of labels (strings) indexed by "labelTypeNum:valueTypeName:languageName"
	 * 
	 * @return array
	 * 
	 */
	public function getAllLabels() {
		
		if(!empty($this->allLabels)) return $this->allLabels; 
	
		/** @var Languages|null $languages */
		$languages = $this->wire('languages');
		
		$all = array();
		
		foreach($this->labelTypes as $labelType) {
			if($languages) {
				foreach($languages as $language) {
					foreach($this->getLabels($labelType, $language) as $valueType => $label) {
						$all["$labelType:$valueType:$language->name"] = $label;
					}
				}
			} else {
				foreach($this->getLabels($labelType) as $valueType => $label) {
					$all["$labelType:$valueType:default"] = $label;
				}
			}
		}
		
		return $all;
	}

	/**
	 * Get the label for the currently set (or given) value
	 * 
	 * @param bool|int|string|null $value Optionally provide value or omit to use currently set value attribute.
	 * @param int|null $labelType Specify labelType constant or omit for selected label type. 
	 * @param Language|int|string $language
	 * @return string Label string
	 * 
	 */
	public function getValueLabel($value = null, $labelType = null, $language = null) {
		
		if($value === null) $value = $this->val();
	
		if($this->hasCustomOptions()) {
			// get custom defined option label from addOption() call (API usage only)
			return isset($this->customOptions[$value]) ? $this->customOptions[$value] : self::valueUnknown;
		}
		
		$labels = $this->getLabels($labelType, $language);
		
		if($value === null || $value === self::valueUnknown) return $labels['unknown'];
		if(is_bool($value)) return $value ? $labels['yes'] : $labels['no'];
		
		if($value === self::valueOther) return $labels['other'];
		if($value === self::valueYes) return $labels['yes'];
		if($value === self::valueNo) return $labels['no'];
		
		return $labels['unknown'];
	}

	/**
	 * Format label for HTML output (entity encode, etc.)
	 * 
	 * @param string $label
	 * @param bool $allowIcon Allow icon markup to appear in label?
	 * @return string
	 * 
	 */
	public function formatLabel($label, $allowIcon = true) {
		$label = $this->wire('sanitizer')->entities1($label);
		if(strpos($label, 'icon-') !== false && preg_match('/\bicon-([-_a-z0-9]+)/', $label, $matches)) {
			$name = $matches[1];
			$icon = $allowIcon ? $icon = wireIconMarkup($name, 'fw') : '';
			$label = str_replace("icon-$name", $icon, $label);
		}
		return trim($label);
	}

	/**
	 * Get all selectable options as array of [ value => label ] 
	 * 
	 * @return array
	 * 
	 */
	public function getOptions() {
		// use custom options instead if any have been set from an addOption() call
		if($this->hasCustomOptions()) return $this->customOptions;
		// use built in toggle options
		$options = array();
		$values = $this->useReverse ? array(self::valueNo, self::valueYes) : array(self::valueYes, self::valueNo);
		if($this->useOther) $values[] = self::valueOther;
		foreach($values as $value) {
			$options[$value] = $this->getValueLabel($value);
		}
		return $options;
	}

	/**
	 * Add a selectable option (custom API usage only, overrides built-in options)
	 * 
	 * Note that once you use this, your options take over and Toggle's default yes/no/other 
	 * are no longer applicable. This is for custom API use and is not used by FieldtypeToggle.
	 * 
	 * @param int|string $value 
	 * @param null|string $label
	 * @return $this
	 * @throws WireException if you attempt to call this method when used with FieldtypeToggle
	 * 
	 */
	public function addOption($value, $label = null) {
		if($this->hasFieldtype) {
			throw new WireException('The addOption() method is not available for FieldtypeToggle');
		}
		if($label === null) $label = $value;
		$this->customOptions[$value] = $label;
		return $this;
	}

	/**
	 * Set all options with array of [ value => label ] (custom API usage only, overrides built-in options)
	 * 
	 * Once you use this (with a non-empty array, your set options take over and the 
	 * built-in yes/no/other no longer apply. This is for custom API use and is not used 
	 * by FieldtypeToggle.
	 * 
	 * The value for each option must be an integer value between -128 and 127.
	 * 
	 * @param array $options
	 * @return $this
	 * @throws WireException if you attempt to call this method when used with FieldtypeToggle
	 * 
	 */
	public function setOptions(array $options) {
		$this->customOptions = array();
		foreach($options as $key => $value) {
			$this->addOption($key, $value);
		}
		return $this;
	}

	/**
	 * Are custom options in use?
	 * 
	 * @return bool
	 * 
	 */
	protected function hasCustomOptions() {
		return count($this->customOptions) > 0;
	}

	/**
	 * Return a list of config property names allowed for fieldgroup/template context
	 *
	 * @param Field $field
	 * @return array of Inputfield names
	 * @see Fieldtype::getConfigAllowContext()
	 *
	 */
	public function ___getConfigAllowContext($field) {
		return array_merge(parent::___getConfigAllowContext($field), array(
			'labelType',
			'inputfieldClass',
			'yesLabel',
			'noLabel',
			'otherLabel',
			'useVertical',
			'useDeselect',
			'useOther',
			'useReverse',
			'defaultOption',
		));
	}
	
	/**
	 * Configure Inputfield
	 *
	 * @return InputfieldWrapper
	 *
	 */
	public function ___getConfigInputfields() {
		
		/** @var Modules $modules */
		$modules = $this->wire('modules');
		/** @var Languages $languages */
		$languages = $this->wire('languages');
		$inputfields = parent::___getConfigInputfields();
		
		if($this->hasFieldtype) {
			/** @var InputfieldFieldset $fieldset */
			$fieldset = $modules->get('InputfieldFieldset');
			$fieldset->label = $this->_('Toggle field labels and input settings');
			$fieldset->icon = 'toggle-on';
			$inputfields->prepend($fieldset);
		} else {
			$fieldset = $inputfields;
		}
		
		$removals = array('defaultValue');
		foreach($removals as $name) {
			$f = $inputfields->getChildByName($name);
			if($f) $inputfields->remove($f);
		}

		/** @var InputfieldRadios $f */
		$f = $modules->get('InputfieldRadios');
		$f->attr('name', 'labelType');
		$f->label = $this->_('Label type');
		foreach($this->labelTypes as $labelType) {
			if($labelType == self::labelTypeCustom) {
				$label = $this->_('Custom');
			} else {
				$label = $this->getValueLabel(self::valueYes, $labelType) . '/' . $this->getValueLabel(self::valueNo, $labelType);
			}
			$f->addOption($labelType, $label);
		}
		$f->attr('value', (int) $this->labelType);
		$f->columnWidth = 34;
		$fieldset->add($f);
		
		/** @var InputfieldRadios $f */
		$f = $modules->get('InputfieldRadios');
		$f->attr('name', 'inputfieldClass');
		$f->label = $this->_('Input type');
		$f->addOption('0', $this->_('Toggle buttons'));
		foreach($modules->findByPrefix('Inputfield') as $name) {
			if(!wireInstanceOf($name, 'InputfieldSelect')) continue;
			if(wireInstanceOf($name, 'InputfieldHasArrayValue')) continue;
			$label = str_replace('Inputfield', '', $name);
			$f->addOption($name, $label);
		}
		$f->val($this->getSetting('inputfieldClass'));
		$f->columnWidth = 33;
		$fieldset->add($f);

		/** @var InputfieldRadios $f */
		$f = $modules->get('InputfieldRadios');
		$f->attr('name', 'useVertical');
		$f->label = $this->_('Radios');
		$f->addOption(0, $this->_('Horizontal'));
		$f->addOption(1, $this->_('Vertical'));
		$f->val($this->useVertical ? 1 : 0); 
		$f->columnWidth = 33;
		$f->showIf = 'inputfieldClass=InputfieldRadios';
		$fieldset->add($f);
		
		/** @var InputfieldCheckbox $f */
		$f = $modules->get('InputfieldCheckbox');
		$f->attr('name', 'useOther');
		$f->label = $this->_('Use a 3rd “other” option?');
		if($this->useOther) $f->attr('checked', 'checked');
		$f->columnWidth = 34;
		$fieldset->add($f);

		/** @var InputfieldCheckbox $f */
		$f = $modules->get('InputfieldCheckbox');
		$f->attr('name', 'useReverse');
		$f->label = $this->_('Reverse order of yes/no options?');
		if($this->useReverse) $f->attr('checked', 'checked');
		$f->columnWidth = 33;
		$fieldset->add($f);

		/** @var InputfieldCheckbox $f */
		$f = $modules->get('InputfieldCheckbox');
		$f->attr('name', 'useDeselect');
		$f->label = $this->_('Support click to de-select?');
		$f->showIf = "inputfieldClass=0|InputfieldRadios";
		if($this->useDeselect) $f->attr('checked', 'checked');
		$f->columnWidth = 33;
		$f->showIf = 'defaultOption=none';
		$fieldset->add($f);
		
		$customStates = array(
			'yesLabel' => $this->_('yes/on'),
			'noLabel' => $this->_('no/off'),
		);
		
		$labelFor = $this->_('Label for “%s” option');

		/** @var InputfieldText $f */
		foreach($customStates as $name => $label) {
			$f = $modules->get('InputfieldText');
			$f->attr('name', $name);
			$f->label = sprintf($labelFor, $label);
			$f->showIf = 'labelType=' . self::labelTypeCustom;
			$f->val($this->get($name));
			$f->columnWidth = 50;
			if($languages) {
				$f->useLanguages = true;
				foreach($languages as $language) {
					$langValue = $this->get("$name$language");
					if(!$language->isDefault()) $f->set("value$language", $langValue); 
				}
			}
			$fieldset->add($f);
		}
		
		/** @var InputfieldText $f */
		$f = $modules->get('InputfieldText');
		$f->attr('name', 'otherLabel');
		$f->label = sprintf($labelFor, $this->_('other'));
		$f->showIf = 'useOther=1';
		$f->val($this->get('otherLabel'));
		if($languages) {
			$f->useLanguages = true;
			foreach($languages as $language) {
				if(!$language->isDefault()) $f->set("value$language", $this->get("otherLabel$language"));
			}
		}
		$fieldset->add($f);
	
		/** @var InputfieldToggle $f */
		$f = $modules->get('InputfieldToggle');
		$f->set('inputfieldClass', $this->inputfieldClass);
		$f->attr('name', 'defaultOption'); 
		$f->label = $this->_('Default selected option');
		$f->addOption('yes', $this->getValueLabel(self::valueYes));
		$f->addOption('no', $this->getValueLabel(self::valueNo));
		if($this->useOther) $f->addOption('other', $this->getValueLabel(self::valueOther));
		$f->addOption('none', $this->_('No selection'));
		$f->val($this->defaultOption);
		$f->addClass('InputfieldToggle', 'wrapClass');
		$fieldset->add($f);
		
		return $inputfields;
	}
}