/src/legacy/Zikula/View.php

Large files files are truncated, but you can click here to view the full file

<?php
/**
 * Copyright Zikula Foundation 2009 - Zikula Application Framework
 *
 * This work is contributed to the Zikula Foundation under one or more
 * Contributor Agreements and licensed to You under the following license:
 *
 * @license GNU/LGPLv3 (or at your option, any later version).
 * @package Zikula_View
 *
 * Please see the NOTICE file distributed with this source code for further
 * information regarding copyright and licensing.
 */

use Zikula\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Zikula\Common\I18n\TranslatableInterface;
use Zikula\Core\Event\GenericEvent;

/**
 * Zikula_View class.
 */
class Zikula_View extends Smarty implements TranslatableInterface
{
    const CACHE_DISABLED = 0;
    const CACHE_ENABLED = 1;
    const CACHE_INDIVIDUAL = 2;

    /**
     * Translation domain of the calling module.
     *
     * @var string
     */
    public $domain;

    /**
     * Module info array, indexed by module name.
     *
     * @var array
     */
    public $module;

    /**
     * Module info.
     *
     * @var array
     */
    public $modinfo;

    /**
     * Top level module.
     *
     * @var string
     */
    public $toplevelmodule;

    /**
     * Type.
     *
     * @var integer
     */
    public $type;

    /**
     * Function.
     *
     * @var string
     */
    public $func;

    /**
     * Language.
     *
     * @var string
     */
    public $language;

    /**
     * Homepage flag.
     *
     * @var boolean
     */
    public $homepage;

    /**
     * Theme name.
     *
     * @var string
     */
    public $theme;

    /**
     * Theme info.
     *
     * @var array
     */
    public $themeinfo;

    /**
     * Base Url.
     *
     * @var string
     */
    public $baseurl;

    /**
     * Base Uri.
     *
     * @var string
     */
    public $baseuri;

    /**
     * The service manager instance.
     *
     * @var \Symfony\Component\DependencyInjection\ContainerBuilder
     */
    protected $container;

    /**
     * The event manager instance.
     *
     * @var EventDispatcher
     */
    protected $dispatcher;

    /**
     * Request object.
     *
     * @var \Symfony\Component\HttpFoundation\Request
     */
    protected $request;

    /**
     * Zikula controller.
     *
     * @var Zikula_AbstractController
     */
    protected $controller;

    /**
     * Cache Id.
     *
     * @var string
     */
    public $cache_id;

    /**
     * Whether or not to expose template.
     *
     * @var boolean
     */
    public $expose_template;

    /**
     * Template path (populated by fetch).
     *
     * @var string
     */
    protected $templatePath;

    /**
     * Templates.
     *
     * @var array
     */
    protected $templateCache = array();

