RichTextElement.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Rtehtmlarea\Form\Element;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Backend\Form\Element\AbstractFormElement;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Localization\LocalizationFactory;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use TYPO3\CMS\Core\FrontendEditing\FrontendEditingController;
use TYPO3\CMS\Core\Html\RteHtmlParser;
use TYPO3\CMS\Core\Localization\Locales;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\ClientUtility;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Backend\Form\InlineStackProcessor;
use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Lang\LanguageService;
use TYPO3\CMS\Rtehtmlarea\RteHtmlAreaApi;

class RichTextElement extends AbstractFormElement
{
    protected $resultArray;

    protected $pidOfPageRecord;

    protected $pidOfVersionedMotherRecord;

    protected $vanillaRteTsConfig;

    protected $processedRteConfiguration;

    protected $domIdentifier;

    protected $defaultExtras;

    protected $client;

    protected $language;

    protected $contentTypo3Language;

    protected $contentISOLanguage;

    protected $contentLanguageUid;

    protected $defaultToolbarOrder;

    protected $convertToolbarForHtmlAreaArray = array(
        'space' => 'space',
        'bar' => 'separator',
        'linebreak' => 'linebreak'
    );

    protected $toolbar = array();

    protected $toolbarOrderArray = array();

    protected $pluginButton = array();

    protected $pluginLabel = array();

    protected $pluginEnabledArray = array();

    protected $pluginEnabledCumulativeArray = array();

    protected $registeredPlugins = array();

    public function render()
    {
        $table = $this->data['tableName'];
        $fieldName = $this->data['fieldName'];
        $row = $this->data['databaseRow'];
        $parameterArray = $this->data['parameterArray'];

        $backendUser = $this->getBackendUserAuthentication();

        $this->resultArray = $this->initializeResultArray();
        $this->defaultExtras = BackendUtility::getSpecConfParts($parameterArray['fieldConf']['defaultExtras']);
        $this->pidOfPageRecord = $table === 'pages' && MathUtility::canBeInterpretedAsInteger($row['uid']) ? (int)$row['uid'] : (int)$row['pid'];
        BackendUtility::fixVersioningPid($table, $row);
        $this->pidOfVersionedMotherRecord = (int)$row['pid'];
        $this->vanillaRteTsConfig = $backendUser->getTSConfig('RTE', BackendUtility::getPagesTSconfig($this->pidOfPageRecord));
        $this->processedRteConfiguration = BackendUtility::RTEsetup(
            $this->vanillaRteTsConfig['properties'],
            $table,
            $fieldName,
            $this->data['recordTypeValue']
        );
        $this->client = $this->clientInfo();
        $this->domIdentifier = preg_replace('/[^a-zA-Z0-9_:.-]/', '_', $parameterArray['itemFormElName']);
        $this->domIdentifier = htmlspecialchars(preg_replace('/^[^a-zA-Z]/', 'x', $this->domIdentifier));

        $this->initializeLanguageRelatedProperties();

        // Get skin file name from Page TSConfig if any
        $skinFilename = trim($this->processedRteConfiguration['skin']) ?: 'EXT:rtehtmlarea/Resources/Public/Css/Skin/htmlarea.css';
        $skinFilename = $this->getFullFileName($skinFilename);
        $skinDirectory = dirname($skinFilename);

        // jQuery UI Resizable style sheet and main skin stylesheet
        $this->resultArray['stylesheetFiles'][] = $skinDirectory . '/jquery-ui-resizable.css';
        $this->resultArray['stylesheetFiles'][] = $skinFilename;

        $this->enableRegisteredPlugins();

        // Configure toolbar
        $this->setToolbar();

        // Check if some plugins need to be disabled
        $this->setPlugins();

        // Merge the list of enabled plugins with the lists from the previous RTE editing areas on the same form
        $this->pluginEnabledCumulativeArray = $this->pluginEnabledArray;

        $this->addInstanceJavaScriptRegistration();

        $this->addOnSubmitJavaScriptCode();

        // Add RTE JavaScript
        $this->loadRequireModulesForRTE();

        // Create language labels
        $this->createJavaScriptLanguageLabelsFromFiles();

        // Get RTE init JS code
        $this->resultArray['additionalJavaScriptPost'][] = $this->getRteInitJsCode();

        $html = $this->getMainHtml();

        $this->resultArray['html'] = $this->renderWizards(
            array($html),
            $parameterArray['fieldConf']['config']['wizards'],
            $table,
            $row,
            $fieldName,
            $parameterArray,
            $parameterArray['itemFormElName'],
            $this->defaultExtras,
            true
        );

        return $this->resultArray;
    }

