theme.php

Go to the documentation of this file.

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/

use Xoops\Core\FixedGroups;

class XoopsThemeFactory
{
    public $xoBundleIdentifier = 'XoopsThemeFactory';

    public $allowedThemes = array();

    public $defaultTheme = 'default';

    public $allowUserSelection = true;

    public function createInstance($options = array())
    {
        $xoops = Xoops::getInstance();
        // Grab the theme folder from request vars if present
        if (empty($options['folderName'])) {
            if (($req = @$_REQUEST['xoops_theme_select']) && $this->isThemeAllowed($req)) {
                $options['folderName'] = $req;
                if (isset($_SESSION) && $this->allowUserSelection) {
                    $_SESSION[$this->xoBundleIdentifier]['defaultTheme'] = $req;
                }
            } else {
                if (isset($_SESSION[$this->xoBundleIdentifier]['defaultTheme'])) {
                    $options['folderName'] = $_SESSION[$this->xoBundleIdentifier]['defaultTheme'];
                } else {
                    if (empty($options['folderName']) || !$this->isThemeAllowed($options['folderName'])) {
                        $options['folderName'] = $this->defaultTheme;
                    }
                }
            }
            $xoops->setConfig('theme_set', $options['folderName']);
        }
        $options['path'] = \XoopsBaseConfig::get('themes-path') . '/' . $options['folderName'];
        $inst = new XoopsTheme();
        foreach ($options as $k => $v) {
            $inst->$k = $v;
        }
        $inst->xoInit();
        return $inst;
    }

    public function isThemeAllowed($name)
    {
        return (empty($this->allowedThemes) || in_array($name, $this->allowedThemes));
    }
}

class XoopsAdminThemeFactory extends XoopsThemeFactory
{
    public function createInstance($options = array())
    {
        $xoops = \Xoops::getInstance();
        $options["plugins"] = array();
        $options['renderBanner'] = false;
        $inst = parent::createInstance($options);
        $inst->path = \XoopsBaseConfig::get('adminthemes-path') . '/' . $inst->folderName;
        $inst->url = \XoopsBaseConfig::get('adminthemes-url') . '/' . $inst->folderName;
        $inst->template->assign(array(
            'theme_path' => $inst->path, 'theme_tpl' => $inst->path . '/xotpl', 'theme_url' => $inst->url,
            'theme_img'  => $inst->url . '/img', 'theme_icons' => $inst->url . '/icons',
            'theme_css'  => $inst->url . '/css', 'theme_js' => $inst->url . '/js',
            'theme_lang' => $inst->url . '/language',
        ));

        return $inst;
    }
}

class XoopsTheme
{
    public $renderBanner = true;

    public $folderName = '';

    public $path = '';

    public $url = '';

    public $bufferOutput = true;

    public $canvasTemplate = 'theme.html';

    public $themesPath = 'themes';

    public $contentTemplate = '';

    public $contentCacheLifetime = 0;

    public $contentCacheId = null;

    public $content = '';

    public $plugins = array('XoopsThemeBlocksPlugin');

    public $renderCount = 0;

    public $template = false;

    public $metas = array(
        'meta' => array(), 'link' => array(), 'script' => array()
    );

    public $assets = null;

    public $baseAssets = array(
        'js' => array(),
        'css' => array(),
    );

    public $htmlHeadStrings = array();

    public $templateVars = array();

    public $use_extra_cache_id = true;

    public $headersCacheEngine = 'default';