    /**
     * Constructor.
     *
     * @param ContainerBuilder $container ServiceManager.
     * @param string           $moduleName     Module name ("zikula" for system plugins).
     * @param integer|null     $caching        Whether or not to cache (Zikula_View::CACHE_*) or use config variable (null).
     */
    public function __construct(ContainerBuilder $container, $moduleName = '', $caching = null)
    {
        $this->container = $container;
        $this->dispatcher = $this->container->get('event_dispatcher');
        $this->request = $this->container->get('request');

        // set the error reporting level
        $this->error_reporting = isset($container['error_reporting']) ? $container['error_reporting'] : E_ALL;
        $this->allow_php_tag = true;

        // get variables from input
        $module = $this->request->attributes->get('_module', null);
        $type   = $this->request->attributes->get('_controller', 'user');
        $func   = $this->request->attributes->get('_action', 'index');

        // set vars based on the module structures
        $this->homepage = empty($module) ? true : false;
        $this->type = strtolower(!$this->homepage ? $type : System::getVar('starttype'));
        $this->func = strtolower(!$this->homepage ? $func : System::getVar('startfunc'));

        // Initialize the module property with the name of
        // the topmost module. For Hooks, Blocks, API Functions and others
        // you need to set this property to the name of the respective module!
        $this->toplevelmodule = ModUtil::getName();

        if (!$moduleName) {
            $moduleName = $this->toplevelmodule;
        }
        $this->modinfo = ModUtil::getInfoFromName($moduleName);
        $this->module  = array($moduleName => $this->modinfo);

        // initialise environment vars
        $this->language = ZLanguage::getLanguageCode();
        $this->baseurl = System::getBaseUrl();
        $this->baseuri = System::getBaseUri();

        // system info
        $this->themeinfo = ThemeUtil::getInfo(ThemeUtil::getIDFromName(UserUtil::getTheme()));
        $this->theme = $this->themeinfo['directory'];

        //---- Plugins handling -----------------------------------------------
        // add plugin paths
        switch ($this->modinfo['type']) {
            case ModUtil::TYPE_MODULE :
                $mpluginPath = "modules/" . $this->modinfo['directory'] . "/Resources/views/plugins";
                break;
            case ModUtil::TYPE_SYSTEM :
                $mpluginPath = "system/" . $this->modinfo['directory'] . "/Rsources/views/plugins";
                break;
            default:
                $mpluginPath = "system/" . $this->modinfo['directory'] . "/Rsources/views/plugins";
        }

        // add standard plugin search path
        $this->plugins_dir = array();
        $this->addPluginDir('config/Resources/plugins'); // Official override
        $this->addPluginDir('config/plugins'); // Official override
        $this->addPluginDir(ZIKULA_ROOT.'/../src/legacy/viewplugins'); // Core plugins
        $this->addPluginDir("themes/$this->theme/Resources/views/plugins"); // Theme plugins
        $this->addPluginDir(SMARTY_DIR.'plugins'); // Smarty core plugins
        $this->addPluginDir($mpluginPath); // Plugins for current module

        // check if the 'type' parameter in the URL is admin and if yes,
        // include system/Admin/templates/plugins to the plugins_dir array
        if ($type === 'admin') {
            if (!$this instanceof Zikula_View_Theme) {
                $this->addPluginDir('system/AdminModule/Resources/views/plugins');
            } else {
                $this->load_filter('output', 'admintitle');
            }
        }

        //---- Cache handling -------------------------------------------------
        if ($caching && in_array((int)$caching, array(0, 1, 2))) {
            $this->caching = (int)$caching;
        } else {
            $this->caching = (int)ModUtil::getVar('Theme', 'render_cache');
        }

        $this->compile_id  = '';
        $this->cache_id    = '';

        // template compilation
        $this->compile_dir    = CacheUtil::getLocalDir('view_compiled');
        $this->compile_check  = ModUtil::getVar('Theme', 'render_compile_check');
        $this->force_compile  = ModUtil::getVar('Theme', 'render_force_compile');
        // template caching
        $this->cache_dir      = CacheUtil::getLocalDir('view_cache');
        $this->cache_lifetime = ModUtil::getVar('Theme', 'render_lifetime');

        $this->expose_template = (ModUtil::getVar('Theme', 'render_expose_template') == true) ? true : false;

        // register resource type 'z' this defines the way templates are searched
        // during {include file='my_template.tpl'} this enables us to store selected module
        // templates in the theme while others can be kept in the module itself.
        $this->register_resource('z', array('Zikula_View_Resource',
                                            'z_get_template',
                                            'z_get_timestamp',
                                            'z_get_secure',
                                            'z_get_trusted'));

        // set 'z' as default resource type
        $this->default_resource_type = 'z';

        // process some plugins specially when Render cache is enabled
        if (!$this instanceof Zikula_View_Theme && $this->caching) {
            $this->register_nocache_plugins();
        }

        // register the 'nocache' block to allow dynamic zones caching templates
        $this->register_block('nocache', array('Zikula_View_Resource', 'block_nocache'), false);

        // For ajax requests we use the short urls filter to 'fix' relative paths
        if (($this->container->get('zikula')->getStage() & \Zikula\Core\Core::STAGE_AJAX) && System::getVar('shorturls')) {
            $this->load_filter('output', 'shorturls');
        }

        // register prefilters
        $this->register_prefilter('z_prefilter_add_literal');

        $this->register_prefilter('z_prefilter_gettext_params');

        // assign some useful settings
        $this->assign('homepage', $this->homepage)
             ->assign('modinfo', $this->modinfo)
             ->assign('module', $moduleName)
             ->assign('toplevelmodule', $this->toplevelmodule)
             ->assign('type', $this->type)
             ->assign('func', $this->func)
             ->assign('lang', $this->language)
             ->assign('themeinfo', $this->themeinfo)
             ->assign('themepath', $this->baseurl . 'themes/' . $this->theme)
             ->assign('baseurl', $this->baseurl)
             ->assign('baseuri', $this->baseuri);

        // for {gt} template plugin to detect gettext domain
        if ($this->modinfo['type'] == ModUtil::TYPE_MODULE) {
            $this->domain = ZLanguage::getModuleDomain($this->modinfo['name']);
        }

        // make render object available to modifiers
        parent::assign('zikula_view', $this);

        // add ServiceManager, EventManager and others to all templates
        parent::assign('container', $this->container);
        parent::assign('dispatcher', $this->dispatcher);
        parent::assign('zikula_core', $this->container->get('zikula'));
        parent::assign('request', $this->request);
        parent::assign('modvars', ModUtil::getModvars()); // Get all modvars from any modules that have accessed their modvars at least once.

        $this->add_core_data();

        // metadata for SEO
        if (!isset($this->container['zikula_view.metatags'])) {
            $this->container['zikula_view.metatags'] = new ArrayObject(array());
        }

        parent::assign('metatags', $this->container['zikula_view.metatags']);

        $event = new GenericEvent($this);
        $this->dispatcher->dispatch('view.init', $event);
    }

    /**
     * Setup the current instance of the Zikula_View class and return it back to the module.
     *
     * @param string       $module   Module name.
     * @param integer|null $caching  Whether or not to cache (Zikula_View::CACHE_*) or use config variable (null).
     * @param string       $cache_id Cache Id.
     *
     * @return Zikula_View This instance.
     */
    public static function getInstance($module = null, $caching = null, $cache_id = null)
    {
        if (is_null($module)) {
            $module = ModUtil::getName();
        }

        $module = preg_match('/\w+Module$/', $module) ? $module : $module.'Module';

        $container = ServiceUtil::getManager();
        $serviceId = strtolower(sprintf('zikula.view.%s', $module));
        if (!$container->has($serviceId)) {
            $view = new self($container, $module, $caching);
            $container->set($serviceId, $view);
        } else {
            $view = $container->get($serviceId);
        }

        if (!is_null($caching)) {
            $view->caching = (int)$caching;
        }

        if (!is_null($cache_id)) {
            $view->cache_id = $cache_id;
        }

        if (!$module) {
            $module = $view->toplevelmodule;
        }

//        if (!array_key_exists($module, $view->module)) {
            $view->module[$module] = ModUtil::getInfoFromName($module);
            $view->_add_plugins_dir($module);
//        }

        // for {gt} template plugin to detect gettext domain
        if ($view->module[$module]['type'] == ModUtil::TYPE_MODULE) {
            $view->domain = ZLanguage::getModuleDomain($view->module[$module]['name']);
        }

        return $view;
    }

