Subversion Repositories Applications.papyrus

Rev

Rev 1688 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1463 alexandre_ 1 
<?php
2 
// +----------------------------------------------------------------------+
3 
// | PEAR :: I18Nv2                                                       |
4 
// +----------------------------------------------------------------------+
5 
// | This source file is subject to version 3.0 of the PHP license,       |
6 
// | that is available at http://www.php.net/license/3_0.txt              |
7 
// | If you did not receive a copy of the PHP license and are unable      |
8 
// | to obtain it through the world-wide-web, please send a note to       |
9 
// | license@php.net so we can mail you a copy immediately.               |
10 
// +----------------------------------------------------------------------+
11 
// | Copyright (c) 2004 Michael Wallner <mike@iworks.at>                  |
12 
// +----------------------------------------------------------------------+
13 
//
14 
// $Id: I18Nv2.php,v 1.1 2007-06-25 09:55:28 alexandre_tb Exp $
15 
 
16 
/**
17 
 * I18Nv2
18 
 *
19 
 * @package     I18Nv2
20 
 * @category    Internationalization
21 
 */
22 
 
23 
define('I18Nv2_WIN', defined('OS_WINDOWS') ? OS_WINDOWS : (strToUpper(substr(PHP_OS, 0,3)) === 'WIN'));
24 
 
25 
/**
26 
 * I18Nv2 - Internationalization v2
27 
 *
28 
 * @author      Michael Wallner <mike@php.net>
29 
 * @version     $Revision: 1.1 $
30 
 * @package     I18Nv2
31 
 * @access      public
32 
 * @static
33 
 */
