Loads Markdown and Twig engines and renders the styleguide
@return rendered HTML
179617
public function render() {
    // Initialize Markdown and Twig
    $engine = new MarkdownEngine\MichelfMarkdownEngine();
    $twig_loader = new Twig_Loader_Filesystem($this->template_folder);
    $twig = new Twig_Environment($twig_loader, array(
      'cache' => $this->twig_cache,
    ));
    $twig->addExtension(new MarkdownExtension($engine));

    print $twig->render('index.html', array(
      'title' => $this->title,
      'description' => $this->description,
      'source' => $this->source,
      'sections' => $this->sections,
      'base_path' => $this->base_path,
      'asset_path' => $this->asset_path,
    ));
  }
1289052
function renderTemplateLoader(source) {
  // Get the loader options object.
  var options = getOptions(this)
  // Get the template locals.
  var locals = getLocals.call(this, options)
  // Create info object of the filename of the resource being loaded.
  var info = { filename: this.resourcePath }
  // Get the engine options to be passed to the engine.
  var engineOptions = getEngineOptions.call(this, options.engineOptions, info)
  // Get the template renderer
  var renderer = getRenderer.call(this, options.engine)
  // Call options.init.
  init.call(this, renderer.engine, info, options)
  // Render the template
  var result = render(renderer, source, locals, engineOptions)
  // Assign the tempate to module.exports.
  return 'module.exports = ' + JSON.stringify(result)
}
694169
public function render()
    {
        if (!$this->checkAnsiAwareSystem()) {
            return $this->str;
        }

        if ($this->has_tags) {
            return $this->tag_format->parse($this->str);
        } elseif (!empty($this->str)) {
            $this->output->useEffect($this->format);
            return $this->output->build();
        }

        return $this->str;
    }
912521
public static function renderDebugBar()
    {
        if (!self::$renderer) {
            return;
        }

        // Requirements may have been cleared (CMS iframes...) or not set (Security...)
        $js = Requirements::backend()->getJavascript();
        $debugBarResource = self::moduleResource('assets/debugbar.js');
        $path = $debugBarResource->getRelativePath();

        // Url in getJavascript has a / slash, so fix if necessary
        $path = str_replace("assets\\debugbar.js", "assets/debugbar.js", $path);
        if (!array_key_exists($path, $js)) {
            return;
        }
        $initialize = true;
        if (Director::is_ajax()) {
            $initialize = false;
        }

        $script = self::$renderer->render($initialize);
        return $script;
    }
1033259
public function renderJs()
    {
        $jsLines = "\n";
        if ($this->getView()->assetBundles) {
            foreach ($this->getView()->assetBundles as $assetBundle) {
                if (!$assetBundle->sourcePath) {
                    foreach ($assetBundle->js as $jsFile) {
                        $jsLines .= "\n" . Html::jsFile($jsFile, $assetBundle->jsOptions);
                    }
                }
            }
        }
        if ($this->getView()->jsFiles) {
            foreach ($this->getView()->jsFiles as $jsFiles) {
                $jsLines .= implode("\n", $jsFiles);
            }
        }
        if ($this->getView()->js) {
            foreach ($this->getView()->js as $js) {
                $jsLines .= implode("\n", $js);
            }
        }
        return $jsLines;
    }
681415
public function render()
    {
        $tools = Html::div()->addClass( 'tools' );

        foreach( $this->blocks() as $name => $content )
        {
            $tools->append(
                Html::div( $content->toArray() )->addClass( $name )
            );
        }

        return $tools;
    }
589957
public function render()
    {
        if ($this->_enabled) {
            if (php_sapi_name() === 'cli') {
                echo 'FireBug: ' . $this->getLoadTime() . ' milliseconds' . "\n";
            } else {
                ob_start();
                include $this->_template;
                $debugPanel = ob_get_contents();
                ob_end_clean();

                return $debugPanel;
            }
        }
    }
1228346
public function render()
    {
        $viewContent = $this->buildBladeViewContent();

        if ($this->isExpired()) {
            $this->filesystem->put($this->cached, $this->bladeCompiler->compileString($viewContent));
        }

        $data = $this->getViewData();

        return $this->engine->get($this->cached, $data);
    }
170671
public function render()
    {
        // Run only in case there are breadcrumbs
        if ($this->breadcrumbBag->has()) {
            $ulClass = $this->getOption('ulClass', 'breadcrumb');
            return $this->renderList($ulClass, $this->createBreadcrumbItems());
        }
    }
890570
public function renderToolStyleHeaderAction()
    {
        // declare the Tool service that we will be using to completely create our tool.
        $melisTool = $this->getServiceLocator()->get('MelisCoreTool');

        // tell the Tool what configuration in the app.tool.php that will be used.
        $melisTool->setMelisToolKey('meliscms', 'meliscms_tool_templates');

        $melisKey = $this->params()->fromRoute('melisKey', '');
        $zoneConfig = $this->params()->fromRoute('zoneconfig', array());

        $view = new ViewModel();
        $view->melisKey = $melisKey;
        $view->title = $melisTool->getTitle();;

        return $view;
    }