    /**
     * Get module plugin Zikula_View_Plugin instance.
     *
     * @param string       $modName    Module name.
     * @param string       $pluginName Plugin name.
     * @param integer|null $caching    Whether or not to cache (Zikula_View::CACHE_*) or use config variable (null).
     * @param string       $cache_id   Cache Id.
     *
     * @return Zikula_View_Plugin The plugin instance.
     */
    public static function getModulePluginInstance($modName, $pluginName, $caching = null, $cache_id = null)
    {
        return Zikula_View_Plugin::getInstance($modName, $pluginName, $caching, $cache_id);
    }

    /**
     * Get system plugin Zikula_View_Plugin instance.
     *
     * @param string       $pluginName Plugin name.
     * @param integer|null $caching    Whether or not to cache (Zikula_View::CACHE_*) or use config variable (null).
     * @param string       $cache_id   Cache Id.
     *
     * @return Zikula_View_Plugin The plugin instance.
     */
    public static function getSystemPluginInstance($pluginName, $caching = null, $cache_id = null)
    {
        $modName = 'zikula';

        return Zikula_View_Plugin::getPluginInstance($modName, $pluginName, $caching, $cache_id);
    }

    /**
     * Internal registration of Zikula core's plugins sensible to cache.
     *
     * Basically the user-based ones and those that has relation with the theme/pagevars.
     *
     * @return void
     */
    protected function register_nocache_plugins()
    {
        // disables the cache for them and do not load them yet
        // that happens later when required
        $delayed_load = true;
        $cacheable    = false;

        //// blocks
        // checkgroup
        Zikula_View_Resource::register($this, 'block', 'checkgroup', $delayed_load, $cacheable, array('gid'));
        // checkpermissionblock
        Zikula_View_Resource::register($this, 'block', 'checkpermissionblock', $delayed_load, $cacheable, array('component', 'instance'));
        // pageaddvarblock
        Zikula_View_Resource::register($this, 'block', 'pageaddvarblock', $delayed_load, $cacheable, array('name'));

        //// plugins
        // ajaxheader
        Zikula_View_Resource::register($this, 'function', 'ajaxheader', $delayed_load, $cacheable, array('modname', 'filename', 'noscriptaculous', 'validation', 'lightbox', 'imageviewer', 'assign'));
        // assign_cache
        Zikula_View_Resource::register($this, 'function', 'assign_cache', $delayed_load, $cacheable, array('var', 'value'));
        // checkpermission
        Zikula_View_Resource::register($this, 'function', 'checkpermission', $delayed_load, $cacheable, array('component', 'instance', 'level', 'assign'));
        // formutil_getfieldmarker
        Zikula_View_Resource::register($this, 'function', 'formutil_getfieldmarker', $delayed_load, $cacheable, array('objectType', 'validation', 'field', 'assign'));
        // formutil_getpassedvalue
        Zikula_View_Resource::register($this, 'function', 'formutil_getpassedvalue', $delayed_load, $cacheable, array('assign', 'html', 'key', 'name', 'default', 'source', 'noprocess'));
        // formutil_getvalidationerror
        Zikula_View_Resource::register($this, 'function', 'formutil_getvalidationerror', $delayed_load, $cacheable, array('objectType', 'field', 'assign'));
        // notifydisplayhooks
        Zikula_View_Resource::register($this, 'function', 'notifydisplayhooks', $delayed_load, $cacheable, array('eventname', 'id', 'urlobject', 'assign'));
        // notifyevent
        Zikula_View_Resource::register($this, 'function', 'notifyevent', $delayed_load, $cacheable, array('eventname', 'eventsubject', 'eventdata', 'assign'));
        // pageaddvar
        Zikula_View_Resource::register($this, 'function', 'pageaddvar', $delayed_load, $cacheable, array('name', 'value'));
        // pagegetvar
        Zikula_View_Resource::register($this, 'function', 'pagegetvar', $delayed_load, $cacheable, array('name', 'html', 'assign'));
        // pager
        Zikula_View_Resource::register($this, 'function', 'pager', $delayed_load, $cacheable, array('modname', 'type', 'func', 'rowcount', 'limit', 'posvar', 'owner', 'template', 'includeStylesheet', 'anchorText', 'maxpages', 'display', 'class', 'processDetailLinks', 'processUrls', 'optimize'));
        // pageregistervar
        Zikula_View_Resource::register($this, 'function', 'pageregistervar', $delayed_load, $cacheable, array('name'));
        // pagesetvar
        Zikula_View_Resource::register($this, 'function', 'pagesetvar', $delayed_load, $cacheable, array('name', 'value'));
        // servergetvar
        Zikula_View_Resource::register($this, 'function', 'servergetvar', $delayed_load, $cacheable, array('name', 'default', 'assign'));
        // sessiondelvar
        Zikula_View_Resource::register($this, 'function', 'sessiondelvar', $delayed_load, $cacheable, array('name', 'path', 'assign'));
        // sessiongetvar
        Zikula_View_Resource::register($this, 'function', 'sessiongetvar', $delayed_load, $cacheable, array('name', 'assign', 'default', 'path'));
        // sessionsetvar
        Zikula_View_Resource::register($this, 'function', 'sessionsetvar', $delayed_load, $cacheable, array('name', 'value', 'path', 'assign'));
        // setmetatag
        Zikula_View_Resource::register($this, 'function', 'setmetatag', $delayed_load, $cacheable, array('name', 'value'));
        // themegetvar
        Zikula_View_Resource::register($this, 'function', 'themegetvar', $delayed_load, $cacheable, array('name', 'default', 'assign'));
        // themesetvar
        Zikula_View_Resource::register($this, 'function', 'themesetvar', $delayed_load, $cacheable, array('name', 'value'));
        // user
        Zikula_View_Resource::register($this, 'function', 'user', $delayed_load, $cacheable);
        // useravatar - without uid caching
        Zikula_View_Resource::register($this, 'function', 'useravatar', $delayed_load, $cacheable);
        // usergetvar
        Zikula_View_Resource::register($this, 'function', 'usergetvar', $delayed_load, $cacheable, array('assign', 'default', 'name', 'uid'));
        // userlinks
        Zikula_View_Resource::register($this, 'function', 'userlinks', $delayed_load, $cacheable, array('start', 'end', 'seperator'));
        // userloggedin
        Zikula_View_Resource::register($this, 'function', 'userloggedin', $delayed_load, $cacheable, array('assign'));
        // userwelcome
        Zikula_View_Resource::register($this, 'function', 'userwelcome', $delayed_load, $cacheable);
        // zdebug
        Zikula_View_Resource::register($this, 'function', 'zdebug', $delayed_load, $cacheable);
    }

