vendor/contao/core-bundle/src/Resources/contao/library/Contao/Widget.php line 603

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. use Contao\Database\Result;
  14. use Doctrine\DBAL\Types\Types;
  15. use Patchwork\Utf8;
  16. use Symfony\Component\HttpFoundation\Request;
  18. /**
  19.  * Generates and validates form fields
  20.  *
  21.  * The class functions as abstract parent class for all widget classes and
  22.  * provides methods to generate the form field markup and to validate the form
  23.  * field input.
  24.  *
  25.  * Usage:
  26.  *
  27.  *     $widget = new TextField();
  28.  *     $widget->name = 'test';
  29.  *     $widget->label = 'Test';
  30.  *
  31.  *     if ($_POST)
  32.  *     {
  33.  *         $widget->validate();
  34.  *
  35.  *         if (!$widget->hasErrors())
  36.  *         {
  37.  *             echo $widget->value;
  38.  *         }
  39.  *     }
  40.  *
  41.  * @property string        $id                 The field ID
  42.  * @property string        $name               the field name
  43.  * @property string        $label              The field label
  44.  * @property mixed         $value              The field value
  45.  * @property string        $class              One or more CSS classes
  46.  * @property string        $prefix             The CSS class prefix
  47.  * @property string        $template           The template name
  48.  * @property string        $wizard             The field wizard markup
  49.  * @property string        $alt                The alternative text
  50.  * @property string        $style              The style attribute
  51.  * @property string        $accesskey          The key to focus the field
  52.  * @property integer       $tabindex           The tabindex of the field
  53.  * @property boolean       $disabled           Adds the disabled attribute
  54.  * @property boolean       $readonly           Adds the readonly attribute
  55.  * @property boolean       $autofocus          Adds the autofocus attribute
  56.  * @property boolean       $required           Adds the required attribute
  57.  * @property string        $onblur             The blur event
  58.  * @property string        $onchange           The change event
  59.  * @property string        $onclick            The click event
  60.  * @property string        $ondblclick         The double click event
  61.  * @property string        $onfocus            The focus event
  62.  * @property string        $onmousedown        The mouse down event
  63.  * @property string        $onmousemove        The mouse move event
  64.  * @property string        $onmouseout         The mouse out event
  65.  * @property string        $onmouseover        The mouse over event
  66.  * @property string        $onmouseup          The mouse up event
  67.  * @property string        $onkeydown          The key down event
  68.  * @property string        $onkeypress         The key press event
  69.  * @property string        $onkeyup            The key up event
  70.  * @property string        $onselect           The select event
  71.  * @property boolean       $mandatory          The field value must not be empty
  72.  * @property boolean       $nospace            Do not allow whitespace characters
  73.  * @property boolean       $allowHtml          Allow HTML tags in the field value
  74.  * @property boolean       $storeFile          Store uploaded files in a given folder
  75.  * @property boolean       $useHomeDir         Store uploaded files in the user's home directory
  76.  * @property boolean       $trailingSlash      Add or remove a trailing slash
  77.  * @property boolean       $spaceToUnderscore  Convert spaces to underscores
  78.  * @property boolean       $doNotTrim          Do not trim the user input
  79.  * @property string        $forAttribute       The "for" attribute
  80.  * @property DataContainer $dataContainer      The data container object
  81.  * @property Result        $activeRecord       The active record
  82.  * @property string        $mandatoryField     The "mandatory field" label
  83.  * @property string        $customTpl          A custom template name
  84.  * @property string        $slabel             The submit button label
  85.  * @property boolean       $preserveTags       Preserve HTML tags
  86.  * @property boolean       $decodeEntities     Decode HTML entities
  87.  * @property boolean       $useRawRequestData  Use the raw request data from the Symfony request
  88.  * @property integer       $minlength          The minimum length
  89.  * @property integer       $maxlength          The maximum length
  90.  * @property integer       $minval             The minimum value
  91.  * @property integer       $maxval             The maximum value
  92.  * @property integer       $rgxp               The regular expression name
  93.  * @property boolean       $isHexColor         The field value is a hex color
  94.  * @property string        $strTable           The table name
  95.  * @property string        $strField           The field name
  96.  * @property string        $xlabel
  97.  * @property string        $customRgxp
  98.  * @property string        $errorMsg
  99.  * @property integer       $currentRecord
  100.  * @property integer       $rowClass
  101.  * @property integer       $rowClassConfirm
  102.  * @property integer       $storeValues
  103.  * @property boolean       $includeBlankOption
  104.  * @property string        $blankOptionLabel
  105.  *
  106.  * @author Leo Feyer <https://github.com/leofeyer>
  107.  */
  108. abstract class Widget extends Controller
  109. {
  110.     use TemplateInheritance;
  112.     /**
  113.      * Id
  114.      * @var integer
  115.      */
  116.     protected $strId;
  118.     /**
  119.      * Name
  120.      * @var string
  121.      */
  122.     protected $strName;
  124.     /**
  125.      * Label
  126.      * @var string
  127.      */
  128.     protected $strLabel;
  130.     /**
  131.      * Value
  132.      * @var mixed
  133.      */
  134.     protected $varValue;
  136.     /**
  137.      * Input callback
  138.      * @var callable
  139.      */
  140.     protected $inputCallback;
  142.     /**
  143.      * CSS class
  144.      * @var string
  145.      */
  146.     protected $strClass;
  148.     /**
  149.      * CSS class prefix
  150.      * @var string
  151.      */
  152.     protected $strPrefix;
  154.     /**
  155.      * Wizard
  156.      * @var string
  157.      */
  158.     protected $strWizard;
  160.     /**
  161.      * Errors
  162.      * @var array
  163.      */
  164.     protected $arrErrors = array();
  166.     /**
  167.      * Attributes
  168.      * @var array
  169.      */
  170.     protected $arrAttributes = array();
  172.     /**
  173.      * Configuration
  174.      * @var array
  175.      */
  176.     protected $arrConfiguration = array();
  178.     /**
  179.      * Options
  180.      * @var array
  181.      */
  182.     protected $arrOptions = array();
  184.     /**
  185.      * Submit indicator
  186.      * @var boolean
  187.      */
  188.     protected $blnSubmitInput = false;
  190.     /**
  191.      * For attribute indicator
  192.      * @var boolean
  193.      */
  194.     protected $blnForAttribute = false;
  196.     /**
  197.      * Data container
  198.      * @var object
  199.      */
  200.     protected $objDca;
  202.     /**
  203.      * Initialize the object
  204.      *
  205.      * @param array $arrAttributes An optional attributes array
  206.      */
  207.     public function __construct($arrAttributes=null)
  208.     {
  209.         parent::__construct();
  211.         $this->addAttributes($arrAttributes);
  212.     }
  214.     /**
  215.      * Set an object property
  216.      *
  217.      * @param string $strKey   The property name
  218.      * @param mixed  $varValue The property value
  219.      */
  220.     public function __set($strKey, $varValue)
  221.     {
  222.         switch ($strKey)
  223.         {
  224.             case 'id':
  225.                 $this->strId = $varValue;
  226.                 break;
  228.             case 'name':
  229.                 $this->strName = $varValue;
  230.                 break;
  232.             case 'label':
  233.                 $this->strLabel = $varValue;
  234.                 break;
  236.             case 'value':
  237.                 $this->varValue = StringUtil::deserialize($varValue);
  239.                 // Decrypt the value if it is encrypted
  240.                 if ($this->arrConfiguration['encrypt'] ?? null)
  241.                 {
  242.                     $this->varValue = Encryption::decrypt($this->varValue);
  243.                 }
  244.                 break;
  246.             case 'class':
  247.                 if ($varValue && strpos($this->strClass ?? '', $varValue) === false)
  248.                 {
  249.                     $this->strClass = trim($this->strClass . ' ' . $varValue);
  250.                 }
  251.                 break;
  253.             case 'prefix':
  254.                 $this->strPrefix = $varValue;
  255.                 break;
  257.             case 'template':
  258.                 $this->strTemplate = $varValue;
  259.                 break;
  261.             case 'wizard':
  262.                 $this->strWizard = $varValue;
  263.                 break;
  265.             case 'autocomplete':
  266.             case 'autocorrect':
  267.             case 'autocapitalize':
  268.             case 'spellcheck':
  269.                 if (\is_bool($varValue))
  270.                 {
  271.                     $varValue = $varValue ? 'on' : 'off';
  272.                 }
  273.                 // no break
  275.             case 'alt':
  276.             case 'style':
  277.             case 'accesskey':
  278.             case 'onblur':
  279.             case 'onchange':
  280.             case 'onclick':
  281.             case 'ondblclick':
  282.             case 'onfocus':
  283.             case 'onmousedown':
  284.             case 'onmousemove':
  285.             case 'onmouseout':
  286.             case 'onmouseover':
  287.             case 'onmouseup':
  288.             case 'onkeydown':
  289.             case 'onkeypress':
  290.             case 'onkeyup':
  291.             case 'onselect':
  292.                 $this->arrAttributes[$strKey] = $varValue;
  293.                 break;
  295.             case 'tabindex':
  296.                 if ($varValue > 0)
  297.                 {
  298.                     trigger_deprecation('contao/core-bundle', '4.12', 'Using a tabindex value greater than 0 has been deprecated and will no longer work in Contao 5.0.');
  299.                     $this->arrAttributes['tabindex'] = $varValue;
  300.                 }
  301.                 break;
  303.             case 'disabled':
  304.             case 'readonly':
  305.                 $this->blnSubmitInput = $varValue ? false : true;
  306.                 // no break
  308.             case 'autofocus':
  309.                 if ($varValue)
  310.                 {
  311.                     $this->arrAttributes[$strKey] = $strKey;
  312.                 }
  313.                 else
  314.                 {
  315.                     unset($this->arrAttributes[$strKey]);
  316.                 }
  317.                 break;
  319.             case 'required':
  320.                 if ($varValue)
  321.                 {
  322.                     $this->strClass = trim($this->strClass . ' mandatory');
  323.                 }
  324.                 // no break
  326.             case 'mandatory':
  327.             case 'nospace':
  328.             case 'allowHtml':
  329.             case 'storeFile':
  330.             case 'useHomeDir':
  331.             case 'storeValues':
  332.             case 'trailingSlash':
  333.             case 'spaceToUnderscore':
  334.             case 'doNotTrim':
  335.             case 'useRawRequestData':
  336.                 $this->arrConfiguration[$strKey] = $varValue ? true : false;
  337.                 break;
  339.             case 'forAttribute':
  340.                 $this->blnForAttribute = $varValue;
  341.                 break;
  343.             case 'dataContainer':
  344.                 $this->objDca = $varValue;
  345.                 break;
  347.             case strncmp($strKey, 'ng-', 3) === 0:
  348.             case strncmp($strKey, 'data-', 5) === 0:
  349.                 $this->arrAttributes[$strKey] = $varValue;
  350.                 break;
  352.             default:
  353.                 $this->arrConfiguration[$strKey] = $varValue;
  354.                 break;
  355.         }
  356.     }
  358.     /**
  359.      * Return an object property
  360.      *
  361.      * @param string $strKey The property name
  362.      *
  363.      * @return string The property value
  364.      */
  365.     public function __get($strKey)
  366.     {
  367.         switch ($strKey)
  368.         {
  369.             case 'id':
  370.                 return $this->strId;
  372.             case 'name':
  373.                 return $this->strName;
  375.             case 'label':
  376.                 return $this->strLabel;
  378.             case 'value':
  379.                 // Encrypt the value
  380.                 if (isset($this->arrConfiguration['encrypt']) && $this->arrConfiguration['encrypt'])
  381.                 {
  382.                     return Encryption::encrypt($this->varValue);
  383.                 }
  385.                 if ($this->varValue === '')
  386.                 {
  387.                     return $this->getEmptyStringOrNull();
  388.                 }
  390.                 return $this->varValue;
  392.             case 'class':
  393.                 return $this->strClass;
  395.             case 'prefix':
  396.                 return $this->strPrefix;
  398.             case 'template':
  399.                 return $this->strTemplate;
  401.             case 'wizard':
  402.                 return $this->strWizard;
  404.             case 'required':
  405.                 return $this->arrConfiguration[$strKey];
  407.             case 'forAttribute':
  408.                 return $this->blnForAttribute;
  410.             case 'dataContainer':
  411.                 return $this->objDca;
  413.             case 'activeRecord':
  414.                 return $this->objDca->activeRecord;
  416.             default:
  417.                 if (isset($this->arrAttributes[$strKey]))
  418.                 {
  419.                     return $this->arrAttributes[$strKey];
  420.                 }
  422.                 if (isset($this->arrConfiguration[$strKey]))
  423.                 {
  424.                     return $this->arrConfiguration[$strKey];
  425.                 }
  426.                 break;
  427.         }
  429.         return parent::__get($strKey);
  430.     }
  432.     /**
  433.      * Check whether an object property exists
  434.      *
  435.      * @param string $strKey The property name
  436.      *
  437.      * @return boolean True if the property exists
  438.      */
  439.     public function __isset($strKey)
  440.     {
  441.         switch ($strKey)
  442.         {
  443.             case 'id':
  444.                 return isset($this->strId);
  446.             case 'name':
  447.                 return isset($this->strName);
  449.             case 'label':
  450.                 return isset($this->strLabel);
  452.             case 'value':
  453.                 return isset($this->varValue);
  455.             case 'class':
  456.                 return isset($this->strClass);
  458.             case 'template':
  459.                 return isset($this->strTemplate);
  461.             case 'wizard':
  462.                 return isset($this->strWizard);
  464.             case 'required':
  465.                 return isset($this->arrConfiguration[$strKey]);
  467.             case 'forAttribute':
  468.                 return isset($this->blnForAttribute);
  470.             case 'dataContainer':
  471.                 return isset($this->objDca);
  473.             case 'activeRecord':
  474.                 return isset($this->objDca->activeRecord);
  476.             default:
  477.                 return isset($this->arrAttributes[$strKey]) || isset($this->arrConfiguration[$strKey]);
  478.         }
  479.     }
  481.     /**
  482.      * Add an attribute
  483.      *
  484.      * @param string $strName  The attribute name
  485.      * @param mixed  $varValue The attribute value
  486.      */
  487.     public function addAttribute($strName, $varValue)
  488.     {
  489.         $this->arrAttributes[$strName] = $varValue;
  490.     }
  492.     /**
  493.      * Add an error message
  494.      *
  495.      * @param string $strError The error message
  496.      */
  497.     public function addError($strError)
  498.     {
  499.         $this->class = 'error';
  500.         $this->arrErrors[] = $strError;
  501.     }
  503.     /**
  504.      * Return true if the widget has errors
  505.      *
  506.      * @return boolean True if there are errors
  507.      */
  508.     public function hasErrors()
  509.     {
  510.         return !empty($this->arrErrors);
  511.     }
  513.     /**
  514.      * Return the errors array
  515.      *
  516.      * @return array An array of error messages
  517.      */
  518.     public function getErrors()
  519.     {
  520.         return $this->arrErrors;
  521.     }
  523.     /**
  524.      * Return a particular error as string
  525.      *
  526.      * @param integer $intIndex The message index
  527.      *
  528.      * @return string The corresponding error message
  529.      */
  530.     public function getErrorAsString($intIndex=0)
  531.     {
  532.         return $this->arrErrors[$intIndex];
  533.     }
  535.     /**
  536.      * Return all errors as string separated by a given separator
  537.      *
  538.      * @param string $strSeparator An optional separator (defaults to "<br>")
  539.      *
  540.      * @return string The error messages string
  541.      */
  542.     public function getErrorsAsString($strSeparator=null)
  543.     {
  544.         if ($strSeparator === null)
  545.         {
  546.             $strSeparator = '<br' . $this->strTagEnding . "\n";
  547.         }
  549.         return $this->hasErrors() ? implode($strSeparator, $this->arrErrors) : '';
  550.     }
  552.     /**
  553.      * Return a particular error as HTML string
  554.      *
  555.      * @param integer $intIndex The message index
  556.      *
  557.      * @return string The HTML markup of the corresponding error message
  558.      */
  559.     public function getErrorAsHTML($intIndex=0)
  560.     {
  561.         return $this->hasErrors() ? sprintf('<p class="%s">%s</p>', ((TL_MODE == 'BE') ? 'tl_error tl_tip' : 'error'), $this->arrErrors[$intIndex]) : '';
  562.     }
  564.     /**
  565.      * Return true if the widgets submits user input
  566.      *
  567.      * @return boolean True if the widget submits user input
  568.      */
  569.     public function submitInput()
  570.     {
  571.         return $this->blnSubmitInput;
  572.     }
  574.     /**
  575.      * Parse the template file and return it as string
  576.      *
  577.      * @param array $arrAttributes An optional attributes array
  578.      *
  579.      * @return string The template markup
  580.      */
  581.     public function parse($arrAttributes=null)
  582.     {
  583.         if (!$this->strTemplate)
  584.         {
  585.             return '';
  586.         }
  588.         $this->addAttributes($arrAttributes);
  590.         $this->mandatoryField = $GLOBALS['TL_LANG']['MSC']['mandatory'];
  592.         if ($this->customTpl)
  593.         {
  594.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  596.             // Use the custom template unless it is a back end request
  597.             if (!$request || !System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  598.             {
  599.                 $this->strTemplate = $this->customTpl;
  600.             }
  601.         }
  603.         $strBuffer = $this->inherit();
  605.         // HOOK: add custom parse filters (see #5553)
  606.         if (isset($GLOBALS['TL_HOOKS']['parseWidget']) && \is_array($GLOBALS['TL_HOOKS']['parseWidget']))
  607.         {
  608.             foreach ($GLOBALS['TL_HOOKS']['parseWidget'] as $callback)
  609.             {
  610.                 $this->import($callback[0]);
  611.                 $strBuffer = $this->{$callback[0]}->{$callback[1]}($strBuffer, $this);
  612.             }
  613.         }
  615.         return $strBuffer;
  616.     }
  618.     /**
  619.      * Generate the label and return it as string
  620.      *
  621.      * @return string The label markup
  622.      */
  623.     public function generateLabel()
  624.     {
  625.         if (!$this->strLabel)
  626.         {
  627.             return '';
  628.         }
  630.         return sprintf(
  631.             '<label%s%s>%s%s%s</label>',
  632.             ($this->blnForAttribute ? ' for="ctrl_' . $this->strId . '"' : ''),
  633.             ($this->strClass ? ' class="' . $this->strClass . '"' : ''),
  634.             ($this->mandatory ? '<span class="invisible">' . $GLOBALS['TL_LANG']['MSC']['mandatory'] . ' </span>' : ''),
  635.             $this->strLabel,
  636.             ($this->mandatory ? '<span class="mandatory">*</span>' : '')
  637.         );
  638.     }
  640.     /**
  641.      * Generate the widget and return it as string
  642.      *
  643.      * @return string The widget markup
  644.      */
  645.     abstract public function generate();
  647.     /**
  648.      * Generate the widget with error message and return it as string
  649.      *
  650.      * @param boolean $blnSwitchOrder If true, the error message will be shown below the field
  651.      *
  652.      * @return string The form field markup
  653.      */
  654.     public function generateWithError($blnSwitchOrder=false)
  655.     {
  656.         $strWidget = $this->generate();
  657.         $strError = $this->getErrorAsHTML();
  659.         return $blnSwitchOrder ? $strWidget . $strError : $strError . $strWidget;
  660.     }
  662.     /**
  663.      * Return all attributes as string
  664.      *
  665.      * @param array $arrStrip An optional array with attributes to strip
  666.      *
  667.      * @return string The attributes string
  668.      */
  669.     public function getAttributes($arrStrip=array())
  670.     {
  671.         $strAttributes = '';
  673.         foreach (array_keys($this->arrAttributes) as $strKey)
  674.         {
  675.             if (!\in_array($strKey, $arrStrip))
  676.             {
  677.                 $strAttributes .= $this->getAttribute($strKey);
  678.             }
  679.         }
  681.         return $strAttributes;
  682.     }
  684.     /**
  685.      * Return a single attribute
  686.      *
  687.      * @param string $strKey The attribute name
  688.      *
  689.      * @return string The attribute markup
  690.      */
  691.     public function getAttribute($strKey)
  692.     {
  693.         if (!isset($this->arrAttributes[$strKey]))
  694.         {
  695.             return '';
  696.         }
  698.         $varValue = $this->arrAttributes[$strKey];
  700.         // Prevent the autofocus attribute from being added multiple times (see #8281)
  701.         if ($strKey == 'autofocus')
  702.         {
  703.             unset($this->arrAttributes[$strKey]);
  704.         }
  706.         if ($strKey == 'disabled' || $strKey == 'readonly' || $strKey == 'required' || $strKey == 'autofocus' || $strKey == 'multiple')
  707.         {
  708.             return ' ' . $strKey;
  709.         }
  711.         if ($varValue)
  712.         {
  713.             return ' ' . $strKey . '="' . StringUtil::specialchars($varValue) . '"';
  714.         }
  716.         return '';
  717.     }
  719.     /**
  720.      * Set a callback to fetch the widget input instead of using getPost()
  721.      *
  722.      * @param callable|null $callback The callback
  723.      *
  724.      * @return $this The widget object
  725.      */
  726.     public function setInputCallback(callable $callback=null)
  727.     {
  728.         $this->inputCallback = $callback;
  730.         return $this;
  731.     }
  733.     /**
  734.      * Validate the user input and set the value
  735.      */
  736.     public function validate()
  737.     {
  738.         $varValue = $this->validator($this->getPost($this->strName));
  740.         if ($this->hasErrors())
  741.         {
  742.             $this->class = 'error';
  743.         }
  745.         $this->varValue = $varValue;
  746.     }
  748.     /**
  749.      * Find and return a $_POST variable
  750.      *
  751.      * @param string $strKey The variable name
  752.      *
  753.      * @return mixed The variable value
  754.      */
  755.     protected function getPost($strKey)
  756.     {
  757.         if (\is_callable($this->inputCallback))
  758.         {
  759.             return \call_user_func($this->inputCallback);
  760.         }
  762.         if ($this->useRawRequestData === true)
  763.         {
  764.             /** @var Request $request */
  765.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  767.             return $request->request->get($strKey);
  768.         }
  770.         $strMethod = $this->allowHtml ? 'postHtml' : 'post';
  772.         if ($this->preserveTags)
  773.         {
  774.             $strMethod = 'postRaw';
  775.         }
  777.         // Support arrays (thanks to Andreas Schempp)
  778.         $arrParts = explode('[', str_replace(']', '', (string) $strKey));
  779.         $varValue = Input::$strMethod(array_shift($arrParts), $this->decodeEntities);
  781.         foreach ($arrParts as $part)
  782.         {
  783.             if (!\is_array($varValue))
  784.             {
  785.                 break;
  786.             }
  788.             $varValue = $varValue[$part] ?? null;
  789.         }
  791.         return $varValue;
  792.     }
  794.     /**
  795.      * Recursively validate an input variable
  796.      *
  797.      * @param mixed $varInput The user input
  798.      *
  799.      * @return mixed The original or modified user input
  800.      */
  801.     protected function validator($varInput)
  802.     {
  803.         if (\is_array($varInput))
  804.         {
  805.             foreach ($varInput as $k=>$v)
  806.             {
  807.                 $varInput[$k] = $this->validator($v);
  808.             }
  810.             return $varInput;
  811.         }
  813.         if (!$this->doNotTrim)
  814.         {
  815.             $varInput = trim($varInput);
  816.         }
  818.         if ((string) $varInput === '')
  819.         {
  820.             if (!$this->mandatory)
  821.             {
  822.                 return '';
  823.             }
  825.             if (!$this->strLabel)
  826.             {
  827.                 $this->addError($GLOBALS['TL_LANG']['ERR']['mdtryNoLabel']);
  828.             }
  829.             else
  830.             {
  831.                 $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['mandatory'], $this->strLabel));
  832.             }
  833.         }
  835.         if ($this->minlength && $varInput && Utf8::strlen($varInput) < $this->minlength)
  836.         {
  837.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minlength'], $this->strLabel, $this->minlength));
  838.         }
  840.         if ($this->maxlength && $varInput && Utf8::strlen($varInput) > $this->maxlength)
  841.         {
  842.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxlength'], $this->strLabel, $this->maxlength));
  843.         }
  845.         if ($this->minval && is_numeric($varInput) && $varInput < $this->minval)
  846.         {
  847.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minval'], $this->strLabel, $this->minval));
  848.         }
  850.         if ($this->maxval && is_numeric($varInput) && $varInput > $this->maxval)
  851.         {
  852.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxval'], $this->strLabel, $this->maxval));
  853.         }
  855.         if ($this->rgxp)
  856.         {
  857.             switch ($this->rgxp)
  858.             {
  859.                 case strncmp($this->rgxp, 'digit_', 6) === 0:
  860.                     // Special validation rule for style sheets
  861.                     $textual = explode('_', $this->rgxp);
  862.                     array_shift($textual);
  864.                     if (\in_array($varInput, $textual) || strncmp($varInput, '$', 1) === 0)
  865.                     {
  866.                         break;
  867.                     }
  868.                     // no break
  870.                 case 'digit':
  871.                     // Support decimal commas and convert them automatically (see #3488)
  872.                     if (substr_count($varInput, ',') == 1 && strpos($varInput, '.') === false)
  873.                     {
  874.                         $varInput = str_replace(',', '.', $varInput);
  875.                     }
  877.                     if (!Validator::isNumeric($varInput))
  878.                     {
  879.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['digit'], $this->strLabel));
  880.                     }
  881.                     break;
  883.                 case 'natural':
  884.                     if (!Validator::isNatural($varInput))
  885.                     {
  886.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['natural'], $this->strLabel));
  887.                     }
  888.                     break;
  890.                 case 'alpha':
  891.                     if (!Validator::isAlphabetic($varInput))
  892.                     {
  893.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alpha'], $this->strLabel));
  894.                     }
  895.                     break;
  897.                 case 'alnum':
  898.                     if (!Validator::isAlphanumeric($varInput))
  899.                     {
  900.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alnum'], $this->strLabel));
  901.                     }
  902.                     break;
  904.                 case 'extnd':
  905.                     if (!Validator::isExtendedAlphanumeric(html_entity_decode($varInput)))
  906.                     {
  907.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['extnd'], $this->strLabel));
  908.                     }
  909.                     break;
  911.                 case 'date':
  912.                     if (!Validator::isDate($varInput))
  913.                     {
  914.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['date'], Date::getInputFormat(Date::getNumericDateFormat())));
  915.                     }
  916.                     else
  917.                     {
  918.                         // Validate the date (see #5086)
  919.                         try
  920.                         {
  921.                             new Date($varInput, Date::getNumericDateFormat());
  922.                         }
  923.                         catch (\OutOfBoundsException $e)
  924.                         {
  925.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  926.                         }
  927.                     }
  928.                     break;
  930.                 case 'time':
  931.                     if (!Validator::isTime($varInput))
  932.                     {
  933.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['time'], Date::getInputFormat(Date::getNumericTimeFormat())));
  934.                     }
  935.                     break;
  937.                 case 'datim':
  938.                     if (!Validator::isDatim($varInput))
  939.                     {
  940.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['dateTime'], Date::getInputFormat(Date::getNumericDatimFormat())));
  941.                     }
  942.                     else
  943.                     {
  944.                         // Validate the date (see #5086)
  945.                         try
  946.                         {
  947.                             new Date($varInput, Date::getNumericDatimFormat());
  948.                         }
  949.                         catch (\OutOfBoundsException $e)
  950.                         {
  951.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  952.                         }
  953.                     }
  954.                     break;
  956.                 case 'friendly':
  957.                     list ($strName, $varInput) = StringUtil::splitFriendlyEmail($varInput);
  958.                     // no break
  960.                 case 'email':
  961.                     if (!Validator::isEmail($varInput))
  962.                     {
  963.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['email'], $this->strLabel));
  964.                     }
  966.                     if ($this->rgxp == 'friendly' && !empty($strName))
  967.                     {
  968.                         $varInput = $strName . ' [' . $varInput . ']';
  969.                     }
  970.                     break;
  972.                 case 'emails':
  973.                     // Check whether the current value is list of valid e-mail addresses
  974.                     $arrEmails = StringUtil::trimsplit(',', $varInput);
  976.                     foreach ($arrEmails as $strEmail)
  977.                     {
  978.                         $strEmail = Idna::encodeEmail($strEmail);
  980.                         if (!Validator::isEmail($strEmail))
  981.                         {
  982.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['emails'], $this->strLabel));
  983.                             break;
  984.                         }
  985.                     }
  986.                     break;
  988.                 case 'url':
  989.                     $varInput = StringUtil::specialcharsUrl($varInput);
  991.                     if ($this->decodeEntities)
  992.                     {
  993.                         $varInput = StringUtil::decodeEntities($varInput);
  994.                     }
  996.                     if (!Validator::isUrl($varInput))
  997.                     {
  998.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['url'], $this->strLabel));
  999.                     }
  1000.                     break;
  1002.                 case 'alias':
  1003.                     if (!Validator::isAlias($varInput))
  1004.                     {
  1005.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alias'], $this->strLabel));
  1006.                     }
  1007.                     break;
  1009.                 case 'folderalias':
  1010.                     if (!Validator::isFolderAlias($varInput))
  1011.                     {
  1012.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['folderalias'], $this->strLabel));
  1013.                     }
  1014.                     break;
  1016.                 case 'phone':
  1017.                     if (!Validator::isPhone(html_entity_decode($varInput)))
  1018.                     {
  1019.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['phone'], $this->strLabel));
  1020.                     }
  1021.                     break;
  1023.                 case 'prcnt':
  1024.                     if (!Validator::isPercent($varInput))
  1025.                     {
  1026.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['prcnt'], $this->strLabel));
  1027.                     }
  1028.                     break;
  1030.                 case 'locale':
  1031.                     if (!Validator::isLocale($varInput))
  1032.                     {
  1033.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['locale'], $this->strLabel));
  1034.                     }
  1035.                     break;
  1037.                 case 'language':
  1038.                     if (!Validator::isLanguage($varInput))
  1039.                     {
  1040.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['language'], $this->strLabel));
  1041.                     }
  1042.                     break;
  1044.                 case 'google+':
  1045.                     if (!Validator::isGooglePlusId($varInput))
  1046.                     {
  1047.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidGoogleId'], $this->strLabel));
  1048.                     }
  1049.                     break;
  1051.                 case 'fieldname':
  1052.                     if (!Validator::isFieldName($varInput))
  1053.                     {
  1054.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidFieldName'], $this->strLabel));
  1055.                     }
  1056.                     break;
  1058.                 // HOOK: pass unknown tags to callback functions
  1059.                 default:
  1060.                     if (isset($GLOBALS['TL_HOOKS']['addCustomRegexp']) && \is_array($GLOBALS['TL_HOOKS']['addCustomRegexp']))
  1061.                     {
  1062.                         foreach ($GLOBALS['TL_HOOKS']['addCustomRegexp'] as $callback)
  1063.                         {
  1064.                             $this->import($callback[0]);
  1065.                             $break = $this->{$callback[0]}->{$callback[1]}($this->rgxp, $varInput, $this);
  1067.                             // Stop the loop if a callback returned true
  1068.                             if ($break === true)
  1069.                             {
  1070.                                 break;
  1071.                             }
  1072.                         }
  1073.                     }
  1074.                     break;
  1075.             }
  1076.         }
  1078.         if ($this->isHexColor && $varInput && strncmp($varInput, '$', 1) !== 0)
  1079.         {
  1080.             $varInput = preg_replace('/[^a-f0-9]+/i', '', $varInput);
  1081.         }
  1083.         if ($this->nospace && preg_match('/[\t ]+/', $varInput))
  1084.         {
  1085.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['noSpace'], $this->strLabel));
  1086.         }
  1088.         if ($this->spaceToUnderscore)
  1089.         {
  1090.             $varInput = preg_replace('/\s+/', '_', trim($varInput));
  1091.         }
  1093.         if (\is_bool($this->trailingSlash) && $varInput)
  1094.         {
  1095.             $varInput = preg_replace('/\/+$/', '', $varInput) . ($this->trailingSlash ? '/' : '');
  1096.         }
  1098.         return $varInput;
  1099.     }
  1101.     /**
  1102.      * Take an associative array and add it to the object's attributes
  1103.      *
  1104.      * @param array $arrAttributes An array of attributes
  1105.      */
  1106.     public function addAttributes($arrAttributes)
  1107.     {
  1108.         if (!\is_array($arrAttributes))
  1109.         {
  1110.             return;
  1111.         }
  1113.         foreach ($arrAttributes as $k=>$v)
  1114.         {
  1115.             $this->$k = $v;
  1116.         }
  1117.     }
  1119.     /**
  1120.      * Check whether an option is checked
  1121.      *
  1122.      * @param array $arrOption The options array
  1123.      *
  1124.      * @return string The "checked" attribute or an empty string
  1125.      */
  1126.     protected function isChecked($arrOption)
  1127.     {
  1128.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1129.         {
  1130.             return static::optionChecked(1, 1);
  1131.         }
  1133.         return static::optionChecked($arrOption['value'] ?? null, $this->varValue);
  1134.     }
  1136.     /**
  1137.      * Check whether an option is selected
  1138.      *
  1139.      * @param array $arrOption The options array
  1140.      *
  1141.      * @return string The "selected" attribute or an empty string
  1142.      */
  1143.     protected function isSelected($arrOption)
  1144.     {
  1145.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1146.         {
  1147.             return static::optionSelected(1, 1);
  1148.         }
  1150.         return static::optionSelected($arrOption['value'] ?? null, $this->varValue);
  1151.     }
  1153.     /**
  1154.      * Return a "selected" attribute if the option is selected
  1155.      *
  1156.      * @param string $strOption The option to check
  1157.      * @param mixed  $varValues One or more values to check against
  1158.      *
  1159.      * @return string The attribute or an empty string
  1160.      */
  1161.     public static function optionSelected($strOption, $varValues)
  1162.     {
  1163.         if ($strOption === '')
  1164.         {
  1165.             return '';
  1166.         }
  1168.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' selected' : '';
  1169.     }
  1171.     /**
  1172.      * Return a "checked" attribute if the option is checked
  1173.      *
  1174.      * @param string $strOption The option to check
  1175.      * @param mixed  $varValues One or more values to check against
  1176.      *
  1177.      * @return string The attribute or an empty string
  1178.      */
  1179.     public static function optionChecked($strOption, $varValues)
  1180.     {
  1181.         if ($strOption === '')
  1182.         {
  1183.             return '';
  1184.         }
  1186.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' checked' : '';
  1187.     }
  1189.     /**
  1190.      * Check whether an input is one of the given options
  1191.      *
  1192.      * @param mixed $varInput The input string or array
  1193.      *
  1194.      * @return boolean True if the selected option exists
  1195.      */
  1196.     protected function isValidOption($varInput)
  1197.     {
  1198.         if (!\is_array($varInput))
  1199.         {
  1200.             $varInput = array($varInput);
  1201.         }
  1203.         // Check each option
  1204.         foreach ($varInput as $strInput)
  1205.         {
  1206.             $blnFound = false;
  1208.             foreach ($this->arrOptions as $v)
  1209.             {
  1210.                 // Single dimensional array
  1211.                 if (\array_key_exists('value', $v))
  1212.                 {
  1213.                     if ($strInput == $v['value'])
  1214.                     {
  1215.                         $blnFound = true;
  1216.                     }
  1217.                 }
  1218.                 // Multi-dimensional array
  1219.                 else
  1220.                 {
  1221.                     foreach ($v as $vv)
  1222.                     {
  1223.                         if ($strInput == $vv['value'])
  1224.                         {
  1225.                             $blnFound = true;
  1226.                         }
  1227.                     }
  1228.                 }
  1229.             }
  1231.             if (!$blnFound)
  1232.             {
  1233.                 return false;
  1234.             }
  1235.         }
  1237.         return true;
  1238.     }
  1240.     /**
  1241.      * Extract the Widget attributes from a Data Container array
  1242.      *
  1243.      * @param array                     $arrData  The field configuration array
  1244.      * @param string                    $strName  The field name in the form
  1245.      * @param mixed                     $varValue The field value
  1246.      * @param string                    $strField The field name in the database
  1247.      * @param string                    $strTable The table name in the database
  1248.      * @param DataContainer|Module|null $objDca   An optional DataContainer or Module object
  1249.      *
  1250.      * @return array An attributes array that can be passed to a widget
  1251.      */
  1252.     public static function getAttributesFromDca($arrData, $strName, $varValue=null, $strField='', $strTable='', $objDca=null)
  1253.     {
  1254.         $arrAttributes = $arrData['eval'] ?? array();
  1256.         if (method_exists(System::getContainer(), 'getParameterBag'))
  1257.         {
  1258.             $objParameterBag = System::getContainer()->getParameterBag();
  1260.             foreach ($arrAttributes as $strAttrKey => $varAttrValue)
  1261.             {
  1262.                 if (!\is_string($varAttrValue) || !preg_match('/%[a-z][a-z0-9_]*\.[a-z0-9_.]+%/i', $varAttrValue, $arrMatches))
  1263.                 {
  1264.                     continue;
  1265.                 }
  1267.                 $varAttrValue = $objParameterBag->resolveValue($varAttrValue);
  1268.                 $varAttrValue = $objParameterBag->unescapeValue($varAttrValue);
  1270.                 $arrAttributes[$strAttrKey] = $varAttrValue;
  1271.             }
  1272.         }
  1274.         $arrAttributes['id'] = $strName;
  1275.         $arrAttributes['name'] = $strName;
  1276.         $arrAttributes['strField'] = $strField;
  1277.         $arrAttributes['strTable'] = $strTable;
  1278.         $arrAttributes['label'] = (($label = \is_array($arrData['label'] ?? null) ? $arrData['label'][0] : $arrData['label'] ?? null) !== null) ? $label : $strField;
  1279.         $arrAttributes['description'] = $arrData['label'][1] ?? null;
  1280.         $arrAttributes['type'] = $arrData['inputType'] ?? null;
  1281.         $arrAttributes['dataContainer'] = $objDca;
  1282.         $arrAttributes['value'] = StringUtil::deserialize($varValue);
  1284.         // Internet Explorer does not support onchange for checkboxes and radio buttons
  1285.         if ($arrData['eval']['submitOnChange'] ?? null)
  1286.         {
  1287.             if (($arrData['inputType'] ?? null) == 'checkbox' || ($arrData['inputType'] ?? null) == 'checkboxWizard' || ($arrData['inputType'] ?? null) == 'radio' || ($arrData['inputType'] ?? null) == 'radioTable')
  1288.             {
  1289.                 $arrAttributes['onclick'] = trim(($arrAttributes['onclick'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1290.             }
  1291.             else
  1292.             {
  1293.                 $arrAttributes['onchange'] = trim(($arrAttributes['onchange'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1294.             }
  1295.         }
  1297.         if (!empty($arrData['eval']['preserveTags']))
  1298.         {
  1299.             $arrAttributes['allowHtml'] = true;
  1300.         }
  1302.         if (!isset($arrAttributes['allowHtml']))
  1303.         {
  1304.             $rte = $arrData['eval']['rte'] ?? '';
  1305.             $arrAttributes['allowHtml'] = 'ace|html' === $rte || 0 === strpos($rte, 'tiny');
  1306.         }
  1308.         // Decode entities if HTML is allowed
  1309.         if ($arrAttributes['allowHtml'] || ($arrData['inputType'] ?? null) == 'fileTree')
  1310.         {
  1311.             $arrAttributes['decodeEntities'] = true;
  1312.         }
  1314.         // Add Ajax event
  1315.         if (($arrData['inputType'] ?? null) == 'checkbox' && ($arrData['eval']['submitOnChange'] ?? null) && \is_array($GLOBALS['TL_DCA'][$strTable]['subpalettes'] ?? null) && \array_key_exists($strField, $GLOBALS['TL_DCA'][$strTable]['subpalettes']))
  1316.         {
  1317.             $arrAttributes['onclick'] = "AjaxRequest.toggleSubpalette(this, 'sub_" . $strName . "', '" . $strField . "')";
  1318.         }
  1320.         // Options callback
  1321.         if (\is_array($arrData['options_callback'] ?? null))
  1322.         {
  1323.             $arrCallback = $arrData['options_callback'];
  1324.             $arrData['options'] = static::importStatic($arrCallback[0])->{$arrCallback[1]}($objDca);
  1325.         }
  1326.         elseif (\is_callable($arrData['options_callback'] ?? null))
  1327.         {
  1328.             $arrData['options'] = $arrData['options_callback']($objDca);
  1329.         }
  1331.         // Foreign key
  1332.         elseif (isset($arrData['foreignKey']))
  1333.         {
  1334.             $arrKey = explode('.', $arrData['foreignKey'], 2);
  1335.             $objOptions = Database::getInstance()->query("SELECT id, " . $arrKey[1] . " AS value FROM " . $arrKey[0] . " WHERE tstamp>0 ORDER BY value");
  1336.             $arrData['options'] = array();
  1338.             while ($objOptions->next())
  1339.             {
  1340.                 $arrData['options'][$objOptions->id] = $objOptions->value;
  1341.             }
  1342.         }
  1344.         // Add default option to single checkbox
  1345.         if (($arrData['inputType'] ?? null) == 'checkbox' && !isset($arrData['options']) && !isset($arrData['options_callback']) && !isset($arrData['foreignKey']))
  1346.         {
  1347.             if (TL_MODE == 'FE' && isset($arrAttributes['description']))
  1348.             {
  1349.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['description']);
  1350.             }
  1351.             else
  1352.             {
  1353.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['label']);
  1354.             }
  1355.         }
  1357.         // Add options
  1358.         if (\is_array($arrData['options'] ?? null))
  1359.         {
  1360.             $blnIsAssociative = ($arrData['eval']['isAssociative'] ?? null) || ArrayUtil::isAssoc($arrData['options'] ?? null);
  1361.             $blnUseReference = isset($arrData['reference']);
  1363.             if (($arrData['eval']['includeBlankOption'] ?? null) && !($arrData['eval']['multiple'] ?? null))
  1364.             {
  1365.                 $strLabel = $arrData['eval']['blankOptionLabel'] ?? '-';
  1366.                 $arrAttributes['options'][] = array('value'=>'', 'label'=>$strLabel);
  1367.             }
  1369.             $unknown = (array) $arrAttributes['value'];
  1371.             foreach ($arrData['options'] as $k=>$v)
  1372.             {
  1373.                 if (!\is_array($v))
  1374.                 {
  1375.                     $value = $blnIsAssociative ? $k : $v;
  1377.                     if (($i = array_search($value, $unknown)) !== false)
  1378.                     {
  1379.                         unset($unknown[$i]);
  1380.                     }
  1382.                     $arrAttributes['options'][] = array('value'=>$value, 'label'=>($blnUseReference && isset($arrData['reference'][$v]) ? ((($ref = (\is_array($arrData['reference'][$v]) ? $arrData['reference'][$v][0] : $arrData['reference'][$v])) != false) ? $ref : $v) : $v));
  1383.                     continue;
  1384.                 }
  1386.                 $key = $blnUseReference && isset($arrData['reference'][$k]) ? ((($ref = (\is_array($arrData['reference'][$k]) ? $arrData['reference'][$k][0] : $arrData['reference'][$k])) != false) ? $ref : $k) : $k;
  1387.                 $blnIsAssoc = ArrayUtil::isAssoc($v);
  1389.                 foreach ($v as $kk=>$vv)
  1390.                 {
  1391.                     $value = $blnIsAssoc ? $kk : $vv;
  1393.                     if (($i = array_search($value, $unknown)) !== false)
  1394.                     {
  1395.                         unset($unknown[$i]);
  1396.                     }
  1398.                     $arrAttributes['options'][$key][] = array('value'=>$value, 'label'=>($blnUseReference && isset($arrData['reference'][$vv]) ? ((($ref = (\is_array($arrData['reference'][$vv]) ? $arrData['reference'][$vv][0] : $arrData['reference'][$vv])) != false) ? $ref : $vv) : $vv));
  1399.                 }
  1400.             }
  1402.             $arrAttributes['unknownOption'] = array_filter($unknown);
  1403.         }
  1405.         if (\is_array($arrAttributes['sql'] ?? null) && !isset($arrAttributes['sql']['columnDefinition']))
  1406.         {
  1407.             if (!isset($arrAttributes['maxlength']) && isset($arrAttributes['sql']['length']))
  1408.             {
  1409.                 $arrAttributes['maxlength'] = $arrAttributes['sql']['length'];
  1410.             }
  1412.             if (!isset($arrAttributes['unique']) && isset($arrAttributes['sql']['customSchemaOptions']['unique']))
  1413.             {
  1414.                 $arrAttributes['unique'] = $arrAttributes['sql']['customSchemaOptions']['unique'];
  1415.             }
  1416.         }
  1418.         // Convert timestamps
  1419.         if ($varValue !== null && $varValue !== '' && \in_array($arrData['eval']['rgxp'] ?? null, array('date', 'time', 'datim')))
  1420.         {
  1421.             $objDate = new Date($varValue, Date::getFormatFromRgxp($arrData['eval']['rgxp']));
  1422.             $arrAttributes['value'] = $objDate->{$arrData['eval']['rgxp']};
  1423.         }
  1425.         // Convert URL insert tags
  1426.         if ($varValue && 'url' === ($arrData['eval']['rgxp'] ?? null))
  1427.         {
  1428.             $arrAttributes['value'] = str_replace('|urlattr}}', '}}', $varValue);
  1429.         }
  1431.         // Add the "rootNodes" array as attribute (see #3563)
  1432.         if (isset($arrData['rootNodes']) && !isset($arrData['eval']['rootNodes']))
  1433.         {
  1434.             $arrAttributes['rootNodes'] = $arrData['rootNodes'];
  1435.         }
  1437.         // HOOK: add custom logic
  1438.         if (isset($GLOBALS['TL_HOOKS']['getAttributesFromDca']) && \is_array($GLOBALS['TL_HOOKS']['getAttributesFromDca']))
  1439.         {
  1440.             foreach ($GLOBALS['TL_HOOKS']['getAttributesFromDca'] as $callback)
  1441.             {
  1442.                 $arrAttributes = static::importStatic($callback[0])->{$callback[1]}($arrAttributes, $objDca);
  1443.             }
  1444.         }
  1446.         // Warn if someone uses the "encrypt" flag (see #8589)
  1447.         if (isset($arrAttributes['encrypt']))
  1448.         {
  1449.             trigger_deprecation('contao/core-bundle', '4.0', 'Using the "encrypt" flag' . (!empty($strTable) && !empty($strField) ? ' on ' . $strTable . '.' . $strField : '') . ' has been deprecated and will no longer work in Contao 5.0. Use the load and save callbacks with a third-party library such as OpenSSL or phpseclib instead.');
  1450.         }
  1452.         return $arrAttributes;
  1453.     }
  1455.     /**
  1456.      * Return the empty value based on the SQL string
  1457.      *
  1458.      * @return string|integer|null The empty value
  1459.      */
  1460.     public function getEmptyValue()
  1461.     {
  1462.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1463.         {
  1464.             return '';
  1465.         }
  1467.         return static::getEmptyValueByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1468.     }
  1470.     /**
  1471.      * Return the empty value based on the SQL string
  1472.      *
  1473.      * @param string|array $sql The SQL string
  1474.      *
  1475.      * @return string|integer|null The empty value
  1476.      */
  1477.     public static function getEmptyValueByFieldType($sql)
  1478.     {
  1479.         if (empty($sql))
  1480.         {
  1481.             return '';
  1482.         }
  1484.         if (\is_array($sql))
  1485.         {
  1486.             if (isset($sql['columnDefinition']))
  1487.             {
  1488.                 $sql = $sql['columnDefinition'];
  1489.             }
  1490.             else
  1491.             {
  1492.                 if (isset($sql['notnull']) && !$sql['notnull'])
  1493.                 {
  1494.                     return null;
  1495.                 }
  1497.                 if (\in_array($sql['type'], array(Types::BIGINT, Types::DECIMAL, Types::INTEGER, Types::SMALLINT, Types::FLOAT)))
  1498.                 {
  1499.                     return 0;
  1500.                 }
  1502.                 if ($sql['type'] === Types::BOOLEAN)
  1503.                 {
  1504.                     return false;
  1505.                 }
  1507.                 return '';
  1508.             }
  1509.         }
  1511.         if (stripos($sql, 'NOT NULL') === false)
  1512.         {
  1513.             return null;
  1514.         }
  1516.         $type = strtolower(preg_replace('/^([A-Za-z]+)[( ].*$/', '$1', $sql));
  1518.         if (\in_array($type, array('int', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint', 'float', 'double', 'dec', 'decimal')))
  1519.         {
  1520.             return 0;
  1521.         }
  1523.         return '';
  1524.     }
  1526.     /**
  1527.      * Return either an empty string or null based on the SQL string
  1528.      *
  1529.      * @return string|int|null The empty value
  1530.      */
  1531.     public function getEmptyStringOrNull()
  1532.     {
  1533.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1534.         {
  1535.             return '';
  1536.         }
  1538.         return static::getEmptyStringOrNullByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1539.     }
  1541.     /**
  1542.      * Return either an empty string or null based on the SQL string
  1543.      *
  1544.      * @param string $sql The SQL string
  1545.      *
  1546.      * @return string|null The empty string or null
  1547.      */
  1548.     public static function getEmptyStringOrNullByFieldType($sql)
  1549.     {
  1550.         if (empty($sql))
  1551.         {
  1552.             return '';
  1553.         }
  1555.         return static::getEmptyValueByFieldType($sql) === null ? null : '';
  1556.     }
  1558.     /**
  1559.      * Generate a submit button
  1560.      *
  1561.      * @return string The submit button markup
  1562.      *
  1563.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1564.      */
  1565.     protected function addSubmit()
  1566.     {
  1567.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Widget::addSubmit()" has been deprecated and will no longer work in Contao 5.0.');
  1569.         return '';
  1570.     }
  1571. }
  1573. class_alias(Widget::class, 'Widget');