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

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