Creates a list of default node renderers.

@return NodeRendererInterface[]
960176
private function createNodeRenderers(): array
    {
        return [
            new NodeRenderer\AssetHyperlink(),
            new NodeRenderer\Blockquote(),
            new NodeRenderer\Document(),
            new NodeRenderer\EmbeddedAssetBlock(),
            new NodeRenderer\EmbeddedAssetInline(),
            new NodeRenderer\EmbeddedEntryBlock(),
            new NodeRenderer\EmbeddedEntryInline(),
            new NodeRenderer\EntryHyperlink(),
            new NodeRenderer\Heading1(),
            new NodeRenderer\Heading2(),
            new NodeRenderer\Heading3(),
            new NodeRenderer\Heading4(),
            new NodeRenderer\Heading5(),
            new NodeRenderer\Heading6(),
            new NodeRenderer\Hr(),
            new NodeRenderer\Hyperlink(),
            new NodeRenderer\ListItem(),
            new NodeRenderer\Nothing(),
            new NodeRenderer\OrderedList(),
            new NodeRenderer\Paragraph(),
            new NodeRenderer\Text(),
            new NodeRenderer\UnorderedList(),
        ];
    }
403483
public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();

        $root = $treeBuilder->root('form');
        $root
            ->children()
                ->arrayNode('themes')
                    ->fixXmlConfig('themes')
                    ->addDefaultChildrenIfNoneSet()
                    ->prototype('scalar')->defaultValue('default')->end()
                    ->validate()
                        ->ifTrue(function ($v) {
                            return !in_array('default', $v);
                        })
                        ->then(function ($v) {
                            return array_merge(['default'], $v);
                        })
                    ->end()
                ->end()
            ->end();

        return $treeBuilder;
    }
901272
public function getDefaultRendering($something) {

        $renderer = new QtiPLRenderer($this->getCRO());
        return $something->getQtiClassName() . $renderer->writeChildElements($something->getExpressions());
    }
817828
private function initRenderersList(): void
    {
        if (!$this->initDone) {
            foreach ($this->customRendererInstanceNames as $instanceName) {
                $this->customRenderers[$instanceName] = $this->container->get($instanceName);
            }
            foreach ($this->packageRendererInstanceNames as $instanceName) {
                $this->packageRenderers[$instanceName] = $this->container->get($instanceName);
            }

            // Note: We ignore template renderers on purpose.
            $this->initDone = true;
        }
    }
855270
protected function getRenderer()
    {
        if (null === $this->renderer) {
            $this->setRenderer(new $this->rendererClass());
        }
        return $this->renderer;
    }
1045957
private function autoloadAdapters()
    {
        $rendererConfig = $this->getApplication()->getConfig()->getRendererConfig();
        $adapters = (array) $rendererConfig['adapter'];
        foreach ($adapters as $adapter) {
            $classname = $adapter;
            $adapterConfig = [];
            if (is_array($adapter)) {
                $classname = isset($adapter['class']) ? $adapter['class'] : null;
                $adapterConfig = isset($adapter['config']) && is_array($adapter['config']) ? $adapter['config'] : [];
            }

            $this->addRendererAdapter(new $classname($this, $adapterConfig));
        }

        return $this;
    }
311703
public function renderChildren()
    {
        if ($this->renderChildrenClosure !== null) {
            $closure = $this->renderChildrenClosure;
            return $closure();
        }
        return $this->viewHelperNode->evaluateChildNodes($this->renderingContext);
    }
445068
private function getDefaultProviders()
    {
        $defaultProviders = array();

        foreach ($this->defaultProviders as $provider) {
            $defaultProviders[$provider] = $this->getProvider($provider);
        }

        return $defaultProviders;
    }
225534
public function getRenderer()
    {
        $locator = $this->getServiceLocator();
        if (null === $this->renderer && $locator->has(Renderer\RendererInterface::class)) {
            $this->setRenderer($locator->get(Renderer\RendererInterface::class));
        }

        return $this->renderer;
    }
54349
private function createDefaultOptionNodes()
    {
        $nodes = array();

        foreach ($this->defaults as $key => $value) {
            // Only scalars are allowed, the rest is ignored
            if (is_scalar($value)) {
                array_push($nodes, $this->createOptionNode($key, $value));
            }
        }

        return $nodes;
    }
81173
public function getRenderer()
    {
        if ($this->renderer === null) {
            $this->renderer = Services::renderer();
        }
        return $this->renderer;
    }
1181798
public static function getDefaultComponentFactories()
    {
        return [
            new Component\ButtonFactory(),
            new Component\CalloutFactory(),
            new Component\CenterFactory(),
            new Component\ColumnsFactory(),
            new Component\ContainerFactory(),
            new Component\ItemFactory(),
            new Component\MenuFactory(),
            new Component\RowFactory(),
            new Component\SpacerFactory(),
            new Component\WrapperFactory(),
        ];
    }
505724
public function getNodeBuilder()
    {
        if (!isset($this->nodeBuilder)) {
            $this->nodeBuilder = $this->getGeneratorConfig()->getConfiguredBuilder($this->getTable(), 'node');
        }

        return $this->nodeBuilder;
    }
224404
public function initRendering()
    {
        $this
            ->register(new Provider\TwigServiceProvider())
            ->register(new Provider\RenderServiceProvider())
            ->register(new Silex\Provider\HttpCacheServiceProvider())
        ;
        $this['http_cache.cache_dir'] = function () {
            return $this['path_resolver']->resolve('%cache%/' . $this['environment'] . '/http');
        };
        $this['http_cache.options'] = function () {
            return $this['config']->get('general/performance/http_cache/options', []);
        };
    }
1289727
public function renderName() : string
    {
        $label = !empty($this->defaultOptions['label']) ? $this->defaultOptions['label'] : '';

        $renderer = $this->config->getProvider('renderName');
        $renderer = new $renderer($this->config);
        $result = $renderer->provide($label);

        return $result;
    }
1347630
protected function getRenderer()
    {
        if ($this->renderer === null) {
            $this->renderer = $this->serviceLocator->get('ViewRenderer');
        }

        return $this->renderer;
    }
607570
protected function makeDefaultComponents()
    {
        return [
            static::CONTAINER_ID => new Part(new Tag('div'), static::CONTAINER_ID, static::ROOT_ID),
            static::FORM_ID => new Part(
                new Tag('form', ['data-role' => 'managed_list_form']),
                static::FORM_ID,
                static::CONTAINER_ID
            ),
            static::CONTROL_CONTAINER_ID => new Part(
                new Tag(
                    'span',
                    [   // margin for positioning submit-button
                        // line-height for multi-row appearance
                        'style' => 'margin:4px;line-height:3'
                    ]
                ),
                static::CONTROL_CONTAINER_ID,
                static::FORM_ID
            ),
            static::SUBMIT_BUTTON_ID => new Part(
                new TagWithText(
                    'button',
                    'Filter',
                    ['type' => 'submit', 'data-role' => 'managed_list_submit_button']
                ),
                static::SUBMIT_BUTTON_ID,
                static::FORM_ID
            ),
            static::LIST_CONTAINER_ID => new Part(
                new Container(),
                static::LIST_CONTAINER_ID,
                static::CONTAINER_ID
            ),
            static::COLLECTION_VIEW_ID => new Part(
                new CollectionView(),
                static::COLLECTION_VIEW_ID,
                static::LIST_CONTAINER_ID
            ),
            static::RECORD_VIEW_ID => new RecordView(new Json()),
        ];
    }