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

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.                 $this->varValue = StringUtil::deserialize($varValue);
  235.                 // Decrypt the value if it is encrypted
  236.                 if ($this->arrConfiguration['encrypt'] ?? null)
  237.                 {
  238.                     $this->varValue = Encryption::decrypt($this->varValue);
  239.                 }
  240.                 break;
  242.             case 'class':
  243.                 if ($varValue && strpos($this->strClass ?? '', $varValue) === false)
  244.                 {
  245.                     $this->strClass = trim($this->strClass . ' ' . $varValue);
  246.                 }
  247.                 break;
  249.             case 'prefix':
  250.                 $this->strPrefix = $varValue;
  251.                 break;
  253.             case 'template':
  254.                 $this->strTemplate = $varValue;
  255.                 break;
  257.             case 'wizard':
  258.                 $this->strWizard = $varValue;
  259.                 break;
  261.             case 'autocomplete':
  262.             case 'autocorrect':
  263.             case 'autocapitalize':
  264.             case 'spellcheck':
  265.                 if (\is_bool($varValue))
  266.                 {
  267.                     $varValue = $varValue ? 'on' : 'off';
  268.                 }
  269.                 // no break
  271.             case 'alt':
  272.             case 'style':
  273.             case 'accesskey':
  274.             case 'onblur':
  275.             case 'onchange':
  276.             case 'onclick':
  277.             case 'ondblclick':
  278.             case 'onfocus':
  279.             case 'onmousedown':
  280.             case 'onmousemove':
  281.             case 'onmouseout':
  282.             case 'onmouseover':
  283.             case 'onmouseup':
  284.             case 'onkeydown':
  285.             case 'onkeypress':
  286.             case 'onkeyup':
  287.             case 'onselect':
  288.                 $this->arrAttributes[$strKey] = $varValue;
  289.                 break;
  291.             case 'tabindex':
  292.                 if ($varValue > 0)
  293.                 {
  294.                     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.');
  295.                     $this->arrAttributes['tabindex'] = $varValue;
  296.                 }
  297.                 break;
  299.             case 'disabled':
  300.             case 'readonly':
  301.                 $this->blnSubmitInput = $varValue ? false : true;
  302.                 // no break
  304.             case 'autofocus':
  305.                 if ($varValue)
  306.                 {
  307.                     $this->arrAttributes[$strKey] = $strKey;
  308.                 }
  309.                 else
  310.                 {
  311.                     unset($this->arrAttributes[$strKey]);
  312.                 }
  313.                 break;
  315.             case 'required':
  316.                 if ($varValue)
  317.                 {
  318.                     $this->strClass = trim($this->strClass . ' mandatory');
  319.                 }
  320.                 // no break
  322.             case 'mandatory':
  323.             case 'nospace':
  324.             case 'allowHtml':
  325.             case 'storeFile':
  326.             case 'useHomeDir':
  327.             case 'storeValues':
  328.             case 'trailingSlash':
  329.             case 'spaceToUnderscore':
  330.             case 'doNotTrim':
  331.             case 'useRawRequestData':
  332.                 $this->arrConfiguration[$strKey] = $varValue ? true : false;
  333.                 break;
  335.             case 'forAttribute':
  336.                 $this->blnForAttribute = $varValue;
  337.                 break;
  339.             case 'dataContainer':
  340.                 $this->objDca = $varValue;
  341.                 break;
  343.             case strncmp($strKey, 'ng-', 3) === 0:
  344.             case strncmp($strKey, 'data-', 5) === 0:
  345.                 $this->arrAttributes[$strKey] = $varValue;
  346.                 break;
  348.             default:
  349.                 $this->arrConfiguration[$strKey] = $varValue;
  350.                 break;
  351.         }
  352.     }
  354.     /**
  355.      * Return an object property
  356.      *
  357.      * @param string $strKey The property name
  358.      *
  359.      * @return string The property value
  360.      */
  361.     public function __get($strKey)
  362.     {
  363.         switch ($strKey)
  364.         {
  365.             case 'id':
  366.                 return $this->strId;
  368.             case 'name':
  369.                 return $this->strName;
  371.             case 'label':
  372.                 return $this->strLabel;
  374.             case 'value':
  375.                 // Encrypt the value
  376.                 if (isset($this->arrConfiguration['encrypt']) && $this->arrConfiguration['encrypt'])
  377.                 {
  378.                     return Encryption::encrypt($this->varValue);
  379.                 }
  381.                 if ($this->varValue === '')
  382.                 {
  383.                     return $this->getEmptyStringOrNull();
  384.                 }
  386.                 return $this->varValue;
  388.             case 'class':
  389.                 return $this->strClass;
  391.             case 'prefix':
  392.                 return $this->strPrefix;
  394.             case 'template':
  395.                 return $this->strTemplate;
  397.             case 'wizard':
  398.                 return $this->strWizard;
  400.             case 'required':
  401.                 return $this->arrConfiguration[$strKey];
  403.             case 'forAttribute':
  404.                 return $this->blnForAttribute;
  406.             case 'dataContainer':
  407.                 return $this->objDca;
  409.             case 'activeRecord':
  410.                 return $this->objDca->activeRecord;
  412.             default:
  413.                 if (isset($this->arrAttributes[$strKey]))
  414.                 {
  415.                     return $this->arrAttributes[$strKey];
  416.                 }
  418.                 if (isset($this->arrConfiguration[$strKey]))
  419.                 {
  420.                     return $this->arrConfiguration[$strKey];
  421.                 }
  422.                 break;
  423.         }
  425.         return parent::__get($strKey);
  426.     }
  428.     /**
  429.      * Check whether an object property exists
  430.      *
  431.      * @param string $strKey The property name
  432.      *
  433.      * @return boolean True if the property exists
  434.      */
  435.     public function __isset($strKey)
  436.     {
  437.         switch ($strKey)
  438.         {
  439.             case 'id':
  440.                 return isset($this->strId);
  442.             case 'name':
  443.                 return isset($this->strName);
  445.             case 'label':
  446.                 return isset($this->strLabel);
  448.             case 'value':
  449.                 return isset($this->varValue);
  451.             case 'class':
  452.                 return isset($this->strClass);
  454.             case 'template':
  455.                 return isset($this->strTemplate);
  457.             case 'wizard':
  458.                 return isset($this->strWizard);
  460.             case 'required':
  461.                 return isset($this->arrConfiguration[$strKey]);
  463.             case 'forAttribute':
  464.                 return isset($this->blnForAttribute);
  466.             case 'dataContainer':
  467.                 return isset($this->objDca);
  469.             case 'activeRecord':
  470.                 return isset($this->objDca->activeRecord);
  472.             default:
  473.                 return isset($this->arrAttributes[$strKey]) || isset($this->arrConfiguration[$strKey]);
  474.         }
  475.     }
  477.     /**
  478.      * Add an attribute
  479.      *
  480.      * @param string $strName  The attribute name
  481.      * @param mixed  $varValue The attribute value
  482.      */
  483.     public function addAttribute($strName, $varValue)
  484.     {
  485.         $this->arrAttributes[$strName] = $varValue;
  486.     }
  488.     /**
  489.      * Add an error message
  490.      *
  491.      * @param string $strError The error message
  492.      */
  493.     public function addError($strError)
  494.     {
  495.         $this->class = 'error';
  496.         $this->arrErrors[] = $strError;
  497.     }
  499.     /**
  500.      * Return true if the widget has errors
  501.      *
  502.      * @return boolean True if there are errors
  503.      */
  504.     public function hasErrors()
  505.     {
  506.         return !empty($this->arrErrors);
  507.     }
  509.     /**
  510.      * Return the errors array
  511.      *
  512.      * @return array An array of error messages
  513.      */
  514.     public function getErrors()
  515.     {
  516.         return $this->arrErrors;
  517.     }
  519.     /**
  520.      * Return a particular error as string
  521.      *
  522.      * @param integer $intIndex The message index
  523.      *
  524.      * @return string The corresponding error message
  525.      */
  526.     public function getErrorAsString($intIndex=0)
  527.     {
  528.         return $this->arrErrors[$intIndex];
  529.     }
  531.     /**
  532.      * Return all errors as string separated by a given separator
  533.      *
  534.      * @param string $strSeparator An optional separator (defaults to "<br>")
  535.      *
  536.      * @return string The error messages string
  537.      */
  538.     public function getErrorsAsString($strSeparator=null)
  539.     {
  540.         if ($strSeparator === null)
  541.         {
  542.             $strSeparator = '<br' . $this->strTagEnding . "\n";
  543.         }
  545.         return $this->hasErrors() ? implode($strSeparator, $this->arrErrors) : '';
  546.     }
  548.     /**
  549.      * Return a particular error as HTML string
  550.      *
  551.      * @param integer $intIndex The message index
  552.      *
  553.      * @return string The HTML markup of the corresponding error message
  554.      */
  555.     public function getErrorAsHTML($intIndex=0)
  556.     {
  557.         return $this->hasErrors() ? sprintf('<p class="%s">%s</p>', ((TL_MODE == 'BE') ? 'tl_error tl_tip' : 'error'), $this->arrErrors[$intIndex]) : '';
  558.     }
  560.     /**
  561.      * Return true if the widgets submits user input
  562.      *
  563.      * @return boolean True if the widget submits user input
  564.      */
  565.     public function submitInput()
  566.     {
  567.         return $this->blnSubmitInput;
  568.     }
  570.     /**
  571.      * Parse the template file and return it as string
  572.      *
  573.      * @param array $arrAttributes An optional attributes array
  574.      *
  575.      * @return string The template markup
  576.      */
  577.     public function parse($arrAttributes=null)
  578.     {
  579.         if (!$this->strTemplate)
  580.         {
  581.             return '';
  582.         }
  584.         $this->addAttributes($arrAttributes);
  586.         $this->mandatoryField = $GLOBALS['TL_LANG']['MSC']['mandatory'];
  588.         if ($this->customTpl)
  589.         {
  590.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  592.             // Use the custom template unless it is a back end request
  593.             if (!$request || !System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  594.             {
  595.                 $this->strTemplate = $this->customTpl;
  596.             }
  597.         }
  599.         $strBuffer = $this->inherit();
  601.         // HOOK: add custom parse filters (see #5553)
  602.         if (isset($GLOBALS['TL_HOOKS']['parseWidget']) && \is_array($GLOBALS['TL_HOOKS']['parseWidget']))
  603.         {
  604.             foreach ($GLOBALS['TL_HOOKS']['parseWidget'] as $callback)
  605.             {
  606.                 $this->import($callback[0]);
  607.                 $strBuffer = $this->{$callback[0]}->{$callback[1]}($strBuffer, $this);
  608.             }
  609.         }
  611.         return $strBuffer;
  612.     }
  614.     /**
  615.      * Generate the label and return it as string
  616.      *
  617.      * @return string The label markup
  618.      */
  619.     public function generateLabel()
  620.     {
  621.         if (!$this->strLabel)
  622.         {
  623.             return '';
  624.         }
  626.         return sprintf(
  627.             '<label%s%s>%s%s%s</label>',
  628.             ($this->blnForAttribute ? ' for="ctrl_' . $this->strId . '"' : ''),
  629.             ($this->strClass ? ' class="' . $this->strClass . '"' : ''),
  630.             ($this->mandatory ? '<span class="invisible">' . $GLOBALS['TL_LANG']['MSC']['mandatory'] . ' </span>' : ''),
  631.             $this->strLabel,
  632.             ($this->mandatory ? '<span class="mandatory">*</span>' : '')
  633.         );
  634.     }
  636.     /**
  637.      * Generate the widget and return it as string
  638.      *
  639.      * @return string The widget markup
  640.      */
  641.     abstract public function generate();
  643.     /**
  644.      * Generate the widget with error message and return it as string
  645.      *
  646.      * @param boolean $blnSwitchOrder If true, the error message will be shown below the field
  647.      *
  648.      * @return string The form field markup
  649.      */
  650.     public function generateWithError($blnSwitchOrder=false)
  651.     {
  652.         $strWidget = $this->generate();
  653.         $strError = $this->getErrorAsHTML();
  655.         return $blnSwitchOrder ? $strWidget . $strError : $strError . $strWidget;
  656.     }
  658.     /**
  659.      * Return all attributes as string
  660.      *
  661.      * @param array $arrStrip An optional array with attributes to strip
  662.      *
  663.      * @return string The attributes string
  664.      */
  665.     public function getAttributes($arrStrip=array())
  666.     {
  667.         $strAttributes = '';
  669.         foreach (array_keys($this->arrAttributes) as $strKey)
  670.         {
  671.             if (!\in_array($strKey, $arrStrip))
  672.             {
  673.                 $strAttributes .= $this->getAttribute($strKey);
  674.             }
  675.         }
  677.         return $strAttributes;
  678.     }
  680.     /**
  681.      * Return a single attribute
  682.      *
  683.      * @param string $strKey The attribute name
  684.      *
  685.      * @return string The attribute markup
  686.      */
  687.     public function getAttribute($strKey)
  688.     {
  689.         if (!isset($this->arrAttributes[$strKey]))
  690.         {
  691.             return '';
  692.         }
  694.         $varValue = $this->arrAttributes[$strKey];
  696.         // Prevent the autofocus attribute from being added multiple times (see #8281)
  697.         if ($strKey == 'autofocus')
  698.         {
  699.             unset($this->arrAttributes[$strKey]);
  700.         }
  702.         if ($strKey == 'disabled' || $strKey == 'readonly' || $strKey == 'required' || $strKey == 'autofocus' || $strKey == 'multiple')
  703.         {
  704.             return ' ' . $strKey;
  705.         }
  707.         if ('' !== (string) $varValue)
  708.         {
  709.             return ' ' . $strKey . '="' . StringUtil::specialchars($varValue) . '"';
  710.         }
  712.         return '';
  713.     }
  715.     /**
  716.      * Set a callback to fetch the widget input instead of using getPost()
  717.      *
  718.      * @param callable|null $callback The callback
  719.      *
  720.      * @return $this The widget object
  721.      */
  722.     public function setInputCallback(callable $callback=null)
  723.     {
  724.         $this->inputCallback = $callback;
  726.         return $this;
  727.     }
  729.     /**
  730.      * Validate the user input and set the value
  731.      */
  732.     public function validate()
  733.     {
  734.         $varValue = $this->validator($this->getPost($this->strName));
  736.         if ($this->hasErrors())
  737.         {
  738.             $this->class = 'error';
  739.         }
  741.         $this->varValue = $varValue;
  742.     }
  744.     /**
  745.      * Find and return a $_POST variable
  746.      *
  747.      * @param string $strKey The variable name
  748.      *
  749.      * @return mixed The variable value
  750.      */
  751.     protected function getPost($strKey)
  752.     {
  753.         if (\is_callable($this->inputCallback))
  754.         {
  755.             return ($this->inputCallback)();
  756.         }
  758.         if ($this->useRawRequestData === true)
  759.         {
  760.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  762.             return $request->request->get($strKey);
  763.         }
  765.         $strMethod = $this->allowHtml ? 'postHtml' : 'post';
  767.         if ($this->preserveTags)
  768.         {
  769.             $strMethod = 'postRaw';
  770.         }
  772.         // Support arrays (thanks to Andreas Schempp)
  773.         $arrParts = explode('[', str_replace(']', '', (string) $strKey));
  774.         $varValue = Input::$strMethod(array_shift($arrParts), $this->decodeEntities);
  776.         foreach ($arrParts as $part)
  777.         {
  778.             if (!\is_array($varValue))
  779.             {
  780.                 break;
  781.             }
  783.             $varValue = $varValue[$part] ?? null;
  784.         }
  786.         return $varValue;
  787.     }
  789.     /**
  790.      * Recursively validate an input variable
  791.      *
  792.      * @param mixed $varInput The user input
  793.      *
  794.      * @return mixed The original or modified user input
  795.      */
  796.     protected function validator($varInput)
  797.     {
  798.         if (\is_array($varInput))
  799.         {
  800.             foreach ($varInput as $k=>$v)
  801.             {
  802.                 $varInput[$k] = $this->validator($v);
  803.             }
  805.             return $varInput;
  806.         }
  808.         if (!$this->doNotTrim)
  809.         {
  810.             $varInput = trim($varInput);
  811.         }
  813.         if ((string) $varInput === '')
  814.         {
  815.             if (!$this->mandatory)
  816.             {
  817.                 return '';
  818.             }
  820.             if (!$this->strLabel)
  821.             {
  822.                 $this->addError($GLOBALS['TL_LANG']['ERR']['mdtryNoLabel']);
  823.             }
  824.             else
  825.             {
  826.                 $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['mandatory'], $this->strLabel));
  827.             }
  828.         }
  830.         if ($this->minlength && $varInput && mb_strlen($varInput) < $this->minlength)
  831.         {
  832.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minlength'], $this->strLabel, $this->minlength));
  833.         }
  835.         if ($this->maxlength && $varInput && mb_strlen($varInput) > $this->maxlength)
  836.         {
  837.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxlength'], $this->strLabel, $this->maxlength));
  838.         }
  840.         if ($this->minval && is_numeric($varInput) && $varInput < $this->minval)
  841.         {
  842.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minval'], $this->strLabel, $this->minval));
  843.         }
  845.         if ($this->maxval && is_numeric($varInput) && $varInput > $this->maxval)
  846.         {
  847.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxval'], $this->strLabel, $this->maxval));
  848.         }
  850.         if ($this->rgxp)
  851.         {
  852.             switch ($this->rgxp)
  853.             {
  854.                 case strncmp($this->rgxp, 'digit_', 6) === 0:
  855.                     // Special validation rule for style sheets
  856.                     $textual = explode('_', $this->rgxp);
  857.                     array_shift($textual);
  859.                     if (\in_array($varInput, $textual) || strncmp($varInput, '$', 1) === 0)
  860.                     {
  861.                         break;
  862.                     }
  863.                     // no break
  865.                 case 'digit':
  866.                     // Support decimal commas and convert them automatically (see #3488)
  867.                     if (substr_count($varInput, ',') == 1 && strpos($varInput, '.') === false)
  868.                     {
  869.                         $varInput = str_replace(',', '.', $varInput);
  870.                     }
  872.                     if (!Validator::isNumeric($varInput))
  873.                     {
  874.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['digit'], $this->strLabel));
  875.                     }
  876.                     break;
  878.                 case 'natural':
  879.                     if (!Validator::isNatural($varInput))
  880.                     {
  881.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['natural'], $this->strLabel));
  882.                     }
  883.                     break;
  885.                 case 'alpha':
  886.                     if (!Validator::isAlphabetic($varInput))
  887.                     {
  888.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alpha'], $this->strLabel));
  889.                     }
  890.                     break;
  892.                 case 'alnum':
  893.                     if (!Validator::isAlphanumeric($varInput))
  894.                     {
  895.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alnum'], $this->strLabel));
  896.                     }
  897.                     break;
  899.                 case 'extnd':
  900.                     if (!Validator::isExtendedAlphanumeric(html_entity_decode($varInput)))
  901.                     {
  902.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['extnd'], $this->strLabel));
  903.                     }
  904.                     break;
  906.                 case 'date':
  907.                     if (!Validator::isDate($varInput))
  908.                     {
  909.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['date'], Date::getInputFormat(Date::getNumericDateFormat())));
  910.                     }
  911.                     else
  912.                     {
  913.                         // Validate the date (see #5086)
  914.                         try
  915.                         {
  916.                             new Date($varInput, Date::getNumericDateFormat());
  917.                         }
  918.                         catch (\OutOfBoundsException $e)
  919.                         {
  920.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  921.                         }
  922.                     }
  923.                     break;
  925.                 case 'time':
  926.                     if (!Validator::isTime($varInput))
  927.                     {
  928.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['time'], Date::getInputFormat(Date::getNumericTimeFormat())));
  929.                     }
  930.                     break;
  932.                 case 'datim':
  933.                     if (!Validator::isDatim($varInput))
  934.                     {
  935.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['dateTime'], Date::getInputFormat(Date::getNumericDatimFormat())));
  936.                     }
  937.                     else
  938.                     {
  939.                         // Validate the date (see #5086)
  940.                         try
  941.                         {
  942.                             new Date($varInput, Date::getNumericDatimFormat());
  943.                         }
  944.                         catch (\OutOfBoundsException $e)
  945.                         {
  946.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidDate'], $varInput));
  947.                         }
  948.                     }
  949.                     break;
  951.                 case 'friendly':
  952.                     list ($strName, $varInput) = StringUtil::splitFriendlyEmail($varInput);
  953.                     // no break
  955.                 case 'email':
  956.                     if (!Validator::isEmail($varInput))
  957.                     {
  958.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['email'], $this->strLabel));
  959.                     }
  961.                     if ($this->rgxp == 'friendly' && !empty($strName))
  962.                     {
  963.                         $varInput = $strName . ' [' . $varInput . ']';
  964.                     }
  965.                     break;
  967.                 case 'emails':
  968.                     // Check whether the current value is list of valid e-mail addresses
  969.                     $arrEmails = StringUtil::trimsplit(',', $varInput);
  971.                     foreach ($arrEmails as $strEmail)
  972.                     {
  973.                         $strEmail = Idna::encodeEmail($strEmail);
  975.                         if (!Validator::isEmail($strEmail))
  976.                         {
  977.                             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['emails'], $this->strLabel));
  978.                             break;
  979.                         }
  980.                     }
  981.                     break;
  983.                 case 'url':
  984.                     $varInput = StringUtil::specialcharsUrl($varInput);
  986.                     if ($this->decodeEntities)
  987.                     {
  988.                         $varInput = StringUtil::decodeEntities($varInput);
  989.                     }
  991.                     if (!Validator::isUrl($varInput))
  992.                     {
  993.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['url'], $this->strLabel));
  994.                     }
  995.                     break;
  997.                 case 'alias':
  998.                     if (!Validator::isAlias($varInput))
  999.                     {
  1000.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['alias'], $this->strLabel));
  1001.                     }
  1002.                     break;
  1004.                 case 'folderalias':
  1005.                     if (!Validator::isFolderAlias($varInput))
  1006.                     {
  1007.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['folderalias'], $this->strLabel));
  1008.                     }
  1009.                     break;
  1011.                 case 'phone':
  1012.                     if (!Validator::isPhone(html_entity_decode($varInput)))
  1013.                     {
  1014.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['phone'], $this->strLabel));
  1015.                     }
  1016.                     break;
  1018.                 case 'prcnt':
  1019.                     if (!Validator::isPercent($varInput))
  1020.                     {
  1021.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['prcnt'], $this->strLabel));
  1022.                     }
  1023.                     break;
  1025.                 case 'locale':
  1026.                     if (!Validator::isLocale($varInput))
  1027.                     {
  1028.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['locale'], $this->strLabel));
  1029.                     }
  1030.                     break;
  1032.                 case 'language':
  1033.                     if (!Validator::isLanguage($varInput))
  1034.                     {
  1035.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['language'], $this->strLabel));
  1036.                     }
  1037.                     break;
  1039.                 case 'google+':
  1040.                     if (!Validator::isGooglePlusId($varInput))
  1041.                     {
  1042.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidGoogleId'], $this->strLabel));
  1043.                     }
  1044.                     break;
  1046.                 case 'fieldname':
  1047.                     if (!Validator::isFieldName($varInput))
  1048.                     {
  1049.                         $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['invalidFieldName'], $this->strLabel));
  1050.                     }
  1051.                     break;
  1053.                 // HOOK: pass unknown tags to callback functions
  1054.                 default:
  1055.                     if (isset($GLOBALS['TL_HOOKS']['addCustomRegexp']) && \is_array($GLOBALS['TL_HOOKS']['addCustomRegexp']))
  1056.                     {
  1057.                         foreach ($GLOBALS['TL_HOOKS']['addCustomRegexp'] as $callback)
  1058.                         {
  1059.                             $this->import($callback[0]);
  1060.                             $break = $this->{$callback[0]}->{$callback[1]}($this->rgxp, $varInput, $this);
  1062.                             // Stop the loop if a callback returned true
  1063.                             if ($break === true)
  1064.                             {
  1065.                                 break;
  1066.                             }
  1067.                         }
  1068.                     }
  1069.                     break;
  1070.             }
  1071.         }
  1073.         if ($this->isHexColor && $varInput && strncmp($varInput, '$', 1) !== 0)
  1074.         {
  1075.             $varInput = preg_replace('/[^a-f0-9]+/i', '', $varInput);
  1076.         }
  1078.         if ($this->nospace && preg_match('/[\t ]+/', $varInput))
  1079.         {
  1080.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['noSpace'], $this->strLabel));
  1081.         }
  1083.         if ($this->spaceToUnderscore)
  1084.         {
  1085.             $varInput = preg_replace('/\s+/', '_', trim($varInput));
  1086.         }
  1088.         if (\is_bool($this->trailingSlash) && $varInput)
  1089.         {
  1090.             $varInput = preg_replace('/\/+$/', '', $varInput) . ($this->trailingSlash ? '/' : '');
  1091.         }
  1093.         return $varInput;
  1094.     }
  1096.     /**
  1097.      * Take an associative array and add it to the object's attributes
  1098.      *
  1099.      * @param array $arrAttributes An array of attributes
  1100.      */
  1101.     public function addAttributes($arrAttributes)
  1102.     {
  1103.         if (!\is_array($arrAttributes))
  1104.         {
  1105.             return;
  1106.         }
  1108.         foreach ($arrAttributes as $k=>$v)
  1109.         {
  1110.             $this->$k = $v;
  1111.         }
  1112.     }
  1114.     /**
  1115.      * Check whether an option is checked
  1116.      *
  1117.      * @param array $arrOption The options array
  1118.      *
  1119.      * @return string The "checked" attribute or an empty string
  1120.      */
  1121.     protected function isChecked($arrOption)
  1122.     {
  1123.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1124.         {
  1125.             return static::optionChecked(1, 1);
  1126.         }
  1128.         return static::optionChecked($arrOption['value'] ?? null, $this->varValue);
  1129.     }
  1131.     /**
  1132.      * Check whether an option is selected
  1133.      *
  1134.      * @param array $arrOption The options array
  1135.      *
  1136.      * @return string The "selected" attribute or an empty string
  1137.      */
  1138.     protected function isSelected($arrOption)
  1139.     {
  1140.         if (empty($this->varValue) && empty($_POST) && ($arrOption['default'] ?? null))
  1141.         {
  1142.             return static::optionSelected(1, 1);
  1143.         }
  1145.         return static::optionSelected($arrOption['value'] ?? null, $this->varValue);
  1146.     }
  1148.     /**
  1149.      * Return a "selected" attribute if the option is selected
  1150.      *
  1151.      * @param string $strOption The option to check
  1152.      * @param mixed  $varValues One or more values to check against
  1153.      *
  1154.      * @return string The attribute or an empty string
  1155.      */
  1156.     public static function optionSelected($strOption, $varValues)
  1157.     {
  1158.         if ($strOption === '')
  1159.         {
  1160.             return '';
  1161.         }
  1163.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' selected' : '';
  1164.     }
  1166.     /**
  1167.      * Return a "checked" attribute if the option is checked
  1168.      *
  1169.      * @param string $strOption The option to check
  1170.      * @param mixed  $varValues One or more values to check against
  1171.      *
  1172.      * @return string The attribute or an empty string
  1173.      */
  1174.     public static function optionChecked($strOption, $varValues)
  1175.     {
  1176.         if ($strOption === '')
  1177.         {
  1178.             return '';
  1179.         }
  1181.         return (\is_array($varValues) ? \in_array($strOption, $varValues) : $strOption == $varValues) ? ' checked' : '';
  1182.     }
  1184.     /**
  1185.      * Check whether an input is one of the given options
  1186.      *
  1187.      * @param mixed $varInput The input string or array
  1188.      *
  1189.      * @return boolean True if the selected option exists
  1190.      */
  1191.     protected function isValidOption($varInput)
  1192.     {
  1193.         if (!\is_array($varInput))
  1194.         {
  1195.             $varInput = array($varInput);
  1196.         }
  1198.         // Check each option
  1199.         foreach ($varInput as $strInput)
  1200.         {
  1201.             $blnFound = false;
  1203.             foreach ($this->arrOptions as $v)
  1204.             {
  1205.                 // Single dimensional array
  1206.                 if (\array_key_exists('value', $v))
  1207.                 {
  1208.                     if ($strInput == $v['value'])
  1209.                     {
  1210.                         $blnFound = true;
  1211.                     }
  1212.                 }
  1213.                 // Multi-dimensional array
  1214.                 else
  1215.                 {
  1216.                     foreach ($v as $vv)
  1217.                     {
  1218.                         if ($strInput == $vv['value'])
  1219.                         {
  1220.                             $blnFound = true;
  1221.                         }
  1222.                     }
  1223.                 }
  1224.             }
  1226.             if (!$blnFound)
  1227.             {
  1228.                 return false;
  1229.             }
  1230.         }
  1232.         return true;
  1233.     }
  1235.     /**
  1236.      * Extract the Widget attributes from a Data Container array
  1237.      *
  1238.      * @param array                     $arrData  The field configuration array
  1239.      * @param string                    $strName  The field name in the form
  1240.      * @param mixed                     $varValue The field value
  1241.      * @param string                    $strField The field name in the database
  1242.      * @param string                    $strTable The table name in the database
  1243.      * @param DataContainer|Module|null $objDca   An optional DataContainer or Module object
  1244.      *
  1245.      * @return array An attributes array that can be passed to a widget
  1246.      */
  1247.     public static function getAttributesFromDca($arrData, $strName, $varValue=null, $strField='', $strTable='', $objDca=null)
  1248.     {
  1249.         $arrAttributes = $arrData['eval'] ?? array();
  1251.         if (method_exists(System::getContainer(), 'getParameterBag'))
  1252.         {
  1253.             $objParameterBag = System::getContainer()->getParameterBag();
  1255.             foreach ($arrAttributes as $strAttrKey => $varAttrValue)
  1256.             {
  1257.                 if (!\is_string($varAttrValue) || !preg_match('/%[a-z][a-z0-9_]*\.[a-z0-9_.]+%/i', $varAttrValue))
  1258.                 {
  1259.                     continue;
  1260.                 }
  1262.                 $varAttrValue = $objParameterBag->resolveValue($varAttrValue);
  1263.                 $varAttrValue = $objParameterBag->unescapeValue($varAttrValue);
  1265.                 $arrAttributes[$strAttrKey] = $varAttrValue;
  1266.             }
  1267.         }
  1269.         $arrAttributes['id'] = $strName;
  1270.         $arrAttributes['name'] = $strName;
  1271.         $arrAttributes['strField'] = $strField;
  1272.         $arrAttributes['strTable'] = $strTable;
  1273.         $arrAttributes['label'] = (($label = \is_array($arrData['label'] ?? null) ? $arrData['label'][0] : $arrData['label'] ?? null) !== null) ? $label : $strField;
  1274.         $arrAttributes['description'] = $arrData['label'][1] ?? null;
  1275.         $arrAttributes['type'] = $arrData['inputType'] ?? null;
  1276.         $arrAttributes['dataContainer'] = $objDca;
  1277.         $arrAttributes['value'] = StringUtil::deserialize($varValue);
  1279.         // Internet Explorer does not support onchange for checkboxes and radio buttons
  1280.         if ($arrData['eval']['submitOnChange'] ?? null)
  1281.         {
  1282.             if (($arrData['inputType'] ?? null) == 'checkbox' || ($arrData['inputType'] ?? null) == 'checkboxWizard' || ($arrData['inputType'] ?? null) == 'radio' || ($arrData['inputType'] ?? null) == 'radioTable')
  1283.             {
  1284.                 $arrAttributes['onclick'] = trim(($arrAttributes['onclick'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1285.             }
  1286.             else
  1287.             {
  1288.                 $arrAttributes['onchange'] = trim(($arrAttributes['onchange'] ?? '') . " Backend.autoSubmit('" . $strTable . "')");
  1289.             }
  1290.         }
  1292.         if (!empty($arrData['eval']['preserveTags']))
  1293.         {
  1294.             $arrAttributes['allowHtml'] = true;
  1295.         }
  1297.         if (!isset($arrAttributes['allowHtml']))
  1298.         {
  1299.             $rte = $arrData['eval']['rte'] ?? '';
  1300.             $arrAttributes['allowHtml'] = 'ace|html' === $rte || 0 === strpos($rte, 'tiny');
  1301.         }
  1303.         // Decode entities if HTML is allowed
  1304.         if ($arrAttributes['allowHtml'] || ($arrData['inputType'] ?? null) == 'fileTree')
  1305.         {
  1306.             $arrAttributes['decodeEntities'] = true;
  1307.         }
  1309.         // Add Ajax event
  1310.         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']))
  1311.         {
  1312.             $arrAttributes['onclick'] = "AjaxRequest.toggleSubpalette(this, 'sub_" . $strName . "', '" . $strField . "')";
  1313.         }
  1315.         // Options callback
  1316.         if (\is_array($arrData['options_callback'] ?? null))
  1317.         {
  1318.             $arrCallback = $arrData['options_callback'];
  1319.             $arrData['options'] = static::importStatic($arrCallback[0])->{$arrCallback[1]}($objDca);
  1320.         }
  1321.         elseif (\is_callable($arrData['options_callback'] ?? null))
  1322.         {
  1323.             $arrData['options'] = $arrData['options_callback']($objDca);
  1324.         }
  1326.         // Foreign key
  1327.         elseif (isset($arrData['foreignKey']))
  1328.         {
  1329.             $arrKey = explode('.', $arrData['foreignKey'], 2);
  1330.             $objOptions = Database::getInstance()->query("SELECT id, " . $arrKey[1] . " AS value FROM " . $arrKey[0] . " WHERE tstamp>0 ORDER BY value");
  1331.             $arrData['options'] = array();
  1333.             while ($objOptions->next())
  1334.             {
  1335.                 $arrData['options'][$objOptions->id] = $objOptions->value;
  1336.             }
  1337.         }
  1339.         // Add default option to single checkbox
  1340.         if (($arrData['inputType'] ?? null) == 'checkbox' && !isset($arrData['options']) && !isset($arrData['options_callback']) && !isset($arrData['foreignKey']))
  1341.         {
  1342.             if (TL_MODE == 'FE' && isset($arrAttributes['description']))
  1343.             {
  1344.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['description']);
  1345.             }
  1346.             else
  1347.             {
  1348.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['label']);
  1349.             }
  1350.         }
  1352.         // Add options
  1353.         if (\is_array($arrData['options'] ?? null))
  1354.         {
  1355.             $blnIsAssociative = ($arrData['eval']['isAssociative'] ?? null) || ArrayUtil::isAssoc($arrData['options'] ?? null);
  1356.             $blnUseReference = isset($arrData['reference']);
  1358.             if (($arrData['eval']['includeBlankOption'] ?? null) && !($arrData['eval']['multiple'] ?? null))
  1359.             {
  1360.                 $strLabel = $arrData['eval']['blankOptionLabel'] ?? '-';
  1361.                 $arrAttributes['options'][] = array('value'=>'', 'label'=>$strLabel);
  1362.             }
  1364.             $unknown = (array) $arrAttributes['value'];
  1366.             foreach ($arrData['options'] as $k=>$v)
  1367.             {
  1368.                 if (!\is_array($v))
  1369.                 {
  1370.                     $value = $blnIsAssociative ? $k : $v;
  1372.                     if (($i = array_search($value, $unknown)) !== false)
  1373.                     {
  1374.                         unset($unknown[$i]);
  1375.                     }
  1377.                     $arrAttributes['options'][] = array('value'=>$value, 'label'=>($blnUseReference && isset($arrData['reference'][$v]) ? ((($ref = (\is_array($arrData['reference'][$v]) ? $arrData['reference'][$v][0] : $arrData['reference'][$v])) != false) ? $ref : $v) : $v));
  1378.                     continue;
  1379.                 }
  1381.                 $key = $blnUseReference && isset($arrData['reference'][$k]) ? ((($ref = (\is_array($arrData['reference'][$k]) ? $arrData['reference'][$k][0] : $arrData['reference'][$k])) != false) ? $ref : $k) : $k;
  1382.                 $blnIsAssoc = ArrayUtil::isAssoc($v);
  1384.                 foreach ($v as $kk=>$vv)
  1385.                 {
  1386.                     $value = $blnIsAssoc ? $kk : $vv;
  1388.                     if (($i = array_search($value, $unknown)) !== false)
  1389.                     {
  1390.                         unset($unknown[$i]);
  1391.                     }
  1393.                     $arrAttributes['options'][$key][] = array('value'=>$value, 'label'=>($blnUseReference && isset($arrData['reference'][$vv]) ? ((($ref = (\is_array($arrData['reference'][$vv]) ? $arrData['reference'][$vv][0] : $arrData['reference'][$vv])) != false) ? $ref : $vv) : $vv));
  1394.                 }
  1395.             }
  1397.             $arrAttributes['unknownOption'] = array_filter($unknown);
  1398.         }
  1400.         if (\is_array($arrAttributes['sql'] ?? null) && !isset($arrAttributes['sql']['columnDefinition']))
  1401.         {
  1402.             if (!isset($arrAttributes['maxlength']) && isset($arrAttributes['sql']['length']))
  1403.             {
  1404.                 $arrAttributes['maxlength'] = $arrAttributes['sql']['length'];
  1405.             }
  1407.             if (!isset($arrAttributes['unique']) && isset($arrAttributes['sql']['customSchemaOptions']['unique']))
  1408.             {
  1409.                 $arrAttributes['unique'] = $arrAttributes['sql']['customSchemaOptions']['unique'];
  1410.             }
  1411.         }
  1413.         // Convert timestamps
  1414.         if ($varValue !== null && $varValue !== '' && \in_array($arrData['eval']['rgxp'] ?? null, array('date', 'time', 'datim')))
  1415.         {
  1416.             $objDate = new Date($varValue, Date::getFormatFromRgxp($arrData['eval']['rgxp']));
  1417.             $arrAttributes['value'] = $objDate->{$arrData['eval']['rgxp']};
  1418.         }
  1420.         // Convert URL insert tags
  1421.         if ($varValue && 'url' === ($arrData['eval']['rgxp'] ?? null))
  1422.         {
  1423.             $arrAttributes['value'] = str_replace('|urlattr}}', '}}', $varValue);
  1424.         }
  1426.         // Add the "rootNodes" array as attribute (see #3563)
  1427.         if (isset($arrData['rootNodes']) && !isset($arrData['eval']['rootNodes']))
  1428.         {
  1429.             $arrAttributes['rootNodes'] = $arrData['rootNodes'];
  1430.         }
  1432.         // HOOK: add custom logic
  1433.         if (isset($GLOBALS['TL_HOOKS']['getAttributesFromDca']) && \is_array($GLOBALS['TL_HOOKS']['getAttributesFromDca']))
  1434.         {
  1435.             foreach ($GLOBALS['TL_HOOKS']['getAttributesFromDca'] as $callback)
  1436.             {
  1437.                 $arrAttributes = static::importStatic($callback[0])->{$callback[1]}($arrAttributes, $objDca);
  1438.             }
  1439.         }
  1441.         // Warn if someone uses the "encrypt" flag (see #8589)
  1442.         if (isset($arrAttributes['encrypt']))
  1443.         {
  1444.             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.');
  1445.         }
  1447.         return $arrAttributes;
  1448.     }
  1450.     /**
  1451.      * Return the empty value based on the SQL string
  1452.      *
  1453.      * @return string|integer|null The empty value
  1454.      */
  1455.     public function getEmptyValue()
  1456.     {
  1457.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1458.         {
  1459.             return '';
  1460.         }
  1462.         return static::getEmptyValueByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1463.     }
  1465.     /**
  1466.      * Return the empty value based on the SQL string
  1467.      *
  1468.      * @param string|array $sql The SQL string
  1469.      *
  1470.      * @return string|integer|null The empty value
  1471.      */
  1472.     public static function getEmptyValueByFieldType($sql)
  1473.     {
  1474.         if (empty($sql))
  1475.         {
  1476.             return '';
  1477.         }
  1479.         if (\is_array($sql))
  1480.         {
  1481.             if (isset($sql['columnDefinition']))
  1482.             {
  1483.                 $sql = $sql['columnDefinition'];
  1484.             }
  1485.             else
  1486.             {
  1487.                 if (isset($sql['notnull']) && !$sql['notnull'])
  1488.                 {
  1489.                     return null;
  1490.                 }
  1492.                 if (\in_array($sql['type'], array(Types::BIGINT, Types::DECIMAL, Types::INTEGER, Types::SMALLINT, Types::FLOAT)))
  1493.                 {
  1494.                     return 0;
  1495.                 }
  1497.                 if ($sql['type'] === Types::BOOLEAN)
  1498.                 {
  1499.                     return false;
  1500.                 }
  1502.                 return '';
  1503.             }
  1504.         }
  1506.         if (stripos($sql, 'NOT NULL') === false)
  1507.         {
  1508.             return null;
  1509.         }
  1511.         $type = strtolower(preg_replace('/^([A-Za-z]+)[( ].*$/', '$1', $sql));
  1513.         if (\in_array($type, array('int', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint', 'float', 'double', 'dec', 'decimal')))
  1514.         {
  1515.             return 0;
  1516.         }
  1518.         return '';
  1519.     }
  1521.     /**
  1522.      * Return either an empty string or null based on the SQL string
  1523.      *
  1524.      * @return string|int|null The empty value
  1525.      */
  1526.     public function getEmptyStringOrNull()
  1527.     {
  1528.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1529.         {
  1530.             return '';
  1531.         }
  1533.         return static::getEmptyStringOrNullByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1534.     }
  1536.     /**
  1537.      * Return either an empty string or null based on the SQL string
  1538.      *
  1539.      * @param string $sql The SQL string
  1540.      *
  1541.      * @return string|null The empty string or null
  1542.      */
  1543.     public static function getEmptyStringOrNullByFieldType($sql)
  1544.     {
  1545.         if (empty($sql))
  1546.         {
  1547.             return '';
  1548.         }
  1550.         return static::getEmptyValueByFieldType($sql) === null ? null : '';
  1551.     }
  1553.     /**
  1554.      * Generate a submit button
  1555.      *
  1556.      * @return string The submit button markup
  1557.      *
  1558.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1559.      */
  1560.     protected function addSubmit()
  1561.     {
  1562.         trigger_deprecation('contao/core-bundle', '4.0', 'Using "Contao\Widget::addSubmit()" has been deprecated and will no longer work in Contao 5.0.');
  1564.         return '';
  1565.     }
  1566. }
  1568. class_alias(Widget::class, 'Widget');