@param string|null $view

@return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
173604
public function render($view = null)
    {
        if (is_null($view)) {
            $view = config('navigation.view.badge', 'navigation::badge');
        }

        return view($view, $this->toArray());
    }
866251
public function render($view = null, $layout = null)
    {
        $content = parent::render($view, $layout);
        if ($this->response->type() == 'text/html') {
            return $content;
        }

        $this->Blocks->set('content', $this->output());
        $this->response->download($this->getFilename());

        return $this->Blocks->get('content');
    }
1225352
protected function loadView($view, $values = [])
    {


        if (isset($this->application[$view])) {
            return $this->application[$view];
        }

        $instance = $this->application->createInstance($view, [$values, $this->response, $this->getHandler()]);

        //Otherwise return an instance of Controller;
        return $this->application->shareInstance($instance, $view);
    }
485672
public function render($view = null) {
            // Automatically hide pagination whenever it is superfluous
            if ($this->config['auto_hide'] === true AND $this->total_pages <= 1) {
                return '';
            }

            if ($view === null) {
                // Use the view from config
                $view = $this->config['view'];
            }
            $tpl = \Meerkat\Twig\Twig::from_template($view);

            // Pass on the whole Pagination object
            //print '<pre>';
            //print_r(get_object_vars($this));
            //print '</pre>';
            return $tpl
                ->set(get_object_vars($this))
                ->set('page', $this)
                ->render();
        }
1068207
public function getFilters($view = null)
    {
        if (!$this->filters) {
            return false;
        }

        $this->filters = array_unique($this->filters);

        //$this->filters = array_unique($this->filters);
        $renderable = false;
        foreach ($this->filters as $filter) {
            if ($filter->renderable) {
                $renderable = true;
                break;
            }
        }
        if (!$renderable) {
            return false;
        }

        $this->attachScripts();

        return view(($view) ? $view : 'datatables-helpers::filters', [
                    'filters'  => $this->filters,
                    'selected' => $this->selected,
                    'route'    => $this->route,
                    'urls'     => [
                        'store'   => handles('antares/foundation::datatables/filters/store'),
                        'destroy' => handles('antares/foundation::datatables/filters/destroy'),
                        'update'  => handles('antares/foundation::datatables/filters/update'),
                    ],
                    'group'    => 'Groups'])->render();
    }
126555
public function getView(View $view)
    {
        if (!$view instanceof ContentValueView) {
            return null;
        }

        $viewType = $view->getViewType();
        $contentInfo = $view->getContent()->contentInfo;

        $legacyKernel = $this->getLegacyKernel();
        $legacyContentClosure = function (array $params) use ($contentInfo, $viewType, $legacyKernel) {
            return $legacyKernel->runCallback(
                function () use ($contentInfo, $viewType, $params) {
                    $tpl = eZTemplate::factory();
                    /**
                     * @var \eZObjectForwarder
                     */
                    $funcObject = $tpl->fetchFunctionObject('content_view_gui');
                    if (!$funcObject) {
                        return '';
                    }

                    // Used by XmlText field type
                    if (isset($params['objectParameters'])) {
                        if (isset($params['linkParameters']) && $params['linkParameters'] !== null) {
                            $linkParameters = $params['linkParameters'];
                        }
                        $tpl->setVariable('object_parameters', $params['objectParameters'], 'ContentView');
                    }
                    // Used by RichText field type
                    elseif (isset($params['embedParams'])) {
                        if (isset($params['embedParams']['link'])) {
                            $linkParameters = $params['embedParams']['link'];
                        }

                        if (isset($params['embedParams']['config'])) {
                            $tpl->setVariable('object_parameters', $params['embedParams']['config'], 'ContentView');
                        }
                    }

                    // Convert link parameters to Legacy Stack format
                    if (isset($linkParameters)) {
                        $tpl->setVariable(
                            'link_parameters',
                            $this->legalizeLinkParameters($linkParameters),
                            'ContentView'
                        );
                    }

                    $children = [];
                    $funcObject->process(
                        $tpl, $children, 'content_view_gui', false,
                        [
                            'content_object' => [
                                [
                                    eZTemplate::TYPE_ARRAY,
                                    // eZTemplate::TYPE_OBJECT does not exist because
                                    // it's not possible to create "inline" objects in
                                    // legacy template engine (ie objects are always
                                    // stored in a tpl variable).
                                    // TYPE_ARRAY is used here to allow to directly
                                    // retrieve the object without creating a variable.
                                    // (TYPE_STRING, TYPE_BOOLEAN, ... have the same
                                    // behaviour, see eZTemplate::elementValue())
                                    eZContentObject::fetch($contentInfo->id),
                                ],
                            ],
                            'view' => [
                                [
                                    eZTemplate::TYPE_STRING,
                                    $viewType,
                                ],
                            ],
                        ],
                        [], '', ''
                    );
                    if (\is_array($children) && isset($children[0])) {
                        return ezpEvent::getInstance()->filter('response/output', $children[0]);
                    }

                    return '';
                },
                false
            );
        };

        $this->decorator->setContentView(
            new ContentView($legacyContentClosure)
        );

        return $this->decorator;
    }