    /**
     * Checks whether requested template exists.
     *
     * @param string $template Template name.
     *
     * @return boolean
     */
    public function template_exists($template)
    {
        return (bool)$this->get_template_path($template);
    }

    /**
     * Checks which path to use for required template.
     *
     * @param string $template Template name.
     *
     * @return string Template path.
     */
    public function get_template_path($template)
    {
        if (isset($this->templateCache[$template])) {
            return $this->templateCache[$template];
        }

        // the current module
        $modname = ModUtil::getName();

        foreach ($this->module as $module => $modinfo) {
            // prepare the values for OS
            $module = $modinfo['name'];

            $os_module = DataUtil::formatForOS($module);
            $os_dir = $modinfo['type'] == ModUtil::TYPE_MODULE ? 'modules' : 'system';

            $ostemplate = DataUtil::formatForOS($template);

            if (is_dir("$os_dir/$os_module/Resources/views")) {
                $relativepath = "$os_dir/$os_module/Resources/views";
            }

            $templatefile = "$relativepath/$ostemplate";
            $override = self::getTemplateOverride($templatefile);
            if ($override === false) {
                // no override present
                if (is_readable($templatefile)) {
                    $this->templateCache[$template] = $relativepath;
                    return $relativepath;
                } else {
                    return false;
                }
            } else {
                if (is_readable($override)) {
                    $path = substr($override, 0, strrpos($override, $ostemplate));
                    $this->templateCache[$template] = $path;

                    return $path;
                }
            }
        }

        // when we arrive here, no path was found
        return false;
    }

    /**
     * Add core data to the template.
     *
     * This function adds some basic data to the template depending on the
     * current user and the Zikula settings.  There is no need to call this as it's
     * invoked automatically on instanciation.
     *
     * @return Zikula_View
     */
    public function add_core_data()
    {
        if (!isset($this->container['zikula_view.coredata'])) {
            $this->container['zikula_view.coredata'] = new ArrayObject(array());
        }

        $core = $this->container['zikula_view.coredata'];
        $core['version_num'] = \Zikula\Core\Core::VERSION_NUM;
        $core['version_id'] = \Zikula\Core\Core::VERSION_ID;
        $core['version_sub'] = \Zikula\Core\Core::VERSION_SUB;
        $core['logged_in'] = UserUtil::isLoggedIn();
        $core['language'] = $this->language;

        // add userdata
        $core['user']   = UserUtil::getVars($this->request->getSession()->get('uid'));

        // Module vars
        parent::assign('coredata', $core);

        return $this;
    }

    /**
     * Executes & returns the template results.
     *
     * This returns the template output instead of displaying it.
     * Supply a valid template name.
     * As an optional second parameter, you can pass a cache id.
     * As an optional third parameter, you can pass a compile id.
     *
     * @param string  $template   The name of the template.
     * @param string  $cache_id   The cache ID (optional).
     * @param string  $compile_id The compile ID (optional).
     * @param boolean $display    Whether or not to display directly (optional).
     * @param boolean $reset      Reset singleton defaults (optional). deprecated.
     *
     * @return string The template output.
     */
    public function fetch($template, $cache_id = null, $compile_id = null, $display = false, $reset = true)
    {
        $this->_setup_template($template);

        if (is_null($cache_id)) {
            $cache_id = $this->cache_id;
        }

        if (is_null($compile_id)) {
            $compile_id = $this->compile_id;
        }

        $this->template = $this->template_dir . '/' . $template;
        $output = $this->_fetch($template, $cache_id, $compile_id, $display);

        if ($this->expose_template == true) {
            $template = DataUtil::formatForDisplay($template);
            $output = "\n<!-- Start " . $this->template_dir . "/$template -->\n" . $output . "\n<!-- End " . $this->template_dir . "/$template -->\n";
        }

        $event = new GenericEvent($this, array('template' => $template), $output);
        try {
            $this->dispatcher->dispatch('view.postfetch', $event);
            $data = $event->getData();
        } catch (Exception $e) {
            var_dump($e->getMessage());
        }
        return $data;
    }

