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
{
        static $current_style = false;

        static $skins = [];

        protected $skin;

        protected static $cached_all_styles_information = null;

        protected $system_style_config;

        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"];
                                        } else if ($_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;
        }
}