IconFactory.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Imaging;
 
use Psr\EventDispatcher\EventDispatcherInterface;
use ‪TYPO3\CMS\Core\Imaging\Event\ModifyIconForResourcePropertiesEvent;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\FolderInterface;
use ‪TYPO3\CMS\Core\Resource\InaccessibleFolder;
use ‪TYPO3\CMS\Core\Resource\ResourceInterface;
use ‪TYPO3\CMS\Core\Type\Icon\IconState;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Versioning\VersionState;
 
class ‪IconFactory
{
    protected ‪$iconRegistry;
 
    protected ‪$recordStatusMapping = [];
 
    protected ‪$overlayPriorities = [];
 
    protected static ‪$iconCache = [];
 
    protected ‪$eventDispatcher;
 
    public function ‪__construct(EventDispatcherInterface ‪$eventDispatcher, ‪IconRegistry ‪$iconRegistry)
    {
        $this->eventDispatcher = ‪$eventDispatcher;
        $this->iconRegistry = ‪$iconRegistry;
        $this->recordStatusMapping = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['IconFactory']['recordStatusMapping'];
        $this->overlayPriorities = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['IconFactory']['overlayPriorities'];
    }
 
    public function ‪getIcon($identifier, $size = ‪Icon::SIZE_DEFAULT, $overlayIdentifier = null, ‪IconState $state = null)
    {
        $cacheIdentifier = md5($identifier . $size . $overlayIdentifier . (string)$state);
        if (!empty(static::$iconCache[$cacheIdentifier])) {
            return static::$iconCache[$cacheIdentifier];
        }
 
        if (
            !$this->iconRegistry->isDeprecated($identifier)
            && !$this->iconRegistry->isRegistered($identifier)
        ) {
            // in case icon identifier is neither deprecated nor registered
            $identifier = $this->iconRegistry->getDefaultIconIdentifier();
        }
 
        $iconConfiguration = $this->iconRegistry->getIconConfigurationByIdentifier($identifier);
        $iconConfiguration['state'] = $state;
        $icon = $this->‪createIcon($identifier, $size, $overlayIdentifier, $iconConfiguration);
 
        $iconProvider = GeneralUtility::makeInstance($iconConfiguration['provider']);
        $iconProvider->prepareIconMarkup($icon, $iconConfiguration['options']);
 
        static::$iconCache[$cacheIdentifier] = $icon;
 
        return $icon;
    }
 
    public function ‪getIconForRecord($table, array $row, $size = ‪Icon::SIZE_DEFAULT)
    {
        $iconIdentifier = $this->‪mapRecordTypeToIconIdentifier($table, $row);
        $overlayIdentifier = $this->‪mapRecordTypeToOverlayIdentifier($table, $row);
        return $this->‪getIcon($iconIdentifier, $size, $overlayIdentifier);
    }
 