    /**
     * Executes & displays the template results.
     *
     * This displays the template.
     * Supply a valid template name.
     * As an optional second parameter, you can pass a cache id.
     * As an optional third parameter, you can pass a compile id.
     *
     * @param string $template   The name of the template.
     * @param string $cache_id   The cache ID (optional).
     * @param string $compile_id The compile ID (optional).
     *
     * @return boolean
     */
    public function display($template, $cache_id = null, $compile_id = null)
    {
        echo $this->fetch($template, $cache_id, $compile_id);

        return true;
    }

    /**
     * Returns an auto_id for auto-file-functions.
     *
     * @param string $cache_id   The cache ID (optional).
     * @param string $compile_id The compile ID (optional).
     *
     * @return string|null The auto_id, or null if neither $cache_id nor $compile_id are set.
     */
    public function _get_auto_id($cache_id=null, $compile_id=null)
    {
        if (!empty($cache_id)) {
            $this->_filter_auto_id($cache_id);
        }
        if (!empty($compile_id)) {
            $this->_filter_auto_id($compile_id);
        }

        $auto_id = $cache_id . (!empty($compile_id) ? '/'.$compile_id  : '');

        $auto_id = trim($auto_id, '/');

        return $auto_id;
    }

    /**
     * utility method to filter the IDs of not desired chars.
     *
     * @param string &$id Cache or compile ID to filter.
     *
     * @return void
     */
    protected function _filter_auto_id(&$id)
    {
        // convert some chars used as separators
        $id = str_replace(array(':', '=', ','), '_', $id);
        // convert the "Smarty cache groups" | to paths
        $id = str_replace('|', '/', $id);
        // and remove anything outside the acceptable range
        $id = preg_replace('#[^a-zA-Z0-9-_/]+#', '', $id);
    }

    /**
     * Get a concrete filename for automagically created content.
     *
     * @param string $path        The base path.
     * @param string $auto_source The file name (optional).
     * @param string $auto_id     The ID (optional).
     *
     * @return string The concrete path and file name to the content.
     */
    public function _get_auto_filename($path, $auto_source = null, $auto_id = null, $themedir = null)
    {
        // enables a flags to detect when is treating compiled templates
        $tocompile = ($path == $this->compile_dir) ? true : false;

        // format auto_source for os to make sure that id does not contain 'ugly' characters
        $auto_source = DataUtil::formatForOS($auto_source);

        // build a hierarchical directory path
        $path .= '/' . $this->modinfo['directory'];

        if ($this instanceof Zikula_View_Plugin) {
            $path .= '_' . $this->pluginName;
        }

        // add the cache_id path if set
        $path .= !empty($auto_id) ? '/' . $auto_id : '';

        // takes in account the source subdirectory
        $path .= strpos($auto_source, '/') !== false ? '/' . dirname($auto_source) : '';

        // make sure the path exists to write the compiled/cached template there
        if (!file_exists($path)) {
            mkdir($path, $this->container['system.chmod_dir'], true);
        }

        // if there's a explicit source, it
        if ($auto_source) {
            $path .= '/';

            $extension = FileUtil::getExtension($auto_source);

            // isolates the filename on the source path passed
            $path .= FileUtil::getFilebase($auto_source);

            // add theme and language to our path
            if (empty($themedir)) $themedir = $this->themeinfo['directory'];
            $path .= '--t_'.$themedir.'-l_' . $this->language;

            // if we are not compiling, end with a suffix
            if (!$tocompile) {
                $path .= ($extension ? ".$extension" : '');
            }
        }

        return $path;
    }

    /**
     * Finds out if a template is already cached.
     *
     * This returns true if there is a valid cache for this template.
     *
     * @param string $template   The name of the template.
     * @param string $cache_id   The cache ID (optional).
     * @param string $compile_id The compile ID (optional).
     *
     * @return boolean
     */
    public function is_cached($template, $cache_id = null, $compile_id = null)
    {
        if (is_null($cache_id)) {
            $cache_id = $this->cache_id;
        }

        if (is_null($compile_id)) {
            $compile_id = $this->compile_id;
        }

        return parent::is_cached($template, $cache_id, $compile_id);
    }

    /**
     * Internal function to delete cache of templates.
     *
     * @param string  $tplpath  Relative template path.
     * @param string  $template Template partial filename.
     * @param integer $expire   Expire limit of the cached templates.
     *
     * @return boolean True on success, false otherwise
     */
    protected function rmtpl($tplpath, $template, $expire = null)
    {
       if (!$template || !is_dir($tplpath) || !is_readable($tplpath)) {
           return false;
       }

       $filebase = FileUtil::getFilebase($template);

       $dh = opendir($tplpath);
       while (($entry = readdir($dh)) !== false) {
           if ($entry != '.' && $entry != '..') {
               $path = $tplpath . DIRECTORY_SEPARATOR . $entry;

               if (is_dir($path)) {
                   // search recusively
                   $this->rmtpl($path, $template, $expire);
               } elseif (strpos($entry, $filebase) === 0) {
                   // delete the files that matches the template base filename
                   $this->_unlink($path, $expire);
               }
           }
       }
       closedir($dh);

       return true;
    }

