class.ilLanguageFile.php

Go to the documentation of this file.

<?php
/*
        +-----------------------------------------------------------------------------+
        | ILIAS open source                                                           |
        +-----------------------------------------------------------------------------+
        | Copyright (c) 1998-2008 ILIAS open source, University of Cologne            |
        |                                                                             |
        | This program is free software; you can redistribute it and/or               |
        | modify it under the terms of the GNU General Public License                 |
        | as published by the Free Software Foundation; either version 2              |
        | of the License, or (at your option) any later version.                      |
        |                                                                             |
        | 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.  See the               |
        | GNU General Public License for more details.                                |
        |                                                                             |
        | You should have received a copy of the GNU General Public License           |
        | along with this program; if not, write to the Free Software                 |
        | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
        +-----------------------------------------------------------------------------+
*/

class ilLanguageFile
{
        private static $global_file_objects = array();
        
        private $lang_file;

        private $lang_key;

        private $scope;


        private $header;

        private $file_start = "<!-- language file start -->";


        private $separator;

        private $comment_separator;

        private $params = array();
        
        private $values = array();

        private $comments = array();

        private $error_message = "";
        
        function __construct($a_file, $a_key = "", $a_scope = 'global')
        {
                global $lng;
                $this->separator = $lng->separator;
                $this->comment_separator = $lng->comment_separator;

                $this->lang_file = $a_file;
                $this->lang_key = $a_key;
                $this->scope = $a_scope;

                // initialize the header of a blank file
                $this->header = $file_start;
                
                // Set the default parameters to be written in a new file.
                // This ensures the correct order of parameters
                
                $this->params["module"] = "language file";
                $this->params["modulegroup"] = "language";
                
                if ($this->scope == "local")
                {
                        $this->params["based_on"] = "";
                }
                else
                {
                        $this->params["author"] = "";
                        $this->params["version"] = "";
                }

                $this->params["il_server"] = ILIAS_HTTP_PATH;
                $this->params["il_version"] = ILIAS_VERSION;
                $this->params["created"] = "";
                $this->params["created_by"] = "";
        }

        public function read()
        {
                global $lng;
                
                $this->header = '';
                $this->params = array();
                $this->values = array();
                $this->comments = array();
                $this->error_message = "";

                $content = file($this->lang_file);
                $in_header = true;

                foreach ($content as $line_num => $line)
                {
                        if ($in_header)
                        {
                                // store the header line
                                $this->header .= $line . "\n";

                                // check header end
                                if (trim($line) == $this->file_start)
                                {
                                        $in_header = false;
                                        continue;
                                }
                                else
                                {
                                        // get header params
                                        $pos_par = strpos($line, "* @");

                                        if ($pos_par !== false)
                                        {
                                        $pos_par += 3;
                                                $pos_space = strpos($line, " ", $pos_par);
                                                $pos_tab = strpos($line, "\t", $pos_par);
                                                if ($pos_space !== false and $pos_tab !== false)
                                                {
                                                        $pos_white = min($pos_space, $pos_tab);
                                                }
                                                elseif ($pos_space !== false)
                                                {
                                                        $pos_white = $pos_space;
                                                }
                                                elseif ($pos_tab !== false)
                                                {
                                $pos_white = $pos_tab;
                                                }
                                                else
                                                {
                                $pos_white = false;
                            }
                                                if ($pos_white)
                                                {
                                                        $param = substr($line, $pos_par, $pos_white-$pos_par);
                                                        $value = trim(substr($line, $pos_white));

                                                        $this->params[$param] = $value;
                                                }
                                        }
                                }
                        }
                        else
                        {
                                // separate the lang file entry
                                $separated = explode($this->separator, trim($line));
                                
                                // not a valid line with module, identifier and value?
                                if (count($separated) != 3)
                                {
                                        $this->error_message =
                                                        $lng->txt("file_not_valid"). " "
                                                        .$lng->txt("err_in_line")." ". $line_num . ". "
                                                        .$lng->txt("err_count_param");
                                        return false;
                                }
                                else
                                {
                                        $key = $separated[0].$this->separator.$separated[1];
                                        $value = $separated[2];

                                        // cut off comment
                                        $pos = strpos($value, $this->comment_separator);
                                        if ($pos !== false)
                                        {
                                                $this->comments[$key]
                                                        = substr($value , $pos + strlen($this->comment_separator));
                                                        
                                                $value = substr($value , 0 , $pos);
                                        }
                                        $this->values[$key] = $value;
                                }
                        }
                }
                // still in header after parsing the whole file?
                if ($in_header)
                {
                        $this->error_message = $lng->txt("file_not_valid")." ".$lng->txt("err_wrong_header");
                        return false;
                }
                else
                {
                        return true;
                }
        }
        
