Source for file phpgettext.class.php

Documentation is available at phpgettext.class.php

  1. <?php
  2. /**
  3.  * @version        0.9
  4.  * @author      Carlos Souza
  5.  * @copyright   Copyright (c) 2005 Carlos Souza <csouza@web-sense.net>
  6.  * @package     PHPGettext
  7.  * @license        MIT License (http://www.opensource.org/licenses/mit-license.php)
  8.  * @link        http://phpgettext.web-sense.net
  9.  *
  10.  *
  11.  */
  12. defined( '_VALID_MOS' ) or die( 'Direct Access to this location is not allowed.' );
  13. class PHPGettext
  14. {
  15.     var $has_gettext;
  16.  
  17.     /**
  18.      * The current locale. eg: en-GB
  19.      */
  20.     var $lang;
  21.     /**
  22.      * The current locale. eg: en-GB
  23.      */
  24.     var $locale;
  25.  
  26.     /**
  27.      * The current domain
  28.      */
  29.     var $domain;
  30.  
  31.     /**
  32.      * The current character set
  33.      */
  34.     var $charset;
  35.  
  36.     /**
  37.      * Container for the loaded domains
  38.      */
  39.     var $text_domains = array();
  40.  
  41.     /**
  42.      * The asssociative array of headers for the current domain
  43.      */
  44.     var $headers = array();
  45.     /**
  46.      * The asssociative array of messages for the current domain
  47.      */
  48.     var $messages = array();
  49.  
  50.     /**
  51.      * The debugging flag
  52.      */
  53.     var $debug;
  54.  
  55.     function PHPGettext() {}
  56.  
  57.     /**
  58.      *
  59.      * Set and lookup the locale from the environment variables.
  60.      * Priority order for gettext is:
  61.      * 1. LANGUAGE
  62.      * 2. LC_ALL
  63.      * 3. LC_MESSAGE
  64.      * 4. LANG
  65.      *
  66.      * @return unknown 
  67.      */
  68.  
  69.     function setVariable($variable){
  70.         if ($this->has_gettext){
  71.             $this->has_gettext = $this->has_gettext && @putenv($variable);
  72.         }
  73.     }
  74.     
  75.     function setlocale($lang, $locale=false) {
  76.         $this->setvariable("LANGUAGE=$lang");
  77.         $this->setvariable("LC_ALL=$lang");
  78.         $this->setvariable("LC_MESSAGE=$lang");
  79.         $this->setvariable("LANG=$lang");
  80.         $this->lang =  $lang;
  81.         if ($locale) {
  82.             $this->locale =  setlocale(LC_ALL,$locale);
  83.         }
  84.     }
  85.  
  86.     function getlocale() {
  87.         if (empty($this->locale)) {
  88.             $langs = array( getenv('LANGUAGE'),
  89.             getenv('LC_ALL'),
  90.             getenv('LC_MESSAGE'),
  91.             getenv('LANG')
  92.             );
  93.             foreach ($langs as $lang)
  94.             if ($lang){
  95.                 $this->locale = $lang;
  96.                 break;
  97.             }
  98.         }
  99.         return $this->locale;
  100.     }
  101.  
  102.     /**
  103.      * debugging function
  104.      *
  105.      */
  106.     function output($message, $untranslated = false){
  107.         switch ($this->debug)
  108.         {
  109.             case 2:
  110.             $trace = debug_backtrace();
  111.             $html = '<span style="border-bottom: thin solid %s" title="%s(%d)">T_(%s)</span>';
  112.             $str = sprintf($html, ($untranslated ? 'red' : 'green'), str_replace('\\', '/', $trace[2]['file']), $trace[2]['line'], $message);
  113.             break;
  114.             case 1:
  115.             $str    = sprintf('%sT_(%s)',$untranslated ? '!' : '', $message);
  116.             break;
  117.             case 0:
  118.             default:
  119.             $str    = $message;
  120.             break;
  121.         }
  122.         return $str;
  123.     }
  124.  
  125.     /**
  126.      * Alias for gettext
  127.      * will also output the result if $output = true
  128.      */
  129.     function _($message, $output = false){
  130.         $return = $this->gettext($message);
  131.         if ($output) {
  132.             echo $return;
  133.             return true;
  134.         }
  135.         return $return;
  136.     }
  137.  
  138.     /**
  139.      * Lookup a message in the current domain
  140.      * returns translation if it exists or original message
  141.      */
  142.     function gettext($message){
  143.         $translation = $message;
  144.         if ($this->has_gettext){
  145.             $translation = gettext($message);
  146.         }
  147.         else{
  148.            $message = addslashes($message);
  149.            $message = str_replace("\n", '\n', $message);
  150.            $message = str_replace("\r", '\r', $message);
  151.            if (isset($this->messages[$this->domain][$message])) {
  152.             $translation = !empty($this->messages[$this->domain][$message]) ? $this->messages[$this->domain][$message] : $message;
  153.             }
  154.         }
  155.         $untranslated = (strcmp($translation, $message) === 0) ? true : false;
  156.         return $this->output($translation, $untranslated);
  157.     }
  158.  
  159.     /**
  160.      * Override the current domain
  161.      * The dgettext() function allows you to override the current domain for a single message lookup.
  162.      */
  163.     function dgettext($domain, $message){
  164.         $translation = $message;
  165.         if (array_key_exists($domain, $this->messages)){
  166.             if (isset($this->messages[$domain][$message]))
  167.             $translation = !empty($this->messages[$domain][$message]) ? $this->messages[$domain][$message] : $message;
  168.         }
  169.         $untranslated = (strcmp($translation, $message) === 0) ? true : false;
  170.         return $this->output($translation, $untranslated);
  171.     }
  172.  
  173.     /**
  174.      * Plural version of gettext
  175.      */
  176.     function ngettext($msgid, $msgid_plural, $count){
  177.         if ($this->has_gettext){
  178.             $translation = ngettext($msgid, $msgid_plural, $count);
  179.         }else{
  180.             $msgid = addslashes($msgid);
  181.             $msgid = str_replace("\n", '\n', $msgid);
  182.             $msgid = str_replace("\r", '\r', $msgid);
  183.             $plural = $this->getplural($count, $this->domain);
  184.             $original = array($msgid, $msgid_plural);
  185.             if (isset($this->messages[$this->domain][$msgid][$plural])) {
  186.                 $translation  = $this->messages[$this->domain][$msgid][$plural];
  187.             } else {
  188.                 $original   = array($msgid, $msgid_plural);
  189.                 $translation  = $original[$plural];
  190.             }
  191.         }
  192.         $untranslated = isset($original[$plural]) && (strcmp($translation, $original[$plural]) === 0) ? true : false;
  193.         return $this->output($translation, $untranslated);
  194.     }
  195.     /**
  196.      * Plural version of dgettext
  197.      */
  198.     function dngettext($domain, $msgid, $msgid_plural, $count){
  199.         $original   = array($msgid, $msgid_plural);
  200.         $plural = $this->getplural($count, $domain);
  201.         if ($this->has_gettext){
  202.             $translation = dngettext($domain, $msgid, $msgid_plural, $count);
  203.         } else {
  204.             $msgid = addslashes($msgid);
  205.             $msgid = str_replace("\n", '\n', $msgid);
  206.             $msgid = str_replace("\r", '\r', $msgid);
  207.             if (isset($this->messages[$domain][$msgid][$plural])) {
  208.                 $translation  = $this->messages[$domain][$msgid][$plural];
  209.             } else {
  210.                 $translation  = $original[$plural];
  211.             }
  212.         }
  213.         $untranslated = (strcmp($translation, $original[$plural]) === 0) ? true : false;
  214.         return $this->output($translation, $untranslated);
  215.     }
  216.  
  217.     /**
  218.      * Specify the character encoding in which the messages
  219.      * from the DOMAIN message catalog will be returned
  220.      *
  221.      */
  222.     function bind_textdomain_codeset($domain, $charset){
  223.         if ($this->has_gettext){
  224.             bind_textdomain_codeset($domain, $charset);
  225.         }
  226.         return $this->text_domains[$domain]["charset"] = $charset;
  227.     }
  228.  
  229.     /**
  230.      * Sets the path for a domain
  231.      * if gettext is unavailable, translation files will be loaded here
  232.      *
  233.      */
  234.     function bindtextdomain($domain, $path){
  235.         if ($this->has_gettext){
  236.             bindtextdomain($domain, $path);
  237.         } else {
  238.             $this->load($domain, $path);
  239.         }
  240.         return $this->text_domains[$domain]["path"] = $path;
  241.     }
  242.  
  243.     /**
  244.      * Sets the default domain textdomain
  245.      */
  246.     function textdomain($domain = null){
  247.         if ($this->has_gettext) {
  248.           $this->domain = textdomain($domain);
  249.         }
  250.         elseif (!is_null($domain)) {
  251.             $this->domain = $domain;
  252.             $this->load($domain, $this->text_domains[$this->domain]['path']);
  253.         }
  254.         return $this->domain;
  255.     }
  256.  
  257.     /**
  258.      * Overrides the domain for a single lookup
  259.      * This function allows you to override the current domain for a single message lookup.
  260.      * It also allows you to specify a category.
  261.      * Categories are folders within the languages directory  .
  262.      * currently, only LC_MESSAGES is implemented
  263.      *
  264.      *   The values for categories are:
  265.      *   LC_CTYPE        0
  266.      *   LC_NUMERIC      1
  267.      *   LC_TIME         2
  268.      *   LC_COLLATE      3
  269.      *   LC_MONETARY     4
  270.      *   LC_MESSAGES     5
  271.      *   LC_ALL          6
  272.      *
  273.      *   not yet implemented
  274.      */
  275.     function dcgettext($domain, $message, $category){
  276.         return $message;
  277.     }
  278.  
  279.     /**
  280.      * dcngettext -- Plural version of dcgettext
  281.      * not yet implemented
  282.      */
  283.     function dcngettext($domain, $msg1, $msg2, $count, $category){
  284.         return $msg1;
  285.     }
  286.  
  287.  
  288.     /**
  289.      * Plural-Forms: nplurals=2; plural=n == 1 ? 0 : 1;
  290.      *
  291.      * nplurals - total number of plurals
  292.      * plural   - the plural index
  293.      *
  294.      * Plural-Forms: nplurals=1; plural=0;
  295.      * 1 form only
  296.      *
  297.      * Plural-Forms: nplurals=2; plural=n == 1 ? 0 : 1;
  298.      * Plural-Forms: nplurals=2; plural=n != 1;
  299.      * 2 forms, singular used for one only
  300.      *
  301.      * Plural-Forms: nplurals=2; plural=n>1;
  302.      * 2 forms, singular used for zero and one
  303.      *
  304.      * Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;
  305.      * 3 forms, special case for zero
  306.      *
  307.      * Plural-Forms: nplurals=3; plural=n==1 ? 0 : n==2 ? 1 : 2;
  308.      * 3 forms, special cases for one and two
  309.      *
  310.      * Plural-Forms: nplurals=4; plural=n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3;
  311.      * 4 forms, special case for one and all numbers ending in 02, 03, or 04
  312.      */
  313.     function getplural($count, $domain) {
  314.         if (isset($this->headers[$domain]['Plural-Forms'])) {
  315.             $plural_forms = $this->headers[$domain]['Plural-Forms'];
  316.             preg_match('/nplurals[\s]*[=]{1}[\s]*([\d]+);[\s]*plural[\s]*[=]{1}[\s]*(.*);/', $plural_forms, $matches);
  317.             $nplurals   = $matches[1];
  318.             $plural_exp = $matches[2];
  319.             if ($nplurals > 1 && strpos($plural_exp, ':') === false) {
  320.                 $plural =  'return ('.preg_replace('/n/', $count, $plural_exp).') ? 1 : 0;';
  321.             } else {
  322.                 $plural = 'return '.preg_replace('/n/', $count, $plural_exp).';';
  323.             }
  324.         } else {
  325.             $plural = 'return '.preg_replace('/n/', $count, 'n != 1 ? 1 : 0;');
  326.         }
  327.         return eval($plural);
  328.     }
  329.  
  330.     function load($domain, $path) {
  331.         $root = dirname(__FILE__);
  332.         require_once($root.'/phpgettext.catalog.php');
  333.         $catalog = new PHPGettext_catalog($domain, $path);
  334.         $catalog->setproperty('mode', _MODE_MO_);
  335.         $catalog->setproperty('lang', $this->lang);
  336.         $catalog->load();
  337.         $this->headers[$domain] = $catalog->headers;
  338.         foreach ($catalog->strings as $string)
  339.         $this->messages[$domain][$string->msgid] = $string->msgstr;
  340.     }
  341.     //Thank you - Inicio Agregado Andres Felipe Vargas
  342.     function add($domain) {
  343.         $catalog = new PHPGettext_catalog($domain, $this->text_domains[$this->domain]["path"]);
  344.         $catalog->setproperty('mode', _MODE_MO_);
  345.         $catalog->setproperty('lang', $this->lang);
  346.         $catalog->load();
  347.         foreach ($catalog->strings as $string)
  348.         $this->messages[$this->domain][$string->msgid] = $string->msgstr;
  349.     }
  350.     //end Inicio Agregado Andres Felipe Vargas
  351.  
  352. }
  353.  
  354.  
  355. class PHPGettextAdmin
  356. {
  357.     var $has_gettext    = false;
  358.     var $gettext_path   = '';
  359.     var $debug          = false;
  360.     var $is_windows     = false;
  361.  
  362.     function PHPGettextAdmin($debug = false)
  363.     {
  364.         if (ini_get('open_basedir') || ini_get('safe_mode') || strstr(ini_get("disable_functions"),"exec")) {
  365.             $this->has_gettext = false;
  366.             return false;
  367.         }
  368.         
  369.         if (substr(strtoupper(PHP_OS), 0, 3) == 'WIN'){
  370.             $this->is_windows = true;
  371.         }
  372.         
  373.         $cmd = 'xgettext --help';
  374.         exec($cmd, $output, $return);
  375.         if ($output) {
  376.             $this->has_gettext = true;
  377.         }
  378.         if ($debug) {
  379.             $this->debug = $debug;
  380.         }
  381.     }
  382.  
  383.     /**
  384.      * Enter description here...
  385.      *
  386.      * @param unknown_type $domain 
  387.      * @param unknown_type $langdir 
  388.      */
  389.     function message_format ($domain, $textdomain, $lang, $enc='utf-8')
  390.     {
  391.         $path   = "$textdomain/$lang";
  392.         if ($this->has_gettext) {
  393.             $cmd = $this->escCommand("msgfmt")." -o ".$this->escPath("{$path}/LC_MESSAGES/{$domain}.mo")." ".$this->escPath("{$path}/{$domain}.po");
  394.             return $this->execute($cmd);
  395.         }
  396.         $catalog = new PHPGettext_catalog($domain, $textdomain);
  397.         $catalog->setproperty('mode', _MODE_PO_);
  398.         $catalog->setproperty('lang', $lang);
  399.         $catalog->load();
  400.         $catalog->setproperty('mode', _MODE_MO_);
  401.         $catalog->save();
  402.         return true;
  403.     }
  404.     /**
  405.      * Enter description here...
  406.      *
  407.      * @param unknown_type $domain 
  408.      * @param unknown_type $langdir 
  409.      */
  410.     function compile($lang, $textdomain, $enc='utf-8') {
  411.         if (!is_dir("$textdomain/$lang/LC_MESSAGES")) {
  412.             mkdir("$textdomain/$lang/LC_MESSAGES/");
  413.         }
  414.         $catalog = new PHPGettext_catalog($lang, $textdomain);
  415.         $catalog->setproperty('mode', _MODE_PO_);
  416.         $catalog->setproperty('lang', $lang);
  417.         $headers = $this->header();
  418.         $catalog->setproperty('comments', $headers[0]);
  419.         $catalog->setproperty('headers', $headers[1]);
  420.         $catalog->load();
  421.         $d = dir($textdomain."/".$lang);
  422.         while (false !== ($file = $d->read())){
  423.            if (preg_match('/.po$/', $file)){
  424.                 list($file,$ext) = explode(".",$file);
  425.                 $catalog_aux = new PHPGettext_catalog($file, $textdomain);
  426.                 $catalog_aux->setproperty('mode', _MODE_PO_);
  427.                 $catalog_aux->setproperty('lang', $lang);
  428.                 $catalog_aux->load();
  429.                 foreach ($catalog_aux->strings as $msgid => $string){
  430.                    if (!$string->is_fuzzy){
  431.                         if (is_array($string->msgstr) ){
  432.                             if(in_array("",$string->msgstr)){
  433.                                 continue;
  434.                             }
  435.                         } else if (!$string->msgstr){
  436.                             continue;
  437.                         }
  438.                        $catalog->addentry($string->msgid, $string->msgid_plural,$string->msgstr, $string->comments );
  439.                    }
  440.                 }
  441.            }
  442.         }
  443.         $catalog->setproperty('mode', _MODE_MO_);
  444.         $catalog->save();
  445.         return true;
  446.     }
  447.  
  448.     /**
  449.      * Enter description here...
  450.      *
  451.      * @param unknown_type $domain 
  452.      * @param unknown_type $langdir 
  453.      */
  454.     function initialize_translation ($domain, $textdomain, $lang, $enc='utf-8')
  455.     {
  456.         if (!$this->has_gettext) {
  457.             return false;
  458.         }
  459.         set_time_limit(120);
  460.         $path   = "$textdomain/$lang";
  461.         copy("$textdomain/untranslated/$domain.pot", "$path/ref.po");
  462.         $cmd = $this->escCommand("msgmerge")." --width=80 --compendium ".$this->escPath("{$textdomain}/glossary/{$lang}.{$enc}.po")." -o ".$this->escPath("{$path}/{$domain}.po")." ".$this->escPath("{$path}/ref.po")." ".$this->escPath("{$textdomain}/untranslated/{$domain}.pot");
  463.         $this->execute($cmd);
  464.         unlink("$textdomain/$lang/ref.po");
  465.     }
  466.  
  467.     /**
  468.      * Enter description here...
  469.      *
  470.      * @param unknown_type $domain 
  471.      * @param unknown_type $langdir 
  472.      */
  473.     
  474.     function update_translation($domain, $textdomain, $lang, $enc='utf-8')
  475.     {
  476.         if (!file_exists("$textdomain/glossary/$lang.$enc.po")) return false;
  477.         $catalog_aux = new PHPGettext_catalog($lang.".".$enc, $textdomain);
  478.         $catalog_aux->setproperty('mode', _MODE_GLO_);
  479.         $catalog_aux->setproperty('lang', $lang);
  480.         $catalog_aux->load();
  481.         foreach ($catalog_aux->strings as $msgid => $string){
  482.            if (!$string->is_fuzzy){
  483.               $trans[$string->msgid] = $string->msgstr;
  484.            }
  485.         }
  486.         $catalog = new PHPGettext_catalog($domain, $textdomain);
  487.         $catalog->setproperty('mode', _MODE_PO_);
  488.         $catalog->setproperty('lang', $lang);
  489.         $catalog->load();
  490.         global $mapcharset;
  491.         $charsets = explode("=",$catalog->headers["Content-Type"]);
  492.         $codecharset = str_replace("\\n","",strtolower($charsets[1]));
  493.         $NewEncoding = new ConvertCharset();
  494.         foreach ($trans as $key => $tran){
  495.                if(trim($mapcharset[$codecharset])!="utf-8")
  496.                     $trans[$key] = $NewEncoding->Convert($tran,"utf-8",trim($mapcharset[$codecharset]),false);
  497.         }
  498.         $catalog->translate($trans );
  499.         $catalog->save();
  500.         return true;
  501.     }
  502.     
  503.     /**
  504.      * Enter description here...
  505.      *
  506.      * @param unknown_type $domain 
  507.      * @param unknown_type $langdir 
  508.      */
  509.  
  510.     function add_to_dict($domain, $textdomain, $lang, $enc='utf-8') {
  511.         $textdomain = rtrim($textdomain, '\/');
  512.         $path = "$textdomain/$lang";
  513.  
  514.         if (!is_dir("$textdomain/glossary/")) {
  515.             mkdir("$textdomain/glossary/");
  516.         }
  517.         
  518.         $catalog = new PHPGettext_catalog($domain, $textdomain);
  519.         $catalog->setproperty('mode', _MODE_PO_);
  520.         $catalog->setproperty('lang', $lang);
  521.         $catalog->setproperty('charset', $enc);
  522.         $catalog->load();
  523.  
  524.         foreach ($catalog->strings as $msgid => $string){
  525.            if (!$string->is_fuzzy){
  526.               if (is_array($string->msgstr) ){
  527.                   if(in_array("",$string->msgstr)){
  528.                   continue;
  529.                   }
  530.               } else if (!$string->msgstr){
  531.                   continue;
  532.               }
  533.               $new[$string->msgid] = $string;
  534.            }
  535.         }
  536.  
  537.         $glossary = new PHPGettext_catalog($lang.".".$enc, $textdomain);
  538.         $glossary->setproperty('mode', _MODE_GLO_);
  539.         $glossary->setproperty('lang', $lang);        
  540.         if (!file_exists("$textdomain/glossary/$lang.$enc.po")) {
  541.             $headers = $this->header();
  542.             $glossary->setproperty('comments', $headers[0]);
  543.             $glossary->setproperty('headers', $headers[1]);
  544.             $glossary->save();
  545.         }else{
  546.             $glossary->load();
  547.         }
  548.         
  549.         $glossary->merge($new );
  550.         $glossary->save();
  551.         
  552.         $language = new mamboLanguage($lang);
  553.         $language->save();
  554.         return true;
  555.     }
  556.     /**
  557.      * Enter description here...
  558.      *
  559.      * @param unknown_type $domain 
  560.      * @param unknown_type $langdir 
  561.      */
  562.     function convert_charset($domain, $textdomain, $lang, $from_charset, $to_charset) {
  563.  
  564.         $path = "$textdomain/$lang";
  565.         if ($this->has_gettext) {
  566.             $cmd = $this->escCommand("msgconv")." --to-code=$to_charset -o ".$this->escPath("{$path}/{$domain}.po")." ".$this->escPath("{$path}/{$domain}.po");
  567.             $ret = $this->execute($cmd);
  568.             return $ret;
  569.         }
  570.  
  571.         if (!class_exists('ConvertCharset')) {
  572.             return false;
  573.         }
  574.  
  575.         $catalog = new PHPGettext_catalog($domain, $textdomain);
  576.         $catalog->setproperty('mode', _MODE_PO_);
  577.         $catalog->setproperty('lang', $lang);
  578.         $catalog->load();
  579.         $catalog->headers['Content-Type'] = "text/plain; charset=$to_charset\n";
  580.         $NewEncoding = new ConvertCharset();
  581.         foreach ($catalog->strings as $index => $message) {
  582.             if (empty($message->msgid_plural)) {
  583.                 $catalog->strings[$index]->msgstr = $NewEncoding->Convert($message->msgstr,$from_charset,$to_charset,false);
  584.             }
  585.         }
  586.         $catalog->save();
  587.         return true;
  588.     }
  589.  
  590.  
  591.     /**
  592.      * Invoke the xgettext utility with $args
  593.      * the xgettext executable must be in PATH
  594.      *
  595.      * @param string the commandline arguments to gettext
  596.      * @return unknown 
  597.      */
  598.     function xgettext($domain, $textdomain, $php_sources, $lang='untranslated') {
  599.         $path = mamboCore::get('rootPath');
  600.         $n=count($php_sources);
  601.         if (!$n) return false;
  602.         $cmd  = $this->escCommand("xgettext");
  603.         if (file_exists("$textdomain/$lang/$domain.pot")) $cmd  .= ' -j ';
  604.         $cmd  .= " -n -c --sort-by-file --keyword=T_ --keyword=Tn_:1,2 --keyword=Td_:2 --keyword=Tdn_:2,3 --output-dir=".$this->escPath("{$textdomain}/{$lang}")." -o {$domain}.pot";
  605.         if (count($php_sources) > 10) {
  606.             $tmp_name = substr(uniqid(),0,8).".txt";
  607.             $tmpfile = $path."/media/$tmp_name";
  608.             $fp = fopen($tmpfile, "w");
  609.             fwrite($fp, implode("\r\n", $php_sources));
  610.             fclose($fp);
  611.             $cmd = $cmd." --files-from=".$this->escPath($tmpfile);
  612.         } else {
  613.             for($i=0;$i<$n;$i++){ 
  614.                 $php_sources[$i] = $this->escPath($php_sources[$i]);
  615.             }
  616.             $cmd = $cmd." ".implode(" ", $php_sources);
  617.         }
  618.         $ret = $this->execute($cmd);
  619.         @unlink($tmpfile);
  620.  
  621.         return $ret;
  622.     }
  623.  
  624.     
  625.     /**
  626.      * Enter description here...
  627.      *
  628.      * @param unknown_type $domain 
  629.      * @param unknown_type $langdir 
  630.      */
  631.     function execute($cmd) {
  632.  
  633.         if (!$this || !$this->has_gettext) return false;
  634.  
  635.         $lastline = exec($cmd, $output, $retval);
  636.         if ($this->debug || $retval > 0) {
  637.             $trace = debug_backtrace();
  638.             $msg = "<div style=\"border: thin solid silver; text-align:left;margin-left:10px\">";
  639.             $msg .= "<p><span style=\"font-weight:bold\">PHPGettextAdmin->execute('</span><i>$cmd</i><span style=\"font-weight:bold\">')</span><br/>in ".str_replace($_SERVER['DOCUMENT_ROOT'], '', $trace[1]['file']).":{$trace[1]['line']}</p>";
  640.             $msg .= "<p><i><b>trace:</b></i></p><ul>";
  641.             for ($a=1; $a < 3; $a++)  {
  642.                 $called = isset($trace[$a]['class']) ? $trace[$a]['class'] : '';
  643.                 $called .= $trace[$a]['type'].$trace[$a]['function']."(".@implode(', ',$trace[$a]['args']).")";
  644.                 $msg .= "<li>$called in ".str_replace($_SERVER['DOCUMENT_ROOT'], '', $trace[$a]['file'])." : {$trace[$a]['line']}</li>";
  645.             }
  646.             $msg .= "</ul>";
  647.             $msg .= "<p><i><b>return value:</b></i>  $retval</p>";
  648.             $msg .= "<p><i><b>output:</b></i> </p><pre>".implode("<br/>",$output)."</pre>";
  649.             $msg .= "</div>";
  650.             echo $msg;
  651.         }
  652.         return $retval == 0;
  653.     }
  654.     
  655.     function escCommand($command){
  656.         if ($this->is_windows){
  657.            $command = "call \"{$command}\"";
  658.         }
  659.         return $command;
  660.     }
  661.  
  662.     function escPath($path){
  663.         if ($this->is_windows){
  664.            $path = "\"".str_replace("/","\\",$path)."\"";
  665.         }
  666.         return $path;
  667.     }
  668.  
  669.     function header($charset='utf-8', $plurals='nplurals=2; plural=n == 1 ? 0 : 1;'){
  670.         $year = date('Y');
  671.         $comments = <<<EOT
  672. # Mambo Open Source.
  673. # Copyright (C) 2005 - $year Mambo Foundation Inc.
  674. # This file is distributed under the same license as the Mambo package.
  675. # Translation Team <translation@mambo-foundation.org>, $year#
  676. #
  677. #, fuzzy
  678. EOT;
  679.         $comments = explode("\n", $comments);
  680.         $headers = array(
  681.         'Project-Id-Version'    => 'Mambo 4.6',
  682.         'Report-Msgid-Bugs-To'  => 'translation@mambo-foundation.org',
  683.         'POT-Creation-Date'     => date('Y-m-d h:iO'),
  684.         'PO-Revision-Date'      => date('Y-m-d h:iO'),
  685.         'Last-Translator'       => 'Translation <translation@mambo-foundation.org>',
  686.         'Language-Team'         => 'Translation <translation@mambo-foundation.org>',
  687.         'MIME-Version'          => '1.0',
  688.         'Content-Type'          => 'text/plain; charset='.$charset,
  689.         'Content-Transfer-Encoding' => '8bit',
  690.         'Plural-Forms'              => $plurals
  691.         );
  692.         return array($comments, $headers);
  693.     }
  694. }
  695.  
  696. /**
  697.  * Enter description here...
  698.  *
  699.  * @return unknown 
  700.  */
  701. function &phpgettext(){
  702.     static $gettext;
  703.     $root = dirname(__FILE__);
  704.     if (is_null($gettext)) {
  705.         require_once($root.'/phpgettext.class.php');
  706.         $gettext = new PHPGettext();
  707.         $gettext->has_gettext = true;
  708.         if (!function_exists("gettext") || !function_exists("_")) {
  709.             $gettext->has_gettext = false;
  710.             require_once($root.'/phpgettext.compat.php');
  711.         }
  712.     }
  713.     return $gettext;
  714. }
  715. function T_($message) {
  716.     $gettext =& phpgettext();
  717.     $trans = $gettext->gettext($message);
  718.     return $trans;
  719. }
  720. function Tn_($msg1, $msg2, $count) {
  721.     $gettext =& phpgettext();
  722.     return $gettext->ngettext($msg1, $msg2, $count);
  723. }
  724. function Td_($domain, $message) {
  725.     $gettext =& phpgettext();
  726.     return $gettext->dgettext($domain, $message);
  727. }
  728. function Tdn_($domain, $msg1, $msg2, $count) {
  729.     $gettext =& phpgettext();
  730.     return $gettext->dngettext($domain, $msg1, $msg2, $count);
  731. }
  732. ?>

Documentation generated on Mon, 05 May 2008 16:22:25 +0400 by phpDocumentor 1.4.0