class.ilStyleDefinition.php

Go to the documentation of this file.

<?php
include_once("Services/Style/System/classes/Utilities/class.ilSkinXML.php");
include_once("Services/Style/System/classes/Utilities/class.ilSystemStyleSkinContainer.php");
include_once("Services/Style/System/classes/class.ilSystemStyleSettings.php");
include_once("Services/Style/System/classes/Utilities/class.ilSystemStyleConfig.php");
 
 
/* Copyright (c) 1998-2012 ILIAS open source, Extended GPL, see docs/LICENSE */
 
 
class ilStyleDefinition
{
    public static $current_style = false;
 
    public static $skins = [];
 
    protected $skin;
 
    protected static $cached_all_styles_information = null;
 
    protected $system_style_config;
 
    public function __construct($skin_id = "", ilSystemStyleConfig $system_style_config = null)
    {
        if ($skin_id == "") {
            $skin_id = self::getCurrentSkin();
        }
 
        if (!$system_style_config) {
            $this->setSystemStylesConf(new ilSystemStyleConfig());
        } else {
            $this->setSystemStylesConf($system_style_config);
        }
 
        if ($skin_id != $this->getSystemStylesConf()->getDefaultSkinId()) {
            $this->setSkin(ilSkinXML::parseFromXML($this->getSystemStylesConf()->getCustomizingSkinPath() . $skin_id . "/template.xml"));
        } else {
            $this->setSkin(ilSkinXML::parseFromXML($this->getSystemStylesConf()->getDefaultTemplatePath()));
        }
    }
 
    public static function getCurrentSkin()
    {
        global $DIC,$ilias, $styleDefinition;
 
        if (is_object($styleDefinition) && is_object($styleDefinition->getSkin())) {
            return $styleDefinition->getSkin()->getId();
        } else {
            $system_style_conf = new ilSystemStyleConfig();
 
            if (is_object($ilias) && is_object($ilias->account) && property_exists($ilias->account, "skin")) {
                $skin_id = $ilias->account->skin;
                if (!self::skinExists($skin_id)) {
                    ilUtil::sendFailure($DIC->language()->txt("set_skin_does_not_exist") . " " . $skin_id);
                    $skin_id = $system_style_conf->getDefaultSkinId();
                }
                return $skin_id;
            } else {
                return null;
            }
        }
    }
 
    public function getStyles()
    {
        return $this->getSkin()->getStyles();
    }
 
 
    public function getTemplateName()
    {
        return $this->getSkin()->getName();
    }
 
 
    public function getStyle($a_id)
    {
        return $this->getSkin()->getStyle($a_id);
    }
 
    public function getStyleName($a_id)
    {
        return $this->getSkin()->getStyle($a_id)->getName();
    }
 
    public function getImageDirectory($style_id)
    {
        if (!$style_id) {
            throw new ilSystemStyleException(ilSystemStyleException::NO_STYLE_ID, $style_id);
        }
        if (!$this->getSkin()->getStyle($style_id)) {
            throw new ilSystemStyleException(ilSystemStyleException::NOT_EXISTING_STYLE, $style_id);
        }
        return $this->getSkin()->getStyle($style_id)->getImageDirectory();
    }
 
    public function getSoundDirectory($style_id)
    {
        return $this->getSkin()->getStyle($style_id)->getSoundDirectory();
    }
 
 
    public static function getAllSkins(ilSystemStyleConfig $system_style_config = null)
    {
        if (!self::$skins) {
            if (!$system_style_config) {
                $system_style_config = new ilSystemStyleConfig();
            }
 
            $skins = [];
            $skins[$system_style_config->getDefaultSkinId()] = ilSkinXML::parseFromXML($system_style_config->getDefaultTemplatePath());
 
 
            if (is_dir($system_style_config->getCustomizingSkinPath())) {
                $cust_skins_directory = new RecursiveDirectoryIterator($system_style_config->getCustomizingSkinPath(), FilesystemIterator::SKIP_DOTS);
                foreach ($cust_skins_directory as $skin_folder) {
                    if ($skin_folder->isDir()) {
                        $template_path = $skin_folder->getRealPath() . "/template.xml";
                        if (file_exists($template_path)) {
                            $skin = ilSkinXML::parseFromXML($template_path);
                            $skins[$skin->getId()] = $skin;
                        }
                    }
                }
            }
 
            self::setSkins($skins);
        }
 
        return self::$skins;
    }
 
    public static function getAllTemplates()
    {
        return self::getAllSkins();
    }
 
    public static function skinExists($skin_id, ilSystemStyleConfig $system_style_config = null)
    {
        if (!$system_style_config) {
            $system_style_config = new ilSystemStyleConfig();
        }
 
        if ($skin_id == $system_style_config->getDefaultSkinId()) {
            if (is_file($system_style_config->getDefaultTemplatePath())) {
                return true;
            }
        } else {
            if (is_file($system_style_config->getCustomizingSkinPath() . $skin_id . "/template.xml")) {
                return true;
            }
        }
        return false;
    }
    
