9.5/_folder_tree_view_8php_source.html

<?php

namespace ‪TYPO3\CMS\Backend\Tree\View;


/*

 * 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\Imaging\Icon;

use ‪TYPO3\CMS\Core\Imaging\IconFactory;

use ‪TYPO3\CMS\Core\Localization\LanguageService;

use ‪TYPO3\CMS\Core\Messaging\FlashMessage;

use ‪TYPO3\CMS\Core\Messaging\FlashMessageService;

use ‪TYPO3\CMS\Core\Resource\Folder;

use ‪TYPO3\CMS\Core\Resource\FolderInterface;

use ‪TYPO3\CMS\Core\Resource\InaccessibleFolder;

use ‪TYPO3\CMS\Core\Resource\ResourceStorage;

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


class ‪FolderTreeView extends ‪AbstractTreeView

{

    protected ‪$storages;


    protected ‪$storageHashNumbers;


    protected ‪$ajaxStatus = false;


    protected ‪$scope;


    protected ‪$iconFactory;


    public ‪$titleAttrib = '';


    public ‪$treeName = 'folder';


    public ‪$domIdPrefix = 'folder';


    public function ‪__construct()

    {

        parent::__construct();

        $this->‪init();

        $this->storages = $this->BE_USER->getFileStorages();

        $this->iconFactory = GeneralUtility::makeInstance(IconFactory::class);

    }


    public function ‪PMicon($folderObject, $subFolderCounter, $totalSubFolders, $nextCount, $isExpanded)

    {

        $icon = '';

        if ($nextCount) {

            $cmd = $this->‪generateExpandCollapseParameter($this->bank, !$isExpanded, $folderObject);

            $icon = $this->‪PMiconATagWrap($icon, $cmd, !$isExpanded);

        }

        return $icon;

    }


    public function ‪PMiconATagWrap($icon, $cmd, $isExpand = true)

    {

        if (empty($this->scope)) {

            $this->scope = [

                'class' => static::class,

                'script' => ‪$this->thisScript,

            ];

        }


        if ($this->thisScript) {

            // Activates dynamic AJAX based tree

            $scopeData = json_encode($this->scope);

            $scopeHash = GeneralUtility::hmac($scopeData);

            $js = htmlspecialchars('Tree.load(' . GeneralUtility::quoteJSvalue($cmd) . ', ' . (int)$isExpand . ', this, ' . GeneralUtility::quoteJSvalue($scopeData) . ', ' . GeneralUtility::quoteJSvalue($scopeHash) . ');');

            return '<a class="list-tree-control' . (!$isExpand ? ' list-tree-control-open' : ' list-tree-control-closed') . '" onclick="' . $js . '"><i class="fa"></i></a>';

        }

        return $icon;

    }


    protected function ‪renderPMIconAndLink($cmd, $isOpen)

    {

        $link = $this->thisScript ? ' href="' . htmlspecialchars($this->‪getThisScript() . 'PM=' . $cmd) . '"' : '';

        return '<a class="list-tree-control list-tree-control-' . ($isOpen ? 'open' : 'closed') . '"' . $link . '><i class="fa"></i></a>';

    }


    public function ‪wrapIcon($icon, $folderObject)

    {

        // Add title attribute to input icon tag

        $theFolderIcon = '';

        // Wrap icon in click-menu link.

        if (!$this->ext_IconMode) {

            // Check storage access to wrap with click menu

            if (!$folderObject instanceof InaccessibleFolder) {

                $tableName = $this->‪getTableNameForClickMenu($folderObject);

                $theFolderIcon = ‪BackendUtility::wrapClickMenuOnIcon($icon, $tableName, $folderObject->getCombinedIdentifier(), 'tree');

            }

        } elseif ($this->ext_IconMode === 'titlelink') {

            $aOnClick = 'return jumpTo(' . GeneralUtility::quoteJSvalue($this->‪getJumpToParam($folderObject)) . ',this,' . GeneralUtility::quoteJSvalue($this->domIdPrefix . $this->‪getId($folderObject)) . ',' . $this->bank . ');';

            $theFolderIcon = '<a href="#" onclick="' . htmlspecialchars($aOnClick) . '">' . $icon . '</a>';

        }

        return $theFolderIcon;

    }


    public function ‪wrapTitle(‪$title, $folderObject, ‪$bank = 0)

    {

        // Check storage access to wrap with click menu

        if ($folderObject instanceof InaccessibleFolder) {

            return ‪$title;

        }

        $aOnClick = 'return jumpTo(' . GeneralUtility::quoteJSvalue($this->‪getJumpToParam($folderObject)) . ', this, ' . GeneralUtility::quoteJSvalue($this->domIdPrefix . $this->‪getId($folderObject)) . ', ' . ‪$bank . ');';

        $tableName = $this->‪getTableNameForClickMenu($folderObject);

        $clickMenuParts = ‪BackendUtility::wrapClickMenuOnIcon('', $tableName, $folderObject->getCombinedIdentifier(), 'tree', '', '', true);


        return '<a href="#" title="' . htmlspecialchars(strip_tags(‪$title)) . '" onclick="' . htmlspecialchars($aOnClick) . '" ' . GeneralUtility::implodeAttributes($clickMenuParts) . '>' . ‪$title . '</a>';

    }


    public function ‪getId($folderObject)

    {

        return GeneralUtility::md5int($folderObject->getCombinedIdentifier());

    }


    public function ‪getJumpToParam($folderObject)

    {

        return rawurlencode($folderObject->getCombinedIdentifier());

    }


    public function ‪getTitleStr($row, $titleLen = 30)

    {

        return $row['_title'] ?? parent::getTitleStr($row, $titleLen);

    }


    public function ‪getTitleAttrib($folderObject)

    {

        return htmlspecialchars($folderObject->getName());

    }


    public function ‪getBrowsableTree()

    {

        // Get stored tree structure AND updating it if needed according to incoming PM GET var.

        $this->‪initializePositionSaving();

        // Init done:

        $treeItems = [];

        // Traverse mounts:

        foreach ($this->storages as $storageObject) {

            $this->‪getBrowseableTreeForStorage($storageObject);

            // Add tree:

            $treeItems = array_merge($treeItems, $this->tree);

        }

        return $this->‪printTree($treeItems);

    }


    public function ‪getBrowseableTreeForStorage(‪ResourceStorage $storageObject)

    {

        // If there are filemounts, show each, otherwise just the rootlevel folder

        $fileMounts = $storageObject->‪getFileMounts();

        $rootLevelFolders = [];

        if (!empty($fileMounts)) {

            foreach ($fileMounts as $fileMountInfo) {

                $rootLevelFolders[] = [

                    'folder' => $fileMountInfo['folder'],

                    'name' => $fileMountInfo['title']

                ];

            }

        } elseif ($this->BE_USER->isAdmin()) {

            $rootLevelFolders[] = [

                'folder' => $storageObject->‪getRootLevelFolder(),

                'name' => $storageObject->‪getName()

            ];

        }

        // Clean the tree

        $this->‪reset();

        // Go through all "root level folders" of this tree (can be the rootlevel folder or any file mount points)

        foreach ($rootLevelFolders as $rootLevelFolderInfo) {

            $rootLevelFolder = $rootLevelFolderInfo['folder'];

            $rootLevelFolderName = $rootLevelFolderInfo['name'];

            $folderHashSpecUID = GeneralUtility::md5int($rootLevelFolder->getCombinedIdentifier());

            $this->specUIDmap[$folderHashSpecUID] = $rootLevelFolder->getCombinedIdentifier();

            // Hash key

            $storageHashNumber = $this->‪getShortHashNumberForStorage($storageObject, $rootLevelFolder);

            // Set first:

            $this->bank = $storageHashNumber;

            $isOpen = $this->stored[$storageHashNumber][$folderHashSpecUID] || ‪$this->expandFirst;

            // Set PM icon:

            $cmd = $this->‪generateExpandCollapseParameter($this->bank, !$isOpen, $rootLevelFolder);

            // Only show and link icon if storage is browseable

            if (!$storageObject->‪isBrowsable() || $this->getNumberOfSubfolders($rootLevelFolder) === 0) {

                $firstHtml = '';

            } else {

                $firstHtml = $this->‪renderPMIconAndLink($cmd, $isOpen);

            }

            // Mark a storage which is not online, as offline

            // maybe someday there will be a special icon for this

            if ($storageObject->‪isOnline() === false) {

                $rootLevelFolderName .= ' (' . $this->‪getLanguageService()->‪sL('LLL:EXT:core/Resources/Private/Language/locallang_mod_file.xlf:sys_file_storage.isOffline') . ')';

            }

            // Preparing rootRec for the mount

            $icon = $this->iconFactory->getIconForResource($rootLevelFolder, ‪Icon::SIZE_SMALL, null, ['mount-root' => true]);

            $firstHtml .= $this->‪wrapIcon($icon, $rootLevelFolder);

            $row = [

                'uid' => $folderHashSpecUID,

                'title' => $rootLevelFolderName,

                'path' => $rootLevelFolder->getCombinedIdentifier(),

                'folder' => $rootLevelFolder

            ];

            // Add the storage root to ->tree

            $this->tree[] = [

                'HTML' => $firstHtml,

                'row' => $row,

                'bank' => ‪$this->bank,

                // hasSub is TRUE when the root of the storage is expanded

                'hasSub' => $isOpen && $storageObject->‪isBrowsable(),

                'invertedDepth' => 1000,

            ];

            // If the mount is expanded, go down:

            if ($isOpen && $storageObject->‪isBrowsable()) {

                // Set depth:

                $this->‪getFolderTree($rootLevelFolder, 999);

            }

        }

    }


    public function ‪getFolderTree(Folder $folderObject, $depth = 999, $type = '')

    {

        $depth = (int)$depth;


        // This generates the directory tree

        /* array of \TYPO3\CMS\Core\Resource\Folder */

        if ($folderObject instanceof InaccessibleFolder) {

            $subFolders = [];

        } else {

            $subFolders = $folderObject->getSubfolders();

            $subFolders = ‪\TYPO3\CMS\Core\Resource\Utility\ListUtility::resolveSpecialFolderNames($subFolders);

            uksort($subFolders, 'strnatcasecmp');

        }


        $totalSubFolders = count($subFolders);

        $HTML = '';

        $subFolderCounter = 0;

        $treeKey = '';

        foreach ($subFolders as $subFolderName => $subFolder) {

            $subFolderCounter++;

            // Reserve space.

            $this->tree[] = [];

            // Get the key for this space

            end($this->tree);

            $isLocked = $subFolder instanceof InaccessibleFolder;

            $treeKey = key($this->tree);

            $specUID = GeneralUtility::md5int($subFolder->getCombinedIdentifier());

            $this->specUIDmap[$specUID] = $subFolder->getCombinedIdentifier();

            $row = [

                'uid' => $specUID,

                'path' => $subFolder->getCombinedIdentifier(),

                'title' => $subFolderName,

                'folder' => $subFolder

            ];

            // Make a recursive call to the next level

            if (!$isLocked && $depth > 1 && $this->‪expandNext($specUID)) {

                $nextCount = $this->‪getFolderTree($subFolder, $depth - 1, $type);

                // Set "did expand" flag

                $isOpen = 1;

            } else {

                $nextCount = $isLocked ? 0 : $this->‪getNumberOfSubfolders($subFolder);

                // Clear "did expand" flag

                $isOpen = 0;

            }

            // Set HTML-icons, if any:

            if ($this->makeHTML) {

                $HTML = $this->‪PMicon($subFolder, $subFolderCounter, $totalSubFolders, $nextCount, $isOpen);

                $type = '';


                $role = $subFolder->getRole();

                if ($role !== ‪FolderInterface::ROLE_DEFAULT) {

                    $row['_title'] = '<strong>' . $subFolderName . '</strong>';

                }

                $icon = '<span title="' . htmlspecialchars($subFolderName) . '">'

                    . $this->iconFactory->getIconForResource($subFolder, ‪Icon::SIZE_SMALL, null, ['folder-open' => (bool)$isOpen])

                    . '</span>';

                $HTML .= $this->‪wrapIcon($icon, $subFolder);

            }

            // Finally, add the row/HTML content to the ->tree array in the reserved key.

            $this->tree[$treeKey] = [

                'row' => $row,

                'HTML' => $HTML,

                'hasSub' => $nextCount && $this->‪expandNext($specUID),

                'isFirst' => $subFolderCounter == 1,

                'isLast' => false,

                'invertedDepth' => $depth,

                'bank' => ‪$this->bank

            ];

        }

        if ($subFolderCounter > 0) {

            $this->tree[$treeKey]['isLast'] = true;

        }

        return $totalSubFolders;

    }


    public function ‪printTree($treeItems = '')

    {

        $doExpand = false;

        $doCollapse = false;

        $ajaxOutput = '';

        $titleLength = (int)$this->BE_USER->uc['titleLen'];

        if (!is_array($treeItems)) {

            $treeItems = ‪$this->tree;

        }


        if (empty($treeItems)) {

            $message = GeneralUtility::makeInstance(

                FlashMessage::class,

                $this->‪getLanguageService()->sL('LLL:EXT:backend/Resources/Private/Language/locallang.xlf:foldertreeview.noFolders.message'),

                $this->‪getLanguageService()->sL('LLL:EXT:backend/Resources/Private/Language/locallang.xlf:foldertreeview.noFolders.title'),

                ‪FlashMessage::INFO

            );

            $flashMessageService = GeneralUtility::makeInstance(FlashMessageService::class);

            $defaultFlashMessageQueue = $flashMessageService->getMessageQueueByIdentifier();

            $defaultFlashMessageQueue->enqueue($message);

            return $defaultFlashMessageQueue->renderFlashMessages();

        }


        $expandedFolderHash = '';

        $invertedDepthOfAjaxRequestedItem = 0;

        $out = '<ul class="list-tree list-tree-root">';

        // Evaluate AJAX request

        if (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_AJAX) {

            list(, $expandCollapseCommand, $expandedFolderHash, ) = $this->‪evaluateExpandCollapseParameter();

            if ($expandCollapseCommand == 1) {

                $doExpand = true;

            } else {

                $doCollapse = true;

            }

        }

        // We need to count the opened <ul>'s every time we dig into another level,

        // so we know how many we have to close when all children are done rendering

        $closeDepth = [];

        foreach ($treeItems as $treeItem) {

            $folderObject = $treeItem['row']['folder'];

            $classAttr = $treeItem['row']['_CSSCLASS'] ?? '';

            $folderIdentifier = $folderObject->getCombinedIdentifier();

            // this is set if the AJAX request has just opened this folder (via the PM command)

            $isExpandedFolderIdentifier = $expandedFolderHash == GeneralUtility::md5int($folderIdentifier);

            $idAttr = htmlspecialchars($this->domIdPrefix . $this->‪getId($folderObject) . '_' . $treeItem['bank']);

            $itemHTML = '';

            // If this item is the start of a new level,

            // then a new level <ul> is needed, but not in ajax mode

            if (!empty($treeItem['isFirst']) && !$doCollapse && !($doExpand && $isExpandedFolderIdentifier)) {

                $itemHTML = '<ul class="list-tree">';

            }

            // Add CSS classes to the list item

            if (!empty($treeItem['hasSub'])) {

                $classAttr .= ' list-tree-control-open';

            }

            $itemHTML .= '

                <li id="' . $idAttr . '" ' . ($classAttr ? ' class="' . trim($classAttr) . '"' : '') . '><span class="list-tree-group">' . $treeItem['HTML'] . $this->‪wrapTitle($this->‪getTitleStr($treeItem['row'], $titleLength), $folderObject, $treeItem['bank']) . '</span>';

            if (empty($treeItem['hasSub'])) {

                $itemHTML .= '</li>';

            }

            // We have to remember if this is the last one

            // on level X so the last child on level X+1 closes the <ul>-tag

            if (!empty($treeItem['isLast']) && !($doExpand && $isExpandedFolderIdentifier)) {

                $closeDepth[$treeItem['invertedDepth']] = 1;

            }

            // If this is the last one and does not have subitems, we need to close

            // the tree as long as the upper levels have last items too

            if (!empty($treeItem['isLast']) && empty($treeItem['hasSub']) && !$doCollapse && !($doExpand && $isExpandedFolderIdentifier)) {

                for ($i = $treeItem['invertedDepth']; !empty($closeDepth[$i]); $i++) {

                    $closeDepth[$i] = 0;

                    $itemHTML .= '</ul></li>';

                }

            }

            // Ajax request: collapse

            if ($doCollapse && $isExpandedFolderIdentifier) {

                $this->ajaxStatus = true;

                return $itemHTML;

            }

            // Ajax request: expand

            if ($doExpand && $isExpandedFolderIdentifier) {

                $ajaxOutput .= $itemHTML;

                $invertedDepthOfAjaxRequestedItem = $treeItem['invertedDepth'];

            } elseif ($invertedDepthOfAjaxRequestedItem) {

                if ($treeItem['invertedDepth'] && ($treeItem['invertedDepth'] < $invertedDepthOfAjaxRequestedItem)) {

                    $ajaxOutput .= $itemHTML;

                } else {

                    $this->ajaxStatus = true;

                    return $ajaxOutput;

                }

            }

            $out .= $itemHTML;

        }

        // If this is an AJAX request, output directly

        if ($ajaxOutput) {

            $this->ajaxStatus = true;

            return $ajaxOutput;

        }

        // Finally close the first ul

        $out .= '</ul>';

        return $out;

    }


    protected function ‪getTableNameForClickMenu(‪Folder $folderObject)

    {

        if (strpos($folderObject->‪getRole(), ‪FolderInterface::ROLE_MOUNT) !== false) {

            $tableName = 'sys_filemounts';

        } elseif ($folderObject->‪getIdentifier() === $folderObject->‪getStorage()->‪getRootLevelFolder()->‪getIdentifier()) {

            $tableName = 'sys_file_storage';

        } else {

            $tableName = 'sys_file';

        }

        return $tableName;

    }


    public function ‪getNumberOfSubfolders(‪Folder $folderObject)

    {

        $subFolders = $folderObject->‪getSubfolders();

        return count($subFolders);

    }


    public function ‪initializePositionSaving()

    {

        // Get stored tree structure:

        $this->stored = unserialize($this->BE_USER->uc['browseTrees'][$this->treeName], ['allowed_classes' => false]);

        $this->‪getShortHashNumberForStorage();

        // PM action:

        // (If an plus/minus icon has been clicked,

        // the PM GET var is sent and we must update the stored positions in the tree):

        // 0: mount key, 1: set/clear boolean, 2: item ID (cannot contain "_"), 3: treeName

        list($storageHashNumber, $doExpand, $numericFolderHash, ‪$treeName) = $this->‪evaluateExpandCollapseParameter();

        if (‪$treeName && ‪$treeName == $this->treeName) {

            if (in_array($storageHashNumber, $this->storageHashNumbers)) {

                if ($doExpand == 1) {

                    // Set

                    $this->stored[$storageHashNumber][$numericFolderHash] = 1;

                } else {

                    // Clear

                    unset($this->stored[$storageHashNumber][$numericFolderHash]);

                }

                $this->‪savePosition();

            }

        }

    }


    protected function ‪getShortHashNumberForStorage(ResourceStorage $storageObject = null, Folder $startingPointFolder = null)

    {

        if (!$this->storageHashNumbers) {

            $this->storageHashNumbers = [];

            foreach ($this->storages as $storageUid => $storage) {

                $fileMounts = $storage->getFileMounts();

                if (!empty($fileMounts)) {

                    foreach ($fileMounts as $fileMount) {

                        $nkey = hexdec(substr(GeneralUtility::md5int($fileMount['folder']->getCombinedIdentifier()), 0, 4));

                        $this->storageHashNumbers[$storageUid . $fileMount['folder']->getCombinedIdentifier()] = $nkey;

                    }

                } else {

                    $folder = $storage->getRootLevelFolder();

                    $nkey = hexdec(substr(GeneralUtility::md5int($folder->getCombinedIdentifier()), 0, 4));

                    $this->storageHashNumbers[$storageUid . $folder->getCombinedIdentifier()] = $nkey;

                }

            }

        }

        if ($storageObject) {

            if ($startingPointFolder) {

                return $this->storageHashNumbers[$storageObject->‪getUid() . $startingPointFolder->getCombinedIdentifier()];

            }

            return $this->storageHashNumbers[$storageObject->‪getUid()];

        }

        return null;

    }


    protected function ‪evaluateExpandCollapseParameter($PM = null)

    {

        if ($PM === null) {

            $PM = GeneralUtility::_GP('PM');

            // IE takes anchor as parameter

            if (($PMpos = strpos($PM, '#')) !== false) {

                $PM = substr($PM, 0, $PMpos);

            }

        }

        // Take the first three parameters

        list($mountKey, $doExpand, $folderIdentifier) = array_pad(explode('_', $PM, 3), 3, null);

        // In case the folder identifier contains "_", we just need to get the fourth/last parameter

        list($folderIdentifier, ‪$treeName) = array_pad(GeneralUtility::revExplode('_', $folderIdentifier, 2), 2, null);

        return [

            $mountKey,

            $doExpand,

            $folderIdentifier,

            ‪$treeName

        ];

    }


    protected function ‪generateExpandCollapseParameter($mountKey = null, $doExpand = false, Folder $folderObject = null, ‪$treeName = null)

    {

        $parts = [

            $mountKey ?? ‪$this->bank,

            $doExpand == 1 ? 1 : 0,

            $folderObject !== null ? GeneralUtility::md5int($folderObject->getCombinedIdentifier()) : '',

            ‪$treeName ?? $this->treeName

        ];

        return implode('_', $parts);

    }


    public function ‪getAjaxStatus()

    {

        return ‪$this->ajaxStatus;

    }


    protected function ‪getLanguageService()

    {

        return ‪$GLOBALS['LANG'];

    }

}