BaseTypeRenderer.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\GlobalScreen\Scope\MainMenu\Collector\Renderer;
 
use ILIAS\Data\URI;
use ILIAS\GlobalScreen\Collector\Renderer\DecoratorApplierTrait;
use ILIAS\GlobalScreen\Collector\Renderer\isSupportedTrait;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\hasSymbol;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\hasTitle;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\isItem;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\supportsAsynchronousLoading;
use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\Symbol\Symbol;
use ILIAS\UI\Factory;
use ILIAS\UI\Renderer;
use Throwable;
use ILIAS\UI\Component\HasHelpTopics;
 
class BaseTypeRenderer implements TypeRenderer
{
    use MakeSlateAsync, SlateSessionStateCode {
        MakeSlateAsync::hash insteadof SlateSessionStateCode;
        MakeSlateAsync::unhash insteadof SlateSessionStateCode;
    }
    use isSupportedTrait;
 
    use DecoratorApplierTrait;
 
    protected \ilLanguage $lng;
    protected Factory $ui_factory;
 
    protected Renderer $ui_renderer;
 
    public function __construct()
    {
        global $DIC;
        $this->ui_factory = $DIC->ui()->factory();
        $this->ui_renderer = $DIC->ui()->renderer();
        $this->lng = $DIC->language();
    }
 
    public function getComponentForItem(isItem $item, bool $with_content = true): Component
    {
        $component = $this->applyComponentDecorator(
            $with_content
                ? $this->getComponentWithContent($item)
                : $this->getComponentWithoutContent($item),
            $item
        );
        if ($component instanceof HasHelpTopics) {
            return $this->applyTopics($component, $item);
        }
 
        return $component;
    }
 
    public function getComponentWithContent(isItem $item): Component
    {
        return $this->ui_factory->legacy()->content($item->getProviderIdentification()->serialize());
    }
 
    public function getComponentWithoutContent(isItem $item): Component
    {
        if (!$this->supportsAsyncContent($item)) {
            return $this->getComponentWithContent($item);
        }
        $content = $this->ui_factory->legacy()->content('...');
        $name = $item instanceof hasTitle ? $item->getTitle() : "-";
        $slate = $this->ui_factory->mainControls()->slate()->legacy(
            $name,
            $this->getStandardSymbol($item),
            $content
        );
        $slate = $this->addAsyncLoadingCode($slate, $item);
 
        return $this->addOnloadCode($slate, $item);
    }
 
    private function supportsAsyncContent(isItem $item): bool
    {
        return $item instanceof supportsAsynchronousLoading && $item->supportsAsynchronousLoading();
    }
 
    protected function getStandardSymbol(isItem $item): Symbol
    {
        if ($item instanceof hasSymbol && $item->hasSymbol()) {
            $c = $item->getSymbolDecorator();
            if ($c !== null) {
                return $this->applySymbolDecorator($item->getSymbol(), $item);
            }
 
            return $item->getSymbol();
        }
        if ($item instanceof hasTitle) {
            if (function_exists('mb_substr')) {
                $abbr = strtoupper(mb_substr($item->getTitle(), 0, 1));
            } else {
                $abbr = strtoupper(substr($item->getTitle(), 0, 1));
            }
        } else {
            $abbr = strtoupper(substr(uniqid('', true), -1));
        }
 
        return $this->ui_factory->symbol()
                                ->icon()
                                ->standard(
                                    $abbr,
                                    $abbr,
                                    'small',
                                    true
                                )
                                ->withAbbreviation($abbr);
    }
 
    protected function getURI(string $uri_string): URI
    {
        $uri_string = trim($uri_string, " ");
 
        if (str_starts_with($uri_string, 'http')) {
            $checker = self::getURIChecker();
            if ($checker($uri_string)) {
                return new URI($uri_string);
            }
            return new URI(rtrim(ILIAS_HTTP_PATH, "/") . "/" . ltrim($_SERVER['REQUEST_URI'] ?? '', "./"));
        }
 
        return new URI(rtrim(ILIAS_HTTP_PATH, "/") . "/" . ltrim($uri_string, "./"));
    }
 
    public static function getURIChecker(): callable
    {
        return static function (string $v): bool {
            $v = self::getURIConverter()($v);
            try {
                new URI($v);
            } catch (Throwable) {
                return false;
            }
            return true;
        };
    }
 
    public static function getURIConverter(): callable
    {
        return static function (string $v): string {
            if (str_starts_with($v, './')) {
                $v = ltrim($v, './');
                return ILIAS_HTTP_PATH . '/' . $v;
            }
 
            return $v;
        };
    }
}