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

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\Type;
  15. use Patchwork\Utf8;
  16. use Symfony\Component\HttpFoundation\Request;
  18. /**
  19.  * Generates and validates form fields
  20.  *
  21.  * The class functions as abstract parent class for all widget classes and
  22.  * provides methods to generate the form field markup and to validate the form
  23.  * field input.
  24.  *
  25.  * Usage:
  26.  *
  27.  *     $widget = new TextField();
  28.  *     $widget->name = 'test';
  29.  *     $widget->label = 'Test';
  30.  *
  31.  *     if ($_POST)
  32.  *     {
  33.  *         $widget->validate();
  34.  *
  35.  *         if (!$widget->hasErrors())
  36.  *         {
  37.  *             echo $widget->value;
  38.  *         }
  39.  *     }
  40.  *
  41.  * @property string        $id                The field ID
  42.  * @property string        $name              the field name
  43.  * @property string        $label             The field label
  44.  * @property mixed         $value             The field value
  45.  * @property string        $class             One or more CSS classes
  46.  * @property string        $prefix            The CSS class prefix
  47.  * @property string        $template          The template name
  48.  * @property string        $wizard            The field wizard markup
  49.  * @property string        $alt               The alternative text
  50.  * @property string        $style             The style attribute
  51.  * @property string        $accesskey         The key to focus the field
  52.  * @property integer       $tabindex          The tabindex of the field
  53.  * @property boolean       $disabled          Adds the disabled attribute
  54.  * @property boolean       $readonly          Adds the readonly attribute
  55.  * @property boolean       $autofocus         Adds the autofocus attribute
  56.  * @property boolean       $required          Adds the required attribute
  57.  * @property string        $onblur            The blur event
  58.  * @property string        $onchange          The change event
  59.  * @property string        $onclick           The click event
  60.  * @property string        $ondblclick        The double click event
  61.  * @property string        $onfocus           The focus event
  62.  * @property string        $onmousedown       The mouse down event
  63.  * @property string        $onmousemove       The mouse move event
  64.  * @property string        $onmouseout        The mouse out event
  65.  * @property string        $onmouseover       The mouse over event
  66.  * @property string        $onmouseup         The mouse up event
  67.  * @property string        $onkeydown         The key down event
  68.  * @property string        $onkeypress        The key press event
  69.  * @property string        $onkeyup           The key up event
  70.  * @property string        $onselect          The select event
  71.  * @property boolean       $mandatory         The field value must not be empty
  72.  * @property boolean       $nospace           Do not allow whitespace characters
  73.  * @property boolean       $allowHtml         Allow HTML tags in the field value
  74.  * @property boolean       $storeFile         Store uploaded files in a given folder
  75.  * @property boolean       $useHomeDir        Store uploaded files in the user's home directory
  76.  * @property boolean       $trailingSlash     Add or remove a trailing slash
  77.  * @property boolean       $spaceToUnderscore Convert spaces to underscores
  78.  * @property boolean       $doNotTrim         Do not trim the user input
  79.  * @property string        $forAttribute      The "for" attribute
  80.  * @property DataContainer $dataContainer     The data container object
  81.  * @property Result        $activeRecord      The active record
  82.  * @property string        $mandatoryField    The "mandatory field" label
  83.  * @property string        $customTpl         A custom template name
  84.  * @property string        $slabel            The submit button label
  85.  * @property boolean       $preserveTags      Preserve HTML tags
  86.  * @property boolean       $decodeEntities    Decode HTML entities
  87.  * @property boolean       $useRawRequestData Use the raw request data from the Symfony request
  88.  * @property integer       $minlength         The minimum length
  89.  * @property integer       $maxlength         The maximum length
  90.  * @property integer       $minval            The minimum value
  91.  * @property integer       $maxval            The maximum value
  92.  * @property integer       $rgxp              The regular expression name
  93.  * @property boolean       $isHexColor        The field value is a hex color
  94.  * @property string        $strTable          The table name
  95.  * @property string        $strField          The field name
  96.  * @property string        $xlabel
  97.  * @property integer       $currentRecord
  98.  * @property integer       $rowClass
  99.  * @property integer       $rowClassConfirm
  100.  * @property integer       $storeValues
  101.  *
  102.  * @author Leo Feyer <https://github.com/leofeyer>
  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'])
  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.                     $this->arrAttributes['tabindex'] = $varValue;
  295.                 }
  296.                 break;
  298.             case 'disabled':
  299.             case 'readonly':
  300.                 $this->blnSubmitInput = $varValue ? false : true;
  301.                 // no break
  303.             case 'autofocus':
  304.                 if ($varValue)
  305.                 {
  306.                     $this->arrAttributes[$strKey] = $strKey;
  307.                 }
  308.                 else
  309.                 {
  310.                     unset($this->arrAttributes[$strKey]);
  311.                 }
  312.                 break;
  314.             case 'required':
  315.                 if ($varValue)
  316.                 {
  317.                     $this->strClass = trim($this->strClass . ' mandatory');
  318.                 }
  319.                 // no break
  321.             case 'mandatory':
  322.             case 'nospace':
  323.             case 'allowHtml':
  324.             case 'storeFile':
  325.             case 'useHomeDir':
  326.             case 'storeValues':
  327.             case 'trailingSlash':
  328.             case 'spaceToUnderscore':
  329.             case 'doNotTrim':
  330.             case 'useRawRequestData':
  331.                 $this->arrConfiguration[$strKey] = $varValue ? true : false;
  332.                 break;
  334.             case 'forAttribute':
  335.                 $this->blnForAttribute = $varValue;
  336.                 break;
  338.             case 'dataContainer':
  339.                 $this->objDca = $varValue;
  340.                 break;
  342.             case strncmp($strKey, 'ng-', 3) === 0:
  343.             case strncmp($strKey, 'data-', 5) === 0:
  344.                 $this->arrAttributes[$strKey] = $varValue;
  345.                 break;
  347.             default:
  348.                 $this->arrConfiguration[$strKey] = $varValue;
  349.                 break;
  350.         }
  351.     }
  353.     /**
  354.      * Return an object property
  355.      *
  356.      * @param string $strKey The property name
  357.      *
  358.      * @return string The property value
  359.      */
  360.     public function __get($strKey)
  361.     {
  362.         switch ($strKey)
  363.         {
  364.             case 'id':
  365.                 return $this->strId;
  367.             case 'name':
  368.                 return $this->strName;
  370.             case 'label':
  371.                 return $this->strLabel;
  373.             case 'value':
  374.                 // Encrypt the value
  375.                 if (isset($this->arrConfiguration['encrypt']) && $this->arrConfiguration['encrypt'])
  376.                 {
  377.                     return Encryption::encrypt($this->varValue);
  378.                 }
  380.                 if ($this->varValue === '')
  381.                 {
  382.                     return $this->getEmptyStringOrNull();
  383.                 }
  385.                 return $this->varValue;
  387.             case 'class':
  388.                 return $this->strClass;
  390.             case 'prefix':
  391.                 return $this->strPrefix;
  393.             case 'template':
  394.                 return $this->strTemplate;
  396.             case 'wizard':
  397.                 return $this->strWizard;
  399.             case 'required':
  400.                 return $this->arrConfiguration[$strKey];
  402.             case 'forAttribute':
  403.                 return $this->blnForAttribute;
  405.             case 'dataContainer':
  406.                 return $this->objDca;
  408.             case 'activeRecord':
  409.                 return $this->objDca->activeRecord;
  411.             default:
  412.                 if (isset($this->arrAttributes[$strKey]))
  413.                 {
  414.                     return $this->arrAttributes[$strKey];
  415.                 }
  417.                 if (isset($this->arrConfiguration[$strKey]))
  418.                 {
  419.                     return $this->arrConfiguration[$strKey];
  420.                 }
  421.                 break;
  422.         }
  424.         return parent::__get($strKey);
  425.     }
  427.     /**
  428.      * Check whether an object property exists
  429.      *
  430.      * @param string $strKey The property name
  431.      *
  432.      * @return boolean True if the property exists
  433.      */
  434.     public function __isset($strKey)
  435.     {
  436.         switch ($strKey)
  437.         {
  438.             case 'id':
  439.                 return isset($this->strId);
  441.             case 'name':
  442.                 return isset($this->strName);
  444.             case 'label':
  445.                 return isset($this->strLabel);
  447.             case 'value':
  448.                 return isset($this->varValue);
  450.             case 'class':
  451.                 return isset($this->strClass);
  453.             case 'template':
  454.                 return isset($this->strTemplate);
  456.             case 'wizard':
  457.                 return isset($this->strWizard);
  459.             case 'required':
  460.                 return isset($this->arrConfiguration[$strKey]);
  462.             case 'forAttribute':
  463.                 return isset($this->blnForAttribute);
  465.             case 'dataContainer':
  466.                 return isset($this->objDca);
  468.             case 'activeRecord':
  469.                 return isset($this->objDca->activeRecord);
  471.             default:
  472.                 return isset($this->arrAttributes[$strKey]) || isset($this->arrConfiguration[$strKey]);
  473.         }
  474.     }
  476.     /**
  477.      * Add an attribute
  478.      *
  479.      * @param string $strName  The attribute name
  480.      * @param mixed  $varValue The attribute value
  481.      */
  482.     public function addAttribute($strName, $varValue)
  483.     {
  484.         $this->arrAttributes[$strName] = $varValue;
  485.     }
  487.     /**
  488.      * Add an error message
  489.      *
  490.      * @param string $strError The error message
  491.      */
  492.     public function addError($strError)
  493.     {
  494.         $this->class = 'error';
  495.         $this->arrErrors[] = $strError;
  496.     }
  498.     /**
  499.      * Return true if the widget has errors
  500.      *
  501.      * @return boolean True if there are errors
  502.      */
  503.     public function hasErrors()
  504.     {
  505.         return !empty($this->arrErrors);
  506.     }
  508.     /**
  509.      * Return the errors array
  510.      *
  511.      * @return array An array of error messages
  512.      */
  513.     public function getErrors()
  514.     {
  515.         return $this->arrErrors;
  516.     }
  518.     /**
  519.      * Return a particular error as string
  520.      *
  521.      * @param integer $intIndex The message index
  522.      *
  523.      * @return string The corresponding error message
  524.      */
  525.     public function getErrorAsString($intIndex=0)
  526.     {
  527.         return $this->arrErrors[$intIndex];
  528.     }
  530.     /**
  531.      * Return all errors as string separated by a given separator
  532.      *
  533.      * @param string $strSeparator An optional separator (defaults to "<br>")
  534.      *
  535.      * @return string The error messages string
  536.      */
  537.     public function getErrorsAsString($strSeparator=null)
  538.     {
  539.         if ($strSeparator === null)
  540.         {
  541.             $strSeparator = '<br' . $this->strTagEnding . "\n";
  542.         }
  544.         return $this->hasErrors() ? implode($strSeparator, $this->arrErrors) : '';
  545.     }
  547.     /**
  548.      * Return a particular error as HTML string
  549.      *
  550.      * @param integer $intIndex The message index
  551.      *
  552.      * @return string The HTML markup of the corresponding error message
  553.      */
  554.     public function getErrorAsHTML($intIndex=0)
  555.     {
  556.         return $this->hasErrors() ? sprintf('<p class="%s">%s</p>', ((TL_MODE == 'BE') ? 'tl_error tl_tip' : 'error'), $this->arrErrors[$intIndex]) : '';
  557.     }
  559.     /**
  560.      * Return true if the widgets submits user input
  561.      *
  562.      * @return boolean True if the widget submits user input
  563.      */
  564.     public function submitInput()
  565.     {
  566.         return $this->blnSubmitInput;
  567.     }
  569.     /**
  570.      * Parse the template file and return it as string
  571.      *
  572.      * @param array $arrAttributes An optional attributes array
  573.      *
  574.      * @return string The template markup
  575.      */
  576.     public function parse($arrAttributes=null)
  577.     {
  578.         if (!$this->strTemplate)
  579.         {
  580.             return '';
  581.         }
  583.         $this->addAttributes($arrAttributes);
  585.         $this->mandatoryField = $GLOBALS['TL_LANG']['MSC']['mandatory'];
  587.         if ($this->customTpl)
  588.         {
  589.             $request = System::getContainer()->get('request_stack')->getCurrentRequest();
  591.             // Use the custom template unless it is a back end request
  592.             if (!$request || !System::getContainer()->get('contao.routing.scope_matcher')->isBackendRequest($request))
  593.             {
  594.                 $this->strTemplate = $this->customTpl;
  595.             }
  596.         }
  598.         $strBuffer = $this->inherit();
  600.         // HOOK: add custom parse filters (see #5553)
  601.         if (isset($GLOBALS['TL_HOOKS']['parseWidget']) && \is_array($GLOBALS['TL_HOOKS']['parseWidget']))
  602.         {
  603.             foreach ($GLOBALS['TL_HOOKS']['parseWidget'] as $callback)
  604.             {
  605.                 $this->import($callback[0]);
  606.                 $strBuffer = $this->{$callback[0]}->{$callback[1]}($strBuffer, $this);
  607.             }
  608.         }
  610.         return $strBuffer;
  611.     }
  613.     /**
  614.      * Generate the label and return it as string
  615.      *
  616.      * @return string The label markup
  617.      */
  618.     public function generateLabel()
  619.     {
  620.         if (!$this->strLabel)
  621.         {
  622.             return '';
  623.         }
  625.         return sprintf(
  626.             '<label%s%s>%s%s%s</label>',
  627.             ($this->blnForAttribute ? ' for="ctrl_' . $this->strId . '"' : ''),
  628.             ($this->strClass ? ' class="' . $this->strClass . '"' : ''),
  629.             ($this->mandatory ? '<span class="invisible">' . $GLOBALS['TL_LANG']['MSC']['mandatory'] . ' </span>' : ''),
  630.             $this->strLabel,
  631.             ($this->mandatory ? '<span class="mandatory">*</span>' : '')
  632.         );
  633.     }
  635.     /**
  636.      * Generate the widget and return it as string
  637.      *
  638.      * @return string The widget markup
  639.      */
  640.     abstract public function generate();
  642.     /**
  643.      * Generate the widget with error message and return it as string
  644.      *
  645.      * @param boolean $blnSwitchOrder If true, the error message will be shown below the field
  646.      *
  647.      * @return string The form field markup
  648.      */
  649.     public function generateWithError($blnSwitchOrder=false)
  650.     {
  651.         $strWidget = $this->generate();
  652.         $strError = $this->getErrorAsHTML();
  654.         return $blnSwitchOrder ? $strWidget . $strError : $strError . $strWidget;
  655.     }
  657.     /**
  658.      * Return all attributes as string
  659.      *
  660.      * @param array $arrStrip An optional array with attributes to strip
  661.      *
  662.      * @return string The attributes string
  663.      */
  664.     public function getAttributes($arrStrip=array())
  665.     {
  666.         $strAttributes = '';
  668.         foreach (array_keys($this->arrAttributes) as $strKey)
  669.         {
  670.             if (!\in_array($strKey, $arrStrip))
  671.             {
  672.                 $strAttributes .= $this->getAttribute($strKey);
  673.             }
  674.         }
  676.         return $strAttributes;
  677.     }
  679.     /**
  680.      * Return a single attribute
  681.      *
  682.      * @param string $strKey The attribute name
  683.      *
  684.      * @return string The attribute markup
  685.      */
  686.     public function getAttribute($strKey)
  687.     {
  688.         if (!isset($this->arrAttributes[$strKey]))
  689.         {
  690.             return '';
  691.         }
  693.         $varValue = $this->arrAttributes[$strKey];
  695.         // Prevent the autofocus attribute from being added multiple times (see #8281)
  696.         if ($strKey == 'autofocus')
  697.         {
  698.             unset($this->arrAttributes[$strKey]);
  699.         }
  701.         if ($strKey == 'disabled' || $strKey == 'readonly' || $strKey == 'required' || $strKey == 'autofocus' || $strKey == 'multiple')
  702.         {
  703.             return ' ' . $strKey;
  704.         }
  706.         if ('' !== (string) $varValue)
  707.         {
  708.             return ' ' . $strKey . '="' . StringUtil::specialchars($varValue) . '"';
  709.         }
  711.         return '';
  712.     }
  714.     /**
  715.      * Set a callback to fetch the widget input instead of using getPost()
  716.      *
  717.      * @param callable|null $callback The callback
  718.      *
  719.      * @return $this The widget object
  720.      */
  721.     public function setInputCallback(callable $callback=null)
  722.     {
  723.         $this->inputCallback = $callback;
  725.         return $this;
  726.     }
  728.     /**
  729.      * Validate the user input and set the value
  730.      */
  731.     public function validate()
  732.     {
  733.         $varValue = $this->validator($this->getPost($this->strName));
  735.         if ($this->hasErrors())
  736.         {
  737.             $this->class = 'error';
  738.         }
  740.         $this->varValue = $varValue;
  741.     }
  743.     /**
  744.      * Find and return a $_POST variable
  745.      *
  746.      * @param string $strKey The variable name
  747.      *
  748.      * @return mixed The variable value
  749.      */
  750.     protected function getPost($strKey)
  751.     {
  752.         if (\is_callable($this->inputCallback))
  753.         {
  754.             return \call_user_func($this->inputCallback);
  755.         }
  757.         if ($this->useRawRequestData === true)
  758.         {
  759.             /** @var Request $request */
  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 && Utf8::strlen($varInput) < $this->minlength)
  831.         {
  832.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minlength'], $this->strLabel, $this->minlength));
  833.         }
  835.         if ($this->maxlength && $varInput && Utf8::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'])
  1124.         {
  1125.             return static::optionChecked(1, 1);
  1126.         }
  1128.         return static::optionChecked($arrOption['value'], $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'])
  1141.         {
  1142.             return static::optionSelected(1, 1);
  1143.         }
  1145.         return static::optionSelected($arrOption['value'], $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'];
  1251.         $arrAttributes['id'] = $strName;
  1252.         $arrAttributes['name'] = $strName;
  1253.         $arrAttributes['strField'] = $strField;
  1254.         $arrAttributes['strTable'] = $strTable;
  1255.         $arrAttributes['label'] = (($label = \is_array($arrData['label']) ? $arrData['label'][0] : $arrData['label']) !== null) ? $label : $strField;
  1256.         $arrAttributes['description'] = $arrData['label'][1];
  1257.         $arrAttributes['type'] = $arrData['inputType'];
  1258.         $arrAttributes['dataContainer'] = $objDca;
  1259.         $arrAttributes['value'] = StringUtil::deserialize($varValue);
  1261.         // Internet Explorer does not support onchange for checkboxes and radio buttons
  1262.         if ($arrData['eval']['submitOnChange'])
  1263.         {
  1264.             if ($arrData['inputType'] == 'checkbox' || $arrData['inputType'] == 'checkboxWizard' || $arrData['inputType'] == 'radio' || $arrData['inputType'] == 'radioTable')
  1265.             {
  1266.                 $arrAttributes['onclick'] = trim($arrAttributes['onclick'] . " Backend.autoSubmit('" . $strTable . "')");
  1267.             }
  1268.             else
  1269.             {
  1270.                 $arrAttributes['onchange'] = trim($arrAttributes['onchange'] . " Backend.autoSubmit('" . $strTable . "')");
  1271.             }
  1272.         }
  1274.         if (!empty($arrData['eval']['preserveTags']))
  1275.         {
  1276.             $arrAttributes['allowHtml'] = true;
  1277.         }
  1279.         if (!isset($arrAttributes['allowHtml']))
  1280.         {
  1281.             $rte = $arrData['eval']['rte'] ?? '';
  1282.             $arrAttributes['allowHtml'] = 'ace|html' === $rte || 0 === strpos($rte, 'tiny');
  1283.         }
  1285.         // Decode entities if HTML is allowed
  1286.         if ($arrAttributes['allowHtml'] || $arrData['inputType'] == 'fileTree')
  1287.         {
  1288.             $arrAttributes['decodeEntities'] = true;
  1289.         }
  1291.         // Add Ajax event
  1292.         if ($arrData['inputType'] == 'checkbox' && $arrData['eval']['submitOnChange'] && \is_array($GLOBALS['TL_DCA'][$strTable]['subpalettes']) && \array_key_exists($strField, $GLOBALS['TL_DCA'][$strTable]['subpalettes']))
  1293.         {
  1294.             $arrAttributes['onclick'] = "AjaxRequest.toggleSubpalette(this, 'sub_" . $strName . "', '" . $strField . "')";
  1295.         }
  1297.         // Options callback
  1298.         if (\is_array($arrData['options_callback']))
  1299.         {
  1300.             $arrCallback = $arrData['options_callback'];
  1301.             $arrData['options'] = static::importStatic($arrCallback[0])->{$arrCallback[1]}($objDca);
  1302.         }
  1303.         elseif (\is_callable($arrData['options_callback']))
  1304.         {
  1305.             $arrData['options'] = $arrData['options_callback']($objDca);
  1306.         }
  1308.         // Foreign key
  1309.         elseif (isset($arrData['foreignKey']))
  1310.         {
  1311.             $arrKey = explode('.', $arrData['foreignKey'], 2);
  1312.             $objOptions = Database::getInstance()->query("SELECT id, " . $arrKey[1] . " AS value FROM " . $arrKey[0] . " WHERE tstamp>0 ORDER BY value");
  1313.             $arrData['options'] = array();
  1315.             while ($objOptions->next())
  1316.             {
  1317.                 $arrData['options'][$objOptions->id] = $objOptions->value;
  1318.             }
  1319.         }
  1321.         // Add default option to single checkbox
  1322.         if ($arrData['inputType'] == 'checkbox' && !isset($arrData['options']) && !isset($arrData['options_callback']) && !isset($arrData['foreignKey']))
  1323.         {
  1324.             if (TL_MODE == 'FE' && isset($arrAttributes['description']))
  1325.             {
  1326.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['description']);
  1327.             }
  1328.             else
  1329.             {
  1330.                 $arrAttributes['options'][] = array('value'=>1, 'label'=>$arrAttributes['label']);
  1331.             }
  1332.         }
  1334.         // Add options
  1335.         if (\is_array($arrData['options']))
  1336.         {
  1337.             $blnIsAssociative = ($arrData['eval']['isAssociative'] || array_is_assoc($arrData['options']));
  1338.             $blnUseReference = isset($arrData['reference']);
  1340.             if ($arrData['eval']['includeBlankOption'] && !$arrData['eval']['multiple'])
  1341.             {
  1342.                 $strLabel = $arrData['eval']['blankOptionLabel'] ?? '-';
  1343.                 $arrAttributes['options'][] = array('value'=>'', 'label'=>$strLabel);
  1344.             }
  1346.             $unknown = (array) $arrAttributes['value'];
  1348.             foreach ($arrData['options'] as $k=>$v)
  1349.             {
  1350.                 if (!\is_array($v))
  1351.                 {
  1352.                     $value = $blnIsAssociative ? $k : $v;
  1354.                     if (($i = array_search($value, $unknown)) !== false)
  1355.                     {
  1356.                         unset($unknown[$i]);
  1357.                     }
  1359.                     $arrAttributes['options'][] = array('value'=>$value, 'label'=>($blnUseReference ? ((($ref = (\is_array($arrData['reference'][$v]) ? $arrData['reference'][$v][0] : $arrData['reference'][$v])) != false) ? $ref : $v) : $v));
  1360.                     continue;
  1361.                 }
  1363.                 $key = $blnUseReference ? ((($ref = (\is_array($arrData['reference'][$k]) ? $arrData['reference'][$k][0] : $arrData['reference'][$k])) != false) ? $ref : $k) : $k;
  1364.                 $blnIsAssoc = array_is_assoc($v);
  1366.                 foreach ($v as $kk=>$vv)
  1367.                 {
  1368.                     $value = $blnIsAssoc ? $kk : $vv;
  1370.                     if (($i = array_search($value, $unknown)) !== false)
  1371.                     {
  1372.                         unset($unknown[$i]);
  1373.                     }
  1375.                     $arrAttributes['options'][$key][] = array('value'=>$value, 'label'=>($blnUseReference ? ((($ref = (\is_array($arrData['reference'][$vv]) ? $arrData['reference'][$vv][0] : $arrData['reference'][$vv])) != false) ? $ref : $vv) : $vv));
  1376.                 }
  1377.             }
  1379.             $arrAttributes['unknownOption'] = array_filter($unknown);
  1380.         }
  1382.         if (\is_array($arrAttributes['sql']) && !isset($arrAttributes['sql']['columnDefinition']))
  1383.         {
  1384.             if (!isset($arrAttributes['maxlength']) && isset($arrAttributes['sql']['length']))
  1385.             {
  1386.                 $arrAttributes['maxlength'] = $arrAttributes['sql']['length'];
  1387.             }
  1389.             if (!isset($arrAttributes['unique']) && isset($arrAttributes['sql']['customSchemaOptions']['unique']))
  1390.             {
  1391.                 $arrAttributes['unique'] = $arrAttributes['sql']['customSchemaOptions']['unique'];
  1392.             }
  1393.         }
  1395.         // Convert timestamps
  1396.         if ($varValue !== null && $varValue !== '' && \in_array($arrData['eval']['rgxp'], array('date', 'time', 'datim')))
  1397.         {
  1398.             $objDate = new Date($varValue, Date::getFormatFromRgxp($arrData['eval']['rgxp']));
  1399.             $arrAttributes['value'] = $objDate->{$arrData['eval']['rgxp']};
  1400.         }
  1402.         // Convert URL insert tags
  1403.         if ($varValue && 'url' === ($arrData['eval']['rgxp'] ?? null))
  1404.         {
  1405.             $arrAttributes['value'] = str_replace('|urlattr}}', '}}', $varValue);
  1406.         }
  1408.         // Add the "rootNodes" array as attribute (see #3563)
  1409.         if (isset($arrData['rootNodes']) && !isset($arrData['eval']['rootNodes']))
  1410.         {
  1411.             $arrAttributes['rootNodes'] = $arrData['rootNodes'];
  1412.         }
  1414.         // HOOK: add custom logic
  1415.         if (isset($GLOBALS['TL_HOOKS']['getAttributesFromDca']) && \is_array($GLOBALS['TL_HOOKS']['getAttributesFromDca']))
  1416.         {
  1417.             foreach ($GLOBALS['TL_HOOKS']['getAttributesFromDca'] as $callback)
  1418.             {
  1419.                 $arrAttributes = static::importStatic($callback[0])->{$callback[1]}($arrAttributes, $objDca);
  1420.             }
  1421.         }
  1423.         // Warn if someone uses the "encrypt" flag (see #8589)
  1424.         if (isset($arrAttributes['encrypt']))
  1425.         {
  1426.             @trigger_error('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.', E_USER_DEPRECATED);
  1427.         }
  1429.         return $arrAttributes;
  1430.     }
  1432.     /**
  1433.      * Return the empty value based on the SQL string
  1434.      *
  1435.      * @return string|integer|null The empty value
  1436.      */
  1437.     public function getEmptyValue()
  1438.     {
  1439.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1440.         {
  1441.             return '';
  1442.         }
  1444.         return static::getEmptyValueByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1445.     }
  1447.     /**
  1448.      * Return the empty value based on the SQL string
  1449.      *
  1450.      * @param string|array $sql The SQL string
  1451.      *
  1452.      * @return string|integer|null The empty value
  1453.      */
  1454.     public static function getEmptyValueByFieldType($sql)
  1455.     {
  1456.         if (empty($sql))
  1457.         {
  1458.             return '';
  1459.         }
  1461.         if (\is_array($sql))
  1462.         {
  1463.             if (isset($sql['columnDefinition']))
  1464.             {
  1465.                 $sql = $sql['columnDefinition'];
  1466.             }
  1467.             else
  1468.             {
  1469.                 if (isset($sql['notnull']) && !$sql['notnull'])
  1470.                 {
  1471.                     return null;
  1472.                 }
  1474.                 if (\in_array($sql['type'], array(Type::BIGINT, Type::DECIMAL, Type::INTEGER, Type::SMALLINT, Type::FLOAT)))
  1475.                 {
  1476.                     return 0;
  1477.                 }
  1479.                 if ($sql['type'] === Type::BOOLEAN)
  1480.                 {
  1481.                     return false;
  1482.                 }
  1484.                 return '';
  1485.             }
  1486.         }
  1488.         if (stripos($sql, 'NOT NULL') === false)
  1489.         {
  1490.             return null;
  1491.         }
  1493.         $type = strtolower(preg_replace('/^([A-Za-z]+)[( ].*$/', '$1', $sql));
  1495.         if (\in_array($type, array('int', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint', 'float', 'double', 'dec', 'decimal')))
  1496.         {
  1497.             return 0;
  1498.         }
  1500.         return '';
  1501.     }
  1503.     /**
  1504.      * Return either an empty string or null based on the SQL string
  1505.      *
  1506.      * @return string|int|null The empty value
  1507.      */
  1508.     public function getEmptyStringOrNull()
  1509.     {
  1510.         if (!isset($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']))
  1511.         {
  1512.             return '';
  1513.         }
  1515.         return static::getEmptyStringOrNullByFieldType($GLOBALS['TL_DCA'][$this->strTable]['fields'][$this->strField]['sql']);
  1516.     }
  1518.     /**
  1519.      * Return either an empty string or null based on the SQL string
  1520.      *
  1521.      * @param string $sql The SQL string
  1522.      *
  1523.      * @return string|null The empty string or null
  1524.      */
  1525.     public static function getEmptyStringOrNullByFieldType($sql)
  1526.     {
  1527.         if (empty($sql))
  1528.         {
  1529.             return '';
  1530.         }
  1532.         return static::getEmptyValueByFieldType($sql) === null ? null : '';
  1533.     }
  1535.     /**
  1536.      * Generate a submit button
  1537.      *
  1538.      * @return string The submit button markup
  1539.      *
  1540.      * @deprecated Deprecated since Contao 4.0, to be removed in Contao 5.0.
  1541.      */
  1542.     protected function addSubmit()
  1543.     {
  1544.         @trigger_error('Using Widget::addSubmit() has been deprecated and will no longer work in Contao 5.0.', E_USER_DEPRECATED);
  1546.         return '';
  1547.     }
  1548. }
  1550. class_alias(Widget::class, 'Widget');