    /**
     * Internal function to delete cache directories and files.
     *
     * @param string  $dirname Relative cache directory path.
     * @param integer $expire  Expire limit of the cached templates.
     * @param boolean $rmbase  Remove the passed directory too (default: true).
     *
     * @return boolean True on success, false otherwise.
     */
    protected function rmdir($dirname, $expire = null, $rmbase = true)
    {
       if (!is_dir($dirname) || !is_readable($dirname)) {
           return false;
       }

       $dh = opendir($dirname);
       while (($entry = readdir($dh)) !== false) {
           if ($entry != '.' && $entry != '..' && $entry != 'index.html') {
               $path = $dirname . DIRECTORY_SEPARATOR . $entry;

               if (is_dir($path)) {
                   // remove recursively
                   $this->rmdir($path, $expire, true);
               } elseif ($expire !== false) {
                   // check expiration time of cached templates
                   $this->_unlink($path, $expire);
               } else {
                   // delete compiled templates directly
                   unlink($path);
               }
           }
       }
       closedir($dh);

       if ($rmbase) {
           return rmdir($dirname);
       }

       return true;
    }

    /**
     * Clears a temporary folder for a auto_id and/or template.
     *
     * This returns true if the operation was successful.
     *
     * @param string $tmpdir   Name of the temporary folder to clear.
     * @param string $auto_id  The cache and compile ID.
     * @param string $template The name of the template.
     * @param string $expire   Minimum age in sec. the cache file must be before it will get cleared (optional).
     *
     * @return boolean
     */
    protected function clear_folder($tmpdir, $auto_id = null, $template = null, $expire = null, $themedir = null)
    {
        if (!$auto_id && !$template) {
            $result = $this->rmdir($tmpdir, $expire, false);

        } else {
            $autofolder = $this->_get_auto_filename($tmpdir, null, $auto_id, $themedir);

            if ($template) {
                $result = $this->rmtpl($autofolder, $template, $expire);
            } else {
                $result = $this->rmdir($autofolder, $expire);
            }
        }

        return $result;
    }

    /**
     * Clears the cache for a specific template or cache_id.
     *
     * @param string $template   The name of the template.
     * @param string $cache_id   The cache ID (optional).
     * @param string $compile_id The compile ID (optional).
     * @param string $expire     Minimum age in sec. the cache file must be before it will get cleared (optional).
     *
     * @return boolean True on success, false otherwise.
     */
    public function clear_cache($template = null, $cache_id = null, $compile_id = null, $expire = null, $themedir = null)
    {
        if (is_null($compile_id) && $template) {
            $compile_id = $this->compile_id;
        }

        $auto_id = $this->_get_auto_id($cache_id, $compile_id);

        return $this->clear_folder($this->cache_dir, $auto_id, $template, $expire, $themedir);
    }

    /**
     * Clears all view cache for a module.
     *
     * @return boolean True on success, false otherwise.
     */
    public function clear_cache_module($moduledir = null)
    {
        if (is_null($moduledir)) {
            $moduledir = $this->modinfo['directory'];
        }

        return $this->clear_folder($this->cache_dir .'/'. $moduledir);
    }

    /**
     * Clear all compiled templates.
     *
     * Needs to clear the cache too as non cached plugins information will need regeneration too.
     *
     * @return boolean True if success, false otherwise.
     */
    public function clear_compiled()
    {
        if ($this->clear_folder($this->compile_dir, null, null, false)) {
            return $this->clear_all_cache();
        }

        return false;
    }

    /**
     * Clear all cached templates.
     *
     * @param string $expire Expire time.
     *
     * @return boolean Results of clear_cache with null parameters.
     */
    public function clear_all_cache($expire = null)
    {
        return $this->clear_cache(null, null, null, $expire);
    }

    /**
     * Set up paths for the template.
     *
     * This function sets the template and the config path according
     * to where the template is found (Theme or Module directory)
     *
     * @param string $template The template name.
     *
     * @return void
     */
    public function _setup_template($template)
    {
        // default directory for templates
        $this->template_dir = $this->get_template_path($template);
        $this->templatePath = $this->template_dir . '/' . $template;
        $this->config_dir   = $this->template_dir . '/config';
    }

    /**
     * Add a plugin dir to the search path.
     *
     * Avoids adding duplicates.
     *
     * @param string  $dir  The directory to add.
     * @param boolean $push Whether to push the new dir to the bottom of the stack (default: true).
     *
     * @return Zikula_View This instance.
     */
    public function addPluginDir($dir, $push=true)
    {
        if (in_array($dir, $this->plugins_dir) || !@is_dir($dir)) {
            return $this;
        }

        if ($push) {
            array_push($this->plugins_dir, $dir);
        } else {
            $this->plugins_dir = array_merge(array($dir), $this->plugins_dir);
        }

        return $this;
    }

    /**
     * add a plugins dir to _plugin_dir array
     *
     * This function takes  module name and adds two path two the plugins_dir array
     * when existing
     *
     * @param string $module Well known module name.
     *
     * @return void
     */
    protected function _add_plugins_dir($module)
    {
        if (empty($module)) {
            return;
        }

        $modinfo = ModUtil::getInfoFromName($module);
        if (!$modinfo) {
            return;
        }

        $modpath = ($modinfo['type'] == ModUtil::TYPE_SYSTEM) ? 'system' : 'modules';
        if (is_dir("$modpath/$modinfo[directory]/Resources/views/plugins")) {
            $this->addPluginDir("$modpath/$modinfo[directory]/Resources/views/plugins");
        }
    }

    /**
     * Execute a template override event.
     *
     * @param string $template Path to template.
     *
     * @throws InvalidArgumentException If event handler returns a non-existent template.
     *
     * @return mixed String if found, false if no override present.
     */
    public static function getTemplateOverride($template)
    {
        $event = new GenericEvent(null, array(), $template);
        EventUtil::getManager()->dispatch('zikula_view.template_override', $event);

        if ($event->isPropagationStopped()) {
            $ostemplate = DataUtil::formatForOS($event->getData());
            if (is_readable($ostemplate)) {
                return $ostemplate;
            } else {
                throw new InvalidArgumentException(__f('zikula_view.template_override returned a non-existent template path %s', $ostemplate));
            }
        }

        return false;
    }