34 
class I18Nv2
35 
{
36 
    /**
37 
     * Set Locale
38 
     *
39 
     * Example:
40 
     * <code>
41 
     * I18Nv2::setLocale('en_GB');
42 
     * </code>
43 
     *
44 
     * @static
45 
     * @access  public
46 
     * @return  mixed   &type.string; used locale or false on failure
47 
     * @param   string  $locale     a valid locale like en_US or de_DE
48 
     * @param   int     $cat        the locale category - usually LC_ALL
49 
     */
50 
    function setLocale($locale = null, $cat = LC_ALL)
51 
    {
52 
        if (!strlen($locale)) {
53 
            return setLocale($cat, null);
54 
        }
55 
 
56 
        $locales = I18Nv2::getStaticProperty('locales');
57 
 
58 
        // get complete standard locale code (en => en_US)
59 
        if (isset($locales[$locale])) {
60 
            $locale = $locales[$locale];
61 
        }
62 
 
63 
        // get Win32 locale code (en_US => enu)
64 
        if (I18Nv2_WIN) {
65 
            $windows   = I18Nv2::getStaticProperty('windows');
66 
            $setlocale = isset($windows[$locale]) ? $windows[$locale] : $locale;
67 
        } else {
68 
            $setlocale = $locale;
69 
        }
70 
 
71 
        $syslocale = setLocale($cat, $setlocale);
72 
 
73 
        // if the locale is not recognized by the system, check if there
74 
        // is a fallback locale and try that, otherwise return false
75 
        if (!$syslocale) {
76 
            $fallbacks = &I18Nv2::getStaticProperty('fallbacks');
77 
            if (isset($fallbacks[$locale])) {
78 
                // avoid endless recursion with circular fallbacks
79 
                $trylocale = $fallbacks[$locale];
80 
                unset($fallbacks[$locale]);
81 
                if ($retlocale = I18Nv2::setLocale($trylocale, $cat)) {
82 
                    $fallbacks[$locale] = $trylocale;
83 
                    return $retlocale;
84 
                }
85 
            }
86 
            return false;
87 
        }
88 
 
89 
        $language = substr($locale, 0,2);
90 
 
91 
        if (I18Nv2_WIN) {
92 
            @putEnv('LANG='     . $language);
93 
            @putEnv('LANGUAGE=' . $language);
94 
        } else {
95 
            @putEnv('LANG='     . $locale);
96 
            @putEnv('LANGUAGE=' . $locale);
97 
        }
98 
 
99 
        // unshift locale stack
100 
        $last = &I18Nv2::getStaticProperty('last');
101 
        array_unshift($last,
102 
            array(
103 
 
104 
                1           => $language,
105 
                2           => $syslocale,
106 
                'locale'    => $locale,
107 
                'language'  => $language,
108 
                'syslocale' => $syslocale,
109 
            )
110 
        );
111 
 
112 
        // fetch locale specific information
113 
        $info = &I18Nv2::getStaticProperty('info');
114 
        $info = localeConv();
115 
 
116 
        return $syslocale;
117 
    }
118 
 
119 
    /**
120 
     * Get current/prior Locale
121 
     *
122 
     * @static
123 
     * @access  public
124 
     * @return  mixed   last locale as string or array
125 
     * @param   int     $prior  if 0, the current otherwise n prior to current
126 
     * @param   bool    $part   true|all|0=locale|1=language|2=syslocale
127 
     */
128 
    function lastLocale($prior = 0, $part = 0)
129 
    {
130 
        $last = I18Nv2::getStaticProperty('last');
131 
        if (!isset($last)) {
132 
            return I18Nv2::setLocale();
133 
        }
134 
        if (!isset($last[$prior])) {
135 
            return null;
136 
        }
137 
        if ($part === true || $part == 'all') {
138 
            return $last[$prior];
139 
        }
140 
        return $last[$prior][$part];
141 
    }
142 
 
143 
    /**
144 
     * Get several locale specific information
145 
     *
146 
     * @see     http://www.php.net/localeconv
147 
     *
148 
     * <code>
149 
     * $locale = I18Nv2::setLocale('en_US');
150 
     * $dollar = I18Nv2::getInfo('currency_symbol');
151 
     * $point  = I18Nv2::getInfo('decimal_point');
152 
     * </code>
153 
     *
154 
     * @static
155 
     * @access  public
156 
     * @return  mixed
157 
     * @param   string  $part
158 
     */
159 
    function getInfo($part = null)
160 
    {
161 
        $info = &I18Nv2::getStaticProperty('info');
162 
        return isset($part, $info[$part]) ? $info[$part] : $info;
163 
    }
164 
 
165 
    /**
166 
     * Create a Locale object
167 
     *
168 
     * @static
169 
     * @access  public
170 
     * @return  object  I18Nv2_Locale
171 
     * @param   string  $locale     The locale to use.
172 
     * @param   bool    $paranoid   Whether to operate in paranoid mode.
173 
     */
174 
    function &createLocale($locale = null, $paranoid = false)
175 
    {
176 
        require_once 'I18Nv2/Locale.php';
177 
        $obj = &new I18Nv2_Locale($locale, $paranoid);
178 
        return $obj;
179 
    }
180 
 
181 
    /**
182 
     * Create a Negotiator object
183 
     *
184 
     * @static
185 
     * @access  public
186 
     * @return  object  I18Nv2_Negotiator
187 
     * @param   string  $defLang        default language
188 
     * @param   string  $defEnc         default encoding
189 
     * @param   string  $defCtry        default country
190 
     */
191 
    function &createNegotiator($defLang = 'en', $defEnc = 'iso-8859-1', $defCtry = '')
192 
    {
193 
        require_once 'I18Nv2/Negotiator.php';
194 
        $obj = &new I18Nv2_Negotiator($defLang, $defEnc, $defCtry);
195 
        return $obj;
196 
    }
197 
 
198 
    /**
199 
     * Automatically transform output between encodings
200 
     *
201 
     * This method utilizes ob_iconv_handler(), so you should call it at the
202 
     * beginning of your script (prior to output).  If any output buffering has
203 
     * been started before, the contents will be fetched with ob_get_contents()
204 
     * and the buffers will be destroyed by ob_end_clean() if $refetchOB is set
205 
     * to true.
206 
     *
207 
     * <code>
208 
     * require_once('I18Nv2.php');
209 
     * I18Nv2::autoConv('CP1252');
210 
     * print('...'); // some iso-8859-1 stuff gets converted to Windows-1252
211 
     * // ...
212 
     * </code>
213 
     *
214 
     * @static
215 
     * @access  public
216 
     * @return  mixed   Returns &true; on success or
217 
     *                  <classname>PEAR_Error</classname> on failure.
218 
     * @param   string  $oe             desired output encoding
219 
     * @param   string  $ie             internal encoding
220 
     * @param   bool    $decodeRequest  whether to decode request variables
221 
     *                                  ($_GET and $_POST) from $oe to $ie
222 
     * @param   bool    $refetchOB      whether contents of already active
223 
     *                                  output buffers should be fetched, the
224 
     *                                  output buffer handlers destroyed and
225 
     *                                  the fetched data be passed through
226 
     *                                  ob_iconvhandler
227 
     */
228 
    function autoConv($oe = 'UTF-8', $ie = 'ISO-8859-1', $decodeRequest = true, $refetchOB = true)
229 
    {
230 
        if (!strcasecmp($oe, $ie)) {
231 
            return true;
232 
        }
233 
 
234 
        if (!extension_loaded('iconv')) {
235 
            require_once 'PEAR.php';
236 
            if (!PEAR::loadExtension('iconv')) {
237 
                return PEAR::raiseError('Error: ext/iconv is not available');
238 
            }
239 
        }
240 
 
241 
        iconv_set_encoding('internal_encoding', $ie);
242 
        iconv_set_encoding('output_encoding', $oe);
243 
        iconv_set_encoding('input_encoding', $oe);
244 
 
245 
        $buffer = '';
246 
        if ($refetchOB && $level = ob_get_level()) {
247 
            while ($level--) {
248 
                $buffer .= ob_get_contents();
249 
                ob_end_clean();
250 
            }
251 
        }
252 
 
253 
        if (!ob_start('ob_iconv_handler')) {
254 
            require_once 'PEAR.php';
255 
            return PEAR::raiseError('Couldn\'t start output buffering');
256 
        }
257 
        echo $buffer;
258 
 
259 
        if ($decodeRequest) {
260 
            I18Nv2::recursiveIconv($_GET, $oe, $ie);
261 
            I18Nv2::recursiveIconv($_POST, $oe, $ie);
262 
        }
263 
 
264 
        return true;
265 
    }
266 
 
267 
    /**
268 
     * Recursive Iconv
269 
     *
270 
     * @static
271 
     * @access  public
272 
     * @return  void
273 
     * @param   array   $value
274 
     * @param   string  $from
275 
     * @param   string  $to
276 
     */
277 
    function recursiveIconv(&$value, $from, $to)
278 
    {
279 
        foreach ($value as $key => $val) {
280 
            if (is_array($val)) {
281 
                I18Nv2::recursiveIconv($value[$key], $from, $to);
282 
            } else {
283 
                $value[$key] = iconv($from, $to .'//TRANSLIT', $val);
284 
            }
285 
        }
286 
    }
287 
 
288 
    /**
289 
     * Traverse locales to languages
290 
     *
291 
     * Returns en-US, de-DE from en_US and de_DE
292 
     *
293 
     * @static
294 
     * @access  public
295 
     * @return  array
296 
     * @param   array   $locales
297 
     */
298 
    function locales2langs($locales)
299 
    {
300 
        return array_map(array('I18Nv2','l2l'), (array) $locales);
301 
    }
302 
 
303 
    /**
304 
     * Traverse languages to locales
305 
     *
306 
     * Returns en_US, de_DE from en-US and de-DE
307 
     *
308 
     * @static
309 
     * @access  public
310 
     * @return  array
311 
     * @param   array   $languages
312 
     */
313 
    function langs2locales($languages)
314 
    {
315 
        return array_map(array('I18Nv2','l2l'), (array) $languages);
316 
    }
317 
 
318 
    /**
319 
     * Locale to language or language to locale
320 
     *
321 
     * @static
322 
     * @access  public
323 
     * @return  string
324 
     * @param   string  $localeOrLanguage
325 
     */
326 
    function l2l($localeOrLanguage)
327 
    {
328 
        return strtr($localeOrLanguage, '-_', '_-');
329 
    }
330 
 
331 
    /**
332 
     * Split locale code
333 
     *
334 
     * Splits locale codes into its language and country part
335 
     *
336 
     * @static
337 
     * @access  public
338 
     * @return  array
339 
     * @param   string  $locale
340 
     */
341 
    function splitLocale($locale)
342 
    {
343 
        @list($l, $c) = preg_split('/[_-]/', $locale, 2, PREG_SPLIT_NO_EMPTY);
344 
        return array($l, $c);
345 
    }
346 
 
347 
    /**
348 
     * Get language code of locale
349 
     *
350 
     * @static
351 
     * @access  public
352 
     * @return  string
353 
     * @patram  string  $locale
354 
     */
355 
    function languageOf($locale)
356 
    {
357 
        return current($a = I18Nv2::splitLocale($locale));
358 
    }
359 
 
360 
    /**
361 
     * Get country code of locale
362 
     *
363 
     * @static
364 
     * @access  public
365 
     * @return  string
366 
     * @param   string  $locale
367 
     */
368 
    function countryOf($locale)
369 
    {
370 
        return end($a = I18Nv2::splitLocale($locale));
371 
    }
372 
 
373 
    /**
374 
     * Get access to static property
375 
     *
376 
     * @static
377 
     * @access  public
378 
     * @return  mixed   Returns a reference to a static property
379 
     * @param   string  $property   the static property
380 
     */
381 
    function &getStaticProperty($property)
382 
    {
383 
        static $properties;
384 
        return $properties[$property];
385 
    }
386 
 
387 
    /**
388 
     * This one gets called automatically
389 
     *
390 
     * @ignore
391 
     * @static
392 
     * @internal
393 
     * @access  private
394 
     * @return  void
395 
     */
396 
    function _main()
397 
    {
398 
        // initialize the locale stack
399 
        $last = &I18Nv2::getStaticProperty('last');
400 
        $last = array();
401 
 
402 
        // map of "fully qualified locale" codes
403 
        $locales = &I18Nv2::getStaticProperty('locales');
404 
        $locales = array(
405 
            'af' => 'af_ZA',
406 
            'de' => 'de_DE',
407 
            'en' => 'en_US',
408 
            'fr' => 'fr_FR',
409 
            'it' => 'it_IT',
410 
            'es' => 'es_ES',
411 
            'pt' => 'pt_PT',
412 
            'sv' => 'sv_SE',
413 
            'nb' => 'nb_NO',
414 
            'nn' => 'nn_NO',
415 
            'no' => 'no_NO',
416 
            'fi' => 'fi_FI',
417 
            'is' => 'is_IS',
418 
            'da' => 'da_DK',
419 
            'nl' => 'nl_NL',
420 
            'pl' => 'pl_PL',
421 
            'sl' => 'sl_SI',
422 
            'hu' => 'hu_HU',
423 
            'ru' => 'ru_RU',
424 
            'cs' => 'cs_CZ',
425 
        );
426 
 
427 
        // define locale fallbacks
428 
        $fallbacks = &I18Nv2::getStaticProperty('fallbacks');
429 
        $fallbacks = array(
430 
            'no_NO' => 'nb_NO',
431 
            'nb_NO' => 'no_NO',
432 
        );
433 
 
434 
        // include Win32 locale codes
435 
        if (I18Nv2_WIN) {
436 
            include_once 'I18Nv2/Locale/Windows.php';
437 
        }
438 
    }
439 
}
440 
 
441 
I18Nv2::_main();
442 
 
443 
?>