vendor/contao/core-bundle/src/Resources/contao/forms/FormTextField.php line 130

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. /**
  14.  * Class FormTextField
  15.  *
  16.  * @property string  $value
  17.  * @property string  $type
  18.  * @property integer $maxlength
  19.  * @property boolean $mandatory
  20.  * @property integer $min
  21.  * @property integer $max
  22.  * @property integer $step
  23.  * @property string  $placeholder
  24.  * @property boolean $hideInput
  25.  *
  26.  * @author Leo Feyer <https://github.com/leofeyer>
  27.  *
  28.  * @todo Rename to FormText in Contao 5.0
  29.  */
  30. class FormTextField extends Widget
  31. {
  32.     /**
  33.      * Submit user input
  34.      *
  35.      * @var boolean
  36.      */
  37.     protected $blnSubmitInput = true;
  39.     /**
  40.      * Add a for attribute
  41.      *
  42.      * @var boolean
  43.      */
  44.     protected $blnForAttribute = true;
  46.     /**
  47.      * Template
  48.      *
  49.      * @var string
  50.      *
  51.      * @todo Rename to form_text in Contao 5.0
  52.      */
  53.     protected $strTemplate = 'form_textfield';
  55.     /**
  56.      * The CSS class prefix
  57.      *
  58.      * @var string
  59.      */
  60.     protected $strPrefix = 'widget widget-text';
  62.     /**
  63.      * Add specific attributes
  64.      *
  65.      * @param string $strKey   The attribute key
  66.      * @param mixed  $varValue The attribute value
  67.      */
  68.     public function __set($strKey, $varValue)
  69.     {
  70.         switch ($strKey)
  71.         {
  72.             case 'minlength':
  73.                 if ($varValue > 0 && $this->rgxp != 'digit' && $this->rgxp != 'natural')
  74.                 {
  75.                     $this->arrAttributes['minlength'] =  $varValue;
  76.                 }
  77.                 break;
  79.             case 'maxlength':
  80.                 if ($varValue > 0 && $this->rgxp != 'digit' && $this->rgxp != 'natural')
  81.                 {
  82.                     $this->arrAttributes['maxlength'] =  $varValue;
  83.                 }
  84.                 break;
  86.             case 'mandatory':
  87.                 if ($varValue)
  88.                 {
  89.                     $this->arrAttributes['required'] = 'required';
  90.                 }
  91.                 else
  92.                 {
  93.                     unset($this->arrAttributes['required']);
  94.                 }
  95.                 parent::__set($strKey, $varValue);
  96.                 break;
  98.             case 'min':
  99.             case 'minval':
  100.                 if ($this->rgxp == 'digit' || $this->rgxp == 'natural')
  101.                 {
  102.                     $this->arrAttributes['min'] = $varValue;
  103.                 }
  104.                 break;
  106.             case 'max':
  107.             case 'maxval':
  108.                 if ($this->rgxp == 'digit' || $this->rgxp == 'natural')
  109.                 {
  110.                     $this->arrAttributes['max'] = $varValue;
  111.                 }
  112.                 break;
  114.             case 'step':
  115.                 if ($varValue > 0 && $this->type == 'number')
  116.                 {
  117.                     $this->arrAttributes[$strKey] = $varValue;
  118.                 }
  119.                 else
  120.                 {
  121.                     unset($this->arrAttributes[$strKey]);
  122.                 }
  123.                 break;
  125.             case 'placeholder':
  126.                 $this->arrAttributes[$strKey] = $varValue;
  127.                 break;
  129.             default:
  130.                 parent::__set($strKey, $varValue);
  131.                 break;
  132.         }
  133.     }
  135.     /**
  136.      * Return a parameter
  137.      *
  138.      * @param string $strKey The parameter key
  139.      *
  140.      * @return mixed The parameter value
  141.      */
  142.     public function __get($strKey)
  143.     {
  144.         switch ($strKey)
  145.         {
  146.             case 'value':
  147.                 // Hide the Punycode format (see #2750)
  148.                 if ($this->rgxp == 'url')
  149.                 {
  150.                     try
  151.                     {
  152.                         return Idna::decodeUrl($this->varValue);
  153.                     }
  154.                     catch (\InvalidArgumentException $e)
  155.                     {
  156.                         return $this->varValue;
  157.                     }
  158.                 }
  160.                 if ($this->rgxp == 'email' || $this->rgxp == 'friendly')
  161.                 {
  162.                     return Idna::decodeEmail($this->varValue);
  163.                 }
  165.                 return $this->varValue;
  167.             case 'type':
  168.                 if ($this->hideInput)
  169.                 {
  170.                     return 'password';
  171.                 }
  173.                 // Use the HTML5 types (see #4138) but not the date, time and datetime types (see #5918)
  174.                 switch ($this->rgxp)
  175.                 {
  176.                     case 'digit':
  177.                         // Allow floats (see #7257)
  178.                         if (!isset($this->arrAttributes['step']))
  179.                         {
  180.                             $this->addAttribute('step', 'any');
  181.                         }
  182.                         // no break
  184.                     case 'natural':
  185.                         return 'number';
  187.                     case 'phone':
  188.                         return 'tel';
  190.                     case 'email':
  191.                         return 'email';
  193.                     case 'url':
  194.                         return 'url';
  195.                 }
  197.                 return 'text';
  199.             case 'min':
  200.             case 'minval':
  201.                 if ($this->rgxp == 'digit')
  202.                 {
  203.                     return $this->arrAttributes['min'];
  204.                 }
  206.                 return parent::__get($strKey);
  208.             case 'max':
  209.             case 'maxval':
  210.                 if ($this->rgxp == 'digit')
  211.                 {
  212.                     return $this->arrAttributes['max'];
  213.                 }
  215.                 return parent::__get($strKey);
  217.             default:
  218.                 return parent::__get($strKey);
  219.         }
  220.     }
  222.     /**
  223.      * Trim the values
  224.      *
  225.      * @param mixed $varInput The user input
  226.      *
  227.      * @return mixed The validated user input
  228.      */
  229.     protected function validator($varInput)
  230.     {
  231.         if (\is_array($varInput))
  232.         {
  233.             return parent::validator($varInput);
  234.         }
  236.         // Convert to Punycode format (see #5571)
  237.         if ($this->rgxp == 'url')
  238.         {
  239.             try
  240.             {
  241.                 $varInput = Idna::encodeUrl($varInput);
  242.             }
  243.             catch (\InvalidArgumentException $e)
  244.             {
  245.             }
  246.         }
  247.         elseif ($this->rgxp == 'email' || $this->rgxp == 'friendly')
  248.         {
  249.             $varInput = Idna::encodeEmail($varInput);
  250.         }
  252.         return parent::validator($varInput);
  253.     }
  255.     /**
  256.      * Generate the widget and return it as string
  257.      *
  258.      * @return string The widget markup
  259.      */
  260.     public function generate()
  261.     {
  262.         return sprintf(
  263.             '<input type="%s" name="%s" id="ctrl_%s" class="text%s%s" value="%s"%s%s',
  264.             $this->type,
  265.             $this->strName,
  266.             $this->strId,
  267.             ($this->hideInput ? ' password' : ''),
  268.             ($this->strClass ? ' ' . $this->strClass : ''),
  269.             StringUtil::specialchars($this->value),
  270.             $this->getAttributes(),
  271.             $this->strTagEnding
  272.         );
  273.     }
  274. }
  276. class_alias(FormTextField::class, 'FormTextField');