    /**
     * Assign variable to template.
     *
     * @param string $key   Variable name.
     * @param mixed  $value Value.
     *
     * @return Zikula_View
     */
    public function assign($key, $value = null)
    {
        $this->_assign_check($key);
        parent::assign($key, $value);

        return $this;
    }

    /**
     * Assign variable to template by reference.
     *
     * @param string $key Variable name.
     * @param mixed  &$value Value.
     *
     * @return Zikula_View
     */
    public function assign_by_ref($key, &$value)
    {
        $this->_assign_check($key);
        parent::assign_by_ref($key, $value);

        return $this;
    }

    /**
     * Prevent certain variables from being overwritten.
     *
     * @param string $key The protected variable key.
     *
     * @return void
     */
    protected function _assign_check($key)
    {
        if (is_array($key)) {
            foreach ($key as $v) {
                self::_assign_check($v);
            }

            return;
        }

        if (is_string($key)) {
            switch (strtolower($key)) {
                case 'zikula_view':
                case 'zikula_core':
                case 'modvars':
                case 'metatags':
                case 'coredata':
                case 'servicemanager':
                case 'eventmanager':
                    $this->trigger_error(__f('%s is a protected template variable and may not be assigned', $key));
                    break;
            }
        }
    }

    /**
     * Translate.
     *
     * @param string $msgid String to be translated.
     *
     * @return string The $msgid translated by gettext.
     */
    public function __($msgid)
    {
        return __($msgid, $this->domain);
    }

    /**
     * Translate with sprintf().
     *
     * @param string       $msgid  String to be translated.
     * @param string|array $params Args for sprintf().
     *
     * @return string The $msgid translated by gettext.
     */
    public function __f($msgid, $params)
    {
        return __f($msgid, $params, $this->domain);
    }

    /**
     * Translate plural string.
     *
     * @param string $singular Singular instance.
     * @param string $plural   Plural instance.
     * @param string $count    Object count.
     *
     * @return string Translated string.
     */
    public function _n($singular, $plural, $count)
    {
        return _n($singular, $plural, $count, $this->domain);
    }

    /**
     * Translate plural string with sprintf().
     *
     * @param string       $sin    Singular instance.
     * @param string       $plu    Plural instance.
     * @param string       $n      Object count.
     * @param string|array $params Sprintf() arguments.
     *
     * @return string The $sin or $plu translated by gettext, based on $n.
     */
    public function _fn($sin, $plu, $n, $params)
    {
        return _fn($sin, $plu, $n, $params, $this->domain);
    }

    /**
     * Retrieves the gettext domain for the module, as {@link ZLanguage::getModuleDomain()}.
     *
     * If the module is a system module this is not set.
     *
     * @return string The gettext domain for the module, or null for system modules.
     */
    public function getDomain()
    {
        return $this->domain;
    }

    /**
     * Retrieve an array of module information, indexed by module name.
     *
     * @return array An array containing the module info, indexed by module name.
     */
    public function getModule()
    {
        return $this->module;
    }

    /**
     * Retrieve the module info array for the top-level module (or the module specified in the constructor).
     *
     * @return array The module info array.
     */
    public function getModInfo()
    {
        return $this->modinfo;
    }

    /**
     * Retrieve the name of the top-level module.
     *
     * @return string The name of the top-level module.
     */
    public function getTopLevelModule()
    {
        return $this->toplevelmodule;
    }

    /**
     * Retrieve module name.
     *
     * @return string Module name.
     */
    public function getModuleName()
    {
        return $this->toplevelmodule;
    }

    /**
     * Retrive the name of the controller type.
     *
     * @return string The name of the controller type.
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Retrive the name of the controller function.
     *
     * @return string The name of the controller function.
     */
    public function getFunc()
    {
        return $this->func;
    }

    /**
     * Retrieve the current language code.
     *
     * @return string The current language code.
     */
    public function getLanguage()
    {
        return $this->language;
    }

    /**
     * Retrieve the name of the current theme.
     *
     * @return string The name of the current theme.
     */
    public function getTheme()
    {
        return $this->theme;
    }

    /**
     * Retrieve the theme info array for the current theme.
     *
     * @param string $key Field to retrieve of the theme info.
     *
     * @return array The theme info array.
     */
    public function getThemeInfo($key=null)
    {
        if ($key && array_key_exists($key, $this->themeinfo)) {
            return $this->themeinfo[$key];
        }

        return $this->themeinfo;
    }

    /**
     * Set a value or all the theme info array.
     *
     * @param mixed  $value Value to assign.
     * @param string $key   Field to set on the theme info.
     *
     * @return void
     */
    public function setThemeInfo($value, $key=null)
    {
        if ($key) {
            $this->themeinfo[$key] = $value;
        }

        $this->themeinfo = $value;
    }

    /**
     * Retrieve the site's base URL.
     *
     * The value returned is the same as {@link System::getBaseUrl()}.
     *
     * @return string The base URL.
     */
    public function getBaseUrl()
    {
        return $this->baseurl;
    }

    /**
     * Retrieve the site's base URI.
     *
     * The value returned is the same as {@link System::getBaseUri()}.
     *
     * @return string The base URI.
     */
    public function getBaseUri()
    {
        return $this->baseuri;
    }

    /**
     * Gets DependencyInjection container.
     *
     * @return ContainerBuilder The service manager.
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * Get EventDispatcher.
     *
     * @return EventDispatcher The event manager.
     */
    public function getDispatcher()
    {
        return $this->dispatcher;
    }

