lepton_template.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
abstract class LEPTON_template
{
    public $language = array();
 
    public $parents = array();
 
    public $template_directory = "";
    
    public $template_name = "";
    
    public $template_function = "";
    
    public $template_version = "";
 
    public $template_platform = "";
 
    public $template_author = "";
 
    public $template_license = "";
 
    public $template_license_terms = "";
 
    public $template_description = "";
 
    public $template_guid = "";
 
    public $block = [];
    
    public $menu = [];
    
    public static $instance;
 
    public static function getInstance()
    {
        if (null === static::$instance)
        {
            static::$instance = new static();
            static::$instance->getParents();
            static::$instance->getTemplateInfo();
            static::$instance->getLanguageFile();
            static::$instance->initialize();
        }
        return static::$instance;
    }
 
    protected function getParents()
    {
        // First the class itself
        static::$instance->parents[] = get_class(static::$instance);
        
        // Now the parents        
        $aTempParents = class_parents( static::$instance, true );
        foreach($aTempParents as $sParentname)
        {
            static::$instance->parents[] = $sParentname;
        }
    }
   
    protected function getTemplateInfo()
    {
        
        foreach(static::$instance->parents as $sModuleDirectory)
        {
            //  strip namespace
            $aTemp = explode("\\", $sModuleDirectory);
            $sModuleDirectory = array_pop($aTemp);
            
            $sLookUpPath = __DIR__."/../../templates/".$sModuleDirectory."/info.php";
            if( file_exists($sLookUpPath) )
            {
                require $sLookUpPath;
                // [1.1]
                if(isset($template_name))
                {
                    static::$instance->template_name = $template_name;
                }
                // [1.2]
                if(isset($template_directory))
                {
                    static::$instance->template_directory = $template_directory;
                }
                // [1.3]
                if(isset($template_function))
                {
                    static::$instance->template_function = $template_function;
                }
                // [1.4]
                if(isset($template_version))
                {
                    static::$instance->template_version = $template_version;
                }
                // [1.5]
                if(isset($template_platform))
                {
                    static::$instance->template_platform = $template_platform;
                }
                // [1.6]
                if(isset($template_author))
                {
                    static::$instance->template_author = $template_author;
                }
                // [1.7]
                if(isset($template_license))
                {
                    static::$instance->template_license = $template_license;
                }
                // [1.8]
                if(isset($template_license_terms))
                {
                    static::$instance->template_license_terms = $template_license_terms;
                }
                // [1.9]
                if(isset($template_description))
                {
                    static::$instance->template_description = $template_description;
                }
                // [1.10]
                if(isset($template_guid))
                {
                    static::$instance->template_guid = $template_guid;
                }
                // [1.11]
                if(isset($block))
                {
                    static::$instance->block = $block;
                }
                // [1.12]
                if(isset($menu))
                {
                    static::$instance->menu = $menu;
                }
                
                break;
            }
        }
    }
    
    protected function getLanguageFile()
    {
        if (defined("LEPTON_PATH"))
        {
            $aLookUpFilenames = [
                LANGUAGE."_add.php",
                LANGUAGE."_custom.php",
                LANGUAGE.".php",
                "EN_custom.php",
                "EN.php"
            ];
            
            foreach (static::$instance->parents as $sClassName)
            {
                //  Strip the namespace
                $aTemp = explode("\\", $sClassName);
                $sClassName = array_pop($aTemp);
 
                $lookUpPath = LEPTON_PATH."/templates/".$sClassName."/languages/";
                
                $bFoundFile = false;
                
                foreach ($aLookUpFilenames as $sTempFilename)
                {
                    if (true === file_exists($lookUpPath.$sTempFilename))
                    {
                        if (isset($template_description))
                        {
                            unset($template_description);
                        }
                        require $lookUpPath.$sTempFilename;
                        $bFoundFile = true;
                        break;
                    }
                }
                
                if (false === $bFoundFile)
                {
                    continue;
                }
                
                $tempName = (static::$instance->template_function == "theme" 
                    ? "THEME" 
                    : "TEMPLATE_".strtoupper($sClassName)
                );
                
                if (isset(${$tempName}))
                {
                    static::$instance->language = ${$tempName};
                    
                    if (isset($template_description))
                    {
                        $this->template_description = $template_description;
                    }
                    break;
                }
            }
        }
    }
 
    abstract protected function initialize();
}