AbstractComponentRenderer.php

Go to the documentation of this file.

<?php

/* Copyright (c) 2016 Richard Klees <richard.klees@concepts-and-training.de> Extended GPL, see docs/LICENSE */

namespace ILIAS\UI\Implementation\Render;

use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\JavaScriptBindable;
use ILIAS\UI\Component\Triggerer;
use ILIAS\UI\Factory;

abstract class AbstractComponentRenderer implements ComponentRenderer
{
    private $ui_factory;

    private $tpl_factory;

    private $lng;

    private $js_binding;
    private static $component_storage = [];

    private $refinery;

    private $image_path_resolver;


    final public function __construct(
        Factory $ui_factory,
        TemplateFactory $tpl_factory,
        \ilLanguage $lng,
        JavaScriptBinding $js_binding,
        \ILIAS\Refinery\Factory $refinery,
        ImagePathResolver $image_path_resolver
    ) {
        $this->ui_factory = $ui_factory;
        $this->tpl_factory = $tpl_factory;
        $this->lng = $lng;
        $this->js_binding = $js_binding;
        $this->refinery = $refinery;
        $this->image_path_resolver = $image_path_resolver;
    }

    public function registerResources(ResourceRegistry $registry)
    {
        $registry->register('./src/UI/templates/js/Core/ui.js');
    }

    final protected function getUIFactory()
    {
        return $this->ui_factory;
    }

    final protected function getRefinery() : \ILIAS\Refinery\Factory
    {
        return $this->refinery;
    }

    final public function txt($id)
    {
        return $this->lng->txt($id);
    }

    final public function toJS($key)
    {
        $this->lng->toJS($key);
    }

    public function getLangKey()
    {
        return $this->lng->getLangKey();
    }


    final protected function getJavascriptBinding()
    {
        return $this->js_binding;
    }

    final protected function getTemplate($name, $purge_unfilled_vars, $purge_unused_blocks)
    {
        $path = $this->getTemplatePath($name);
        return $this->tpl_factory->getTemplate($path, $purge_unfilled_vars, $purge_unused_blocks);
    }

    protected function getTemplatePath($name)
    {
        $component = $this->getMyComponent();
        return "src/UI/templates/default/$component/$name";
    }

    final protected function bindJavaScript(JavaScriptBindable $component)
    {
        if ($component instanceof Triggerer) {
            $component = $this->addTriggererOnLoadCode($component);
        }
        return $this->bindOnloadCode($component);
    }

    final protected function createId() : string
    {
        return $this->js_binding->createId();
    }

    private function bindOnloadCode(JavaScriptBindable $component)
    {
        $binder = $component->getOnLoadCode();
        if ($binder === null) {
            return null;
        }

        $id = $this->js_binding->createId();
        $on_load_code = $binder($id);
        if (!is_string($on_load_code)) {
            throw new \LogicException(
                "Expected JavaScript binder to return string" .
                " (used component: " . get_class($component) . ")"
            );
        }
        $this->js_binding->addOnLoadCode($on_load_code);
        return $id;
    }

    private function addTriggererOnLoadCode(Triggerer $triggerer)
    {
        $triggered_signals = $triggerer->getTriggeredSignals();
        if (count($triggered_signals) == 0) {
            return $triggerer;
        }
        return $triggerer->withAdditionalOnLoadCode(function ($id) use ($triggered_signals) {
            $code = "";
            foreach ($triggered_signals as $triggered_signal) {
                $signal = $triggered_signal->getSignal();
                $event = $triggered_signal->getEvent();
                $options = json_encode($signal->getOptions());
                //Note this switch is necessary since $(#...).on('load', ...) could be fired before the binding of the event.
                //Same seems true fro ready, see: #27456
                if ($event == 'load' || $event == 'ready') {
                    $code .=
                            "$(document).trigger('{$signal}',
                                                        {
                                                                'id' : '{$signal}', 'event' : '{$event}',
                                                                'triggerer' : $('#{$id}'),
                                                                'options' : JSON.parse('{$options}')
                                                        }
                                                );";
                } else {
                    $code .=
                    "$('#{$id}').on('{$event}', function(event) {
                                                $(this).trigger('{$signal}',
                                                        {
                                                                'id' : '{$signal}', 'event' : '{$event}',
                                                                'triggerer' : $(this),
                                                                'options' : JSON.parse('{$options}')
                                                        }
                                                );
                                                return false;
                                        });";
                }
            }
            return $code;
        });
    }

    final protected function checkComponent(Component $component)
    {
        $interfaces = $this->getComponentInterfaceName();
        if (!is_array($interfaces)) {
            throw new \LogicException(
                "Expected array, found '" . (string) (null) . "' when rendering."
            );
        }

        foreach ($interfaces as $interface) {
            if ($component instanceof $interface) {
                return;
            }
        }
        $ifs = implode(", ", $interfaces);
        throw new \LogicException(
            "Expected $ifs, found '" . get_class($component) . "' when rendering."
        );
    }

    abstract protected function getComponentInterfaceName();


    private function getMyComponent()
    {
        $class = get_class($this);
        if (isset(self::$component_storage[$class])) {
            return self::$component_storage[$class];
        }
        $matches = array();
        // Extract component
        $re = "%ILIAS\\\\UI\\\\Implementation\\\\Component\\\\(\\w+)\\\\(\\w+)%";
        preg_match($re, $class, $matches);
        if (preg_match($re, $class, $matches) !== 1) {
            throw new \LogicException("The Renderer needs to be located in ILIAS\\UI\\Implementation\\Component\\*.");
        }
        self::$component_storage[$class] = $matches[1];

        return self::$component_storage[$class];
    }

    public function getImagePathResolver() : ImagePathResolver
    {
        return $this->image_path_resolver;
    }
}