* @version $Revision: 463 $ * @date $Date: 2006-11-18 23:25:24 +0100 (Sat, 18 Nov 2006) $ * @license http://www.gnu.org/licenses/gpl.html GNU General Public * License (GPL) * @package PEL */ /* Initialize Gettext, if available. This must be done before any * part of PEL calls Pel::tra() or Pel::fmt() --- this is ensured if * every piece of code using those two functions require() this file. * * If Gettext is not available, wrapper functions will be created, * allowing PEL to function, but without any translations. * * The PEL translations are stored in './locale'. It is important to * use an absolute path here because the lookups will be relative to * the current directory. */ if (function_exists('dgettext')) { bindtextdomain('pel', dirname(__FILE__) . '/locale'); } else { /** * Pretend to lookup a message in a specific domain. * * This is just a stub which will return the original message * untranslated. The function will only be defined if the Gettext * extension has not already defined it. * * @param string $domain the domain. * * @param string $str the message to be translated. * * @return string the original, untranslated message. */ function dgettext($domain, $str) { return $str; } } /** * Class with miscellaneous static methods. * * This class will contain various methods that govern the overall * behavior of PEL. * * Debugging output from PEL can be turned on and off by assigning * true or false to {@link Pel::$debug}. * * @author Martin Geisler * @package PEL */ class Pel { /** * Flag for controlling debug information. * * The methods producing debug information ({@link debug()} and * {@link warning()}) will only output something if this variable is * set to true. * * @var boolean */ private static $debug = false; /** * Flag for strictness of parsing. * * If this variable is set to true, then most errors while loading * images will result in exceptions being thrown. Otherwise a * warning will be emitted (using {@link Pel::warning}) and the * exceptions will be appended to {@link Pel::$exceptions}. * * Some errors will still be fatal and result in thrown exceptions, * but an effort will be made to skip over as much garbage as * possible. * * @var boolean */ private static $strict = false; /** * Stored exceptions. * * When {@link Pel::$strict} is set to false exceptions will be * accumulated here instead of being thrown. */ private static $exceptions = array(); /** * Return list of stored exceptions. * * When PEL is parsing in non-strict mode, it will store most * exceptions instead of throwing them. Use this method to get hold * of them when a call returns. * * Code for using this could look like this: * * * Pel::setStrictParsing(true); * Pel::clearExceptions(); * * $jpeg = new PelJpeg($file); * * // Check for exceptions. * foreach (Pel::getExceptions() as $e) { * printf("Exception: %s\n", $e->getMessage()); * if ($e instanceof PelEntryException) { * // Warn about entries that couldn't be loaded. * printf("Warning: Problem with %s.\n", * PelTag::getName($e->getType(), $e->getTag())); * } * } * * * This gives applications total control over the amount of error * messages shown and (hopefully) provides the necessary information * for proper error recovery. * * @return array the exceptions. */ static function getExceptions() { return self::$exceptions; } /** * Clear list of stored exceptions. * * Use this function before a call to some method if you intend to * check for exceptions afterwards. */ static function clearExceptions() { self::$exceptions = array(); } /** * Conditionally throw an exception. * * This method will throw the passed exception when strict parsing * in effect (see {@link setStrictParsing()}). Otherwise the * exception is stored (it can be accessed with {@link * getExceptions()}) and a warning is issued (with {@link * Pel::warning}). * * @param PelException $e the exceptions. */ static function maybeThrow(PelException $e) { if (self::$strict) { throw $e; } else { self::$exceptions[] = $e; self::warning('%s (%s:%s)', $e->getMessage(), basename($e->getFile()), $e->getLine()); } } /** * Enable/disable strict parsing. * * If strict parsing is enabled, then most errors while loading * images will result in exceptions being thrown. Otherwise a * warning will be emitted (using {@link Pel::warning}) and the * exceptions will be stored for later use via {@link * getExceptions()}. * * Some errors will still be fatal and result in thrown exceptions, * but an effort will be made to skip over as much garbage as * possible. * * @param boolean $flag use true to enable strict parsing, false to * diable. */ function setStrictParsing($flag) { self::$strict = $flag; } /** * Get current setting for strict parsing. * * @return boolean true if strict parsing is in effect, false * otherwise. */ function getStrictParsing() { return self::$strict; } /** * Enable/disable debugging output. * * @param boolean $flag use true to enable debug output, false to * diable. */ function setDebug($flag) { self::$debug = $flag; } /** * Get current setting for debug output. * * @return boolean true if debug is enabled, false otherwise. */ function getDebug() { return self::$debug; } /** * Conditionally output debug information. * * This method works just like printf() except that it always * terminates the output with a newline, and that it only outputs * something if the {@link Pel::$debug} is true. * * @param string $format the format string. * * @param mixed $args,... any number of arguments can be given. The * arguments will be available for the format string as usual with * sprintf(). */ static function debug() { if (self::$debug) { $args = func_get_args(); $str = array_shift($args); vprintf($str . "\n", $args); } } /** * Conditionally output a warning. * * This method works just like printf() except that it prepends the * output with the string 'Warning: ', terminates the output with a * newline, and that it only outputs something if the PEL_DEBUG * defined to some true value. * * @param string $format the format string. * * @param mixed $args,... any number of arguments can be given. The * arguments will be available for the format string as usual with * sprintf(). */ static function warning() { if (self::$debug) { $args = func_get_args(); $str = array_shift($args); vprintf('Warning: ' . $str . "\n", $args); } } /** * Translate a string. * * This static function will use Gettext to translate a string. By * always using this function for static string one is assured that * the translation will be taken from the correct text domain. * Dynamic strings should be passed to {@link fmt} instead. * * @param string the string that should be translated. * * @return string the translated string, or the original string if * no translation could be found. */ static function tra($str) { return dgettext('pel', $str); } /** * Translate and format a string. * * This static function will first use Gettext to translate a format * string, which will then have access to any extra arguments. By * always using this function for dynamic string one is assured that * the translation will be taken from the correct text domain. If * the string is static, use {@link tra} instead as it will be * faster. * * @param string $format the format string. This will be translated * before being used as a format string. * * @param mixed $args,... any number of arguments can be given. The * arguments will be available for the format string as usual with * sprintf(). * * @return string the translated string, or the original string if * no translation could be found. */ static function fmt() { $args = func_get_args(); $str = array_shift($args); return vsprintf(dgettext('pel', $str), $args); } } ?>