    public function xoInit()
    {
        $xoops = Xoops::getInstance();
        $this->assets = $xoops->assets();
        $this->path = \XoopsBaseConfig::get('themes-path') . '/' . $this->folderName;
        $this->url = \XoopsBaseConfig::get('themes-url') . '/' . $this->folderName;
        $this->template = null;
        $this->template = new XoopsTpl();
        //$this->template->currentTheme = $this;
        $this->template->assignByRef('xoTheme', $this);
        $this->template->assign(array(
            'xoops_theme'      => $xoops->getConfig('theme_set'),
            'xoops_imageurl'   => \XoopsBaseConfig::get('themes-url') . '/' . $xoops->getConfig('theme_set') . '/',
            'xoops_themecss'   => $xoops->getCss($xoops->getConfig('theme_set')),
            'xoops_requesturi' => htmlspecialchars($_SERVER['REQUEST_URI'], ENT_QUOTES),
            'xoops_sitename'   => htmlspecialchars($xoops->getConfig('sitename'), ENT_QUOTES),
            'xoops_slogan'     => htmlspecialchars($xoops->getConfig('slogan'), ENT_QUOTES),
            'xoops_dirname'    => $xoops->moduleDirname,
            'xoops_banner'     => $this->renderBanner ? $xoops->getBanner() : '&nbsp;',
            'xoops_pagetitle'  => $xoops->isModule() ? $xoops->module->getVar('name') : htmlspecialchars($xoops->getConfig('slogan'), ENT_QUOTES)
        ));
        $this->template->assign(array(
            'theme_path' => $this->path, 'theme_tpl' => $this->path . '/xotpl', 'theme_url' => $this->url,
            'theme_img'  => $this->url . '/img', 'theme_icons' => $this->url . '/icons',
            'theme_css'  => $this->url . '/css', 'theme_js' => $this->url . '/js',
            'theme_lang' => $this->url . '/language',
        ));

        if ($xoops->isUser()) {
            $response = $xoops->service("Avatar")->getAvatarUrl($xoops->user);
            $avatar = $response->getValue();
            $avatar = empty($avatar) ? '' : $avatar;

            $this->template->assign(array(
                'xoops_isuser'     => true,
                'xoops_avatar'     => $avatar,
                'xoops_userid'     => $xoops->user->getVar('uid'), 'xoops_uname' => $xoops->user->getVar('uname'),
                'xoops_name'       => $xoops->user->getVar('name'), 'xoops_isadmin' => $xoops->isAdmin(),
                'xoops_usergroups' => $xoops->user->getGroups()
            ));
        } else {
            $this->template->assign(array(
                'xoops_isuser' => false,
                'xoops_isadmin' => false,
                'xoops_usergroups' => array(FixedGroups::ANONYMOUS)
            ));
        }

        // Meta tags
        $metas = array(
            'description', 'keywords', 'robots', 'rating', 'author', 'copyright'
        );
        foreach ($metas as $name) {
            $this->addMeta('meta', $name, $xoops->getConfig('meta_' . $name));
        }

        // Other assigns
        $assigns = array(
            'title', 'slogan', 'locale', 'footer', 'jquery_theme', 'startpage'
        );
        foreach ($assigns as $name) {
            // prefix each tag with 'xoops_'
            $this->template->assign("xoops_$name", $xoops->getConfig($name));
        }

        // Load global javascript
        //$this->addScript('include/xoops.js');
        //$this->loadLocalization();
        list($cssAssets, $jsAssets) = $this->getLocalizationAssets();
        if (!empty($cssAssets)) {
            $this->addBaseStylesheetAssets($cssAssets);
        }
        $this->addBaseScriptAssets('include/xoops.js');
        $this->addBaseScriptAssets('@jquery');
        //$this->addBaseScriptAssets('media/bootstrap/js/bootstrap.min.js');
        if (!empty($jsAssets)) {
            $this->addBaseScriptAssets($jsAssets);
        }

        if ($this->bufferOutput) {
            ob_start();
        }
        $xoops->setTheme($this);
        $xoops->setTpl($this->template);

        //For legacy only, never use this Globals
        $GLOBALS['xoTheme'] = $xoops->theme();
        $GLOBALS['xoopsTpl'] = $xoops->tpl();

        //to control order of loading JS and CSS
        // TODO - this should be done in such a way it can join the base asset
        //        load above.
        if (XoopsLoad::fileExists($this->path . "/theme_onload.php")) {
            include_once($this->path . "/theme_onload.php");
        }

        // Instanciate and initialize all the theme plugins
        foreach ($this->plugins as $k => $bundleId) {
            if (!is_object($bundleId)) {
                /* @var $plugin XoopsThemePlugin */
                $plugin = new $bundleId();
                $plugin->theme = $this;
                $plugin->xoInit();

                $this->plugins[$bundleId] = null;
                $this->plugins[$bundleId] = $plugin;
                unset($this->plugins[$k]);
            }
        }
        return true;
    }

    public function generateCacheId($cache_id, $extraString = '')
    {
        $xoops = Xoops::getInstance();
        static $extra_string;
        if (!$this->use_extra_cache_id) {
            return $cache_id;
        }

        if (empty($extraString)) {
            if (empty($extra_string)) {
                // Generate language section
                $extra_string = $xoops->getConfig('locale');
                // Generate group section
                if (!$xoops->isUser()) {
                    $extra_string .= '-' . FixedGroups::ANONYMOUS;
                } else {
                    $groups = $xoops->user->getGroups();
                    sort($groups);
                    // Generate group string for non-anonymous groups,
                    // db-pass and db-name (before we find better variables) are used to protect group sensitive contents
                    $extra_string .= '-' . substr(md5(implode('-', $groups)), 0, 8) . '-' . substr(md5(\XoopsBaseConfig::get('db-pass') . \XoopsBaseConfig::get('db-name') . \XoopsBaseConfig::get('db-user')), 0, 8);
                }
            }
            $extraString = $extra_string;
        }
        $cache_id .= '-' . $extraString;
        return $cache_id;
    }

