Get the rendered view code.

@throws Exception
@return string
@link http://koldy.net/docs/view#get-output
972167
public function getOutput(): string
    {
        $this->prepareFlush();
        $path = $this->getViewPath($this->view);

        if (!file_exists($path)) {
            throw new ResponseException("View ({$this->view}) not found on path={$path}");
        }

        ob_start(null, 0, PHP_OUTPUT_HANDLER_CLEANABLE | PHP_OUTPUT_HANDLER_FLUSHABLE | PHP_OUTPUT_HANDLER_REMOVABLE);

        require $path;

        return ob_get_clean();
    }
949455
public function render()
    {
        try{
            $output = '';

            $form = $this->resolve();

            $errors = $this->kernel->getErrors($this->form);

            $output = $this->kernel->render($form, $errors);

        } catch(\Exception $e){

            // todo log exception
            $output = '<error>'.$e->getMessage().'</error>';

        }

        return $output;
    }
1213819
public function get()
	{
		$__data = $this->data();

		// The contents of each view file is cached in an array for the
		// request since partial views may be rendered inside of for
		// loops which could incur performance penalties.
		$__contents = $this->load();

		ob_start() and extract($__data, EXTR_SKIP);

		// We'll include the view contents for parsing within a catcher
		// so we can avoid any WSOD errors. If an exception occurs we
		// will throw it out to the exception handler.
		try
		{
			eval('?>'.$__contents);
		}

		// If we caught an exception, we'll silently flush the output
		// buffer so that no partially rendered views get thrown out
		// to the client and confuse the user with junk.
		catch (\Exception $e)
		{
			ob_get_clean(); throw $e;
		}

		$content = ob_get_clean();

		// The view filter event gives us a last chance to modify the
		// evaluated contents of the view and return them. This lets
		// us do something like run the contents through Jade, etc.
		if (Event::listeners('view.filter'))
		{
			return Event::first('view.filter', array($content, $this->path));
		}

		return $content;
	}
64322
public function getView()
    {
        if (!empty($this->view)) {
            return $this->view;
        }

        $class = explode('\\', get_called_class());

        return 'merchant::form.'.strtolower(end($class));
    }
173980
public function render()
    {
        // Check if there is a valid view
        if (empty($this->view)) {
            throw new InvalidArgumentException(__METHOD__ . ': The view file given is a not valid view.');
        }

        // Load the view file
        $this->output = $this->executable ? include $this->view : file_get_contents($this->view);

        // Interpolate parameters on the view
        $this->output = StringHelper::interpolate($this->output, $this->parameters);

        return $this;
    }
859538
public function render()
    {
        $this->handleExportRequest(true);

        try {
            $this->build();
        } catch (\Exception $e) {
            return Handler::renderException($e);
        }

        return view($this->view, $this->variables())->render();
    }
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);
    }
894350
public function render()
    {
        if (! $this->display) {
            return;
        }

        $this->runBeforeRender();
        $this->checkRequired();
        $this->translate();

        $attributes = $this->getModifyAttributes();
        $this->attributes['id'] = $this->getId();

        if ($this->hasError()) {
            if (! isset($attributes['class']) || is_null($attributes['class'])) {
                $attributes['class'] = ' is-invalid';
            } else {
                $attributes['class'] .= ' is-invalid';
            }
        }

        return view($this->view, array_merge($this->getAttributes(), [
            'attributes' => $attributes,
            'id'         => $this->getId(),
            'old'        => $this->getOldValue(),
            'slug'       => $this->getSlug(),
            'oldName'    => $this->getOldName(),
            'typeForm'   => $this->typeForm ?? $this->vertical()->typeForm,
        ]))
            ->withErrors(session()->get('errors', app(ViewErrorBag::class)));
    }
553155
public function render()
    {
        foreach ($this->data as $key => $var_data) {
            $$key = $var_data;
        }

        ob_start();

        $app_template_file = CORDILLERA_APP_DIR.$this->_template.'.php';
        $cordillera_template_file = CORDILLERA_DIR.$this->_template.'.php';

        if (is_file($app_template_file)) {
            require_once $app_template_file;
        } elseif (!is_file($app_template_file) && is_file($cordillera_template_file)) {
            require_once $cordillera_template_file;
        } else {
            throw new Exception(
                translate('The view %s not found', [$this->_template]),
                500,
                Exception::VIEW
            );
        }

        $this->_output = ob_get_contents();

        ob_end_clean();

        if ($this->layout && !app()->request->isAjax() && !app()->controller->is_rest && app()->controller->response_type != 'json') {
            $this->_output = $this->layout->render($this->_output);
        }

        return $this->_output;
    }