    public static function getCurrentStyle()
    {
        global $DIC;
 
        global $ilias, $styleDefinition, $tree;
        
        if (self::$current_style) {
            return self::$current_style;
        }
 
        if (!is_object($ilias)) {
            return null;
        }
 
        self::setCurrentStyle($ilias->account->prefs['style']);
 
        if (is_object($styleDefinition) && self::styleExistsForCurrentSkin(self::$current_style)) {
            if ($styleDefinition->getSkin()->hasStyleSubstyles(self::$current_style)) {
                // read assignments, if given
                $assignments = ilSystemStyleSettings::getSystemStyleCategoryAssignments(self::getCurrentSkin(), self::$current_style);
                if (count($assignments) > 0) {
                    $ref_ass = [];
                    foreach ($assignments as $a) {
                        if ($styleDefinition->getSkin()->hasStyle($a["substyle"])) {
                            $ref_ass[$a["ref_id"]] = $a["substyle"];
                        }
                    }
 
                    $ref_id = false;
                    if ($_GET["ref_id"]) {
                        $ref_id = $_GET["ref_id"];
                    } elseif ($_GET["target"]) {
                        $target_arr = explode("_", $_GET["target"]);
                        $ref_id = $target_arr[1];
                    }
 
                    // check whether any ref id assigns a new style
                    if (is_object($tree) && $ref_id && $tree->isInTree($ref_id)) {
                        $path = $tree->getPathId($ref_id);
                        for ($i = count($path) - 1; $i >= 0; $i--) {
                            if (isset($ref_ass[$path[$i]])) {
                                self::$current_style = $ref_ass[$path[$i]];
                                return self::$current_style;
                            }
                        }
                    }
                }
            }
        }
 
        if (!self::styleExistsForCurrentSkin(self::$current_style)) {
            ilUtil::sendFailure($DIC->language()->txt("set_style_does_not_exist") . " " . self::$current_style);
            $system_style_config = new ilSystemStyleConfig();
            self::setCurrentSkin($system_style_config->getDefaultSkinId());
            self::setCurrentStyle($system_style_config->getDefaultStyleId());
        }
 
        return self::$current_style;
    }
 
    public static function getAllSkinStyles()
    {
        global $styleDefinition;
 
 
 
        if (!self::getCachedAllStylesInformation()) {
            $all_styles = [];
 
            $skins = $styleDefinition->getSkins();
 
            foreach ($skins as $skin) {
                foreach ($skin->getStyles() as $style) {
                    $num_users = ilObjUser::_getNumberOfUsersForStyle($skin->getId(), $style->getId());
 
                    $parent_name = "";
                    if ($style->getSubstyleOf()) {
                        $parent_name = $skin->getStyle($style->getSubstyleOf())->getName();
                    }
 
                    // default selection list
                    $all_styles[$skin->getId() . ":" . $style->getId()] = [
                                    "title" => $skin->getName() . " / " . $style->getName(),
                                    "id" => $skin->getId() . ":" . $style->getId(),
                                    "skin_id" => $skin->getId(),
                                    "skin_name" => $skin->getName(),
                                    "template_id" => $skin->getId(),
                                    "template_name" => $skin->getName(),
                                    "style_id" =>  $style->getId(),
                                    "style_name" => $style->getName(),
                                    "substyle_of" => $style->getSubstyleOf(),
                                    "substyle_of_name" => $parent_name,
                                    "users" => $num_users
                            ];
                }
            }
            self::setCachedAllStylesInformation($all_styles);
        }
 
        return self::getCachedAllStylesInformation();
    }
 
 
    public static function setCurrentSkin($a_skin)
    {
        global $styleDefinition;
 
        if (is_object($styleDefinition) && $styleDefinition->getSkin()->getName() != $a_skin) {
            $styleDefinition = new ilStyleDefinition($a_skin);
            if (!self::styleExistsForCurrentSkin(self::$current_style)) {
                $styleDefinition->setCurrentStyle($styleDefinition->getSkin()->getDefaultStyle()->getId());
            }
        }
    }
 
 
    public static function styleExists($style_id)
    {
        foreach (self::getSkins() as $skin) {
            if ($skin->hasStyle($style_id)) {
                return true;
            }
        }
        return false;
    }
 
    public static function styleExistsForSkinId($skin_id, $style_id)
    {
        if (!self::skinExists($skin_id)) {
            return false;
        }
        $skin = ilSystemStyleSkinContainer::generateFromId($skin_id)->getSkin();
        return $skin->hasStyle($style_id);
    }
 
    public static function styleExistsForCurrentSkin($style_id)
    {
        global $styleDefinition;
 
        return $styleDefinition->getSkin()->hasStyle($style_id);
    }
 
    public static function setCurrentStyle($a_style)
    {
        self::$current_style = $a_style;
    }
 
    public static function getSkins()
    {
        return self::getAllSkins();
    }
 
    public static function setSkins($skins)
    {
        self::$skins = $skins;
    }
 
    public function getSkin()
    {
        return $this->skin;
    }
 
    public function setSkin($skin)
    {
        $this->skin = $skin;
    }
 
    protected static function getCachedAllStylesInformation()
    {
        return self::$cached_all_styles_information;
    }
 
    protected static function setCachedAllStylesInformation($cached_all_styles_information)
    {
        self::$cached_all_styles_information = $cached_all_styles_information;
    }
 
    public function getSystemStylesConf()
    {
        return $this->system_style_config;
    }
 
    public function setSystemStylesConf($system_style_config)
    {
        $this->system_style_config = $system_style_config;
    }
}