Gets templateEngine property

@return TemplateEngineInterface
960394
public function getTemplateEngine()
    {
        if (null == $this->templateEngine) {
            Template::addPath(dirname(dirname(__DIR__)).'/templates');
            $template = (new Template())->initialize();
            $this->setTemplateEngine($template);
        }
        return $this->templateEngine;
    }
966202
protected static function getEngine(): ?string
    {
        static $engine = null;
        
        if ($engine === null) {
            if (extension_loaded('yaml')) {
                $engine = self::ENGINE_NATIVE;
            } else  {
                $engine = class_exists('\Symfony\Component\Yaml\Yaml')
                        ? self::ENGINE_SYMFONY
                        : self::ENGINE_NONE;
            }
        }
        
        return $engine;
    }
998154
public function getEngine($new = false)
    {
        if (!($this->engine instanceof \Twig_Environment) || $new) {
            $this->engine = new \Twig_Environment($this->getLoader(), $this->config->toArray());

            foreach (GlobalContainer::getExtensions() as $extension) {
                $this->engine->addExtension(clone $extension);
            }

            foreach ($this->extensions as $extension) {
                $this->engine->addExtension($extension);
            }

            foreach (GlobalContainer::getGlobals() as $name => $value) {
                $this->engine->addGlobal($name, $value);
            }

            if ($this->config->get('debug')) {
                $this->engine->addExtension($this->getDebugExtension());
            }
        }

        return $this->engine;
    }
906057
public function getTemplate($fileName='',$useEngine = false)
	{
		ob_start();
		$file = $this->getTemplateName($fileName);
		if($useEngine)
		{
			$this->view->display($file);
		}
		else
		{
			include $file;
		}
		return ob_get_clean();
	}
690395
public function getTemplate()
    {
        if (null === $this->template) {
            $this->template = $this->getTemplatePathDefault('layout');
        }

        return $this->template;
    }
585372
public function getEngine($new = false)
    {
        if (!$this->engine || $new) {
            $this->engine = new BladeEnvironment($this->getResolver(), $this->getFinder(), $this->getDispatcher());

            /** @var BladeCompiler $bladeCompiler */
            $bladeCompiler = $this->getCompiler()->getCompiler();

            foreach (GlobalContainer::getCompilers() as $name => $callback) {
                BladeExtending::extend($bladeCompiler, $name, $callback);
            }

            foreach ($this->getCustomCompilers() as $name => $callback) {
                BladeExtending::extend($bladeCompiler, $name, $callback);
            }

            foreach (GlobalContainer::getExtensions() as $name => $callback) {
                $bladeCompiler->extend($callback);
            }

            // B/C for 4.* and 5.*
            if (($rawTags = GlobalContainer::getRawTags()) && is_callable([$bladeCompiler, 'setRawTags'])) {
                $bladeCompiler->setRawTags($rawTags[0], $rawTags[1]);
            }

            if ($tags = GlobalContainer::getContentTags()) {
                $bladeCompiler->setContentTags($tags[0], $tags[1]);
            }

            if ($tags = GlobalContainer::getEscapedTags()) {
                $bladeCompiler->setEscapedContentTags($tags[0], $tags[1]);
            }
        }

        return $this->engine;
    }
177371
public function getTemplate()
    {
        if (empty($this->_template)) {

            if (! AnService::get('application.registry')->offsetExists('application-template')) {
                AnService::get('application.registry')->offsetSet('application-template', $this->_site_settings->template);
            }

            $template = AnService::get('application.registry')->offsetGet('application-template');
            $this->setTemplate(pick($template, 'base'));
        }

        return $this->_template;
    }
488482
public function getEngine()
    {
        if($this->engine) {
            return $this->engine;
        }

        //get the template path
        $path = eve()->path('template');

        //create engine
        $this->engine = eve('handlebars');

        //add helpers
        $helpers = include(__DIR__.'/helpers.php');

        foreach($helpers as $name => $callback) {
            $this->engine->registerHelper($name, $callback);
        }

        return $this->engine;
    }
179149
public function get(string $name): TemplateInterface
    {
        if (!isset($this->engines[$name])) {
            throw new InvalidArgumentException('Template engine "' . $name . '" is not known or registered');
        }

        return $this->engines[$name];
    }
637724
static function getEngine($template)
    {
        foreach (self::$engines as $pattern => $engine){
            if (fnmatch($pattern, $template)){
                if (is_string($engine)){
                    self::$engines[$pattern] = new $engine();
                }
                return self::$engines[$pattern];
            }
        }
        return null;
    }
338550
public function getTemplate()
    {
        if (is_null($this->_template)) {
            $this->_template = new \Slick\Form\Template\SelectMultiple();
        }
        return $this->_template;
    }
1202640
public function getLayoutFromTemplate($template)
	{
	    $content = file_get_contents($this->getTemplateFile($template));
	    
	    return $this->getEngineInstance()->getLayout($content);
	}
547016
public static function getEngine($engine = null)
    {
        is_null($engine) && $engine = Config::get('view_render_engine');
        return Cml::getContainer()->make('view_' . strtolower($engine));
    }
289950
public function getEngine($new = false)
    {
        if (!$this->engine || $new) {
            $this->engine = new PlatesEngine(
                dirname($this->config->get('path.found')),
                ltrim($this->config->get('extension', '.tpl'), '.')
            );

            foreach ($this->folders as $namespace => $folder) {
                $this->engine->addFolder($namespace, $folder['folder'], $folder['fallback']);
            }

            foreach ($this->extensions as $extension) {
                $this->engine->loadExtension($extension);
            }
        }

        return $this->engine;
    }
462473
public function getTemplate()
    {
        if (!$this->__template instanceof TemplateInterface)
        {
            //Make sure we have a template identifier
            if (!($this->__template instanceof ObjectIdentifier)) {
                $this->setTemplate($this->__template);
            }

            $options = array(
                'filters'   => $this->getConfig()->template_filters,
                'functions' => $this->getConfig()->template_functions,
            );

            $this->__template = $this->getObject($this->__template, $options);

            if(!$this->__template instanceof TemplateInterface)
            {
                throw new \UnexpectedValueException(
                    'Template: '.get_class($this->__template).' does not implement TemplateInterface'
                );
            }
        }

        return $this->__template;
    }
1217948
protected function getPropertyValue(\DOMElement $element, ContextInterface $context)
    {
        $value = $this->getPropertyCache($element);
        if ($value !== null) {
            return $value;
        }

        $propertyChild = $this->getPropertyChildValue($element, $context);
        if ($propertyChild instanceof ThingInterface) {
            return $this->setPropertyCache($element, $propertyChild);
        }

        // Return a string property value
        return $this->setPropertyCache($element, $this->getPropertyStringValue($element));
    }
699152
private function getTemplate()
    {
        if ($this->template) {
            return $this->template;
        }

        return $this->template = $this->twig->load('@EkynaCms/Editor/Block/tabs.html.twig');
    }