843535
public function render($view = null)
    {
        $this->findActivePage();
        $this->filterByAccessRights();
        $this->filterEmptyPages();

        $this->sort();

        if (is_null($view)) {
            $view = config('navigation.view.navigation', 'navigation::navigation');
        }

        return view($view, $this->toArray())->render();
    }
406505
public function render($view, array $data = null)
	{
		$engine = new Engine($this->templatePath);
		$template = new Template($engine);
		return $template->render($view, $data);
	}
49010
protected function initViewContentBlocks($view)
    {
        $view->setBlock(
            'content',
            $this->getRequest()->getControllerName() . '/' . $this->getRequest()->getActionName()
        );

        return $view;
    }
1084897
public function compose(View $view)
    {
        if ($this->overwriteDisabled($view)) {
            return $view;
        }

        $this->currentPath = collect(explode('/views/', $view->getPath()))->last();

        if (\View::exists($this->getNewView())) {
            $view->setPath($this->getNewPath());
        }

        return $view;
    }
435506
public function getStylesheets($view = null)
    {
        if($view === null) {
            $view = $this;
        }
        $result = '';
        foreach ($view->stylesheetMedia as $css) {
            $result .= $css->getBrowserCode() . "\n";
        }
        $view->stylesheetMedia = array();
        return $result;
    }
337972
public function getView(View $view)
    {
        if (($configHash = $this->matcherFactory->match($view)) === null) {
            return null;
        }

        // We can set the collection directly to the view, no need to go through DTO
        $view->addParameters([
            ContentView::QUERY_DEFINITION_COLLECTION_NAME => $this->getQueryDefinitionCollection($configHash, $view),
        ]);

        // Return DTO so that Configurator can set the data back to the $view
        return $this->getDTO($configHash);
    }
274131
public function getView($view) {
		$path = explode("/", $view);
		include (count($path) > 1) ? "src/views/" . $path[0] . "/" . $path[1] . ".php" : "src/views/" .$path[0] . "/index.php";
	}
7594
public function render($view = null)
    {
        if ($this->hasChild() && ! $this->hasClassProperty($class = config('navigation.class.has_child', 'treeview'))) {
            $this->setHtmlAttribute('class', $class);
        }

        $data = $this->toArray();

        if (! is_null($view)) {
            return view($view, $data)->render();
        }

        return app('sleeping_owl.template')->view('_partials.navigation.page', $data)->render();
    }
1295900
private function deriveView($view)
    {
        // Check if the view already exists as specified
        if(self::exists($view))
        {
            // It does so just return it
            return $view;
        }

        // Check if there are any namespaces yet
        if($this->namespaces === NULL)
        {
            // There aren't so grab the namespace information from the configuration file
            $this->namespaces = config('layout-view.namespaces');
        }

        // Check if the selected layout has been set
        if($this->selected_layout === NULL)
        {
            // It hasn't been, so set it based on the config values
            $this->selected_layout = config('layout-view.layout.selected');
        }

        // Check if the fallback layout has been set
        if($this->fallback_layout === NULL)
        {
            // It hasn't been, so set it based on the config values
            $this->fallback_layout = config('layout-view.layout.fallback');
        }

        // The view that will be rendered
        $target = NULL;

        // Cycle through all of the namespaces
        foreach($this->namespaces as $namespace)
        {
            // Does the namespace have the colons in it?
            if($namespace != '' && stripos($namespace, '::') === FALSE)
            {
                // Didn't exist, so append it
                $namespace .= '::';
            }

            // Derive the base view
            $derived = $namespace . (is_null($this->selected_layout) ? '' :  $this->selected_layout . '.') . $view;

            // Look to see if the view exists
            if(self::exists($derived))
            {
                // It does, so render it
                $target = $derived;
            }
            else
            {
                // It didn't so try in the fallback
                $derived = $namespace . (is_null($this->fallback_layout) ? '' : $this->fallback_layout .  '.') . $view;

                // Check if the fallback view exists
                if(self::exists($derived))
                {
                    $target = $derived;
                }
            }

            // Check if we found a match
            if($target !== NULL)
            {
                // We did, so no sense looping
                break;
            }
        }

        // Return the name of the view we found.
        return $target === NULL ? $view : $target;
    }
939386
protected function stringViewInstance($view, $data)
    {
        return new StringView($this, $this->engines->resolve('stringblade'), $view, null, $data);
    }
165609
public function make($view, $style = null)
    {
        $viewPath = $this->viewFinder->find($view);

        try {
            $stylePath = $this->styleFinder->find($style ?: $view);
        } catch (InvalidArgumentException $e) {
            $stylePath = null;
        }

        return new View($this->viewParser, $viewPath, $this->styleParser, $stylePath);
    }