9.5/_richtext_8php_source.html

<?php

declare(strict_types = 1);

namespace ‪TYPO3\CMS\Core\Configuration;


/*

 * 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\Utility\BackendUtility;

use ‪TYPO3\CMS\Core\Configuration\Loader\YamlFileLoader;

use ‪TYPO3\CMS\Core\TypoScript\TypoScriptService;

use ‪TYPO3\CMS\Core\Utility\ArrayUtility;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;


class ‪Richtext

{

    public function ‪getConfiguration(string $table, string $field, int $pid, string $recordType, array $tcaFieldConf): array

    {

        // create instance of NodeFactory, ask for "text" element

        //

        // As soon an the Data handler starts using FormDataProviders, this class can vanish again, and the hack to

        // test for specific rich text instances can be dropped: Split the "TcaText" data provider into multiple parts, each

        // RTE should register and own data provider that does the transformation / configuration providing. This way,

        // the explicit check for different RTE classes is removed from core and "hooked in" by the RTE's.


        // The main problem here is that all parameters that the processing needs is handed over to as TSconfig

        // "dotted array" syntax. We convert at least the processing information available under "processing"

        // together with pageTS, this way it can be overridden and understood in RteHtmlParser.

        // However, all other parts of the core will depend on the non-dotted syntax (coming from YAML directly)


        $pageTs = $this->‪getPageTsConfiguration($table, $field, $pid, $recordType);


        // determine which preset to use

        $usePreset = $pageTs['preset'] ?? $tcaFieldConf['richtextConfiguration'] ?? 'default';


        // load configuration from preset

        $configuration = $this->‪loadConfigurationFromPreset($usePreset);


        // overlay preset configuration with pageTs

        ‪ArrayUtility::mergeRecursiveWithOverrule(

            $configuration,

            $this->‪addFlattenedPageTsConfig($pageTs)

        );


        // Handle "mode" / "transformation" config when overridden

        if (!isset($configuration['proc.']['mode']) && !isset($configuration['proc.']['overruleMode'])) {

            $configuration['proc.']['overruleMode'] = 'default';

        }


        return $configuration;

    }


    protected function ‪loadConfigurationFromPreset(string $presetName = ''): array

    {

        $configuration = [];

        if (!empty($presetName) && isset(‪$GLOBALS['TYPO3_CONF_VARS']['RTE']['Presets'][$presetName])) {

            $fileLoader = GeneralUtility::makeInstance(YamlFileLoader::class);

            $configuration = $fileLoader->load(‪$GLOBALS['TYPO3_CONF_VARS']['RTE']['Presets'][$presetName]);

            // For future versions, you should however rely on the "processing" key and not the "proc" key.

            if (is_array($configuration['processing'])) {

                $configuration['proc.'] = $this->‪convertPlainArrayToTypoScriptArray($configuration['processing']);

            }

        }

        return $configuration;

    }


    protected function ‪getRtePageTsConfigOfPid(int $pid): array

    {

        return ‪BackendUtility::getPagesTSconfig($pid)['RTE.'] ?? [];

    }


    protected function ‪convertPlainArrayToTypoScriptArray(array $plainArray)

    {

        $typoScriptArray = [];

        foreach ($plainArray as $key => $value) {

            if (is_array($value)) {

                if (!isset($typoScriptArray[$key])) {

                    $typoScriptArray[$key] = 1;

                }

                $typoScriptArray[$key . '.'] = $this->‪convertPlainArrayToTypoScriptArray($value);

            } else {

                $typoScriptArray[$key] = $value === null ? '' : $value;

            }

        }

        return $typoScriptArray;

    }


    protected function ‪addFlattenedPageTsConfig(array $typoScriptArray): array

    {

        foreach ($typoScriptArray as $key => $data) {

            if (substr($key, -1) !== '.') {

                continue;

            }

            $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);

            $typoScriptArray[substr($key, 0, -1)] = $typoScriptService->convertTypoScriptArrayToPlainArray($typoScriptArray[$key]);

        }


        return $typoScriptArray;

    }


    protected function ‪getPageTsConfiguration(string $table, string $field, int $pid, string $recordType): array

    {

        // Load PageTSconfig configuration

        $fullPageTsConfig = $this->‪getRtePageTsConfigOfPid($pid);

        $defaultPageTsConfigOverrides = $fullPageTsConfig['default.'] ?? null;

        $fieldSpecificPageTsConfigOverrides = $fullPageTsConfig['config.'][$table . '.'][$field . '.'] ?? null;

        unset($fullPageTsConfig['default.'], $fullPageTsConfig['config.']);


        // First use RTE.*

        $rtePageTsConfiguration = $fullPageTsConfig;


        // Then overload with RTE.default.*

        if (is_array($defaultPageTsConfigOverrides)) {

            ‪ArrayUtility::mergeRecursiveWithOverrule($rtePageTsConfiguration, $defaultPageTsConfigOverrides);

        }


        // Then overload with RTE.config.tt_content.bodytext

        if (is_array($fieldSpecificPageTsConfigOverrides)) {

            $fieldSpecificPageTsConfigOverridesWithoutType = $fieldSpecificPageTsConfigOverrides;

            unset($fieldSpecificPageTsConfigOverridesWithoutType['types.']);

            ‪ArrayUtility::mergeRecursiveWithOverrule($rtePageTsConfiguration, $fieldSpecificPageTsConfigOverridesWithoutType);


            // Then overload with RTE.config.tt_content.bodytext.types.textmedia

            if (

                $recordType

                && isset($fieldSpecificPageTsConfigOverrides['types.'][$recordType . '.'])

                && is_array($fieldSpecificPageTsConfigOverrides['types.'][$recordType . '.'])

            ) {

                ‪ArrayUtility::mergeRecursiveWithOverrule(

                    $rtePageTsConfiguration,

                    $fieldSpecificPageTsConfigOverrides['types.'][$recordType . '.']

                );

            }

        }


        return $rtePageTsConfiguration;

    }

}