    protected function getMainHtml()
    {
        $backendUser = $this->getBackendUserAuthentication();

        if ($this->isInFullScreenMode()) {
            $width = '100%';
            $height = '100%';
            $paddingRight = '0px';
            $editorWrapWidth = '100%';
        } else {
            $options = $backendUser->userTS['options.'];
            $width = 530 + (isset($options['RTELargeWidthIncrement']) ? (int)$options['RTELargeWidthIncrement'] : 150);
            $inlineStackProcessor = GeneralUtility::makeInstance(InlineStackProcessor::class);
            $inlineStackProcessor->initializeByGivenStructure($this->data['inlineStructure']);
            $inlineStructureDepth = $inlineStackProcessor->getStructureDepth();
            $width -= $inlineStructureDepth > 0 ? ($inlineStructureDepth + 1) * 12 : 0;
            $widthOverride = isset($backendUser->uc['rteWidth']) && trim($backendUser->uc['rteWidth']) ?: trim($this->processedRteConfiguration['RTEWidthOverride']);
            if ($widthOverride) {
                if (strstr($widthOverride, '%')) {
                    if ($this->client['browser'] !== 'msie') {
                        $width = (int)$widthOverride > 0 ? (int)$widthOverride : '100%';
                    }
                } else {
                    $width = (int)$widthOverride > 0 ? (int)$widthOverride : $width;
                }
            }
            $width = strstr($width, '%') ? $width : $width . 'px';
            $height = 380 + (isset($options['RTELargeHeightIncrement']) ? (int)$options['RTELargeHeightIncrement'] : 0);
            $heightOverride = isset($backendUser->uc['rteHeight']) && (int)$backendUser->uc['rteHeight'] ?: (int)$this->processedRteConfiguration['RTEHeightOverride'];
            $height = $heightOverride > 0 ? $heightOverride . 'px' : $height . 'px';
            $paddingRight = '2';
            $editorWrapWidth = '99%';
        }
        $rteDivStyle = 'position:relative; left:0px; top:0px; height:' . $height . '; width:' . $width . '; border: 1px solid black; padding: 2 ' . $paddingRight . ' 2 2;';

        $itemFormElementName = $this->data['parameterArray']['itemFormElName'];

        // This seems to result in:
        //      _TRANSFORM_bodytext (the handled field name) in case the field is a direct DB field
        //      _TRANSFORM_vDEF (constant string) in case the RTE is within a flex form
        $triggerFieldName = preg_replace('/\\[([^]]+)\\]$/', '[_TRANSFORM_\\1]', $itemFormElementName);

        $value = $this->transformDatabaseContentToEditor($this->data['parameterArray']['itemFormElValue']);

        $result = array();
        // The hidden field tells the DataHandler that processing should be done on this value.
        $result[] = '<input type="hidden" name="' . htmlspecialchars($triggerFieldName) . '" value="RTE" />';
        $result[] = '<div id="pleasewait' . $this->domIdentifier . '" class="pleasewait" style="display: block;" >';
        $result[] =    $this->getLanguageService()->sL('LLL:EXT:rtehtmlarea/Resources/Private/Language/locallang.xlf:Please wait');
        $result[] = '</div>';
        $result[] = '<div id="editorWrap' . $this->domIdentifier . '" class="editorWrap" style="visibility: hidden; width:' . $editorWrapWidth . '; height:100%;">';
        $result[] =    '<textarea id="RTEarea' . $this->domIdentifier . '" name="' . htmlspecialchars($itemFormElementName) . '" rows="0" cols="0" style="' . htmlspecialchars($rteDivStyle) . '">';
        $result[] =        htmlspecialchars($value);
        $result[] =    '</textarea>';
        $result[] = '</div>';

        return implode(LF, $result);
    }