    public function checkCache()
    {
        if ($_SERVER['REQUEST_METHOD'] != 'POST' && $this->contentCacheLifetime) {
            $template = $this->contentTemplate ? $this->contentTemplate : 'module:system/system_dummy.tpl';
            $this->template->caching = 2;
            $this->template->cache_lifetime = $this->contentCacheLifetime;
            $uri = str_replace(\XoopsBaseConfig::get('url'), '', $_SERVER['REQUEST_URI']);
            // Clean uri by removing session id
            if (defined('SID') && SID && strpos($uri, SID)) {
                $uri = preg_replace("/([\?&])(" . SID . "$|" . SID . "&)/", "\\1", $uri);
            }
            $this->contentCacheId = $this->generateCacheId('page_' . substr(md5($uri), 0, 8));
            if ($this->template->isCached($template, $this->contentCacheId)) {
                Xoops::getInstance()->events()->triggerEvent('core.theme.checkcache.success', array($template, $this));
                $this->render(null, null, $template);
                return true;
            }
        }
        return false;
    }

    public function render($canvasTpl = null, $pageTpl = null, $contentTpl = null, $vars = array())
    {
        if ($this->renderCount) {
            return false;
        }
        $xoops = Xoops::getInstance();
        $xoops->events()->triggerEvent('core.theme.render.start', array($this));
        $cache = $xoops->cache($this->headersCacheEngine);

        //Get meta information for cached pages
        if ($this->contentCacheLifetime && $this->contentCacheId && $content = $cache->read($this->contentCacheId)) {
            //we need to merge metas set by blocks with the module cached meta
            $this->htmlHeadStrings = array_merge($this->htmlHeadStrings, $content['htmlHeadStrings']);
            foreach ($content['metas'] as $type => $value) {
                $this->metas[$type] = array_merge($this->metas[$type], $content['metas'][$type]);
            }
            $xoops->setOption('xoops_pagetitle', $content['xoops_pagetitle']);
            $xoops->setOption('xoops_module_header', $content['header']);
        }

        if ($xoops->getOption('xoops_pagetitle')) {
            $this->template->assign('xoops_pagetitle', $xoops->getOption('xoops_pagetitle'));
        }
        $header = !$xoops->getOption('xoops_module_header') ? $this->template->getTemplateVars('xoops_module_header') : $xoops->getOption('xoops_module_header');

        //save meta information of cached pages
        if ($this->contentCacheLifetime && $this->contentCacheId && !$contentTpl) {
            $content['htmlHeadStrings'] = (array)$this->htmlHeadStrings;
            $content['metas'] = (array)$this->metas;
            $content['xoops_pagetitle'] = $this->template->getTemplateVars('xoops_pagetitle');
            $content['header'] = $header;
            $cache->write($this->contentCacheId, $content);
        }

        //  @internal : Lame fix to ensure the metas specified in the xoops config page don't appear twice
        $old = array('robots', 'keywords', 'description', 'rating', 'author', 'copyright');
        foreach ($this->metas['meta'] as $name => $value) {
            if (in_array($name, $old)) {
                $this->template->assign("xoops_meta_$name", htmlspecialchars($value, ENT_QUOTES));
                unset($this->metas['meta'][$name]);
            }
        }

        // We assume no overlap between $GLOBALS['xoopsOption']['xoops_module_header'] and $this->template->getTemplateVars( 'xoops_module_header' ) ?
        $this->template->assign('xoops_module_header', $this->renderMetas(true) . "\n" . $header);

        if ($canvasTpl) {
            $this->canvasTemplate = $canvasTpl;
        }
        if ($contentTpl) {
            $this->contentTemplate = $contentTpl;
        }
        if (!empty($vars)) {
            $this->template->assign($vars);
        }
        if ($this->contentTemplate) {
            $this->content = $this->template->fetch($this->contentTemplate, $this->contentCacheId);
        }
        if ($this->bufferOutput) {
            $this->content .= ob_get_contents();
            ob_end_clean();
        }

        $this->template->assignByRef('xoops_contents', $this->content);

        // Do not cache the main (theme.html) template output
        $this->template->caching = 0;
        $this->template->display($this->path . '/' . $this->canvasTemplate);
        $this->renderCount++;
        $xoops->events()->triggerEvent('core.theme.render.end', array($this));
        return true;
    }

