Register renderer

@param \ViKon\Parser\Renderer\Renderer $renderer

@return mixed
498756
public function register(Renderer $renderer) {
        $this->registerTokenRenderer(StrikethroughRule::NAME . StrikethroughRule::OPEN, 'renderOpen', $renderer);
        $this->registerTokenRenderer(StrikethroughRule::NAME . StrikethroughRule::CLOSE, 'renderClose', $renderer);

    }
425836
public function addRenderer(SwatCellRenderer $renderer)
    {
        $this->renderers->addRenderer($renderer);
        $renderer->parent = $this;
    }
81173
public function getRenderer()
    {
        if ($this->renderer === null) {
            $this->renderer = Services::renderer();
        }
        return $this->renderer;
    }
306044
public function render( RendererInterface $renderer )
    {
        return $renderer->translate(
            'default.' . ( $this->successful ? 'success' : 'failed' ),
            'default'
        ) . ( empty( $this->loginWith ) ? '' : ', ' . sprintf(
            $renderer->translate( 'user.action.loginWith.%s', 'user' ),
            $renderer->translate( 'user.loginWith.' . $this->loginWith, 'user' )
        ) );
    }
39147
public function registerBladeEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->singleton('blade.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];

            // Fetch the view.loader instnace that we created in registerViewLoader()
            $loader = $app['view.loader'];

            // Create our own BladeCompiler that can use the loader that we created.
            return new BladeCompiler($app['files'], $cache, $loader);
        });

        $resolver->register('blade', function () use ($app) {
            return new CompilerEngine($app['blade.compiler']);
        });
    }
139346
protected function registerCompiler()
    {
        $this->app->singleton('markdown.compiler', function (Container $app) {
            $markdown = $app['markdown'];
            $files = $app['files'];
            $storagePath = $app->config->get('view.compiled');

            return new MarkdownCompiler($markdown, $files, $storagePath);
        });

        $this->app->alias('markdown.compiler', MarkdownCompiler::class);
    }
2960
public function getRenderer()
    {
        if (null === $this->renderer) {
            $this->setRenderer(new Renderer($this));
        }
        return $this->renderer;
    }
399536
public function render(RendererInterface $renderer = null)
    {
        $renderer = $renderer ?: $this->getDefaultRenderer();
        $form = $this->header();
        foreach ($this->rows as $row) {
            $form .= $row->render($renderer);
        }
        $form .= '</form>';

        return $form;
    }
969534
public function render(HTML_QuickForm2_Renderer $renderer)
    {
        $renderer->startGroup($this);
        foreach ($this as $element) {
            $element->render($renderer);
        }
        $renderer->finishGroup($this);
        return $renderer;
    }
456563
public function registerHandlebarsEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Handlebars compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->singleton('handlebars.lightncandy', function ($app) {
            return new LightnCandy;
        });

        $app->singleton('handlebars.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];

            return new HandlebarsCompiler($app['files'], $app['handlebars.lightncandy'], $cache);
        });

        $resolver->register('handlebars', function () use ($app) {
            return new HandlebarsEngine($app['handlebars.compiler']);
        });
    }
1268622
public function registerTplEngine($resolver)
    {
        $app = $this->app;

        $resolver->register('tpl', function() use ($app)
        {
            $cache = $app['path.storage'].'/views';

            // The Compiler engine requires an instance of the CompilerInterface, which in
            // this case will be the Blade compiler, so we'll first create the compiler
            // instance to pass into the engine so it can compile the views properly.
            $compiler = new TplCompiler($app['files'], $cache);


            return new CompilerEngine($compiler, $app['files']);
        });
    }
315277
protected function rendererFactory($renderer): RendererInterface
	{
		return $renderer instanceof Closure ? $this->container->call($renderer) : $this->container->get($renderer);
	}
104895
public function render($renderer)
    {
        if ($this->x1 === ReportBaseElement::CURRENT_POSITION) {
            $this->x1 = $renderer->GetX();
        }
        if ($this->y1 === ReportBaseElement::CURRENT_POSITION) {
            $this->y1 = $renderer->GetY();
        }
        if ($this->x2 === ReportBaseElement::CURRENT_POSITION) {
            $this->x2 = $renderer->getMaxLineWidth();
        }
        if ($this->y2 === ReportBaseElement::CURRENT_POSITION) {
            $this->y2 = $renderer->GetY();
        }
        if ($renderer->getRTL()) {
            $renderer->Line($renderer->getPageWidth() - $this->x1, $this->y1, $renderer->getPageWidth() - $this->x2, $this->y2);
        } else {
            $renderer->Line($this->x1, $this->y1, $this->x2, $this->y2);
        }
    }
568587
public function render($renderer)
    {
        $renderer->setCurrentStyle('footnotenum');
        echo '<a href="#footnote', $this->num, '"><sup>';
        $renderer->write($renderer->entityRTL . $this->num);
        echo "</sup></a>\n";
    }
17630
public function render(Render $renderer)
	{
		$legend = '';

		//Make sure the legend is added if needed
		if ( !is_null($this->getLegend()) )
		{
			$legend = Html::tag('legend', [], $this->getLegend());
		}

		//Makes sure the legend is added if one exists
		$elements = $legend;

		//Render all the elements
		foreach ( $this->getContents() as $element )
		{
			$elements .= "\n" . $renderer->render($element);
		}

		return Html::tag('fieldset', $this->getAttributes(), $elements);
	}
799475
protected function addRenderFormat(RenderInterface $renderer)
    {
        foreach ($renderer->getSupportedFormats() as $format) {
            $this->renderers[$format] = $renderer;
        }
    }
966033
public function registerCustomRenderer($callback, array $args = null):Renderer
    {
        if (is_callable($callback)) {
            $end = substr($callback, (strlen($callback) - 8));
            if ($end === "Renderer") {
                $this->display_elements["custom"] = $callback;
                $this->display_elements["args"] = $args;
                return ($this);
            } else {
                throw new Server500(new \ArrayObject(array("explain" =>
                    "Renderer name must be contain [Renderer] keyword at the end to be valid : $callback",
                    "solution" => "Please set a valid renderer name")));
            }
        } else {
            throw new Server500(new \ArrayObject(array("explain" =>
                "Cannot register $callback custom renderer : Is not callable", "solution" =>
                "Please set a callable renderer")));
        }
    }