    /**
     * Get the request.
     *
     * @return \Symfony\Component\HttpFoundation\Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Get the Zikula controller.
     *
     * @return \Zikula\Framework\Controller\AbstractController
     */
    public function getController()
    {
        return $this->controller;
    }

    /**
     * Set the controller property.
     *
     * @param \Zikula\Framework\Controller\AbstractController $controller Controller to set.
     *
     * @return void
     */
    public function setController(\Zikula\Framework\Controller\AbstractController $controller)
    {
        $this->controller = $controller;
    }

    /**
     * Retrieve the current setting for the 'render_expose_template' Theme module variable.
     *
     * @return boolean True if The 'render_expose_template' Theme module template is true.
     */
    public function getExposeTemplate()
    {
        return $this->expose_template;
    }

    /**
     * Get template path.
     *
     * This is calculated by _setup_template() invoked during fetch().
     *
     * @return string
     */
    public function getTemplatePath()
    {
        return $this->templatePath;
    }

    /**
     * Retrieve the name of the directory where templates are located.
     *
     * @return string The directory name.
     */
    public function getTemplateDir()
    {
        return $this->template_dir;
    }

    /**
     * Retrieve the template variables array ({@link Smarty::$_tpl_vars}).
     *
     * @return array The template variables array.
     */
    public function getTplVars()
    {
        return $this->_tpl_vars;
    }

    /**
     * Get a template variable.
     *
     * @param string $key Key of assigned template variable.
     *
     * @return mixed
     */
    public function getTplVar($key)
    {
        if (!array_key_exists($key, $this->_tpl_vars)) {
            return null;
        }

        return $this->_tpl_vars[$key];
    }

    /**
     * Retrieve the compile ID used to compile different sets of compiled files for the same templates.
     *
     * @return string|null The compile id, or null if none.
     */
    public function getCompileId()
    {
        return $this->compile_id;
    }

    /**
     * Set this if you want different sets of compiled files for the same templates.
     *
     * This is useful for things like different languages.
     * Instead of creating separate sets of templates per language, you
     * set different compile_ids like 'en' and 'de'.
     *
     * @param string|null $compile_id The compile id, or null.
     *
     * @return $this
     */
    public function setCompileId($compile_id)
    {
        $this->compile_id = $compile_id;

        return $this;
    }

    /**
     * Retrieve the directory where compiled templates are located.
     *
     * @return string The directory name.
     */
    public function getCompileDir()
    {
        return $this->compile_dir;
    }

    /**
     * Set the directory where compiled templates are located.
     *
     * @param string $compile_dir The directory name.
     *
     * @return $this
     */
    public function setCompileDir($compile_dir)
    {
        $this->compile_dir = $compile_dir;

        return $this;
    }

    /**
     * Retrieve the flag that controls whether to check for recompiling or not.
     *
     * Recompiling does not need to happen unless a template or config file is changed.
     * Typically you enable this during development, and disable for production.
     *
     * @return boolean True if checked, otherwise false.
     */
    public function getCompileCheck()
    {
        return $this->compile_check;
    }

    /**
     * Set compile check.
     *
     * @param boolean $doCompileCheck If true, checks for compile will be performed.
     *
     * @return $this
     */
    public function setCompileCheck($doCompileCheck)
    {
        $this->compile_check = $doCompileCheck;

        return $this;
    }

    /**
     * Retrieve whether templates are forced to be compiled.
     *
     * @return boolean True if templates are forced to be compiled, otherwise false.
     */
    public function getForceCompile()
    {
        return $this->force_compile;
    }

    /**
     * Set whether templates are forced to be compiled.
     *
     * @param boolean $force_compile True to force compilation, otherwise false.
     *
     * @return $this
     */
    public function setForceCompile($force_compile)
    {
        $this->force_compile = $force_compile;

        return $this;
    }

    /**
     * Retrieve whether caching is enabled.
     *
     * @return integer A code indicating whether caching is enabled.
     */
    public function getCaching()
    {
        return $this->caching;
    }

    /**
     * Set Caching.
     *
     * Possible value:
     * <ul>
     *  <li>0 = no caching</li>
     *  <li>1 = use class cache_lifetime value</li>
     *  <li>2 = use cache_lifetime in cache file</li>
     * </ul>
     *
     * @param integer $caching Cache value to set.
     *
     * @return $this
     */
    public function setCaching($caching)
    {
        $this->caching = (int)$caching;

        return $this;
    }

    /**
     * Retrieve the current cache ID.
     *
     * @return string The current cache ID.
     */
    public function getCacheId()
    {
        return $this->cache_id;
    }

    /**
     * Set cache ID.
     *
     * @param string $id Cache ID.
     *
     * @return $this
     */
    public function setCacheId($id)
    {
        $this->cache_id = $id;

        return $this;
    }

    /**
     * Retrieve the number of seconds cached content will persist.
     *
     * Special values:
     * <ul>
     *  <li>0 = always regenerate cache</li>
     *  <li>-1 = never expires</li>
     * </ul>
     *
     * @return integer The number of seconds cached content will persist.
     */
    public function getCacheLifetime()
    {
        return $this->cache_lifetime;
    }

    /**
     * Set cache lifetime.
     *
     * @param integer $time Lifetime in seconds.
     *
     * @return $this
     */
    public function setCacheLifetime($time)
    {
        $this->cache_lifetime = $time;

        return $this;
    }

    /**
     * Retrieve the name of the directory for cache files.
 …