    public function ‪mapRecordTypeToIconIdentifier($table, array $row)
    {
        $recordType = [];
        $ref = null;
 
        if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_column'])) {
            $column = ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_column'];
            if (isset($row[$column])) {
                // even if not properly documented the value of the typeicon_column in a record could be
                // an array (multiselect) in typeicon_classes a key could consist of a comma-separated string "foo,bar"
                // but mostly it should be only one entry in that array
                if (is_array($row[$column])) {
                    $recordType[1] = implode(',', $row[$column]);
                } else {
                    $recordType[1] = $row[$column];
                }
            } else {
                $recordType[1] = 'default';
            }
            // Workaround to give nav_hide pages a complete different icon
            // Although it's not a separate doctype
            // and to give root-pages an own icon
            if ($table === 'pages') {
                if ((int)$row['nav_hide'] > 0) {
                    $recordType[2] = $this->‪getRecordTypeForPageType(
                        $recordType[1],
                        'hideinmenu',
                        $table
                    );
                }
                if ((int)$row['is_siteroot'] > 0) {
                    $recordType[3] = $this->‪getRecordTypeForPageType(
                        $recordType[1],
                        'root',
                        $table
                    );
                }
                if (!empty($row['module'])) {
                    $recordType[4] = 'contains-' . $row['module'];
                }
                if ((int)$row['content_from_pid'] > 0) {
                    if ($row['is_siteroot']) {
                        $recordType[4] = $this->‪getRecordTypeForPageType(
                            $recordType[1],
                            'contentFromPid-root',
                            $table
                        );
                    } else {
                        $suffix = (int)$row['nav_hide'] === 0 ? 'contentFromPid' : 'contentFromPid-hideinmenu';
                        $recordType[4] = $this->‪getRecordTypeForPageType($recordType[1], $suffix, $table);
                    }
                }
            }
            if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'])
                && is_array(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'])
            ) {
                foreach ($recordType as $key => $type) {
                    if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'][$type])) {
                        $recordType[$key] = ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'][$type];
                    } else {
                        unset($recordType[$key]);
                    }
                }
                $recordType[0] = ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['default'];
                if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['mask'])) {
                    $recordType[5] = str_replace(
                        '###TYPE###',
                        $row[$column],
                        ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['mask']
                    );
                }
                if (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['userFunc'])) {
                    $parameters = ['row' => $row];
                    $recordType[6] = GeneralUtility::callUserFunction(
                        ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['userFunc'],
                        $parameters,
                        $ref
                    );
                }
            } else {
                foreach ($recordType as &$type) {
                    $type = 'tcarecords-' . $table . '-' . $type;
                }
                unset($type);
                $recordType[0] = 'tcarecords-' . $table . '-default';
            }
        } elseif (isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'])
            && is_array(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'])
        ) {
            $recordType[0] = ‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes']['default'];
        } else {
            $recordType[0] = 'tcarecords-' . $table . '-default';
        }
 
        krsort($recordType);
        foreach ($recordType as $iconName) {
            if ($this->iconRegistry->isRegistered($iconName)) {
                return $iconName;
            }
        }
 
        return $this->iconRegistry->getDefaultIconIdentifier();
    }
 
    protected function ‪getRecordTypeForPageType(string $typeName, string $suffix, string $table): string
    {
        $recordType = $typeName . '-' . $suffix;
 
        // Check if typeicon class exists. If not fallback to page as typeName
        if (!isset(‪$GLOBALS['TCA'][$table]['ctrl']['typeicon_classes'][$recordType])) {
            $recordType = 'page-' . $suffix;
        }
        return $recordType;
    }
 
    protected function ‪mapRecordTypeToOverlayIdentifier($table, array $row)
    {
        $tcaCtrl = ‪$GLOBALS['TCA'][$table]['ctrl'];
        // Calculate for a given record the actual visibility at the moment
        $status = [
            'hidden' => false,
            'starttime' => false,
            'endtime' => false,
            'futureendtime' => false,
            'fe_group' => false,
            'deleted' => false,
            'protectedSection' => false,
            'nav_hide' => !empty($row['nav_hide']),
        ];
        // Icon state based on "enableFields":
        if (isset($tcaCtrl['enablecolumns']) && is_array($tcaCtrl['enablecolumns'])) {
            $enableColumns = $tcaCtrl['enablecolumns'];
            // If "hidden" is enabled:
            if (isset($enableColumns['disabled']) && !empty($row[$enableColumns['disabled']])) {
                $status['hidden'] = true;
            }
            // If a "starttime" is set and higher than current time:
            if (!empty($enableColumns['starttime']) && ‪$GLOBALS['EXEC_TIME'] < (int)$row[$enableColumns['starttime']]) {
                $status['starttime'] = true;
            }
            // If an "endtime" is set
            if (!empty($enableColumns['endtime'])) {
                if ((int)$row[$enableColumns['endtime']] > 0) {
                    if ((int)$row[$enableColumns['endtime']] < ‪$GLOBALS['EXEC_TIME']) {
                        // End-timing applies at this point.
                        $status['endtime'] = true;
                    } else {
                        // End-timing WILL apply in the future for this element.
                        $status['futureendtime'] = true;
                    }
                }
            }
            // If a user-group field is set
            if (!empty($enableColumns['fe_group']) && $row[$enableColumns['fe_group']]) {
                $status['fe_group'] = true;
            }
        }
        // If "deleted" flag is set (only when listing records which are also deleted!)
        if (isset($tcaCtrl['delete']) && !empty($row[$tcaCtrl['delete']])) {
            $status['deleted'] = true;
        }
        // Detecting extendToSubpages (for pages only)
        if ($table === 'pages' && (int)$row['extendToSubpages'] > 0) {
            $status['protectedSection'] = true;
        }
        if (isset($row['t3ver_state'])
            && ‪VersionState::cast($row['t3ver_state'])->equals(‪VersionState::DELETE_PLACEHOLDER)) {
            $status['deleted'] = true;
        }
 
        // Now only show the status with the highest priority
        $iconName = '';
        foreach ($this->overlayPriorities as $priority) {
            if ($status[$priority]) {
                $iconName = $this->recordStatusMapping[$priority];
                break;
            }
        }
 
        // Hook to define an alternative iconName
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS'][self::class]['overrideIconOverlay'] ?? [] as $className) {
            $hookObject = GeneralUtility::makeInstance($className);
            if (method_exists($hookObject, 'postOverlayPriorityLookup')) {
                $iconName = $hookObject->postOverlayPriorityLookup($table, $row, $status, $iconName);
            }
        }
 
        return $iconName;
    }
 
    public function ‪getIconForFileExtension($fileExtension, $size = ‪Icon::SIZE_DEFAULT, $overlayIdentifier = null)
    {
        $iconName = $this->iconRegistry->getIconIdentifierForFileExtension($fileExtension);
        return $this->‪getIcon($iconName, $size, $overlayIdentifier);
    }
 
    public function ‪getIconForResource(
        ResourceInterface $resource,
        $size = ‪Icon::SIZE_DEFAULT,
        $overlayIdentifier = null,
        array $options = []
    ) {
        $iconIdentifier = null;
 
        // Folder
        if ($resource instanceof FolderInterface) {
            // non browsable storage
            if ($resource->getStorage()->isBrowsable() === false && !empty($options['mount-root'])) {
                $iconIdentifier = 'apps-filetree-folder-locked';
            } else {
                // storage root
                if ($resource->getStorage()->getRootLevelFolder()->getIdentifier() === $resource->getIdentifier()) {
                    $iconIdentifier = 'apps-filetree-root';
                }
 
                $role = is_callable([$resource, 'getRole']) ? $resource->getRole() : '';
 
                // user/group mount root
                if (!empty($options['mount-root'])) {
                    $iconIdentifier = 'apps-filetree-mount';
                    if ($role === ‪FolderInterface::ROLE_READONLY_MOUNT) {
                        $overlayIdentifier = 'overlay-locked';
                    } elseif ($role === ‪FolderInterface::ROLE_USER_MOUNT) {
                        $overlayIdentifier = 'overlay-restricted';
                    }
                }
 
                if ($iconIdentifier === null) {
                    // in folder tree view $options['folder-open'] can define an open folder icon
                    if (!empty($options['folder-open'])) {
                        $iconIdentifier = 'apps-filetree-folder-opened';
                    } else {
                        $iconIdentifier = 'apps-filetree-folder-default';
                    }
 
                    if ($role === ‪FolderInterface::ROLE_TEMPORARY) {
                        $iconIdentifier = 'apps-filetree-folder-temp';
                    } elseif ($role === ‪FolderInterface::ROLE_RECYCLER) {
                        $iconIdentifier = 'apps-filetree-folder-recycler';
                    }
                }
 
                // if locked add overlay
                if ($resource instanceof InaccessibleFolder ||
                    !$resource->getStorage()->isBrowsable() ||
                    !$resource->getStorage()->checkFolderActionPermission('add', $resource)
                ) {
                    $overlayIdentifier = 'overlay-locked';
                }
            }
        } elseif ($resource instanceof File) {
            $mimeTypeIcon = $this->iconRegistry->getIconIdentifierForMimeType($resource->getMimeType());
 
            // Check if we find an exact matching mime type
            if ($mimeTypeIcon !== null) {
                $iconIdentifier = $mimeTypeIcon;
            } else {
                $fileExtensionIcon = $this->iconRegistry->getIconIdentifierForFileExtension($resource->getExtension());
                if ($fileExtensionIcon !== 'mimetypes-other-other') {
                    // Fallback 1: icon by file extension
                    $iconIdentifier = $fileExtensionIcon;
                } else {
                    // Fallback 2: icon by mime type with subtype replaced by *
                    $mimeTypeParts = explode('/', $resource->getMimeType());
                    $mimeTypeIcon = $this->iconRegistry->getIconIdentifierForMimeType($mimeTypeParts[0] . '/*');
                    if ($mimeTypeIcon !== null) {
                        $iconIdentifier = $mimeTypeIcon;
                    } else {
                        // Fallback 3: use 'mimetypes-other-other'
                        $iconIdentifier = $fileExtensionIcon;
                    }
                }
            }
            if ($resource->isMissing()) {
                $overlayIdentifier = 'overlay-missing';
            }
        }
 
        $event = $this->eventDispatcher->dispatch(
            new ModifyIconForResourcePropertiesEvent(
                $resource,
                $size,
                $options,
                $iconIdentifier,
                $overlayIdentifier
            )
        );
        return $this->‪getIcon($event->getIconIdentifier(), $size, $event->getOverlayIdentifier());
    }
 
    protected function ‪createIcon($identifier, $size, $overlayIdentifier = null, array $iconConfiguration = [])
    {
        $icon = GeneralUtility::makeInstance(Icon::class);
        $icon->setIdentifier($identifier);
        $icon->setSize($size);
        $icon->setState($iconConfiguration['state'] ?: new IconState());
        if (!empty($overlayIdentifier)) {
            $icon->setOverlayIcon($this->‪getIcon($overlayIdentifier, ‪Icon::SIZE_OVERLAY));
        }
        if (!empty($iconConfiguration['options']['spinning'])) {
            $icon->setSpinning(true);
        }
 
        return $icon;
    }
 
    public function ‪clearIconCache()
    {
        static::$iconCache = [];
    }
}