    protected function enableRegisteredPlugins()
    {
        // Traverse registered plugins
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['rtehtmlarea']['plugins'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['rtehtmlarea']['plugins'] as $pluginId => $pluginObjectConfiguration) {
                if (is_array($pluginObjectConfiguration) && isset($pluginObjectConfiguration['objectReference'])) {
                    $plugin = GeneralUtility::makeInstance($pluginObjectConfiguration['objectReference']);
                    $configuration = array(
                        'language' => $this->language,
                        'contentTypo3Language' => $this->contentTypo3Language,
                        'contentISOLanguage' => $this->contentISOLanguage,
                        'contentLanguageUid' => $this->contentLanguageUid,
                        'RTEsetup' => $this->vanillaRteTsConfig,
                        'client' => $this->client,
                        'thisConfig' => $this->processedRteConfiguration,
                        'specConf' => $this->defaultExtras,
                    );
                    if ($plugin->main($configuration)) {
                        $this->registeredPlugins[$pluginId] = $plugin;
                        // Override buttons from previously registered plugins
                        $pluginButtons = GeneralUtility::trimExplode(',', $plugin->getPluginButtons(), true);
                        foreach ($this->pluginButton as $previousPluginId => $buttonList) {
                            $this->pluginButton[$previousPluginId] = implode(',', array_diff(GeneralUtility::trimExplode(',', $this->pluginButton[$previousPluginId], true), $pluginButtons));
                        }
                        $this->pluginButton[$pluginId] = $plugin->getPluginButtons();
                        $pluginLabels = GeneralUtility::trimExplode(',', $plugin->getPluginLabels(), true);
                        foreach ($this->pluginLabel as $previousPluginId => $labelList) {
                            $this->pluginLabel[$previousPluginId] = implode(',', array_diff(GeneralUtility::trimExplode(',', $this->pluginLabel[$previousPluginId], true), $pluginLabels));
                        }
                        $this->pluginLabel[$pluginId] = $plugin->getPluginLabels();
                        $this->pluginEnabledArray[] = $pluginId;
                    }
                }
            }
        }
        // Process overrides
        $hidePlugins = array();
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($plugin->addsButtons() && !$this->pluginButton[$pluginId]) {
                $hidePlugins[] = $pluginId;
            }
        }
        $this->pluginEnabledArray = array_unique(array_diff($this->pluginEnabledArray, $hidePlugins));
    }

    protected function setToolbar()
    {
        $backendUser = $this->getBackendUserAuthentication();

        if ($this->client['browser'] === 'msie' || $this->client['browser'] === 'opera') {
            $this->processedRteConfiguration['keepButtonGroupTogether'] = 0;
        }
        $this->defaultToolbarOrder = 'bar, blockstylelabel, blockstyle, textstylelabel, textstyle, linebreak,
                        bar, formattext, bold,  strong, italic, emphasis, big, small, insertedtext, deletedtext, citation, code,'
                . 'definition, keyboard, monospaced, quotation, sample, variable, bidioverride, strikethrough, subscript, superscript, underline, span,
                        bar, fontstyle, fontsize, bar, formatblock, insertparagraphbefore, insertparagraphafter, blockquote, line,
                        bar, left, center, right, justifyfull,
                        bar, orderedlist, unorderedlist, definitionlist, definitionitem, outdent, indent,
                        bar, language, showlanguagemarks,lefttoright, righttoleft,
                        bar, textcolor, bgcolor, textindicator,
                        bar, editelement, showmicrodata,
                        bar, image, emoticon, insertcharacter, insertsofthyphen, abbreviation, user,
                        bar, link, unlink,
                        bar, table,'
                . ($this->processedRteConfiguration['hideTableOperationsInToolbar']
                    && is_array($this->processedRteConfiguration['buttons.'])
                    && is_array($this->processedRteConfiguration['buttons.']['toggleborders.'])
                    && $this->processedRteConfiguration['buttons.']['toggleborders.']['keepInToolbar'] ? ' toggleborders,' : '')
            . 'bar, findreplace, spellcheck,
                        bar, chMode, inserttag, removeformat, bar, copy, cut, paste, pastetoggle, pastebehaviour, bar, undo, redo, bar, about, linebreak,'
            . ($this->processedRteConfiguration['hideTableOperationsInToolbar'] ? '' : 'bar, toggleborders,')
            . ' bar, tableproperties, tablerestyle, bar, rowproperties, rowinsertabove, rowinsertunder, rowdelete, rowsplit, bar,
                        columnproperties, columninsertbefore, columninsertafter, columndelete, columnsplit, bar,
                        cellproperties, cellinsertbefore, cellinsertafter, celldelete, cellsplit, cellmerge';

        // Additional buttons from registered plugins
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($this->isPluginEnabled($pluginId)) {
                $pluginButtons = $plugin->getPluginButtons();
                //Add only buttons not yet in the default toolbar order
                $addButtons = implode(
                    ',',
                    array_diff(
                        GeneralUtility::trimExplode(',', $pluginButtons, true),
                        GeneralUtility::trimExplode(',', $this->defaultToolbarOrder, true)
                    )
                );
                $this->defaultToolbarOrder = ($addButtons ? 'bar,' . $addButtons . ',linebreak,' : '') . $this->defaultToolbarOrder;
            }
        }
        $toolbarOrder = $this->processedRteConfiguration['toolbarOrder'] ?: $this->defaultToolbarOrder;
        // Getting rid of undefined buttons
        $this->toolbarOrderArray = array_intersect(GeneralUtility::trimExplode(',', $toolbarOrder, true), GeneralUtility::trimExplode(',', $this->defaultToolbarOrder, true));
        $toolbarOrder = array_unique(array_values($this->toolbarOrderArray));
        // Fetching specConf for field from backend
        $pList = is_array($this->defaultExtras['richtext']['parameters']) ? implode(',', $this->defaultExtras['richtext']['parameters']) : '';
        if ($pList !== '*') {
            // If not all
            $show = is_array($this->defaultExtras['richtext']['parameters']) ? $this->defaultExtras['richtext']['parameters'] : array();
            if ($this->processedRteConfiguration['showButtons']) {
                if (!GeneralUtility::inList($this->processedRteConfiguration['showButtons'], '*')) {
                    $show = array_unique(array_merge($show, GeneralUtility::trimExplode(',', $this->processedRteConfiguration['showButtons'], true)));
                } else {
                    $show = array_unique(array_merge($show, $toolbarOrder));
                }
            }
            if (is_array($this->processedRteConfiguration['showButtons.'])) {
                foreach ($this->processedRteConfiguration['showButtons.'] as $buttonId => $value) {
                    if ($value) {
                        $show[] = $buttonId;
                    }
                }
                $show = array_unique($show);
            }
        } else {
            $show = $toolbarOrder;
        }
        $RTEkeyList = isset($backendUser->userTS['options.']['RTEkeyList']) ? $backendUser->userTS['options.']['RTEkeyList'] : '*';
        if ($RTEkeyList !== '*') {
            // If not all
            $show = array_intersect($show, GeneralUtility::trimExplode(',', $RTEkeyList, true));
        }
        // Hiding buttons of disabled plugins
        $hideButtons = array('space', 'bar', 'linebreak');
        foreach ($this->pluginButton as $pluginId => $buttonList) {
            if (!$this->isPluginEnabled($pluginId)) {
                $buttonArray = GeneralUtility::trimExplode(',', $buttonList, true);
                foreach ($buttonArray as $button) {
                    $hideButtons[] = $button;
                }
            }
        }
        // Hiding labels of disabled plugins
        foreach ($this->pluginLabel as $pluginId => $label) {
            if (!$this->isPluginEnabled($pluginId)) {
                $hideButtons[] = $label;
            }
        }
        // Hiding buttons
        $show = array_diff($show, GeneralUtility::trimExplode(',', $this->processedRteConfiguration['hideButtons'], true));
        // Apply toolbar constraints from registered plugins
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($this->isPluginEnabled($pluginId) && method_exists($plugin, 'applyToolbarConstraints')) {
                $show = $plugin->applyToolbarConstraints($show);
            }
        }
        // Getting rid of the buttons for which we have no position
        $show = array_intersect($show, $toolbarOrder);
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            $plugin->setToolbar($show);
        }
        $this->toolbar = $show;
    }

    protected function setPlugins()
    {
        // Disabling a plugin that adds buttons if none of its buttons is in the toolbar
        $hidePlugins = array();
        foreach ($this->pluginButton as $pluginId => $buttonList) {
            $plugin = $this->registeredPlugins[$pluginId];
            if ($plugin->addsButtons()) {
                $showPlugin = false;
                $buttonArray = GeneralUtility::trimExplode(',', $buttonList, true);
                foreach ($buttonArray as $button) {
                    if (in_array($button, $this->toolbar)) {
                        $showPlugin = true;
                    }
                }
                if (!$showPlugin) {
                    $hidePlugins[] = $pluginId;
                }
            }
        }
        $this->pluginEnabledArray = array_diff($this->pluginEnabledArray, $hidePlugins);
        // Hiding labels of disabled plugins
        $hideLabels = array();
        foreach ($this->pluginLabel as $pluginId => $label) {
            if (!$this->isPluginEnabled($pluginId)) {
                $hideLabels[] = $label;
            }
        }
        $this->toolbar = array_diff($this->toolbar, $hideLabels);
        // Adding plugins declared as prerequisites by enabled plugins
        $requiredPlugins = array();
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($this->isPluginEnabled($pluginId)) {
                $requiredPlugins = array_merge($requiredPlugins, GeneralUtility::trimExplode(',', $plugin->getRequiredPlugins(), true));
            }
        }
        $requiredPlugins = array_unique($requiredPlugins);
        foreach ($requiredPlugins as $pluginId) {
            if (is_object($this->registeredPlugins[$pluginId]) && !$this->isPluginEnabled($pluginId)) {
                $this->pluginEnabledArray[] = $pluginId;
            }
        }
        $this->pluginEnabledArray = array_unique($this->pluginEnabledArray);
        // Completing the toolbar conversion array for htmlArea
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($this->isPluginEnabled($pluginId)) {
                $this->convertToolbarForHtmlAreaArray = array_unique(array_merge($this->convertToolbarForHtmlAreaArray, $plugin->getConvertToolbarForHtmlAreaArray()));
            }
        }
    }

    protected function loadRequireModulesForRTE()
    {
        $this->resultArray['requireJsModules'] = array();
        $this->resultArray['requireJsModules'][] = 'TYPO3/CMS/Rtehtmlarea/HTMLArea/HTMLArea';
        foreach ($this->pluginEnabledCumulativeArray as $pluginId) {
            $plugin = $this->registeredPlugins[$pluginId];
            $extensionKey = is_object($plugin) ? $plugin->getExtensionKey() : 'rtehtmlarea';
            $requirePath = 'TYPO3/CMS/' . GeneralUtility::underscoredToUpperCamelCase($extensionKey);
            $this->resultArray['requireJsModules'][] = $requirePath . '/Plugins/' . $pluginId;
        }
    }

    protected function getRteInitJsCode()
    {
        $skinFilename = trim($this->processedRteConfiguration['skin']) ?: 'EXT:rtehtmlarea/Resources/Public/Css/Skin/htmlarea.css';
        $skinFilename = $this->getFullFileName($skinFilename);
        $skinDirectory = dirname($skinFilename);
        // Editing area style sheet
        $editedContentCSS = GeneralUtility::createVersionNumberedFilename($skinDirectory . '/htmlarea-edited-content.css');

        return 'require(["TYPO3/CMS/Rtehtmlarea/HTMLArea/HTMLArea"], function (HTMLArea) {
                        if (typeof RTEarea === "undefined") {
                                RTEarea = new Object();
                                RTEarea[0] = new Object();
                                RTEarea[0].version = "' . $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['rtehtmlarea']['version'] . '";
                                RTEarea[0].editorUrl = "' . ExtensionManagementUtility::extRelPath('rtehtmlarea') . '";
                                RTEarea[0].editorSkin = "' . $skinDirectory . '/";
                                RTEarea[0].editedContentCSS = "' . $editedContentCSS . '";
                                RTEarea.init = function() {
                                        if (typeof HTMLArea === "undefined" || !Ext.isReady) {
                                                window.setTimeout(function () {
                                                        RTEarea.init();
                                                }, 10);
                                        } else {
                                                HTMLArea.init();
                                        }
                                };
                                RTEarea.initEditor = function(editorNumber) {
                                        if (typeof HTMLArea === "undefined" || !HTMLArea.isReady) {
                                                window.setTimeout(function () {
                                                        RTEarea.initEditor(editorNumber);
                                                }, 40);
                                        } else {
                                                HTMLArea.initEditor(editorNumber);
                                        }
                                };
                        }
                        RTEarea.init();
                });';
    }

    protected function addInstanceJavaScriptRegistration()
    {
        $backendUser = $this->getBackendUserAuthentication();

        $jsArray = array();
        $jsArray[] = 'if (typeof configureEditorInstance === "undefined") {';
        $jsArray[] = '  configureEditorInstance = new Object();';
        $jsArray[] = '}';
        $jsArray[] = 'configureEditorInstance["' . $this->domIdentifier . '"] = function() {';
        $jsArray[] = 'if (typeof RTEarea === "undefined" || typeof HTMLArea === "undefined") {';
        $jsArray[] = '  window.setTimeout("configureEditorInstance[\'' . $this->domIdentifier . '\']();", 40);';
        $jsArray[] = '} else {';
        $jsArray[] = 'editornumber = "' . $this->domIdentifier . '";';
        $jsArray[] = 'RTEarea[editornumber] = new Object();';
        $jsArray[] = 'RTEarea[editornumber].RTEtsConfigParams = "&RTEtsConfigParams=' . rawurlencode($this->RTEtsConfigParams()) . '";';
        $jsArray[] = 'RTEarea[editornumber].number = editornumber;';
        $jsArray[] = 'RTEarea[editornumber].deleted = false;';
        $jsArray[] = 'RTEarea[editornumber].textAreaId = "' . $this->domIdentifier . '";';
        $jsArray[] = 'RTEarea[editornumber].id = "RTEarea" + editornumber;';
        $jsArray[] = 'RTEarea[editornumber].RTEWidthOverride = "'
            . (isset($backendUser->uc['rteWidth']) && trim($backendUser->uc['rteWidth'])
                ? trim($backendUser->uc['rteWidth'])
                : trim($this->processedRteConfiguration['RTEWidthOverride'])) . '";';
        $jsArray[] = 'RTEarea[editornumber].RTEHeightOverride = "'
            . (isset($backendUser->uc['rteHeight']) && (int)$backendUser->uc['rteHeight']
                ? (int)$backendUser->uc['rteHeight']
                : (int)$this->processedRteConfiguration['RTEHeightOverride']) . '";';
        $jsArray[] = 'RTEarea[editornumber].resizable = '
            . (isset($backendUser->uc['rteResize']) && $backendUser->uc['rteResize']
                ? 'true;'
                : (trim($this->processedRteConfiguration['rteResize']) ? 'true;' : 'false;'));
        $jsArray[] = 'RTEarea[editornumber].maxHeight = "'
            . (isset($backendUser->uc['rteMaxHeight']) && (int)$backendUser->uc['rteMaxHeight']
                ? trim($backendUser->uc['rteMaxHeight'])
                : ((int)$this->processedRteConfiguration['rteMaxHeight'] ?: '2000')) . '";';
        $jsArray[] = 'RTEarea[editornumber].fullScreen = ' . ($this->isInFullScreenMode() ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].showStatusBar = ' . (trim($this->processedRteConfiguration['showStatusBar']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].enableWordClean = ' . (trim($this->processedRteConfiguration['enableWordClean']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].htmlRemoveComments = ' . (trim($this->processedRteConfiguration['removeComments']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].disableEnterParagraphs = ' . (trim($this->processedRteConfiguration['disableEnterParagraphs']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].disableObjectResizing = ' . (trim($this->processedRteConfiguration['disableObjectResizing']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].removeTrailingBR = ' . (trim($this->processedRteConfiguration['removeTrailingBR']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].useCSS = ' . (trim($this->processedRteConfiguration['useCSS']) ? 'true' : 'false') . ';';
        $jsArray[] = 'RTEarea[editornumber].keepButtonGroupTogether = ' . (trim($this->processedRteConfiguration['keepButtonGroupTogether']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].disablePCexamples = ' . (trim($this->processedRteConfiguration['disablePCexamples']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].showTagFreeClasses = ' . (trim($this->processedRteConfiguration['showTagFreeClasses']) ? 'true;' : 'false;');
        $jsArray[] = 'RTEarea[editornumber].tceformsNested = ' . (!empty($this->data) ? json_encode($this->data['tabAndInlineStack']) : '[]') . ';';
        $jsArray[] = 'RTEarea[editornumber].dialogueWindows = new Object();';
        if (isset($this->processedRteConfiguration['dialogueWindows.']['defaultPositionFromTop'])) {
            $jsArray[] = 'RTEarea[editornumber].dialogueWindows.positionFromTop = ' . (int)$this->processedRteConfiguration['dialogueWindows.']['defaultPositionFromTop'] . ';';
        }
        if (isset($this->processedRteConfiguration['dialogueWindows.']['defaultPositionFromLeft'])) {
            $jsArray[] = 'RTEarea[editornumber].dialogueWindows.positionFromLeft = ' . (int)$this->processedRteConfiguration['dialogueWindows.']['defaultPositionFromLeft'] . ';';
        }
        $jsArray[] = 'RTEarea[editornumber].sys_language_content = "' . $this->contentLanguageUid . '";';
        $jsArray[] = 'RTEarea[editornumber].typo3ContentLanguage = "' . $this->contentTypo3Language . '";';
        $jsArray[] = 'RTEarea[editornumber].userUid = "' . 'BE_' . $backendUser->user['uid'] . '";';

        // Setting the plugin flags
        $jsArray[] = 'RTEarea[editornumber].plugin = new Object();';
        foreach ($this->pluginEnabledArray as $pluginId) {
            $jsArray[] = 'RTEarea[editornumber].plugin.' . $pluginId . ' = true;';
        }

        // Setting the buttons configuration
        $jsArray[] = 'RTEarea[editornumber].buttons = new Object();';
        if (is_array($this->processedRteConfiguration['buttons.'])) {
            foreach ($this->processedRteConfiguration['buttons.'] as $buttonIndex => $conf) {
                $button = substr($buttonIndex, 0, -1);
                if (is_array($conf)) {
                    $jsArray[] = 'RTEarea[editornumber].buttons.' . $button . ' = ' . $this->buildNestedJSArray($conf) . ';';
                }
            }
        }

        // Setting the list of tags to be removed if specified in the RTE config
        if (trim($this->processedRteConfiguration['removeTags'])) {
            $jsArray[] = 'RTEarea[editornumber].htmlRemoveTags = /^(' . implode('|', GeneralUtility::trimExplode(',', $this->processedRteConfiguration['removeTags'], true)) . ')$/i;';
        }

        // Setting the list of tags to be removed with their contents if specified in the RTE config
        if (trim($this->processedRteConfiguration['removeTagsAndContents'])) {
            $jsArray[] = 'RTEarea[editornumber].htmlRemoveTagsAndContents = /^(' . implode('|', GeneralUtility::trimExplode(',', $this->processedRteConfiguration['removeTagsAndContents'], true)) . ')$/i;';
        }

        // Setting array of custom tags if specified in the RTE config
        if (!empty($this->processedRteConfiguration['customTags'])) {
            $customTags = GeneralUtility::trimExplode(',', $this->processedRteConfiguration['customTags'], true);
            if (!empty($customTags)) {
                $jsArray[] = 'RTEarea[editornumber].customTags= ' . json_encode($customTags) . ';';
            }
        }

        // Setting array of content css files if specified in the RTE config
        $versionNumberedFileNames = array();
        $contentCssFileNames = $this->getContentCssFileNames();
        foreach ($contentCssFileNames as $contentCssFileName) {
            $versionNumberedFileNames[] = GeneralUtility::createVersionNumberedFilename($contentCssFileName);
        }
        $jsArray[] = 'RTEarea[editornumber].pageStyle = ["' . implode('","', $versionNumberedFileNames) . '"];';

        $jsArray[] = 'RTEarea[editornumber].classesUrl = "' . $this->writeTemporaryFile(('classes_' . $this->language), 'js', $this->buildJSClassesArray()) . '";';

        // Add Javascript configuration for registered plugins
        foreach ($this->registeredPlugins as $pluginId => $plugin) {
            if ($this->isPluginEnabled($pluginId)) {
                $jsPluginString = $plugin->buildJavascriptConfiguration();
                if ($jsPluginString) {
                    $jsArray[] = $plugin->buildJavascriptConfiguration();
                }
            }
        }

        // Avoid premature reference to HTMLArea when being initially loaded by IRRE Ajax call
        $jsArray[] = 'RTEarea[editornumber].toolbar = ' . $this->getJSToolbarArray() . ';';
        $jsArray[] = 'RTEarea[editornumber].convertButtonId = ' . json_encode(array_flip($this->convertToolbarForHtmlAreaArray)) . ';';
        $jsArray[] = 'RTEarea.initEditor(editornumber);';
        $jsArray[] = '}';
        $jsArray[] = '}';
        $jsArray[] = 'configureEditorInstance["' . $this->domIdentifier . '"]();';

        $this->resultArray['additionalJavaScriptPost'][] =  implode(LF, $jsArray);
    }

    protected function getContentCssFileNames()
    {
        $contentCss = is_array($this->processedRteConfiguration['contentCSS.']) ? $this->processedRteConfiguration['contentCSS.'] : array();
        if (isset($this->processedRteConfiguration['contentCSS'])) {
            $contentCss[] = trim($this->processedRteConfiguration['contentCSS']);
        }
        $contentCssFiles = array();
        if (!empty($contentCss)) {
            foreach ($contentCss as $contentCssKey => $contentCssfile) {
                $fileName = trim($contentCssfile);
                $absolutePath = GeneralUtility::getFileAbsFileName($fileName);
                if (file_exists($absolutePath) && filesize($absolutePath)) {
                    $contentCssFiles[$contentCssKey] = $this->getFullFileName($fileName);
                }
            }
        } else {
            // Fallback to default content css file if none of the configured files exists and is not empty
            $contentCssFiles['default'] = $this->getFullFileName('EXT:rtehtmlarea/Resources/Public/Css/ContentCss/Default.css');
        }
        return array_unique($contentCssFiles);
    }

    protected function isPluginEnabled($pluginId)
    {
        return in_array($pluginId, $this->pluginEnabledArray);
    }

    protected function buildJSClassesArray()
    {
        $RTEProperties = $this->vanillaRteTsConfig['properties'];
        // Declare sub-arrays
        $classesArray = array(
            'labels' => array(),
            'values' => array(),
            'noShow' => array(),
            'alternating' => array(),
            'counting' => array(),
            'selectable' => array(),
            'requires' => array(),
            'requiredBy' => array(),
            'XOR' => array()
        );
        $JSClassesArray = '';
        // Scanning the list of classes if specified in the RTE config
        if (is_array($RTEProperties['classes.'])) {
            foreach ($RTEProperties['classes.'] as $className => $conf) {
                $className = rtrim($className, '.');

                $label = '';
                if (!empty($conf['name'])) {
                    $label = $this->getLanguageService()->sL(trim($conf['name']));
                    $label = str_replace('"', '\\"', str_replace('\\\'', '\'', $label));
                }
                $classesArray['labels'][$className] = $label;
                $classesArray['values'][$className] = str_replace('\\\'', '\'', $conf['value']);
                if (isset($conf['noShow'])) {
                    $classesArray['noShow'][$className] = $conf['noShow'];
                }
                if (is_array($conf['alternating.'])) {
                    $classesArray['alternating'][$className] = $conf['alternating.'];
                }
                if (is_array($conf['counting.'])) {
                    $classesArray['counting'][$className] = $conf['counting.'];
                }
                if (isset($conf['selectable'])) {
                    $classesArray['selectable'][$className] = $conf['selectable'];
                }
                if (isset($conf['requires'])) {
                    $classesArray['requires'][$className] = explode(',', GeneralUtility::rmFromList($className, $this->cleanList($conf['requires'])));
                }
            }
            // Remove circularities from classes dependencies
            $requiringClasses = array_keys($classesArray['requires']);
            foreach ($requiringClasses as $requiringClass) {
                if ($this->hasCircularDependency($classesArray, $requiringClass, $requiringClass)) {
                    unset($classesArray['requires'][$requiringClass]);
                }
            }
            // Reverse relationship for the dependency checks when removing styles
            $requiringClasses = array_keys($classesArray['requires']);
            foreach ($requiringClasses as $className) {
                foreach ($classesArray['requires'][$className] as $requiredClass) {
                    if (!is_array($classesArray['requiredBy'][$requiredClass])) {
                        $classesArray['requiredBy'][$requiredClass] = array();
                    }
                    if (!in_array($className, $classesArray['requiredBy'][$requiredClass])) {
                        $classesArray['requiredBy'][$requiredClass][] = $className;
                    }
                }
            }
        }
        // Scanning the list of sets of mutually exclusives classes if specified in the RTE config
        if (is_array($RTEProperties['mutuallyExclusiveClasses.'])) {
            foreach ($RTEProperties['mutuallyExclusiveClasses.'] as $listName => $conf) {
                $classSet = GeneralUtility::trimExplode(',', $conf, true);
                $classList = implode(',', $classSet);
                foreach ($classSet as $className) {
                    $classesArray['XOR'][$className] = '/^(' . implode('|', GeneralUtility::trimExplode(',', GeneralUtility::rmFromList($className, $classList), true)) . ')$/';
                }
            }
        }
        foreach ($classesArray as $key => $subArray) {
            $JSClassesArray .= 'HTMLArea.classes' . ucfirst($key) . ' = ' . $this->buildNestedJSArray($subArray) . ';' . LF;
        }
        return $JSClassesArray;
    }

    protected function hasCircularDependency(&$classesArray, $requiringClass, $initialClass, $recursionLevel = 0)
    {
        if (is_array($classesArray['requires'][$requiringClass])) {
            if (in_array($initialClass, $classesArray['requires'][$requiringClass])) {
                return true;
            } else {
                if ($recursionLevel++ < 20) {
                    foreach ($classesArray['requires'][$requiringClass] as $requiringClass2) {
                        if ($this->hasCircularDependency($classesArray, $requiringClass2, $initialClass, $recursionLevel)) {
                            return true;
                        }
                    }
                }
                return false;
            }
        } else {
            return false;
        }
    }

    protected function buildNestedJSArray($conf)
    {
        $convertedConf = GeneralUtility::removeDotsFromTS($conf);
        return str_replace(
            array(':"0"', ':"\\/^(', ')$\\/i"', ':"\\/^(', ')$\\/"', '[]'),
            array(':false', ':/^(', ')$/i', ':/^(', ')$/', '{}'), json_encode($convertedConf)
        );
    }

    protected function writeTemporaryFile($label, $fileExtension = 'js', $contents = '')
    {
        $relativeFilename = 'typo3temp/RteHtmlArea/' . str_replace('-', '_', $label) . '_' . GeneralUtility::shortMD5($contents, 20) . '.' . $fileExtension;
        $destination = PATH_site . $relativeFilename;
        if (!file_exists($destination)) {
            $minifiedJavaScript = '';
            if ($fileExtension === 'js' && $contents !== '') {
                $minifiedJavaScript = GeneralUtility::minifyJavaScript($contents);
            }
            $failure = GeneralUtility::writeFileToTypo3tempDir($destination, $minifiedJavaScript ? $minifiedJavaScript : $contents);
            if ($failure) {
                throw new \RuntimeException($failure, 1294585668);
            }
        }
        if (isset($GLOBALS['TSFE'])) {
            $fileName = $relativeFilename;
        } else {
            $fileName = '../' . $relativeFilename;
        }
        return GeneralUtility::resolveBackPath($fileName);
    }

    protected function createJavaScriptLanguageLabelsFromFiles()
    {
        $labelArray = array();
        // Load labels of 3 base files into JS
        foreach (array('tooltips', 'msg', 'dialogs') as $identifier) {
            $fileName = 'EXT:rtehtmlarea/Resources/Private/Language/locallang_' . $identifier . '.xlf';
            $newLabels = $this->getMergedLabelsFromFile($fileName);
            if (!empty($newLabels)) {
                $labelArray[$identifier] = $newLabels;
            }
        }
        // Load labels of plugins into JS
        foreach ($this->pluginEnabledCumulativeArray as $pluginId) {
            $plugin = $this->registeredPlugins[$pluginId];
            $extensionKey = is_object($plugin) ? $plugin->getExtensionKey() : 'rtehtmlarea';
            $fileName = 'EXT:' . $extensionKey . '/Resources/Private/Language/Plugins/' . $pluginId . '/locallang_js.xlf';
            $newLabels = $this->getMergedLabelsFromFile($fileName);
            if (!empty($newLabels)) {
                $labelArray[$pluginId] = $newLabels;
            }
        }
        $javaScriptString = 'TYPO3.jQuery(function() {';
        $javaScriptString .= 'HTMLArea.I18N = new Object();' . LF;
        $javaScriptString .= 'HTMLArea.I18N = ' . json_encode($labelArray);
        $javaScriptString .= '});';
        $this->resultArray['additionalJavaScriptPost'][] = $javaScriptString;
    }

    protected function getMergedLabelsFromFile($fileName)
    {
        $languageFactory = GeneralUtility::makeInstance(LocalizationFactory::class);
        $localizationArray = $languageFactory->getParsedData($fileName, $this->language, 'utf-8', 1);
        if (is_array($localizationArray) && !empty($localizationArray)) {
            if (!empty($localizationArray[$this->language])) {
                $finalLocalLang = $localizationArray['default'];
                ArrayUtility::mergeRecursiveWithOverrule($finalLocalLang, $localizationArray[$this->language], true, false);
                $localizationArray[$this->language] = $finalLocalLang;
            } else {
                $localizationArray[$this->language] = $localizationArray['default'];
            }
        } else {
            $localizationArray = array();
        }
        return $localizationArray[$this->language];
    }

    protected function getJSToolbarArray()
    {
        // The toolbar array
        $toolbar = array();
        // The current row;  a "linebreak" ends the current row
        $row = array();
        // The current group; each group is between "bar"s; a "linebreak" ends the current group
        $group = array();
        // Process each toolbar item in the toolbar order list
        foreach ($this->toolbarOrderArray as $item) {
            switch ($item) {
                case 'linebreak':
                    // Add row to toolbar if not empty
                    if (!empty($group)) {
                        $row[] = $group;
                        $group = array();
                    }
                    if (!empty($row)) {
                        $toolbar[] = $row;
                        $row = array();
                    }
                    break;
                case 'bar':
                    // Add group to row if not empty
                    if (!empty($group)) {
                        $row[] = $group;
                        $group = array();
                    }
                    break;
                case 'space':
                    if (end($group) != $this->convertToolbarForHtmlAreaArray[$item]) {
                        $group[] = $this->convertToolbarForHtmlAreaArray[$item];
                    }
                    break;
                default:
                    if (in_array($item, $this->toolbar)) {
                        // Add the item to the group
                        $convertedItem = $this->convertToolbarForHtmlAreaArray[$item];
                        if ($convertedItem) {
                            $group[] = $convertedItem;
                        }
                    }
            }
        }
        // Add the last group and last line, if not empty
        if (!empty($group)) {
            $row[] = $group;
        }
        if (!empty($row)) {
            $toolbar[] = $row;
        }
        return json_encode($toolbar);
    }

    protected function getFullFileName($filename)
    {
        if (substr($filename, 0, 4) === 'EXT:') {
            // extension
            list($extKey, $local) = explode('/', substr($filename, 4), 2);
            $newFilename = '';
            if ((string)$extKey !== '' && ExtensionManagementUtility::isLoaded($extKey) && (string)$local !== '') {
                $newFilename = ($this->isFrontendEditActive()
                        ? ExtensionManagementUtility::siteRelPath($extKey)
                        : ExtensionManagementUtility::extRelPath($extKey))
                    . $local;
            }
        } else {
            $path = ($this->isFrontendEditActive() ? '' : '../');
            $newFilename = $path . ($filename[0] === '/' ? substr($filename, 1) : $filename);
        }
        return GeneralUtility::resolveBackPath($newFilename);
    }

    protected function addOnSubmitJavaScriptCode()
    {
        $onSubmitCode = array();
        $onSubmitCode[] = 'if (RTEarea["' . $this->domIdentifier . '"]) {';
        $onSubmitCode[] =    'document.editform["' . $this->data['parameterArray']['itemFormElName'] . '"].value = RTEarea["' . $this->domIdentifier . '"].editor.getHTML();';
        $onSubmitCode[] = '} else {';
        $onSubmitCode[] =    'OK = 0;';
        $onSubmitCode[] = '};';
        $this->resultArray['additionalJavaScriptSubmit'][] = implode(LF, $onSubmitCode);
    }

    protected function isFrontendEditActive()
    {
        return is_object($GLOBALS['TSFE']) && $GLOBALS['TSFE']->beUserLogin && $GLOBALS['BE_USER']->frontendEdit instanceof FrontendEditingController;
    }

    protected function clientInfo()
    {
        $userAgent = GeneralUtility::getIndpEnv('HTTP_USER_AGENT');
        $browserInfo = ClientUtility::getBrowserInfo($userAgent);
        // Known engines: order is not irrelevant!
        $knownEngines = array('opera', 'msie', 'gecko', 'webkit');
        if (is_array($browserInfo['all'])) {
            foreach ($knownEngines as $engine) {
                if ($browserInfo['all'][$engine]) {
                    $browserInfo['browser'] = $engine;
                    $browserInfo['version'] = ClientUtility::getVersion($browserInfo['all'][$engine]);
                    break;
                }
            }
        }
        return $browserInfo;
    }

    public function initializeLanguageRelatedProperties()
    {
        $database = $this->getDatabaseConnection();
        $this->language = $GLOBALS['LANG']->lang;
        if ($this->language === 'default' || !$this->language) {
            $this->language = 'en';
        }
        $currentLanguageUid = $this->data['databaseRow']['sys_language_uid'];
        if (is_array($currentLanguageUid)) {
            $currentLanguageUid = $currentLanguageUid[0];
        }
        $this->contentLanguageUid = (int)max($currentLanguageUid, 0);
        if ($this->contentLanguageUid) {
            $this->contentISOLanguage = $this->language;
            if (ExtensionManagementUtility::isLoaded('static_info_tables')) {
                $tableA = 'sys_language';
                $tableB = 'static_languages';
                $selectFields = $tableA . '.uid,' . $tableB . '.lg_iso_2,' . $tableB . '.lg_country_iso_2';
                $tableAB = $tableA . ' LEFT JOIN ' . $tableB . ' ON ' . $tableA . '.static_lang_isocode=' . $tableB . '.uid';
                $whereClause = $tableA . '.uid = ' . intval($this->contentLanguageUid);
                $whereClause .= BackendUtility::BEenableFields($tableA);
                $whereClause .= BackendUtility::deleteClause($tableA);
                $res = $database->exec_SELECTquery($selectFields, $tableAB, $whereClause);
                while ($languageRow = $database->sql_fetch_assoc($res)) {
                    $this->contentISOLanguage = strtolower(trim($languageRow['lg_iso_2']) . (trim($languageRow['lg_country_iso_2']) ? '_' . trim($languageRow['lg_country_iso_2']) : ''));
                }
                $database->sql_free_result($res);
            }
        } else {
            $this->contentISOLanguage = trim($this->processedRteConfiguration['defaultContentLanguage']) ?: 'en';
            $languageCodeParts = explode('_', $this->contentISOLanguage);
            $this->contentISOLanguage = strtolower($languageCodeParts[0]) . ($languageCodeParts[1] ? '_' . strtoupper($languageCodeParts[1]) : '');
            // Find the configured language in the list of localization locales
            $locales = GeneralUtility::makeInstance(Locales::class);
            // If not found, default to 'en'
            if (!in_array($this->contentISOLanguage, $locales->getLocales())) {
                $this->contentISOLanguage = 'en';
            }
        }
        $this->contentTypo3Language = $this->contentISOLanguage === 'en' ? 'default' : $this->contentISOLanguage;
    }

    protected function logDeprecatedProperty($deprecatedProperty, $useProperty, $version)
    {
        $backendUser = $this->getBackendUserAuthentication();
        if (!$this->processedRteConfiguration['logDeprecatedProperties.']['disabled']) {
            $message = sprintf(
                'RTE Page TSConfig property "%1$s" used on page id #%4$s is DEPRECATED and will be removed in TYPO3 %3$s. Use "%2$s" instead.',
                $deprecatedProperty,
                $useProperty,
                $version,
                $this->data['databaseRow']['pid']
            );
            GeneralUtility::deprecationLog($message);
            if ($this->processedRteConfiguration['logDeprecatedProperties.']['logAlsoToBELog']) {
                $message = sprintf(
                    $this->getLanguageService()->sL('LLL:EXT:rtehtmlarea/Resources/Private/Language/locallang.xlf:deprecatedPropertyMessage'),
                    $deprecatedProperty,
                    $useProperty,
                    $version,
                    $this->data['databaseRow']['pid']
                );
                $backendUser->simplelog($message, 'rtehtmlarea');
            }
        }
    }

    protected function RTEtsConfigParams()
    {
        $parameters = BackendUtility::getSpecConfParametersFromArray($this->defaultExtras['rte_transform']['parameters']);
        $result = array(
            $this->data['tableName'],
            $this->data['databaseRow']['uid'],
            $this->data['fieldName'],
            $this->pidOfVersionedMotherRecord,
            $this->data['recordTypeValue'],
            $this->pidOfPageRecord,
            $parameters['imgpath'],
        );
        return implode(':', $result);
    }

    protected function cleanList($str)
    {
        if (strstr($str, '*')) {
            $str = '*';
        } else {
            $str = implode(',', array_unique(GeneralUtility::trimExplode(',', $str, true)));
        }
        return $str;
    }

    protected function transformDatabaseContentToEditor($value)
    {
        // change <strong> to <b>
        $value = preg_replace('/<(\\/?)strong/i', '<$1b', $value);
        // change <em> to <i>
        $value = preg_replace('/<(\\/?)em([^b>]*>)/i', '<$1i$2', $value);

        if ($this->defaultExtras['rte_transform']) {
            $parameters = BackendUtility::getSpecConfParametersFromArray($this->defaultExtras['rte_transform']['parameters']);
            // There must be a mode set for transformation
            if ($parameters['mode']) {
                $parseHTML = GeneralUtility::makeInstance(RteHtmlParser::class);
                $parseHTML->init($this->data['table'] . ':' . $this->data['fieldName'], $this->pidOfVersionedMotherRecord);
                $parseHTML->setRelPath('');
                $value = $parseHTML->RTE_transform($value, $this->defaultExtras, 'rte', $this->processedRteConfiguration);
            }
        }
        return $value;
    }

    protected function isInFullScreenMode()
    {
        return GeneralUtility::_GP('M') === 'wizard_rte';
    }

    protected function getLanguageService()
    {
        return $GLOBALS['LANG'];
    }

    protected function getBackendUserAuthentication()
    {
        return $GLOBALS['BE_USER'];
    }

    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }
}