Display text on screen
@param string $text text value
@param string $dataType The data type
@return Renderer The renderer object
@throws
6550
public function textRenderer(string $text, string $dataType = 'text'): Renderer
    {
        if (!$this->allowedTypeExist($dataType)) {
            throw new Server500(new \ArrayObject(array("explain" => 'Undefined {'.$dataType.'} type for text render',
                "solution" => "Please set the allowed text render type : ".json_encode($this->allowed_text_render))));
        }
        array_push(self::$buffer_text, array("text" => $text, "type" => $dataType));
        $this->display_elements = array("text" => $text, "type" => $dataType);
        return ($this);
    }
1007609
public function RenderHtml(&$Content, &$Data)
    {
        header('Content-Type: text/html');

        foreach ($Content as $key => $val) {

            $datum = isset($Data[$val['key']]) ? $Data[$val['key']] : null;
            $hasChild = isset($val['child']) ? true : false;

            $this->_Output .= $val['text'];

            if ($this->CustomRender !== null) {
                $this->CustomRender->RegisterFunction($val['key'], $val['param']);
                $this->_Output .= $this->CustomRender->Parse();
            }

            if ($val['param'] !== false) {
                if ($val['key'] === 'css') {
                    $this->tempCss .= $val['param'];
                }
                if ($val['key'] === 'js') {
                    $this->tempJs .= $val['param'];
                }

                if ($val['key'] === 'part') {
                    if ($val['param'] === 'css') {
                        $this->_Output .= $this->tempCss;
                    }
                    if ($val['param'] === 'js') {
                        $this->_Output .= $this->tempJs;
                    }
                }
            }

            if ($this->GetVarType($datum) === $this->STRINGS) {
                $this->_Output .= (string)$Data[$val['key']];
            } else if ($this->GetVarType($datum) === $this->NUMERIC) {
                $this->_Output .= (double)$Data[$val['key']];
            } else if ($this->GetVarType($datum) === $this->ARRAYS) {
                foreach ($datum as $k => $v) {
                    if (is_array($v)) {
                        //Numeric Array
                        $this->RenderHtml($val['child'], $v);
                    } else {
                        //Associative Arrays
                        $this->RenderHtml($val['child'], $datum);
                        break;
                    }
                }
            } else if ($this->GetVarType($datum) === $this->BOOLEANS) {
                if ($datum) {
                    $this->RenderHtml($val['child'], $datum);
                }
            } else if ($this->GetVarType($datum) === $this->OBJECTS) {
                if ($datum instanceof Parts) {
                    $datum->RegisterFunction($val['key'], $val['param']);
                    if ($datum->tags === $datum->fnName) {
                        //Append output
                        $this->_Output .= $datum->Parse();
                        //Append property
                        $this->tempCss .= $datum->pte->GetTempCss();
                        $this->tempJs .= $datum->pte->GetTempJs();
                    }
                }
            } else {
                if ($hasChild && $datum !== null) {
                    $this->RenderHtml($val['child'], $datum);
                }
            }
        }
        return $this->_Output;
    }
972904
public function display($content, $data = []) {
        $this->content = $content;

        extract($data, EXTR_OVERWRITE);
        eval('?>' . $this->content);
    }
520482
public function do_text(
        $text,
        $offsetX = 0,
        $offsetY = 0,
        $opacity = 1.0,
        $color = 0x000000,
        $size = 12,
        $font_file = null
    ) {
        $textColor = imagecolorallocatealpha($this->_image, ($color >> 16) & 0xFF, ($color >> 8) & 0xFF,
            $color & 0xFF, abs(1 - $opacity) * 127);
        if ($font_file) {
            imagettftext($this->_image, $size, 0, $offsetX, $offsetY, $textColor, $this->alias->resolve($font_file), $text);
        } else {
            imagestring($this->_image, $size, $offsetX, $offsetY, $text, $textColor);
        }

        return $this;
    }
616269
public function addText($text) {
		$content = new HtmlString();
		$content->htmlString = $text;
		$this->children[] = $content;
		return $this;
	}
1342985
protected function renderText($text, $status = 200, $minetype = 'html') {
		// Check if a output action has be already performed
		$this->_checkIfPerformed();

		// Set template settings
		$this->useTemplate(false, $status, $minetype);

		return $text;
	}
846211
public function setTextBody($text) {
    if (!is_string($text)) {
      $error = sprintf("Plain text given is not a string (Actual type: %s).",
                       gettype($text));
      throw new \InvalidArgumentException($error);
    }
    $this->message->setTextbody($text);
  }