580960
protected function render()
    {
        $presenter = $this->createPresenter($this->getRequiredTemplateVariable('Presenter'));

        try {
            $arguments = $this->getArguments($presenter);
            $result = call_user_func_array($presenter, $arguments);
        } catch(\Exception $e) {
            if ($this->throwRenderExceptions) {
                throw $e;
            }

            $this->Logger->error($e->getMessage() .
                    "\n\nURL: " . \URLUtils::fullUrl() .
                    "\n\nTemplate Vars:\n" . print_r($this->templateVars, true) .
                    (isset($arguments) ? "\n\n$presenter args:\n" . print_r($arguments, true) : '')
                );

            $result = '';
        }

        $this->setTemplateVariable('PRESENTER_RESULT', $result);

        // just return something so the template engine thinks
        // something happened.
        return array(array());
    }
288728
public function render()
    {
        try {
            $html = $this->html();

            if ($this->editable === true || Editor::isHistory()) {
                $html = $this->addAttributesToHtml($html);
            }

            return empty($html) ? $html : $this->before.$html.$this->after;
        } catch (\Exception $e) {
            if (App::environment() === 'local') {
                throw $e;
            }
        }
    }
319651
final function Render()
    {
        $this->output = '';
        $this->ReadTranslations();
        if ($this->BeforeInit())
        {
            return $this->output;
        }
        if ($this->Init())
        {
            return $this->output;
        }
        if ($this->BeforeGather())
        {
            return $this->output;
        }
        $this->GatherOutput();
        $this->AfterGather();
        return $this->output;        
    }
720130
final function render()
    {
        if ($this->_c__isNowRendering)
            return '';

        $this->_c__isNowRendering = true;


        # Render Bind View Models:
        #
        $makeCopyOfCurrentQueue = clone $this->queue;
        foreach($this->queue as $vc)
        {
            /** @var DecorateViewModel $vc */

            try
            {
                $vc->delegateRenderBy($this, $this->nextRoot);
                // prepare bind view model result into parent model
                $vc->assertRenderResult(
                    $vc_render = $vc->render()
                    , $this
                );

                if ( $vc->isFinal() )
                    $rFinal = (string) $vc_render;
            }
            catch (\Exception $e) {
                ## set render flag to false, render job is done
                $this->_c__isNowRendering = false;
                throw $e;
            }
        }

        $this->queue = $makeCopyOfCurrentQueue;
        $this->_c__isNowRendering = false;


        if ( isset($rFinal) )
            return $rFinal;

        # Then Render Self ...
        ## ... implement on extend classes
        return $this->_view->render();
    }
556407
public function render()
    {
        // Set the request arguments as GET parameters
        $_GET = $this->getRequestArguments();

        try {
            $this->controllerContext->getRequest()->setOriginalRequestMappingResults($this->validationErrors);

            // Render the content element
            $result = $this->beautify($GLOBALS['TSFE']->cObj->cObjGetSingle('RECORDS', $this->config));

            // In case of an error
        } catch (\Exception $e) {
            $result = '<pre class="error"><strong>'.$e->getMessage().'</strong>'.PHP_EOL
                      .$e->getTraceAsString().'</pre>';
        }

        return $result;
    }
1057994
public function render(): string
    {
        $view = $this->viewer->make($this->getView(), $this->getFormData());

        // Indicates that the form has been rendered at least once.
        // Then return its content.
        $this->rendered = true;

        return $view->render();
    }
1041984
public function render()
    {
        if (!$this->display) {
            return '';
        }

        Admin::script($this->script);

        return view($this->getView(), $this->variables());
    }
1142626
protected function getView()
    {
        $ret = "";
        if (null !== $this->getRequest()) {
            $ret = $this->getRequest()->attributes->get("_view", "");
        }

        return $ret;
    }