`. * - `input`: The primary `` element(s) that accept input for the Inputfield. * - `class`: This is the same as the 'input' type, just an alias. * - `+foo`: Force adding your own new element type (i.e. “foo”) that is not indicated above. * * Class names prefixed with a minus sign i.e. `-class` will be removed rather than added. * * A string like `hello:world` where `hello` is not one of those element types listed above, * and is not prefixed with a plus sign `+`, will be added as a literal class name with the * colon in it (such as those used by Tailwind). * * @param string $class Formatted class string to parse class types and names from * @param string $property Default/fallback element/property if not indicated in string * @return self * @since 3.0.204 * * */ protected function addClassString($class, $property = 'class') { if(ctype_alnum($class)) return $this->addClass($class, $property); $typeNames = array('wrap', 'header', 'content', 'input', 'class'); $class = trim($class); if(strpos($class, "\n")) $class = str_replace("\n", ",", $class); $groups = strpos($class, ',') ? explode(',', $class) : array($class); foreach($groups as $group) { $type = $property; $group = trim($group); $classes = explode(' ', $group); foreach($classes as $class) { if(empty($class)) continue; if(strpos($class, ':')) { // setting new element type i.e. wrap:myclass or +foo:myclass list($typeName, $className) = explode(':', $class, 2); $typeName = trim($typeName); if(in_array($typeName, $typeNames) || strpos($typeName, '+') === 0) { // accepted as element/type for adding classes $type = ltrim($typeName, '+'); $class = trim($className); } else { // literal class name with a colon in it such as "lg:bg-red-400' } } if(strpos($class, '-') === 0) { $this->removeClass(ltrim($class, '-'), $type); } else { $this->addClass($class, "=$type"); // "=type" prevents further processing } } } return $this; } /** * Does this Inputfield have the given class name (or names)? * * ~~~~~ * if($inputfield->hasClass('foo')) { * // This Inputfield has a class attribute with "foo" * } * * if($inputfield->hasClass('bar', 'wrapClass')) { * // This .Inputfield wrapper has a class attribute with "bar" * } * * if($inputfield->hasClass('foo bar')) { * // This Inputfield has both "foo" and "bar" classes (Since 3.0.16) * } * ~~~~~ * * #pw-group-attribute-methods * * @param string|array $class Specify class name or one of the following: * - String containing name of class you want to check (string). * - String containing Space separated string class names you want to check, all must be present for * this method to return true. (Since 3.0.16) * - Array of class names you want to check, all must be present for this method to return true. (Since 3.0.16) * @param string $property Optionally specify property you want to pull class from: * - `class` (string): Default setting. Class for the input element (or whatever the Inputfield default is). * - `wrapClass` (string): Class for the ".Inputfield" wrapping element, the most outer level element used for this Inputfield. * - `headerClass` (string): Class for the ".InputfieldHeader" label element. * - `contentClass` (string): Class for the ".InputfieldContent" wrapping element. * - Or some other class property defined by a descending Inputfield class. * @return bool * @see Inputfield::addClass(), Inputfield::removeClass() * */ public function hasClass($class, $property = 'class') { if(is_string($class)) $class = trim($class); // checking multiple classes if(is_array($class) || strpos($class, ' ')) { $classes = is_string($class) ? explode(' ', $class) : $class; if(!count($classes)) return false; $n = 0; foreach($classes as $c) { $c = trim($c); if(empty($c) || $this->hasClass($c, $property)) $n++; } // return whether it had all the given classes return $n === count($classes); } // checking single class $classes = $this->getClassArray($property, true); return isset($classes[$class]); } /** * Get classes in array for given class property * * @param string $property One of 'wrap', 'header', 'content' or 'input' (or alias 'class') * @param bool $assoc Return as associative array where both keys and values are class names? (default=false) * @return array * @since 3.0.204 * */ public function getClassArray($property = 'class', $assoc = false) { $property = $this->getClassProperty($property); $value = ($property === 'class' ? $this->attr('class') : $this->getSetting($property)); $value = trim("$value"); while(strpos($value, ' ') !== false) $value = str_replace(' ', ' ', $value); $classes = strlen($value) ? explode(' ', $value) : array(); if($assoc) { $a = array(); foreach($classes as $class) $a[$class] = $class; $classes = $a; } return $classes; } /** * Get the internal property name for given class property * * This converts things like 'wrap' to 'wrapClass', 'header' to 'headerClass', etc. * * @param string $property * @return string * @since 3.0.204 * */ protected function getClassProperty($property) { if($property === 'class' || $property === 'input' || empty($property)) { $property = 'class'; } else if(strpos($property, 'Class') === false) { if(in_array($property, array('wrap', 'header', 'content'))) $property .= 'Class'; } return $property; } /** * Remove the given class (or classes) from this Inputfield * * ~~~~~ * // Remove the "foo" class * $inputfield->removeClass('foo'); * * // Remove both the "foo" and "bar" classes (since 3.0.16) * $inputfield->removeClass('foo bar'); * * // Remove the "bar" class from the wrapping .Inputfield element * $inputfield->removeClass('bar', 'wrapClass'); * ~~~~~ * * #pw-group-attribute-methods * * @param string|array $class Class name you want to remove or specify one of the following: * - Single class name to remove. * - Space-separated class names you want to remove (Since 3.0.16). * - Array of class names you want to remove (Since 3.0.16). * @param string $property Optionally specify the property you want to remove class from: * - `class` (string): Default setting. Class for the input element (or whatever the Inputfield default is). * - `wrapClass` (string): Class for the ".Inputfield" wrapping element, the most outer level element used for this Inputfield. * - `headerClass` (string): Class for the ".InputfieldHeader" label element. * - `contentClass` (string): Class for the ".InputfieldContent" wrapping element. * - Or some other class property defined by a descending Inputfield class. * @return $this * @see Inputfield::addClass(), Inputfield::hasClass() * */ public function removeClass($class, $property = 'class') { $property = $this->getClassProperty($property); $classes = $this->getClassArray($property, true); $removeClasses = is_array($class) ? $class : explode(' ', $class); foreach($removeClasses as $removeClass) { if(strlen($removeClass)) unset($classes[$removeClass]); } if($property === 'class') { $this->attributes['class'] = implode(' ', $classes); } else { $this->set($property, implode(' ', $classes)); } return $this; } /** * Get an HTML-ready string of all this Inputfield’s attributes * * ~~~~~ * // Outputs: name="foo" value="bar" class="baz" * echo $inputfield->getAttributesString([ * 'name' => 'foo', * 'value' => 'bar', * 'class' => 'baz' * ]); * * // Outputs actual attributes specified with this Inputfield * echo $inputfield->getAttributesString(); * ~~~~~ * * #pw-internal * * @param array $attributes Associative array of attributes to build the string from, or omit to use this Inputfield's attributes. * @return string * */ public function getAttributesString(array $attributes = null) { $str = ''; // if no attributes provided then use the ones for this Inputfield by default if(is_null($attributes)) $attributes = $this->getAttributes(); if($this instanceof InputfieldHasArrayValue) { // fields that use arrays as values aren't going to be using a value attribute in this string, so skip it unset($attributes['value']); // tell PHP to return an array by adding [] to the name attribute, i.e. "myfield[]" if(isset($attributes['name']) && substr($attributes['name'], -1) != ']') $attributes['name'] .= '[]'; } foreach($attributes as $attr => $value) { if(is_array($value)) { // if an attribute has multiple values (like class), then bundle them into a string separated by spaces $value = implode(' ', $value); } else if(is_bool($value)) { // boolean attribute uses only attribute name when true, or omit when false if($value === true) $str .= "$attr "; continue; } else if(!strlen("$value") && strpos($attr, 'data-') !== 0) { // skip over empty non-data attributes that are not arrays // if(!$value = $this->attr($attr))) continue; // was in 3.0.132 and earlier continue; } $str .= "$attr=\"" . htmlspecialchars($value, ENT_QUOTES, "UTF-8") . '" '; } return trim($str); } /** * Render the HTML input element(s) markup, ready for insertion in an HTML form. * * This is an abstract method that descending Inputfield module classes are required to implement. * * #pw-group-output * * @return string * */ abstract public function ___render(); /** * Render just the value (not input) in text/markup for presentation purposes. * * #pw-group-output * * @return string Text or markup where applicable * */ public function ___renderValue() { // This is within the context of an InputfieldForm, where the rendered markup can have // external CSS or JS dependencies (in Inputfield[Name].css or Inputfield[Name].js) $value = $this->attr('value'); if(is_array($value)) { if(!count($value)) return ''; $out = "

"; foreach($value as $v) $out .= "
• " . $this->wire()->sanitizer->entities($v) . "
"; $out .= "

"; } else { $out = $this->wire()->sanitizer->entities($value); } return $out; } /** * Method called right before Inputfield markup is rendered, so that any dependencies can be loaded as well. * * Called before `Inputfield::render()` or `Inputfield::renderValue()` method by the parent `InputfieldWrapper` * instance. If you are calling either of those methods yourself for some reason, make sure that you call this * `renderReady()` method first. * * The default behavior of this method is to populate Inputfield-specific CSS and JS file assets into * `$config->styles` and `$config->scripts`. * * The return value is true if assets were just added, and false if assets have already been added in a previous * call. This distinction probably doesn't matter in most usages, but here just in case a descending class needs * to know when/if to add additional assets (i.e. when this method returns true). * * #pw-group-output * * @param Inputfield|InputfieldWrapper|null The parent InputfieldWrapper that is rendering it, or null if no parent. * @param bool $renderValueMode Specify true only if this is for `Inputfield::renderValue()` rather than `Inputfield::render()`. * @return bool True if assets were just added, false if already added. * */ public function renderReady(Inputfield $parent = null, $renderValueMode = false) { $result = $this->wire()->modules->loadModuleFileAssets($this) > 0; if($this->wire()->hooks->isMethodHooked($this, 'renderReadyHook')) { $this->renderReadyHook($parent, $renderValueMode); } return $result; } /** * Hookable version of renderReady(), not called unless 'renderReadyHook' is hooked * * Hook this method instead if you want to hook renderReady(). * * @param Inputfield $parent * @param bool $renderValueMode * */ public function ___renderReadyHook(Inputfield $parent = null, $renderValueMode = false) { } /** * This hook was replaced by renderReady * * #pw-internal * * @param $event * @deprecated * */ public function hookRender($event) { } /** * Process input for this Inputfield directly from the POST (or GET) variables * * This method should pull the value from the given `$input` argument, sanitize/validate it, and * populate it to the `value` attribute of this Inputfield. * * Inputfield modules should implement this method if the built-in one here doesn't solve their need. * If this one does solve their need, then they should add any additional sanitization or validation * to the `Inputfield::setAttribute('value', $value)` method to occur when given the `value` attribute. * * #pw-group-input * * @param WireInputData $input User input where value should be pulled from (typically `$input->post`) * @return $this * */ public function ___processInput(WireInputData $input) { if(isset($input[$this->name])) { $value = $input[$this->name]; } else if($this instanceof InputfieldHasArrayValue) { $value = array(); } else { $value = $input[$this->name]; } $changed = false; if($this instanceof InputfieldHasArrayValue && !is_array($value)) { /** @var Inputfield $this */ $this->error("Expected an array value and did not receive it"); return $this; } $previousValue = $this->attr('value'); if(is_array($value)) { // an array value was provided in the input // note: only arrays one level deep are allowed if(!$this instanceof InputfieldHasArrayValue) { $this->error("Received an unexpected array value"); return $this; } $values = array(); foreach($value as $v) { if(is_array($v)) continue; // skip over multldimensional arrays, not allowed if(ctype_digit("$v") && (((int) $v) <= PHP_INT_MAX)) $v = (int) "$v"; // force digit strings as integers $values[] = $v; } if($previousValue !== $values) { // If it has changed, then update for the changed value $changed = true; /** @var Inputfield $this */ $this->setAttribute('value', $values); } } else { // string value provided in the input $this->setAttribute('value', $value); $value = $this->attr('value'); if("$value" !== (string) $previousValue) { $changed = true; } } if($changed) { $this->trackChange('value', $previousValue, $value); // notify the parent of the change $parent = $this->getParent(); if($parent) $parent->trackChange($this->name); } return $this; } /** * Is this Inputfield empty? (Value attribute reflects an empty state) * * Return true if this field is empty (no value or blank value), or false if it’s not empty. * * Used by the 'required' check to see if the field is populated, and descending Inputfields may * override this according to their own definition of 'empty'. * * #pw-group-attribute-methods * * @return bool * */ public function isEmpty() { $value = $this->attr('value'); if(is_array($value)) return count($value) == 0; if(!strlen("$value")) return true; // if($value === 0) return true; return false; } /** * Get any custom configuration fields for this Inputfield * * - Intended to be extended by each Inputfield as needed to add more config options. * * - The returned InputfieldWrapper ultimately ends up as the "Input" tab in the fields editor (admin). * * - Descending Inputfield classes should first call this method from the parent class to get the * default configuration fields and the InputfieldWrapper they can add to. * * - Returned Inputfield instances with a name attribute that starts with an underscore, i.e. "_myname" * are assumed to be for runtime use and are NOT stored in the database. * * - If you prefer, you may instead implement the `Inputfield::getConfigArray()` method as an alternative. * * ~~~~ * // Example getConfigInputfields() implementation * public function ___getConfigInputfields() { * // Get the defaults and $inputfields wrapper we can add to * $inputfields = parent::___getConfigInputfields(); * // Add a new Inputfield to it * $f = $this->wire('modules')->get('InputfieldText'); * $f->attr('name', 'first_name'); * $f->attr('value', $this->get('first_name')); * $f->label = 'Your First Name'; * $inputfields->add($f); * return $inputfields; * } * ~~~~ * * #pw-group-module * * @return InputfieldWrapper Populated with Inputfield instances * @see Inputfield::getConfigArray() * */ public function ___getConfigInputfields() { $conditionsText = $this->_('Conditions are expressed with a "field=value" selector containing fields and values to match. Multiple conditions should be separated by a comma.'); $conditionsNote = $this->_('Read more about [how to use this](https://processwire.com/api/selectors/inputfield-dependencies/).'); /** @var InputfieldWrapper $inputfields */ $inputfields = $this->wire(new InputfieldWrapper()); $fieldset = $inputfields->InputfieldFieldset; $fieldset->label = $this->_('Visibility'); $fieldset->attr('name', 'visibility'); $fieldset->icon = 'eye'; if($this->collapsed == Inputfield::collapsedNo && !$this->getSetting('showIf')) { $fieldset->collapsed = Inputfield::collapsedYes; } $inputfields->append($fieldset); $f = $inputfields->InputfieldSelect; $f->attr('name', 'collapsed'); $f->label = $this->_('Presentation'); $f->icon = 'eye-slash'; $f->description = $this->_("How should this field be displayed in the editor?"); $f->addOption(self::collapsedNo, $this->_('Open')); $f->addOption(self::collapsedNever, $this->_('Open + Cannot be closed')); $f->addOption(self::collapsedNoLocked, $this->_('Open + Locked (not editable)')); $f->addOption(self::collapsedBlank, $this->_('Open when populated + Closed when blank')); if($this->hasFieldtype !== false) { $f->addOption(self::collapsedBlankAjax, $this->_('Open when populated + Closed when blank + Load only when opened (AJAX)') . " †"); } $f->addOption(self::collapsedBlankLocked, $this->_('Open when populated + Closed when blank + Locked (not editable)')); $f->addOption(self::collapsedPopulated, $this->_('Open when blank + Closed when populated')); $f->addOption(self::collapsedYes, $this->_('Closed')); $f->addOption(self::collapsedYesLocked, $this->_('Closed + Locked (not editable)')); if($this->hasFieldtype !== false) { $f->addOption(self::collapsedYesAjax, $this->_('Closed + Load only when opened (AJAX)') . " †"); $f->notes = sprintf($this->_('Options indicated with %s may not work with all input types or placements, test to ensure compatibility.'), '†'); $f->addOption(self::collapsedTab, $this->_('Tab')); $f->addOption(self::collapsedTabAjax, $this->_('Tab + Load only when clicked (AJAX)') . " †"); $f->addOption(self::collapsedTabLocked, $this->_('Tab + Locked (not editable)')); } $f->addOption(self::collapsedHidden, $this->_('Hidden (not shown in the editor)')); $f->attr('value', (int) $this->collapsed); $fieldset->append($f); $f = $inputfields->InputfieldText; $f->label = $this->_('Show this field only if'); $f->description = $this->_('Enter the conditions under which the field will be shown.') . ' ' . $conditionsText; $f->notes = $conditionsNote; $f->icon = 'question-circle'; $f->attr('name', 'showIf'); $f->attr('value', $this->getSetting('showIf')); $f->collapsed = Inputfield::collapsedBlank; $f->showIf = "collapsed!=" . self::collapsedHidden; $fieldset->append($f); $value = (int) $this->getSetting('columnWidth'); if($value < 10 || $value >= 100) $value = 100; $f = $inputfields->InputfieldInteger; $f->label = sprintf($this->_('Column width (%d%%)'), $value); $f->icon = 'arrows-h'; $f->attr('id+name', 'columnWidth'); $f->addClass('columnWidthInput'); $f->attr('type', 'text'); $f->attr('maxlength', 4); $f->attr('size', 4); $f->attr('max', 100); $f->attr('value', $value . '%'); $f->description = $this->_("The percentage width of this field's container (10%-100%). If placed next to other fields with reduced widths, it will create floated columns."); // Description of colWidth option $f->notes = $this->_("Note that not all fields will work at reduced widths, so you should test the result after changing this."); // Notes for colWidth option if(!$this->wire()->input->get('process_template') && $value == 100) $f->collapsed = Inputfield::collapsedYes; $inputfields->append($f); if(!$this instanceof InputfieldWrapper) { $f = $inputfields->InputfieldCheckbox; $f->label = $this->_('Required?'); $f->icon = 'asterisk'; $f->attr('name', 'required'); $f->attr('value', 1); $f->attr('checked', $this->getSetting('required') ? 'checked' : ''); $f->description = $this->_("If checked, a value will be required for this field."); $f->collapsed = $this->getSetting('required') ? Inputfield::collapsedNo : Inputfield::collapsedYes; $inputfields->add($f); $requiredAttr = $this->getSetting('requiredAttr'); if($requiredAttr !== null) { // Inputfield must have set requiredAttr to some non-null value before this will appear as option in config $f->columnWidth = 50; // required checkbox $f = $inputfields->InputfieldCheckbox; $f->attr('name', 'requiredAttr'); $f->label = $this->_('Also use HTML5 “required” attribute?'); $f->showIf = "required=1, showIf='', requiredIf=''"; $f->description = $this->_('Use only on fields *always* visible to the user.'); $f->icon = 'html5'; $f->columnWidth = 50; if($requiredAttr) $f->attr('checked', 'checked'); $inputfields->add($f); } $f = $inputfields->InputfieldText; $f->label = $this->_('Required only if'); $f->icon = 'asterisk'; $f->description = $this->_('Enter the conditions under which a value will be required for this field.') . ' ' . $conditionsText; $f->notes = $conditionsNote; $f->attr('name', 'requiredIf'); $f->attr('value', $this->getSetting('requiredIf')); $f->collapsed = $f->attr('value') ? Inputfield::collapsedNo : Inputfield::collapsedYes; $f->showIf = "required>0"; $inputfields->add($f); } if($this->hasFieldtype === false || $this->wire()->config->advanced) { $f = $inputfields->InputfieldTextarea; $f->attr('name', 'addClass'); $f->label = $this->_('Custom class attributes'); $f->description = $this->_('Optionally add to the class attribute for specific elements in this Inputfield.') . ' ' . $this->_('Format is one per line of `element:class` where `element` is one of: “wrap”, “header”, “content” or “input” and `class` is one or more class names.') . ' ' . $this->_('If no element is specified then the “input” element is assumed.'); $f->notes = $this->_('Example:') . "`" . "\nwrap:card card-default" . "\nheader:card-header" . "\ncontent:card-body" . "\ninput:form-input input-checkbox" . "`"; $f->collapsed = Inputfield::collapsedBlank; $f->renderFlags = self::renderLast; $f->val($this->getSetting('addClass')); $inputfields->add($f); } return $inputfields; } /** * Alternative method for configuration that allows for array definition * * - This method is typically used instead of the `Inputfield::getConfigInputfields` method * for module authors that prefer to use the array definition. * * - If both `getConfigInputfields()` and `getConfigArray()` are implemented, both will be used. * * - See comments for `InputfieldWrapper::importArray()` for example of array definition. * * ~~~~~ * // Example implementation * public function ___getConfigArray() { * return [ * 'test' => [ * 'type' => 'text', * 'label' => 'This is a test', * 'value' => 'Test' * ] * ]; * ); * ~~~~~ * * #pw-group-module * * @return array * */ public function ___getConfigArray() { return array(); } /** * Return a list of config property names allowed for fieldgroup/template context * * These should be the names of Inputfields returned by `Inputfield::getConfigInputfields()` or * `Inputfield::getConfigArray()` that are allowed in fieldgroup/template context. * * The config property names specified here are allowed to be configured within the context * of a given `Fieldgroup`, enabling the user to configure them independently per template * in the admin. * * This is the equivalent to the `Fieldtype::getConfigAllowContext()` method, but for the "Input" * tab rather than the "Details" tab. * * #pw-group-module * * @param Field $field * @return array of Inputfield names * @see Fieldtype::getConfigAllowContext() * */ public function ___getConfigAllowContext($field) { if($field) {} return array( 'visibility', 'collapsed', 'columnWidth', 'required', 'requiredIf', 'requiredAttr', 'showIf' ); } /** * Export configuration values for external consumption * * Use this method to externalize any config values when necessary. * For example, internal IDs should be converted to GUIDs where possible. * * Most Inputfields do not need to implement this. * * #pw-internal * * @param array $data * @return array * */ public function ___exportConfigData(array $data) { $inputfields = $this->getConfigInputfields(); if(!$inputfields || !count($inputfields)) return $data; foreach($inputfields->getAll() as $inputfield) { /** @var Inputfield $inputfield */ $value = $inputfield->isEmpty() ? '' : $inputfield->value; if(is_object($value)) $value = (string) $value; $data[$inputfield->name] = $value; } return $data; } /** * Convert an array of exported data to a format that will be understood internally (opposite of exportConfigData) * * Most Inputfields do not need to implement this. * * #pw-internal * * @param array $data * @return array Data as given and modified as needed. Also included is $data[errors], an associative array * indexed by property name containing errors that occurred during import of config data. * */ public function ___importConfigData(array $data) { return $data; } /** * Returns a unique key variable used to store errors in the session * * #pw-internal * */ public function getErrorSessionKey() { $name = $this->attr('name'); if(!$name) $name = $this->attr('id'); $key = "_errors_" . $this->className() . "_$name"; return $key; } /** * Record an error for this Inputfield * * The error message will be placed in the context of this Inputfield. * See the `Wire::error()` method for full details on arguments and options. * * #pw-group-states * * @param string $text Text of error message * @param int $flags Optional flags * @return $this * */ public function error($text, $flags = 0) { // Override Wire's error method and place errors in the context of their inputfield $session = $this->wire()->session; $key = $this->getErrorSessionKey(); $errors = $session->$key; if(!is_array($errors)) $errors = array(); if(!in_array($text, $errors)) { $errors[] = $text; $session->set($key, $errors); } $label = $this->getSetting('label'); if(empty($label)) $label = $this->attr('name'); if(strlen($label)) $text .= " - $label"; return parent::error($text, $flags); } /** * Return array of strings containing errors that occurred during input processing * * Note that this is different from `Wire::errors()` in that it retrieves errors from the session * rather than just the current run. * * #pw-group-states * * @param bool $clear Optionally clear the errors after getting them (Default=false). * @return array * */ public function getErrors($clear = false) { $session = $this->wire()->session; $key = $this->getErrorSessionKey(); $errors = $session->get($key); if(!is_array($errors)) $errors = array(); if($clear) { $session->remove($key); parent::errors("clear"); } return $errors; } /** * Clear errors from this Inputfield * * This is the same as `$inputfield->getErrors(true);` but has no return value. * * #pw-group-states * * @since 3.0.205 * */ public function clearErrors() { $this->getErrors(true); } /** * Does this Inputfield have the requested property or attribute? * * #pw-group-attribute-methods * #pw-group-settings * * @param string $key Requested property or attribute. * @return bool True if it has it, false if it doesn't * */ public function has($key) { $has = parent::has($key); if(!$has) $has = isset($this->attributes[$key]); return $has; } /** * Does this Inputfield have the given setting? * * Return value does not indicate that it is non-empty, only that the setting is available. * * #pw-internal * * @param string $key Setting name * @return bool * */ public function hasSetting($key) { return isset($this->data[$key]); } /** * Does this Inputfield have the given attribute? * * Return value does not indicate that it is non-empty, only that the setting is available. * * #pw-internal * * @param string $key Attribute name * @return bool * */ public function hasAttribute($key) { return isset($this->attributes[$key]); } /** * Track the change, but only if it was to the 'value' attribute. * * We don't track changes to any other properties of Inputfields. * * #pw-internal * * @param string $what Name of property that changed * @param mixed $old Previous value before change * @param mixed $new New value * @return Inputfield|WireData $this * */ public function trackChange($what, $old = null, $new = null) { if($what != 'value') return $this; return parent::trackChange($what, $old, $new); } /** * Entity encode a string with optional Markdown support. * * - Markdown support provided with second argument. * - If string is already entity-encoded it will first be decoded. * * #pw-group-output * * @param string $str String to encode * @param bool|int $markdown Optionally specify one of the following: * - `true` (boolean): To allow Markdown using default "textFormat" setting (which is basic Markdown by default). * - `false` (boolean): To disallow Markdown support (this is the default when $markdown argument omitted). * - `Inputfield::textFormatNone` (constant): Disallow Markdown support (default). * - `Inputfield::textFormatBasic` (constant): To support basic/inline Markdown. * - `Inputfield::textFormatMarkdown` (constant): To support full Markdown and HTML. * @return string Entity encoded string or HTML string * */ public function entityEncode($str, $markdown = false) { $sanitizer = $this->wire()->sanitizer; $str = (string) $str; // if already encoded, then un-encode it if(strpos($str, '&') !== false && preg_match('/&(#\d+|[a-zA-Z]+);/', $str)) { $str = $sanitizer->unentities($str); } if($markdown && $markdown !== self::textFormatNone) { if(is_int($markdown)) { $textFormat = $markdown; } else { $textFormat = $this->getSetting('textFormat'); } if(!$textFormat) $textFormat = self::textFormatBasic; if($textFormat & self::textFormatBasic) { // only basic markdown allowed (default behavior) $str = $sanitizer->entitiesMarkdown($str, array('allowBrackets' => true)); } else if($textFormat & self::textFormatMarkdown) { // full markdown, plus HTML is also allowed $str = $sanitizer->entitiesMarkdown($str, array('fullMarkdown' => true)); } else { // nothing allowed, text fully entity encoded regardless of $markdown request $str = $sanitizer->entities($str); } } else { $str = $sanitizer->entities($str); } return $str; } /** * Get or set editable state for this Inputfield * * When set to false, the `Inputfield::processInput()` method won't be called by parent InputfieldWrapper, * effectively skipping over input processing entirely for this Inputfield. * * #pw-group-states * * @param bool|null $setEditable Specify true or false to set the editable state, or omit just to get the editable state. * @return bool Returns the current editable state. * */ public function editable($setEditable = null) { if(!is_null($setEditable)) $this->editable = (bool) $setEditable; return $this->editable; } /** * debugInfo PHP 5.6+ magic method * * @return array * */ public function __debugInfo() { $info = array( 'className' => $this->className(), 'attributes' => $this->attributes, 'wrapAttributes' => $this->wrapAttributes, ); if(is_object($this->parent)) { $info['parent'] = array( 'className' => $this->parent->className(), 'name' => $this->parent->attr('name'), 'id' => $this->parent->attr('id'), ); } $info = array_merge($info, parent::__debugInfo()); return $info; } /** * Set custom html render, see $this->html at top for reference. * * @param string $html * public function setHTML($html) { $this->html = $html; } */ /** * Get default or custom HTML for render * * If $this->html is populated, it gets returned. * If not, then this should return the default HTML for the Inputfield, * where supported. * * If this returns blank, then it means custom HTML is not supported. * * @param array $attr When populated with key=value, tags will be replaced. * @return array * public function getHTML($attr = array()) { if(!strlen($this->html) || empty($attr) || strpos($this->html, '{') === false) return $this->html; $html = $this->html; if(strpos($html, '{attr}')) { $html = str_replace('{attr}', $this->getAttributesString($attr), $html); // @todo remove any other {tags} that might be present } else { // a version of html where the {tags} get replaced with blanks // used for testing if more attributes present without possibility // of those attributes being injected // $_html = $html; // extract value so that a substitution can't result in input-injected tags if(isset($attr['value'])) { $value = $attr['value']; unset($attr['value']); } else { $value = null; } // populate attributes foreach($attr as $name => $v) { $tag = '{' . $name . '}'; if(strpos($html, $tag) === false) continue; $v = htmlspecialchars($v, ENT_QUOTES, 'UTF-8'); $html = str_replace($tag, $v, $html); //$_html = str_replace($tag, '', $html); } // see if any non-value attributes are left $pos = strpos($html, '{'); if($pos !== false && $pos != strpos($html, '{value}')) { // there are unpopulated tags that need to be removed preg_match_all('/\{[-_a-zA-Z0-9]+\}/', $html, $matches); } // once all other attributes populated, we can populate {value} if($value !== null) { $value = htmlspecialchars($value, ENT_QUOTES, 'UTF-8'); $html = str_replace('{value}', $value, $html); $_html = str_replace('{value}', '', $html); } // if ther } return $html; } */ }