    public function getLocalizationAssets($type = "main")
    {
        $cssAssets = array();
        $jsAssets = array();

        $xoops = Xoops::getInstance();

        Xoops_Locale::loadThemeLocale($this);

        $language = XoopsLocale::getLocale();
        // Load global localization stylesheet if available
        if (XoopsLoad::fileExists($xoops->path('locale/' . $language . '/style.css'))) {
            $cssAssets[] = $xoops->path('locale/' . $language . '/style.css');
        }
        //$this->addLanguage($type);
        // Load theme localization stylesheet and scripts if available
        if (XoopsLoad::fileExists($this->path . '/locale/' . $language . '/script.js')) {
            $jsAssets[] = $this->url . '/locale/' . $language . '/script.js';
        }
        if (XoopsLoad::fileExists($this->path . '/locale/' . $language . '/style.css')) {
            $cssAssets[] = $this->path . '/locale/' . $language . '/style.css';
        }
        return array($cssAssets, $jsAssets);
    }

    /*
    public function addLanguage($type = "main", $language = null)
    {
        $xoops = Xoops::getInstance();
        $language = is_null($language) ? $xoops->getConfig('locale') : $language;
        if (!XoopsLoad::fileExists($file = $xoops->path($this->resourcePath("/locale/{$language}/{$type}.php")))) {
            if (!XoopsLoad::fileExists($file = $xoops->path($this->resourcePath("/locale/en_US/{$type}.php")))) {
                return false;
            }
        }
        $ret = include_once $file;
        return $ret;
    }*/

    public function addScript($src = '', $attributes = array(), $content = '')
    {
        $xoops = Xoops::getInstance();
        if (empty($attributes)) {
            $attributes = array();
        }
        if (!empty($src)) {
            $src = $xoops->url($this->resourcePath($src));
            $attributes['src'] = $src;
        }
        if (!empty($content)) {
            $attributes['_'] = $content;
        }
        if (!isset($attributes['type'])) {
            $attributes['type'] = 'text/javascript';
        }
        $this->addMeta('script', $src, $attributes);
    }

    public function addStylesheet($src = '', $attributes = array(), $content = '')
    {
        $xoops = Xoops::getInstance();
        if (empty($attributes)) {
            $attributes = array();
        }
        if (!empty($src)) {
            $src = $xoops->url($this->resourcePath($src));
            $attributes['href'] = $src;
        }
        if (!isset($attributes['type'])) {
            $attributes['type'] = 'text/css';
        }
        if (!empty($content)) {
            $attributes['_'] = $content;
        }
        $this->addMeta('stylesheet', $src, $attributes);
    }

    public function addScriptAssets($assets, $filters = 'default', $target = null)
    {
        $url = $this->assets->getUrlToAssets('js', $assets, $filters, $target);
        $this->addScript($url);
    }

    public function addStylesheetAssets($assets, $filters = 'default', $target = null)
    {
        $url = $this->assets->getUrlToAssets('css', $assets, $filters, $target);
        $this->addStylesheet($url);
    }

    public function addBaseAssets($type, $assets)
    {
        if (is_scalar($assets)) {
            $this->baseAssets[$type][]=$assets;
        } elseif (is_array($assets)) {
            $this->baseAssets[$type] = array_merge($this->baseAssets[$type], $assets);
        }
    }

    public function addBaseScriptAssets($assets)
    {
        $this->addBaseAssets('js', $assets);
    }

    public function addBaseStylesheetAssets($assets)
    {
        $this->addBaseAssets('css', $assets);
    }

    public function setNamedAsset($name, $assets, $filters = null)
    {
        return $this->assets->registerAssetReference($name, $assets, $filters);
    }

    public function addLink($rel, $href = '', $attributes = array())
    {
        if (empty($attributes)) {
            $attributes = array();
        }
        if (!empty($href)) {
            $attributes['href'] = $href;
        }
        $attributes['rel'] = $rel;
        $this->addMeta('link', '', $attributes);
    }

    public function addHttpMeta($name, $value = null)
    {
        if (isset($value)) {
            return $this->addMeta('http', $name, $value);
        }
        unset($this->metas['http'][$name]);
        return false;
    }

    public function addMeta($type = 'meta', $name = '', $value = '')
    {
        if (!isset($this->metas[$type])) {
            $this->metas[$type] = array();
        }
        if (!empty($name)) {
            $this->metas[$type][$name] = $value;
        } else {
            $this->metas[$type][md5(serialize(array($value)))] = $value;
        }
        return $value;
    }