        public function write($a_header = '')
        {
                $fp = fopen($this->lang_file, "w");
                fwrite($fp, $this->build($a_header));
                fclose($fp);
        }

        public function build($a_header = '')
        {
                global $ilUser, $lng;

                if ($a_header)
                {
                // take the given header
                        $content = $a_header;
                }
                else
                {
                        // set default params
            $lng->loadLanguageModule('meta');
            $lang_name = $lng->txtlng('meta','meta_l_'.$this->lang_key,'en');
                        $this->params["module"] = "language file ". $lang_name;
                        $this->params["created"] = date('Y-m-d H:i:s');
                        $this->params["created_by"] = $ilUser->getFullname()." <".$ilUser->getEmail().">";

                        // build the header
                $tpl = new ilTemplate("tpl.lang_file_header.html", true,true, "Services/Language");
                        foreach ($this->getAllParams() as $name => $value)
                        {
                    $tabs = ceil((20 - 3 - strlen($name)) / 4);
                                $tabs = $tabs > 0 ? $tabs : 1;

                                $tpl->setCurrentBlock('param');
                                $tpl->setVariable('PAR_NAME', $name);
                                $tpl->setVariable('PAR_SPACE', str_repeat("\t", $tabs));
                                $tpl->setVariable('PAR_VALUE', $value);
                                $tpl->parseCurrentBlock();
                        }
                        $txt_scope = $lng->txtlng('administration','language_scope_'.$this->scope, 'en');
                        $tpl->setVariable('SCOPE', $txt_scope);

                        $content = $tpl->get();
                }

                // fault tolerant check for adding newline
                $add_newline = (substr($content, strlen($content)-1, 1) != "\n");

                // build the content
                foreach ($this->values as $key => $value)
                {
                // add the newline before the line!
                        // a valid lang file should not have a newline at the end!
                        if ($add_newline)
                        {
                                $content .= "\n";
                        }
                        $add_newline = true;

                        $content .= $key . $this->separator . $value;

                        if ($this->comments[$key])
                        {
                    $content .= $this->comment_separator . $this->comments[$key];
                }
                }
                return $content;
        }
        
        
        public function getErrorMessage()
        {
                return $this->error_message;
        }


        public function getHeader()
        {
                return $this->header;
        }

        
        public function getAllParams()
        {
                return $this->params;
        }

        public function getAllValues()
        {
                return $this->values;
        }

        public function getAllComments()
        {
                return $this->comments;
        }

        public function getParam($a_name)
        {
                return $this->params[$a_name];
        }

        public function getValue($a_module, $a_identifier)
        {
                return $this->values[$a_module.$this->separator.$a_identifier];
        }

        public function getComment($a_module, $a_identifier)
        {
                return $this->comments[$a_module.$this->separator.$a_identifier];
        }

        public function setParam($a_name, $a_value)
        {
                $this->params[$a_name] = $a_value;
        }

        public function setValue($a_module, $a_identifier, $a_value)
        {
                $this->values[$a_module.$this->separator.$a_identifier] = $a_value;
        }

        public function setAllValues($a_values)
        {
                $this->values = $a_values;
        }

        public function setAllComments($a_comments)
        {
                $this->comments = $a_comments;
        }


        public function setComment($a_module, $a_identifier, $a_value)
        {
                return $this->comments[$a_module.$this->separator.$a_identifier] = $a_comment;
        }
        
        public static function _getGlobalLanguageFile($a_lang_key)
        {
                global $lng;
                
                if (!isset(self::$global_file_objects[$a_lang_key]))
                {
                        $file_object = new ilLanguageFile(
                                $lng->lang_path . "/ilias_" . $a_lang_key . ".lang",
                                $a_lang_key, 'global');
                        $file_object->read();
                        
                        self::$global_file_objects[$a_lang_key] = $file_object;
                }
                
                return self::$global_file_objects[$a_lang_key];
        }
}
?>