1351233
protected function renderDescription($text, $isFieldset = false)
    {
        $output = '';

        // Help text.
        if (!empty($text)) {
            // Allow for links in the help text, so no filtering anymore.
            $wrapperType = $isFieldset ? 'fieldsetDescription' : 'description';
            $output .= $this->getWrapper($wrapperType);
            $output .= $text;
            $output .= $this->getWrapperEnd($wrapperType);
        }

        return $output;
    }
1349237
public function setDataType($dataType)
    {
        $formDefinition = $this->getRootForm();
        $formDefinition->getProcessingRule($this->getIdentifier())->setDataType($dataType);
    }
716241
public function paintText($text, Definition $definition, TestResult $result)
    {
        $regex = $this->patternTransformer->transformPatternToRegex($definition->getPattern());
        $style = $this->resultConverter->convertResultToString($result);
        $paramStyle = $style . '_param';

        // If it's just a string - skip
        if ('/' !== substr($regex, 0, 1)) {
            return $text;
        }

        // Find arguments with offsets
        $matches = array();
        preg_match($regex, $text, $matches, PREG_OFFSET_CAPTURE);
        array_shift($matches);

        // Replace arguments with colorized ones
        $shift = 0;
        $lastReplacementPosition = 0;
        foreach ($matches as $key => $match) {
            if (!is_numeric($key) || -1 === $match[1] || false !== strpos($match[0], '<')) {
                continue;
            }

            $offset = $match[1] + $shift;
            $value = $match[0];

            // Skip inner matches
            if ($lastReplacementPosition > $offset) {
                continue;
            }
            $lastReplacementPosition = $offset + strlen($value);

            $begin = substr($text, 0, $offset);
            $end = substr($text, $lastReplacementPosition);
            $format = "{-$style}{+$paramStyle}%s{-$paramStyle}{+$style}";
            $text = sprintf("%s{$format}%s", $begin, $value, $end);

            // Keep track of how many extra characters are added
            $shift += strlen($format) - 2;
            $lastReplacementPosition += strlen($format) - 2;
        }

        // Replace "<", ">" with colorized ones
        $text = preg_replace(
            '/(<[^>]+>)/',
            "{-$style}{+$paramStyle}\$1{-$paramStyle}{+$style}",
            $text
        );

        return $text;
    }
602740
public function aILabText(string $text, int $type = 0)
    {
        $this->checkAILabTextType($type);

        return Request::exec(self::AILAB_TEXT, compact('text', 'type'));
    }
40295
public function setText(string $text)
    {
        $this
            ->getScanner()
            ->setText($text);
        $this->buffer = null;
        return $this;
    }
184990
public function setDisplayType($type)
    {
        if (empty($type)) {
            $this->displayType = null;
            return $this;
        }

        if (!is_string($type)) {
            throw new InvalidArgumentException(
                'Property display type must be a string'
            );
        }

        $this->displayType = $type;

        return $this;
    }
868342
public function do_text(
        $text,
        $offsetX = 0,
        $offsetY = 0,
        $opacity = 1.0,
        $color = 0x000000,
        $size = 12,
        $font_file = null
    ) {
        return $this->_handler->do_text($text, $offsetX, $offsetY, $opacity, $color, $size, $font_file);
    }
145250
public function text($textView, array $data = [])
    {
        $this->textView = $textView;
        $this->viewData = array_merge($this->viewData, $data);

        return $this;
    }
1307084
public function parse($text)
	{
		// Reset the parser and save the uid
		$this->reset($text);
		$uid = $this->uid;

		// Do the heavy lifting
		$this->executePluginParsers();
		$this->processTags();

		// Finalize the document
		$this->finalizeOutput();

		// Check the uid in case a plugin or a filter reset the parser mid-execution
		if ($this->uid !== $uid)
		{
			throw new RuntimeException('The parser has been reset during execution');
		}

		// Log a warning if the fixing cost limit was exceeded
		if ($this->currentFixingCost > $this->maxFixingCost)
		{
			$this->logger->warn('Fixing cost limit exceeded');
		}

		return $this->output;
	}
1367465
protected function renderHeaderColumn(string $label, string $attributeName, string $dataType = "text") : string
    {
        $this->getTableAttributes();
        $inputAttr = [
            "data-parent" => $this->tableAttributes['id'], //"traktCollectionTable",
            "data-attribute" => $attributeName,
            "data-sort" => "ASC",
            "data-type" => $dataType,
            "class" => "infiniteScrollTableHeaderLink",
        ];
        
        $inputField = "";
        if ($dataType !== null) {
            $fieldAttr = [
                "size" => strlen($label),
            ];
            $inputField = H::input($attributeName, $dataType, null, $fieldAttr);
        }
        
        return H::span($label, $inputAttr).$inputField;
    }