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

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        $type               the field type
  41.  * @property string        $name               the field name
  42.  * @property string        $label              The field label
  43.  * @property mixed         $value              The field value
  44.  * @property string        $class              One or more CSS classes
  45.  * @property string        $prefix             The CSS class prefix
  46.  * @property string        $template           The template name
  47.  * @property string        $wizard             The field wizard markup
  48.  * @property string        $alt                The alternative text
  49.  * @property string        $style              The style attribute
  50.  * @property string        $accesskey          The key to focus the field
  51.  * @property integer       $tabindex           The tabindex of the field
  52.  * @property boolean       $disabled           Adds the disabled attribute
  53.  * @property boolean       $readonly           Adds the readonly attribute
  54.  * @property boolean       $autofocus          Adds the autofocus attribute
  55.  * @property boolean       $required           Adds the required attribute
  56.  * @property string        $onblur             The blur event
  57.  * @property string        $onchange           The change event
  58.  * @property string        $onclick            The click event
  59.  * @property string        $ondblclick         The double click event
  60.  * @property string        $onfocus            The focus event
  61.  * @property string        $onmousedown        The mouse down event
  62.  * @property string        $onmousemove        The mouse move event
  63.  * @property string        $onmouseout         The mouse out event
  64.  * @property string        $onmouseover        The mouse over event
  65.  * @property string        $onmouseup          The mouse up event
  66.  * @property string        $onkeydown          The key down event
  67.  * @property string        $onkeypress         The key press event
  68.  * @property string        $onkeyup            The key up event
  69.  * @property string        $onselect           The select event
  70.  * @property boolean       $mandatory          The field value must not be empty
  71.  * @property boolean       $nospace            Do not allow whitespace characters
  72.  * @property boolean       $allowHtml          Allow HTML tags in the field value
  73.  * @property boolean       $storeFile          Store uploaded files in a given folder
  74.  * @property boolean       $useHomeDir         Store uploaded files in the user's home directory
  75.  * @property boolean       $trailingSlash      Add or remove a trailing slash
  76.  * @property boolean       $spaceToUnderscore  Convert spaces to underscores
  77.  * @property boolean       $doNotTrim          Do not trim the user input
  78.  * @property string        $forAttribute       The "for" attribute
  79.  * @property DataContainer $dataContainer      The data container object
  80.  * @property Result        $activeRecord       The active record
  81.  * @property string        $mandatoryField     The "mandatory field" label
  82.  * @property string        $customTpl          A custom template name
  83.  * @property string        $slabel             The submit button label
  84.  * @property boolean       $preserveTags       Preserve HTML tags
  85.  * @property boolean       $decodeEntities     Decode HTML entities
  86.  * @property boolean       $useRawRequestData  Use the raw request data from the Symfony request
  87.  * @property integer       $minlength          The minimum length
  88.  * @property integer       $maxlength          The maximum length
  89.  * @property integer       $minval             The minimum value
  90.  * @property integer       $maxval             The maximum value
  91.  * @property integer       $rgxp               The regular expression name
  92.  * @property boolean       $isHexColor         The field value is a hex color
  93.  * @property string        $strTable           The table name
  94.  * @property string        $strField           The field name
  95.  * @property string        $xlabel
  96.  * @property string        $customRgxp
  97.  * @property string        $errorMsg
  98.  * @property integer       $currentRecord
  99.  * @property integer       $rowClass
  100.  * @property integer       $rowClassConfirm
  101.  * @property integer       $storeValues
  102.  * @property boolean       $includeBlankOption
  103.  * @property string        $blankOptionLabel
  104.  */
  105. abstract class Widget extends Controller
  106. {
  107.     use TemplateInheritance;
  109.     /**
  110.      * Id
  111.      * @var integer
  112.      */
  113.     protected $strId;
  115.     /**
  116.      * Name
  117.      * @var string
  118.      */
  119.     protected $strName;
  121.     /**
  122.      * Label
  123.      * @var string
  124.      */
  125.     protected $strLabel;
  127.     /**
  128.      * Value
  129.      * @var mixed
  130.      */
  131.     protected $varValue;
  133.     /**
  134.      * Input callback
  135.      * @var callable
  136.      */
  137.     protected $inputCallback;
  139.     /**
  140.      * CSS class
  141.      * @var string
  142.      */
  143.     protected $strClass;
  145.     /**
  146.      * CSS class prefix
  147.      * @var string
  148.      */
  149.     protected $strPrefix;
  151.     /**
  152.      * Wizard
  153.      * @var string
  154.      */
  155.     protected $strWizard;
  157.     /**
  158.      * Errors
  159.      * @var array
  160.      */
  161.     protected $arrErrors = array();
  163.     /**
  164.      * Attributes
  165.      * @var array
  166.      */
  167.     protected $arrAttributes = array();
  169.     /**
  170.      * Configuration
  171.      * @var array
  172.      */
  173.     protected $arrConfiguration = array();
  175.     /**
  176.      * Options
  177.      * @var array
  178.      */
  179.     protected $arrOptions = array();
  181.     /**
  182.      * Submit indicator
  183.      * @var boolean
  184.      */
  185.     protected $blnSubmitInput = false;
  187.     /**
  188.      * For attribute indicator
  189.      * @var boolean
  190.      */
  191.     protected $blnForAttribute = false;
  193.     /**
  194.      * Data container
  195.      * @var object
  196.      */
  197.     protected $objDca;
  199.     /**
  200.      * Initialize the object
  201.      *
  202.      * @param array $arrAttributes An optional attributes array
  203.      */
  204.     public function __construct($arrAttributes=null)
  205.     {
  206.         parent::__construct();
  208.         $this->addAttributes($arrAttributes);
  209.     }
  211.     /**
  212.      * Set an object property
  213.      *
  214.      * @param string $strKey   The property name
  215.      * @param mixed  $varValue The property value
  216.      */
  217.     public function __set($strKey, $varValue)
  218.     {
  219.         switch ($strKey)
  220.         {
  221.             case 'id':
  222.                 $this->strId = $varValue;
  223.                 break;
  225.             case 'name':
  226.                 $this->strName = $varValue;
  227.                 break;
  229.             case 'label':
  230.                 $this->strLabel = $varValue;
  231.                 break;
  233.             case 'value':
  234.                 if (\is_float($varValue))
  235.                 {
  236.                     // Prevent exponential notations (see #5296)
  237.                     $this->varValue = StringUtil::numberToString($varValue);
  238.                 }
  239.                 else
  240.                 {
  241.                     $this->varValue = StringUtil::deserialize($varValue);
  242.                 }
  244.                 // Decrypt the value if it is encrypted
  245.                 if ($this->arrConfiguration['encrypt'] ?? null)
  246.                 {
  247.                     $this->varValue = Encryption::decrypt($this->varValue);
  248.                 }
  249.                 break;
  251.             case 'class':
  252.                 if ($varValue && strpos($this->strClass ?? '', $varValue) === false)
  253.                 {
  254.                     $this->strClass = trim($this->strClass . ' ' . $varValue);
  255.                 }
  256.                 break;
  258.             case 'prefix':
  259.                 $this->strPrefix = $varValue;
  260.                 break;
  262.             case 'template':
  263.                 $this->strTemplate = $varValue;
  264.                 break;
  266.             case 'wizard':
  267.                 $this->strWizard = $varValue;
  268.                 break;
  270.             case 'autocomplete':
  271.             case 'autocorrect':
  272.             case 'autocapitalize':
  273.             case 'spellcheck':
  274.                 if (\is_bool($varValue))
  275.                 {
  276.                     $varValue = $varValue ? 'on' : 'off';
  277.                 }
  278.                 // no break
  280.             case 'alt':
  281.             case 'style':
  282.             case 'accesskey':
  283.             case 'onblur':
  284.             case 'onchange':
  285.             case 'onclick':
  286.             case 'ondblclick':
  287.             case 'onfocus':
  288.             case 'onmousedown':
  289.             case 'onmousemove':
  290.             case 'onmouseout':
  291.             case 'onmouseover':
  292.             case 'onmouseup':
  293.             case 'onkeydown':
  294.             case 'onkeypress':
  295.             case 'onkeyup':
  296.             case 'onselect':
  297.                 $this->arrAttributes[$strKey] = $varValue;
  298.                 break;
  300.             case 'tabindex':
  301.                 if ($varValue > 0)
  302.                 {
  303.                     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.');
  304.                     $this->arrAttributes['tabindex'] = $varValue;
  305.                 }
  306.                 break;
  308.             case 'disabled':
  309.             case 'readonly':
  310.                 $this->blnSubmitInput = $varValue ? false : true;
  311.                 // no break
  313.             case 'autofocus':
  314.                 if ($varValue)
  315.                 {
  316.                     $this->arrAttributes[$strKey] = $strKey;
  317.                 }
  318.                 else
  319.                 {
  320.                     unset($this->arrAttributes[$strKey]);
  321.                 }
  322.                 break;
  324.             case 'required':
  325.                 if ($varValue)
  326.                 {
  327.                     $this->strClass = trim($this->strClass . ' mandatory');
  328.                 }
  329.                 // no break
  331.             case 'mandatory':
  332.             case 'nospace':
  333.             case 'allowHtml':
  334.             case 'storeFile':
  335.             case 'useHomeDir':
  336.             case 'storeValues':
  337.             case 'trailingSlash':
  338.             case 'spaceToUnderscore':
  339.             case 'doNotTrim':
  340.             case 'useRawRequestData':
  341.                 $this->arrConfiguration[$strKey] = $varValue ? true : false;
  342.                 break;
  344.             case 'forAttribute':
  345.                 $this->blnForAttribute = $varValue;
  346.                 break;
  348.             case 'dataContainer':
  349.                 $this->objDca = $varValue;
  350.                 break;
  352.             case strncmp($strKey, 'ng-', 3) === 0:
  353.             case strncmp($strKey, 'data-', 5) === 0:
  354.                 $this->arrAttributes[$strKey] = $varValue;
  355.                 break;
  357.             default:
  358.                 $this->arrConfiguration[$strKey] = $varValue;
  359.                 break;
  360.         }
  361.     }
  363.     /**
  364.      * Return an object property
  365.      *
  366.      * @param string $strKey The property name
  367.      *
  368.      * @return string The property value
  369.      */
  370.     public function __get($strKey)
  371.     {
  372.         switch ($strKey)
  373.         {
  374.             case 'id':
  375.                 return $this->strId;
  377.             case 'name':
  378.                 return $this->strName;
  380.             case 'label':
  381.                 return $this->strLabel;
  383.             case 'value':
  384.                 // Encrypt the value
  385.                 if (isset($this->arrConfiguration['encrypt']) && $this->arrConfiguration['encrypt'])
  386.                 {
  387.                     return Encryption::encrypt($this->varValue);
  388.                 }
  390.                 if ($this->varValue === '')
  391.                 {
  392.                     return $this->getEmptyStringOrNull();
  393.                 }
  395.                 return $this->varValue;
  397.             case 'class':
  398.                 return $this->strClass;
  400.             case 'prefix':
  401.                 return $this->strPrefix;
  403.             case 'template':
  404.                 return $this->strTemplate;
  406.             case 'wizard':
  407.                 return $this->strWizard;
  409.             case 'required':
  410.                 return $this->arrConfiguration[$strKey] ?? null;
  412.             case 'forAttribute':
  413.                 return $this->blnForAttribute;
  415.             case 'dataContainer':
  416.                 return $this->objDca;
  418.             case 'activeRecord':
  419.                 return $this->objDca->activeRecord;
  421.             default:
  422.                 if (isset($this->arrAttributes[$strKey]))
  423.                 {
  424.                     return $this->arrAttributes[$strKey];
  425.                 }
  427.                 if (isset($this->arrConfiguration[$strKey]))
  428.                 {
  429.                     return $this->arrConfiguration[$strKey];
  430.                 }
  431.                 break;
  432.         }
  434.         return parent::__get($strKey);
  435.     }
  437.     /**
  438.      * Check whether an object property exists
  439.      *
  440.      * @param string $strKey The property name
  441.      *
  442.      * @return boolean True if the property exists
  443.      */
  444.     public function __isset($strKey)
  445.     {
  446.         switch ($strKey)
  447.         {
  448.             case 'id':
  449.                 return isset($this->strId);
  451.             case 'name':
  452.                 return isset($this->strName);
  454.             case 'label':
  455.                 return isset($this->strLabel);
  457.             case 'value':
  458.                 return isset($this->varValue);
  460.             case 'class':
  461.                 return isset($this->strClass);
  463.             case 'template':
  464.                 return isset($this->strTemplate);
  466.             case 'wizard':
  467.                 return isset($this->strWizard);
  469.             case 'required':
  470.                 return isset($this->arrConfiguration[$strKey]);
  472.             case 'forAttribute':
  473.                 return isset($this->blnForAttribute);
  475.             case 'dataContainer':
  476.                 return isset($this->objDca);
  478.             case 'activeRecord':
  479.                 return isset($this->objDca->activeRecord);
  481.             default:
  482.                 return isset($this->arrAttributes[$strKey]) || isset($this->arrConfiguration[$strKey]);
  483.         }
  484.     }
  486.     /**
  487.      * Add an attribute
  488.      *
  489.      * @param string $strName  The attribute name
  490.      * @param mixed  $varValue The attribute value
  491.      */
  492.     public function addAttribute($strName, $varValue)
  493.     {
  494.         $this->arrAttributes[$strName] = $varValue;
  495.     }
  497.     /**
  498.      * Add an error message
  499.      *
  500.      * @param string $strError The error message
  501.      */
  502.     public function addError($strError)
  503.     {
  504.         $this->class = 'error';
  505.         $this->arrErrors[] = $strError;
  506.     }
  508.     /**
  509.      * Return true if the widget has errors
  510.      *
  511.      * @return boolean True if there are errors
  512.      */
  513.     public function hasErrors()
  514.     {
  515.         return !empty($this->arrErrors);
  516.     }
  518.     /**
  519.      * Return the errors array
  520.      *
  521.      * @return array An array of error messages
  522.      */
  523.     public function getErrors()
  524.     {
  525.         return $this->arrErrors;
  526.     }
  528.     /**
  529.      * Return a particular error as string
  530.      *
  531.      * @param integer $intIndex The message index
  532.      *
  533.      * @return string The corresponding error message
  534.      */
  535.     public function getErrorAsString($intIndex=0)
  536.     {
  537.         return $this->arrErrors[$intIndex];
  538.     }
  540.     /**
  541.      * Return all errors as string separated by a given separator
  542.      *
  543.      * @param string $strSeparator An optional separator (defaults to "<br>")
  544.      *
  545.      * @return string The error messages string
  546.      */
  547.     public function getErrorsAsString($strSeparator=null)
  548.     {
  549.         if ($strSeparator === null)
  550.         {
  551.             $strSeparator = '<br' . $this->strTagEnding . "\n";
  552.         }
  554.         return $this->hasErrors() ? implode($strSeparator, $this->arrErrors) : '';
  555.     }
  557.     /**
  558.      * Return a particular error as HTML string
  559.      *
  560.      * @param integer $intIndex The message index
  561.      *
  562.      * @return string The HTML markup of the corresponding error message
  563.      */
  564.     public function getErrorAsHTML($intIndex=0)
  565.     {
  566.         return $this->hasErrors() ? sprintf('<p class="%s">%s</p>', ((TL_MODE == 'BE') ? 'tl_error tl_tip' : 'error'), $this->arrErrors[$intIndex]) : '';
  567.     }
  569.     /**
  570.      * Return true if the widgets submits user input
  571.      *
  572.      * @return boolean True if the widget submits user input
  573.      */
  574.     public function submitInput()
  575.     {
  576.         return $this->blnSubmitInput;
  577.     }
  579.     /**
  580.      * Parse the template file and return it as string
  581.      *
  582.      * @param array $arrAttributes An optional attributes array
  583.      *
  584.      * @return string The template markup
  585.      */
  586.     public function parse($arrAttributes=null)
  587.     {
  588.         if (!$this->strTemplate)
  589.         {
  590.             return '';
  591.         }
  593.         $this->addAttributes($arrAttributes);
  595.         $this->mandatoryField = $GLOBALS['TL_LANG']['MSC']['mandatory'];
  597.         if ($this->customTpl)
  598.         {
  599.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  601.             // Use the custom template unless it is a back end request
  602.             if (!$request || !System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  603.             {
  604.                 $this->strTemplate = $this->customTpl;
  605.             }
  606.         }
  608.         $strBuffer = $this->inherit();
  610.         // HOOK: add custom parse filters (see #5553)
  611.         if (isset($GLOBALS['TL_HOOKS']['parseWidget']) && \is_array($GLOBALS['TL_HOOKS']['parseWidget']))
  612.         {
  613.             foreach ($GLOBALS['TL_HOOKS']['parseWidget'] as $callback)
  614.             {
  615.                 $this->import($callback[0]);
  616.                 $strBuffer = $this->{$callback[0]}->{$callback[1]}($strBuffer, $this);
  617.             }
  618.         }
  620.         return $strBuffer;
  621.     }
  623.     /**
  624.      * Generate the label and return it as string
  625.      *
  626.      * @return string The label markup
  627.      */
  628.     public function generateLabel()
  629.     {
  630.         if (!$this->strLabel)
  631.         {
  632.             return '';
  633.         }
  635.         return sprintf(
  636.             '<label%s%s>%s%s%s</label>',
  637.             ($this->blnForAttribute ? ' for="ctrl_' . $this->strId . '"' : ''),
  638.             ($this->strClass ? ' class="' . $this->strClass . '"' : ''),
  639.             ($this->mandatory ? '<span class="invisible">' . $GLOBALS['TL_LANG']['MSC']['mandatory'] . ' </span>' : ''),
  640.             $this->strLabel,
  641.             ($this->mandatory ? '<span class="mandatory">*</span>' : '')
  642.         );
  643.     }
  645.     /**
  646.      * Generate the widget and return it as string
  647.      *
  648.      * @return string The widget markup
  649.      */
  650.     abstract public function generate();
  652.     /**
  653.      * Generate the widget with error message and return it as string
  654.      *
  655.      * @param boolean $blnSwitchOrder If true, the error message will be shown below the field
  656.      *
  657.      * @return string The form field markup
  658.      */
  659.     public function generateWithError($blnSwitchOrder=false)
  660.     {
  661.         $strWidget = $this->generate();
  662.         $strError = $this->getErrorAsHTML();
  664.         return $blnSwitchOrder ? $strWidget . $strError : $strError . $strWidget;
  665.     }
  667.     /**
  668.      * Return all attributes as string
  669.      *
  670.      * @param array $arrStrip An optional array with attributes to strip
  671.      *
  672.      * @return string The attributes string
  673.      */
  674.     public function getAttributes($arrStrip=array())
  675.     {
  676.         $strAttributes = '';
  678.         foreach (array_keys($this->arrAttributes) as $strKey)
  679.         {
  680.             if (!\in_array($strKey, $arrStrip))
  681.             {
  682.                 $strAttributes .= $this->getAttribute($strKey);
  683.             }
  684.         }
  686.         return $strAttributes;
  687.     }
  689.     /**
  690.      * Return a single attribute
  691.      *
  692.      * @param string $strKey The attribute name
  693.      *
  694.      * @return string The attribute markup
  695.      */
  696.     public function getAttribute($strKey)
  697.     {
  698.         if (!isset($this->arrAttributes[$strKey]))
  699.         {
  700.             return '';
  701.         }
  703.         $varValue = $this->arrAttributes[$strKey];
  705.         // Prevent the autofocus attribute from being added multiple times (see #8281)
  706.         if ($strKey == 'autofocus')
  707.         {
  708.             unset($this->arrAttributes[$strKey]);
  709.         }
  711.         if ($strKey == 'disabled' || $strKey == 'readonly' || $strKey == 'required' || $strKey == 'autofocus' || $strKey == 'multiple')
  712.         {
  713.             return ' ' . $strKey;
  714.         }
  716.         if ('' !== (string) $varValue)
  717.         {
  718.             return ' ' . $strKey . '="' . StringUtil::specialchars($varValue) . '"';
  719.         }
  721.         return '';
  722.     }
  724.     /**
  725.      * Set a callback to fetch the widget input instead of using getPost()
  726.      *
  727.      * @param callable|null $callback The callback
  728.      *
  729.      * @return $this The widget object
  730.      */
  731.     public function setInputCallback(callable $callback=null)
  732.     {
  733.         $this->inputCallback = $callback;
  735.         return $this;
  736.     }
  738.     /**
  739.      * Validate the user input and set the value
  740.      */
  741.     public function validate()
  742.     {
  743.         $varValue = $this->validator($this->getPost($this->strName));
  745.         if ($this->hasErrors())
  746.         {
  747.             $this->class = 'error';
  748.         }
  750.         $this->varValue = $varValue;
  751.     }
  753.     /**
  754.      * Find and return a $_POST variable
  755.      *
  756.      * @param string $strKey The variable name
  757.      *
  758.      * @return mixed The variable value
  759.      */
  760.     protected function getPost($strKey)
  761.     {
  762.         if (\is_callable($this->inputCallback))
  763.         {
  764.             return ($this->inputCallback)();
  765.         }
  767.         if ($this->useRawRequestData === true)
  768.         {
  769.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  771.             return $request->request->get($strKey);
  772.         }
  774.         $strMethod = $this->allowHtml ? 'postHtml' : 'post';
  776.         if ($this->preserveTags)
  777.         {
  778.             $strMethod = 'postRaw';
  779.         }
  781.         // Support arrays (thanks to Andreas Schempp)
  782.         $arrParts = explode('[', str_replace(']', '', (string) $strKey));
  783.         $varValue = Input::$strMethod(array_shift($arrParts), $this->decodeEntities);
  785.         foreach ($arrParts as $part)
  786.         {
  787.             if (!\is_array($varValue))
  788.             {
  789.                 break;
  790.             }
  792.             $varValue = $varValue[$part] ?? null;
  793.         }
  795.         return $varValue;
  796.     }
  798.     /**
  799.      * Recursively validate an input variable
  800.      *
  801.      * @param mixed $varInput The user input
  802.      *
  803.      * @return mixed The original or modified user input
  804.      */
  805.     protected function validator($varInput)
  806.     {
  807.         if (\is_array($varInput))
  808.         {
  809.             foreach ($varInput as $k=>$v)
  810.             {
  811.                 $varInput[$k] = $this->validator($v);
  812.             }
  814.             return $varInput;
  815.         }
  817.         if (!$this->doNotTrim && \is_string($varInput))
  818.         {
  819.             $varInput = trim($varInput);
  820.         }
  822.         if ((string) $varInput === '')
  823.         {
  824.             if (!$this->mandatory)
  825.             {
  826.                 return '';
  827.             }
  829.             if (!$this->strLabel)
  830.             {
  831.                 $this->addError($GLOBALS['TL_LANG']['ERR']['mdtryNoLabel']);
  832.             }
  833.             else
  834.             {
  835.                 $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['mandatory'], $this->strLabel));
  836.             }
  837.         }
  839.         if ($this->minlength && $varInput && mb_strlen($varInput) < $this->minlength)
  840.         {
  841.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minlength'], $this->strLabel, $this->minlength));
  842.         }
  844.         if ($this->maxlength && $varInput && mb_strlen($varInput) > $this->maxlength)
  845.         {
  846.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxlength'], $this->strLabel, $this->maxlength));
  847.         }
  849.         if ($this->minval && is_numeric($varInput) && $varInput < $this->minval)
  850.         {
  851.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minval'], $this->strLabel, $this->minval));
  852.         }
  854.         if ($this->maxval && is_numeric($varInput) && $varInput > $this->maxval)
  855.         {
  856.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxval'], $this->strLabel, $this->maxval));
  857.         }
  859.         if ($this->rgxp)
  860.         {
  861.             switch ($this->rgxp)
  862.             {
  863.                 case strncmp($this->rgxp, 'digit_', 6) === 0:
  864.                     // Special validation rule for style sheets
  865.                     $textual = explode('_', $this->rgxp);
  866.                     array_shift($textual);
  868.                     if (\in_array($varInput, $textual) || strncmp($varInput, '$', 1) === 0)
  869.                     {
  870.                         break;
  871.                     }
  872.                     // no break
  874.                 case 'digit':
  875.                     // Support decimal commas and convert them automatically (see #3488)
  876.                     if (substr_count($varInput, ',') == 1 && strpos($varInput, '.') === false)
  877.                     {
  878.                         $varInput = str_replace(',', '.', $varInput);
  879.                     }
  881.                     if (!Validator::isNumeric($varInput))
  882.                     {
  883.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['digit'], $this->strLabel));
  884.                     }
  885.                     break;
  887.                 case 'natural':
  888.                     if (!Validator::isNatural($varInput))
  889.                     {
  890.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['natural'], $this->strLabel));
  891.                     }
  892.                     break;
  894.                 case 'alpha':
  895.                     if (!Validator::isAlphabetic($varInput))
  896.                     {
  897.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alpha'], $this->strLabel));
  898.                     }
  899.                     break;
  901.                 case 'alnum':
  902.                     if (!Validator::isAlphanumeric($varInput))
  903.                     {
  904.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alnum'], $this->strLabel));
  905.                     }
  906.                     break;
  908.                 case 'extnd':
  909.                     if (!Validator::isExtendedAlphanumeric(html_entity_decode($varInput)))
  910.                     {
  911.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['extnd'], $this->strLabel));
  912.                     }
  913.                     break;
  915.                 case 'date':
  916.                     if (!Validator::isDate($varInput))
  917.                     {
  918.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['date'], Date::getInputFormat(Date::getNumericDateFormat())));
  919.                     }
  920.                     else
  921.                     {
  922.                         // Validate the date (see #5086)
  923.                         try
  924.                         {
  925.                             new Date($varInput, Date::getNumericDateFormat());
  926.                         }
  927.                         catch (\OutOfBoundsException $e)
  928.                         {
  929.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  930.                         }
  931.                     }
  932.                     break;
  934.                 case 'time':
  935.                     if (!Validator::isTime($varInput))
  936.                     {
  937.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['time'], Date::getInputFormat(Date::getNumericTimeFormat())));
  938.                     }
  939.                     break;
  941.                 case 'datim':
  942.                     if (!Validator::isDatim($varInput))
  943.                     {
  944.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['dateTime'], Date::getInputFormat(Date::getNumericDatimFormat())));
  945.                     }
  946.                     else
  947.                     {
  948.                         // Validate the date (see #5086)
  949.                         try
  950.                         {
  951.                             new Date($varInput, Date::getNumericDatimFormat());
  952.                         }
  953.                         catch (\OutOfBoundsException $e)
  954.                         {
  955.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  956.                         }
  957.                     }
  958.                     break;
  960.                 case 'friendly':
  961.                     list ($strName, $varInput) = StringUtil::splitFriendlyEmail($varInput);
  962.                     // no break
  964.                 case 'email':
  965.                     if (!Validator::isEmail($varInput))
  966.                     {
  967.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['email'], $this->strLabel));
  968.                     }
  970.                     if ($this->rgxp == 'friendly' && !empty($strName))
  971.                     {
  972.                         $varInput = $strName . ' [' . $varInput . ']';
  973.                     }
  974.                     break;
  976.                 case 'emails':
  977.                     // Check whether the current value is list of valid e-mail addresses
  978.                     $arrEmails = StringUtil::trimsplit(',', $varInput);
  980.                     foreach ($arrEmails as $strEmail)
  981.                     {
  982.                         $strEmail = Idna::encodeEmail($strEmail);
  984.                         if (!Validator::isEmail($strEmail))
  985.                         {
  986.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['emails'], $this->strLabel));
  987.                             break;
  988.                         }
  989.                     }
  990.                     break;
  992.                 case 'url':
  993.                     $varInput = StringUtil::specialcharsUrl($varInput);
  995.                     if ($this->decodeEntities)
  996.                     {
  997.                         $varInput = StringUtil::decodeEntities($varInput);
  998.                     }
  1000.                     if (!Validator::isUrl($varInput))
  1001.                     {
  1002.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['url'], $this->strLabel));
  1003.                     }
  1004.                     break;
  1006.                 case 'alias':
  1007.                     if (!Validator::isAlias($varInput))
  1008.                     {
  1009.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alias'], $this->strLabel));
  1010.                     }
  1011.                     break;
  1013.                 case 'folderalias':
  1014.                     if (!Validator::isFolderAlias($varInput))
  1015.                     {
  1016.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['folderalias'], $this->strLabel));
  1017.                     }
  1018.                     break;
  1020.                 case 'phone':
  1021.                     if (!Validator::isPhone(html_entity_decode($varInput)))
  1022.                     {
  1023.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['phone'], $this->strLabel));
  1024.                     }
  1025.                     break;
  1027.                 case 'prcnt':
  1028.                     if (!Validator::isPercent($varInput))
  1029.                     {
  1030.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['prcnt'], $this->strLabel));
  1031.                     }
  1032.                     break;
  1034.                 case 'locale':
  1035.                     if (!Validator::isLocale($varInput))
  1036.                     {
  1037.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['locale'], $this->strLabel));
  1038.                     }
  1039.                     break;
  1041.                 case 'language':
  1042.                     if (!Validator::isLanguage($varInput))
  1043.                     {
  1044.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['language'], $this->strLabel));
  1045.                     }
  1046.                     break;
  1048.                 case 'google+':
  1049.                     if (!Validator::isGooglePlusId($varInput))
  1050.                     {
  1051.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidGoogleId'], $this->strLabel));
  1052.                     }
  1053.                     break;
  1055.                 case 'fieldname':
  1056.                     if (!Validator::isFieldName($varInput))
  1057.                     {
  1058.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidFieldName'], $this->strLabel));
  1059.                     }
  1060.                     break;
  1062.                 // HOOK: pass unknown tags to callback functions
  1063.                 default:
  1064.                     if (isset($GLOBALS['TL_HOOKS']['addCustomRegexp']) && \is_array($GLOBALS['TL_HOOKS']['addCustomRegexp']))
  1065.                     {
  1066.                         foreach ($GLOBALS['TL_HOOKS']['addCustomRegexp'] as $callback)
  1067.                         {
  1068.                             $this->import($callback[0]);
  1069.                             $break = $this->{$callback[0]}->{$callback[1]}($this->rgxp, $varInput, $this);
  1071.                             // Stop the loop if a callback returned true
  1072.                             if ($break === true)
  1073.                             {
  1074.                                 break;
  1075.                             }
  1076.                         }
  1077.                     }
  1078.                     break;
  1079.             }
  1080.         }
  1082.         if ($this->isHexColor && $varInput && strncmp($varInput, '$', 1) !== 0)
  1083.         {
  1084.             $varInput = preg_replace('/[^a-f0-9]+/i', '', $varInput);
  1085.         }
  1087.         if ($this->nospace && preg_match('/[\t ]+/', $varInput))
  1088.         {
  1089.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['noSpace'], $this->strLabel));
  1090.         }
  1092.         if ($this->spaceToUnderscore)
  1093.         {
  1094.             $varInput = preg_replace('/\s+/', '_', trim($varInput));
  1095.         }
  1097.         if (\is_bool($this->trailingSlash) && $varInput)
  1098.         {
  1099.             $varInput = preg_replace('/\/+$/', '', $varInput) . ($this->trailingSlash ? '/' : '');
  1100.         }
  1102.         return $varInput;
  1103.     }
  1105.     /**
  1106.      * Take an associative array and add it to the object's attributes
  1107.      *
  1108.      * @param array $arrAttributes An array of attributes
  1109.      */
  1110.     public function addAttributes($arrAttributes)
  1111.     {
  1112.         if (!\is_array($arrAttributes))
  1113.         {
  1114.             return;
  1115.         }
  1117.         foreach ($arrAttributes as $k=>$v)
  1118.         {
  1119.             $this->$k = $v;
  1120.         }
  1121.     }
  1123.     /**
  1124.      * Check whether an option is checked
  1125.      *
  1126.      * @param array $arrOption The options array
  1127.      *
  1128.      * @return string The "checked" attribute or an empty string
  1129.      */
  1130.     protected function isChecked($arrOption)
  1131.     {
  1132.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1133.         {
  1134.             return static::optionChecked(1, 1);
  1135.         }
  1137.         return static::optionChecked($arrOption['value'] ?? null, $this->varValue);
  1138.     }
  1140.     /**
  1141.      * Check whether an option is selected
  1142.      *
  1143.      * @param array $arrOption The options array
  1144.      *
  1145.      * @return string The "selected" attribute or an empty string
  1146.      */
  1147.     protected function isSelected($arrOption)
  1148.     {
  1149.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1150.         {
  1151.             return static::optionSelected(1, 1);
  1152.         }
  1154.         return static::optionSelected($arrOption['value'] ?? null, $this->varValue);
  1155.     }
  1157.     /**
  1158.      * Return a "selected" attribute if the option is selected
  1159.      *
  1160.      * @param string $strOption The option to check
  1161.      * @param mixed  $varValues One or more values to check against
  1162.      *
  1163.      * @return string The attribute or an empty string
  1164.      */
  1165.     public static function optionSelected($strOption, $varValues)
  1166.     {
  1167.         if ($strOption === '')
  1168.         {
  1169.             return '';
  1170.         }
  1172.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' selected' : '';
  1173.     }
  1175.     /**
  1176.      * Return a "checked" attribute if the option is checked
  1177.      *
  1178.      * @param string $strOption The option to check
  1179.      * @param mixed  $varValues One or more values to check against
  1180.      *
  1181.      * @return string The attribute or an empty string
  1182.      */
  1183.     public static function optionChecked($strOption, $varValues)
  1184.     {
  1185.         if ($strOption === '')
  1186.         {
  1187.             return '';
  1188.         }
  1190.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' checked' : '';
  1191.     }
  1193.     /**
  1194.      * Check whether an input is one of the given options
  1195.      *
  1196.      * @param mixed $varInput The input string or array
  1197.      *
  1198.      * @return boolean True if the selected option exists
  1199.      */
  1200.     protected function isValidOption($varInput)
  1201.     {
  1202.         if (!\is_array($varInput))
  1203.         {
  1204.             $varInput = array($varInput);
  1205.         }
  1207.         // Check each option
  1208.         foreach ($varInput as $strInput)
  1209.         {
  1210.             $blnFound = false;
  1212.             foreach ($this->arrOptions as $v)
  1213.             {
  1214.                 // Single dimensional array
  1215.                 if (\array_key_exists('value', $v))
  1216.                 {
  1217.                     if ($strInput == $v['value'])
  1218.                     {
  1219.                         $blnFound = true;
  1220.                     }
  1221.                 }
  1222.                 // Multi-dimensional array
  1223.                 else
  1224.                 {
  1225.                     foreach ($v as $vv)
  1226.                     {
  1227.                         if ($strInput == $vv['value'])
  1228.                         {
  1229.                             $blnFound = true;
  1230.                         }
  1231.                     }
  1232.                 }
  1233.             }
  1235.             if (!$blnFound)
  1236.             {
  1237.                 return false;
  1238.             }
  1239.         }
  1241.         return true;
  1242.     }
  1244.     /**
  1245.      * Extract the Widget attributes from a Data Container array
  1246.      *
  1247.      * @param array                     $arrData  The field configuration array
  1248.      * @param string                    $strName  The field name in the form
  1249.      * @param mixed                     $varValue The field value
  1250.      * @param string                    $strField The field name in the database
  1251.      * @param string                    $strTable The table name in the database
  1252.      * @param DataContainer|Module|null $objDca   An optional DataContainer or Module object
  1253.      *
  1254.      * @return array An attributes array that can be passed to a widget
  1255.      */
  1256.     public static function getAttributesFromDca($arrData, $strName, $varValue=null, $strField='', $strTable='', $objDca=null)
  1257.     {
  1258.         $arrAttributes = $arrData['eval'] ?? array();
  1260.         if (method_exists(System::getContainer(), 'getParameterBag'))
  1261.         {
  1262.             $objParameterBag = System::getContainer()->getParameterBag();
  1264.             foreach ($arrAttributes as $strAttrKey => $varAttrValue)
  1265.             {
  1266.                 if (!\is_string($varAttrValue) || !preg_match('/%[a-z][a-z0-9_]*\.[a-z0-9_.]+%/i', $varAttrValue))
  1267.                 {
  1268.                     continue;
  1269.                 }
  1271.                 $varAttrValue = $objParameterBag->resolveValue($varAttrValue);
  1272.                 $varAttrValue = $objParameterBag->unescapeValue($varAttrValue);
  1274.                 $arrAttributes[$strAttrKey] = $varAttrValue;
  1275.             }
  1276.         }
  1278.         $arrAttributes['id'] = $strName;
  1279.         $arrAttributes['name'] = $strName;
  1280.         $arrAttributes['strField'] = $strField;
  1281.         $arrAttributes['strTable'] = $strTable;
  1282.         $arrAttributes['label'] = (($label = \is_array($arrData['label'] ?? null) ? $arrData['label'][0] : $arrData['label'] ?? null) !== null) ? $label : $strField;
  1283.         $arrAttributes['description'] = $arrData['label'][1] ?? null;
  1284.         $arrAttributes['type'] = $arrData['inputType'] ?? null;
  1285.         $arrAttributes['dataContainer'] = $objDca;
  1286.         $arrAttributes['value'] = StringUtil::deserialize($varValue);
  1288.         // Internet Explorer does not support onchange for checkboxes and radio buttons
  1289.         if ($arrData['eval']['submitOnChange'] ?? null)
  1290.         {
  1291.             if (($arrData['inputType'] ?? null) == 'checkbox' || ($arrData['inputType'] ?? null) == 'checkboxWizard' || ($arrData['inputType'] ?? null) == 'radio' || ($arrData['inputType'] ?? null) == 'radioTable')
  1292.             {
  1293.                 $arrAttributes['onclick'] = trim(($arrAttributes['onclick'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1294.             }
  1295.             else
  1296.             {
  1297.                 $arrAttributes['onchange'] = trim(($arrAttributes['onchange'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1298.             }
  1299.         }
  1301.         if (!empty($arrData['eval']['preserveTags']))
  1302.         {
  1303.             $arrAttributes['allowHtml'] = true;
  1304.         }
  1306.         if (!isset($arrAttributes['allowHtml']))
  1307.         {
  1308.             $rte = $arrData['eval']['rte'] ?? '';
  1309.             $arrAttributes['allowHtml'] = 'ace|html' === $rte || 0 === strpos($rte, 'tiny');
  1310.         }
  1312.         // Decode entities if HTML is allowed
  1313.         if ($arrAttributes['allowHtml'] || ($arrData['inputType'] ?? null) == 'fileTree')
  1314.         {
  1315.             $arrAttributes['decodeEntities'] = true;
  1316.         }
  1318.         // Add Ajax event
  1319.         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']))
  1320.         {
  1321.             $arrAttributes['onclick'] = "AjaxRequest.toggleSubpalette(this, 'sub_" . $strName . "', '" . $strField . "')";
  1322.         }
  1324.         // Options callback
  1325.         if (\is_array($arrData['options_callback'] ?? null))
  1326.         {
  1327.             $arrCallback = $arrData['options_callback'];
  1328.             $arrData['options'] = static::importStatic($arrCallback[0])->{$arrCallback[1]}($objDca);
  1329.         }
  1330.         elseif (\is_callable($arrData['options_callback'] ?? null))
  1331.         {
  1332.             $arrData['options'] = $arrData['options_callback']($objDca);
  1333.         }
  1335.         // Foreign key
  1336.         elseif (isset($arrData['foreignKey']))
  1337.         {
  1338.             $arrKey = explode('.', $arrData['foreignKey'], 2);
  1339.             $objOptions = Database::getInstance()->query("SELECT id, " . $arrKey[1] . " AS value FROM " . $arrKey[0] . " WHERE tstamp>0 ORDER BY value");
  1340.             $arrData['options'] = array();
  1342.             while ($objOptions->next())
  1343.             {
  1344.                 $arrData['options'][$objOptions->id] = $objOptions->value;
  1345.             }
  1346.         }
  1348.         // Add default option to single checkbox
  1349.         if (($arrData['inputType'] ?? null) == 'checkbox' && !isset($arrData['options']) && !isset($arrData['options_callback']) && !isset($arrData['foreignKey']))
  1350.         {
  1351.             if (TL_MODE == 'FE' && isset($arrAttributes['description']))
  1352.             {
  1353.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['description']);
  1354.             }
  1355.             else
  1356.             {
  1357.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['label']);
  1358.             }
  1359.         }
  1361.         // Add options
  1362.         if (\is_array($arrData['options'] ?? null))
  1363.         {
  1364.             $blnIsAssociative = ($arrData['eval']['isAssociative'] ?? null) || ArrayUtil::isAssoc($arrData['options'] ?? null);
  1365.             $blnUseReference = isset($arrData['reference']);
  1367.             if (($arrData['eval']['includeBlankOption'] ?? null) && !($arrData['eval']['multiple'] ?? null))
  1368.             {
  1369.                 $strLabel = $arrData['eval']['blankOptionLabel'] ?? '-';
  1370.                 $arrAttributes['options'][] = array('value'=>'', 'label'=>$strLabel);
  1371.             }
  1373.             $unknown = (array) $arrAttributes['value'];
  1375.             foreach ($arrData['options'] as $k=>$v)
  1376.             {
  1377.                 if (!\is_array($v))
  1378.                 {
  1379.                     $value = $blnIsAssociative ? $k : $v;
  1381.                     if (($i = array_search($value, $unknown)) !== false)
  1382.                     {
  1383.                         unset($unknown[$i]);
  1384.                     }
  1386.                     $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));
  1387.                     continue;
  1388.                 }
  1390.                 $key = $blnUseReference && isset($arrData['reference'][$k]) ? (($ref = (\is_array($arrData['reference'][$k]) ? $arrData['reference'][$k][0] : $arrData['reference'][$k])) ? $ref : $k) : $k;
  1391.                 $blnIsAssoc = ArrayUtil::isAssoc($v);
  1393.                 foreach ($v as $kk=>$vv)
  1394.                 {
  1395.                     $value = $blnIsAssoc ? $kk : $vv;
  1397.                     if (($i = array_search($value, $unknown)) !== false)
  1398.                     {
  1399.                         unset($unknown[$i]);
  1400.                     }
  1402.                     $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));
  1403.                 }
  1404.             }
  1406.             $arrAttributes['unknownOption'] = array_filter($unknown);
  1407.         }
  1409.         if (\is_array($arrAttributes['sql'] ?? null) && !isset($arrAttributes['sql']['columnDefinition']))
  1410.         {
  1411.             if (!isset($arrAttributes['maxlength']) && isset($arrAttributes['sql']['length']))
  1412.             {
  1413.                 $arrAttributes['maxlength'] = $arrAttributes['sql']['length'];
  1414.             }
  1416.             if (!isset($arrAttributes['unique']) && isset($arrAttributes['sql']['customSchemaOptions']['unique']))
  1417.             {
  1418.                 $arrAttributes['unique'] = $arrAttributes['sql']['customSchemaOptions']['unique'];
  1419.             }
  1420.         }
  1422.         // Convert timestamps
  1423.         if ($varValue !== null && $varValue !== '' && \in_array($arrData['eval']['rgxp'] ?? null, array('date', 'time', 'datim')))
  1424.         {
  1425.             $objDate = new Date($varValue, Date::getFormatFromRgxp($arrData['eval']['rgxp']));
  1426.             $arrAttributes['value'] = $objDate->{$arrData['eval']['rgxp']};
  1427.         }
  1429.         // Convert URL insert tags
  1430.         if ($varValue && 'url' === ($arrData['eval']['rgxp'] ?? null))
  1431.         {
  1432.             $arrAttributes['value'] = str_replace('|urlattr}}', '}}', $varValue);
  1433.         }
  1435.         // Add the "rootNodes" array as attribute (see #3563)
  1436.         if (isset($arrData['rootNodes']) && !isset($arrData['eval']['rootNodes']))
  1437.         {
  1438.             $arrAttributes['rootNodes'] = $arrData['rootNodes'];
  1439.         }
  1441.         // HOOK: add custom logic
  1442.         if (isset($GLOBALS['TL_HOOKS']['getAttributesFromDca']) && \is_array($GLOBALS['TL_HOOKS']['getAttributesFromDca']))
  1443.         {
  1444.             foreach ($GLOBALS['TL_HOOKS']['getAttributesFromDca'] as $callback)
  1445.             {
  1446.                 $arrAttributes = static::importStatic($callback[0])->{$callback[1]}($arrAttributes, $objDca);
  1447.             }
  1448.         }
  1450.         // Warn if someone uses the "encrypt" flag (see #8589)
  1451.         if (isset($arrAttributes['encrypt']))
  1452.         {
  1453.             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.');
  1454.         }
  1456.         return $arrAttributes;
  1457.     }
  1459.     /**
  1460.      * Return the empty value based on the SQL string
  1461.      *
  1462.      * @return string|integer|null The empty value
  1463.      */
  1464.     public function getEmptyValue()
  1465.     {
  1466.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1467.         {
  1468.             return '';
  1469.         }
  1471.         return static::getEmptyValueByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1472.     }
  1474.     /**
  1475.      * Return the empty value based on the SQL string
  1476.      *
  1477.      * @param string|array $sql The SQL string
  1478.      *
  1479.      * @return string|integer|null The empty value
  1480.      */
  1481.     public static function getEmptyValueByFieldType($sql)
  1482.     {
  1483.         if (empty($sql))
  1484.         {
  1485.             return '';
  1486.         }
  1488.         if (\is_array($sql))
  1489.         {
  1490.             if (isset($sql['columnDefinition']))
  1491.             {
  1492.                 $sql = $sql['columnDefinition'];
  1493.             }
  1494.             else
  1495.             {
  1496.                 if (isset($sql['notnull']) && !$sql['notnull'])
  1497.                 {
  1498.                     return null;
  1499.                 }
  1501.                 if (\in_array($sql['type'], array(Types::BIGINT, Types::DECIMAL, Types::INTEGER, Types::SMALLINT, Types::FLOAT)))
  1502.                 {
  1503.                     return 0;
  1504.                 }
  1506.                 if ($sql['type'] === Types::BOOLEAN)
  1507.                 {
  1508.                     return false;
  1509.                 }
  1511.                 return '';
  1512.             }
  1513.         }
  1515.         if (stripos($sql, 'NOT NULL') === false)
  1516.         {
  1517.             return null;
  1518.         }
  1520.         $type = strtolower(preg_replace('/^([A-Za-z]+)[( ].*$/', '$1', $sql));
  1522.         if (\in_array($type, array('int', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint', 'float', 'double', 'dec', 'decimal')))
  1523.         {
  1524.             return 0;
  1525.         }
  1527.         return '';
  1528.     }
  1530.     /**
  1531.      * Return either an empty string or null based on the SQL string
  1532.      *
  1533.      * @return string|int|null The empty value
  1534.      */
  1535.     public function getEmptyStringOrNull()
  1536.     {
  1537.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1538.         {
  1539.             return '';
  1540.         }
  1542.         return static::getEmptyStringOrNullByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1543.     }
  1545.     /**
  1546.      * Return either an empty string or null based on the SQL string
  1547.      *
  1548.      * @param string $sql The SQL string
  1549.      *
  1550.      * @return string|null The empty string or null
  1551.      */
  1552.     public static function getEmptyStringOrNullByFieldType($sql)
  1553.     {
  1554.         if (empty($sql))
  1555.         {
  1556.             return '';
  1557.         }
  1559.         return static::getEmptyValueByFieldType($sql) === null ? null : '';
  1560.     }
  1562.     /**
  1563.      * Generate a submit button
  1564.      *
  1565.      * @return string The submit button markup
  1566.      *
  1567.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1568.      */
  1569.     protected function addSubmit()
  1570.     {
  1571.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Widget::addSubmit()" has been deprecated and will no longer work in Contao 5.0.');
  1573.         return '';
  1574.     }
  1575. }
  1577. class_alias(Widget::class, 'Widget');