    public function headContent($params, $content, &$smarty, &$repeat)
    {
        if (!$repeat) {
            $this->htmlHeadStrings[] = $content;
        }
    }

    public function renderMetas($return = false)
    {
        $str = '';

        if (!empty($this->baseAssets['js'])) {
            $url = $this->assets->getUrlToAssets('js', $this->baseAssets['js']);
            if (!empty($url)) {
                $str .= '<script src="' . $url . '" type="text/javascript"></script>'."\n";
            }
        }

        if (!empty($this->baseAssets['css'])) {
            $url = $this->assets->getUrlToAssets('css', $this->baseAssets['css']);
            if (!empty($url)) {
                $str .= '<link rel="stylesheet" href="' . $url . '" type="text/css" />'."\n";
            }
        }

        foreach (array_keys($this->metas) as $type) {
            $str .= $this->renderMetasByType($type);
        }
        $str .= implode("\n", $this->htmlHeadStrings);

        if ($return) {
            return $str;
        }
        echo $str;
        return true;
    }

    public function renderMetasByType($type)
    {
        if (!isset($type)) {
            return '';
        }

        $str = '';
        switch ($type) {
            case 'script':
                foreach ($this->metas[$type] as $attrs) {
                    $str .= "<script" . $this->renderAttributes($attrs) . ">";
                    if (@$attrs['_']) {
                        $str .= "\n//<![CDATA[\n" . $attrs['_'] . "\n//]]>";
                    }
                    $str .= "</script>\n";
                }
                break;
            case 'link':
                foreach ($this->metas[$type] as $attrs) {
                    $rel = $attrs['rel'];
                    unset($attrs['rel']);
                    $str .= '<link rel="' . $rel . '"' . $this->renderAttributes($attrs) . " />\n";
                }
                break;
            case 'stylesheet':
                foreach ($this->metas[$type] as $attrs) {
                    if (@$attrs['_']) {
                        $str .= '<style' . $this->renderAttributes($attrs)
                            . ">\n/* <![CDATA[ */\n" . $attrs['_'] . "\n/* //]]> */\n</style>";
                    } else {
                        $str .= '<link rel="stylesheet"' . $this->renderAttributes($attrs) . " />\n";
                    }
                }
                break;
            case 'http':
                foreach ($this->metas[$type] as $name => $content) {
                    $str .= '<meta http-equiv="' . htmlspecialchars($name, ENT_QUOTES) . '" content="' . htmlspecialchars($content, ENT_QUOTES) . "\" />\n";
                }
                break;
            default:
                foreach ($this->metas[$type] as $name => $content) {
                    $str .= '<meta name="' . htmlspecialchars($name, ENT_QUOTES) . '" content="' . htmlspecialchars($content, ENT_QUOTES) . "\" />\n";
                }
                break;
        }

        return $str;
    }

    public function genElementId($tagName = 'xos')
    {
        static $cache = array();
        if (!isset($cache[$tagName])) {
            $cache[$tagName] = 1;
        }
        return $tagName . '-' . $cache[$tagName]++;
    }

    public function renderAttributes($coll)
    {
        $str = '';
        foreach ($coll as $name => $val) {
            if ($name != '_') {
                $str .= ' ' . $name . '="' . htmlspecialchars($val, ENT_QUOTES) . '"';
            }
        }
        return $str;
    }

    public function resourcePath($path)
    {
        if (substr($path, 0, 1) == '/') {
            $path = substr($path, 1);
        }
        $xoops_root_path = \XoopsBaseConfig::get('root-path');
//\Xoops::getInstance()->events()->triggerEvent('debug.log', $this);
        if (XoopsLoad::fileExists($xoops_root_path . "/{$this->themesPath}/{$this->folderName}/{$path}")) {
//\Xoops::getInstance()->events()->triggerEvent('debug.log', "custom theme path {$this->themesPath}/{$this->folderName}/{$path}");
            return "{$this->themesPath}/{$this->folderName}/{$path}";
        }

        if (XoopsLoad::fileExists($xoops_root_path . "/themes/{$this->folderName}/{$path}")) {
//\Xoops::getInstance()->events()->triggerEvent('debug.log', "main theme folder themes/{$this->folderName}/{$path}");
            return "themes/{$this->folderName}/{$path}";
        }
//\Xoops::getInstance()->events()->triggerEvent('debug.log', "drop thru {$path}");
        return $path;
    }
}

abstract class XoopsThemePlugin
{
    public $theme = false;

    abstract function xoInit();
}