280918
function Render()
    {
        self::$currentPage = $this->page;
        self::$Title = self::$currentPage->GetTitle();
        self::$Description = self::$currentPage->GetDescription();
        self::$Keywords = self::$currentPage->GetKeywords();
        if ($this->page->GetType() == (string)PageType::NotFound())
        {
            header('HTTP/1.0 404 Not Found');
        }
        else if ($this->page->GetType() !== (string)PageType::Normal())
        {
            throw new \Exception('Internal phine error: not normal page called');
        }
        ob_start();
        require PathUtil::LayoutTemplate($this->layout);
        $result = ob_get_clean();
        $replacer = new Replacer();
        return $replacer->RealizeVariables($result);
    }
980133
public function Render()
    {
        $string = $this->string;
        $tag = $this->tag;

        $classes = $this->classes;
        if (Count($classes)) {
            if ($classPrefix = $this->classPrefix) {
                foreach ($classes as $key => $value) {
                    $prefixedClass = $classPrefix . '__' . $value;
                    $classes[$prefixedClass] = $prefixedClass;
                }
            }
            $this->addAttribute('class', implode(' ', $classes));
        }

        if ($this->isVoidElement() && $string) {
            if ($voidAttributeName = $this->VoidElements[$tag]) {
                $this->addAttribute($voidAttributeName, $string);
            } else {
                throw new InvalidArgumentException("Void element \"{$tag}\" cannot have string");
            }
        }

        $attributes = [];
        foreach ($this->attributes as $name => $value) {
            $attributes[] = sprintf(
                '%s="%s"',
                $name,
                Convert::raw2att($value)
            );
        }
        $attributes = Count($attributes) ? ' ' . implode(' ', $attributes) : '';

        if ($this->isVoidElement()) {
            return "<{$tag}{$attributes} />";
        }

        if (!isset($string) || !$string || $string == '') {
            return null;
        }

        return "<{$tag}{$attributes}>{$string}</{$tag}>";
    }
319619
def _render_content(self):
        """"""
        if self.content_format == "rst" and docutils_publish is not None:
            doc_parts = docutils_publish(
                source=self.raw_content,
                writer_name="html4css1"
            )
            self.rendered_content = doc_parts['fragment']
        elif self.content_format == "rs" and docutils_publish is None:
            raise RuntimeError("Install docutils to pubilsh reStructuredText")
        elif self.content_format == "md" and markdown is not None:
            self.rendered_content = markdown(self.raw_content)
        elif self.content_format == "md" and markdown is None:
            raise RuntimeError("Install Markdown to pubilsh markdown")
        else:  # Assume we've got html
            self.rendered_content = self.raw_content
525105
public function renderToolStyleContentAction()
    {

        $melisKey = $this->params()->fromRoute('melisKey', '');

        $translator = $this->getServiceLocator()->get('translator');


        // declare the Tool service that we will be using to completely create our tool.
        $melisTool = $this->getServiceLocator()->get('MelisCoreTool');

        // tell the Tool what configuration in the app.tool.php that will be used.
        $melisTool->setMelisToolKey('meliscms', 'meliscms_tool_styles');

        $view = new ViewModel();

        // get the columns that has been set in the configuration (app.tools.php)
        $columns = $melisTool->getColumns();

        // add an extra column which is Action
        $columns['actions'] = array('text' => $translator->translate('tr_meliscms_action'), 'css' => 'width:10%');

        // get the column texts set, this will be used in the thead table
        $view->tableColumns = $columns;

        $view->melisKey = $melisKey;

        $view->getToolDataTableConfig = $melisTool->getDataTableConfiguration();

        return $view;
    }
668781
public function render()
	{
		$a = Html::el('a', [
			'class' => [$this->class],
			'title' => $this->grid->getTranslator()->translate($this->getTitle()),
			'href' => $this->link,
		]);

		$this->tryAddIcon(
			$a,
			$this->getIcon(),
			$this->grid->getTranslator()->translate($this->getTitle())
		);

		$a->addText($this->grid->getTranslator()->translate($this->text));

		if ($this->isAjax()) {
			$a->class[] = 'ajax';
		}
		
		if ($this->confirmDialog !== null) {
			$a->setAttribute('data-datagrid-confirm', $this->confirmDialog);
		}
		
		
		return $a;
	}
1025076
public function renderTemplates()
    {
        $html = '';

        if ($this->getOption('debug')) {
            $html .= "\n\n<!-- Start Asset Template -->\n\n";
        }

        foreach ($this->templates as $name => $template) {
            if ($this->getOption('debug')) {
                $html .= sprintf("\n<!-- $name -->\n");
            }

            $html .= $template;
        }

        return $html;
    }
518321
public function render($markdown)
    {
        $ast = $this->docParser->parse($markdown);
        return $this->cliRenderer->renderBlock($ast);
    }