<?php
/**
* This file would normally be split into multiple files but since it must
* be fast (it gets loaded for every hit to the admin screen), we put it
* all in one file.
*/
/**
* Includes
*/
require_once 'File.php';
require_once 'File/Find.php';
require_once dirname(__FILE__).'/LocalizerConfig.php';
require_once dirname(__FILE__).'/LocalizerLanguage.php';
require_once dirname(__FILE__).'/LanguageMetadata.php';
/**
* Translate the given string and print it. This function accepts a variable
* number of parameters and works something like printf().
*
* @param string $p_translateString
* The string to translate.
*
* @return void
*/
function putGS($p_translateString)
{
$args = func_get_args();
echo call_user_func_array('getGS', $args);
} // fn putGS
/**
* Translate the given string and return it. This function accepts a variable
* number of parameters and works something like printf().
*
* @param string $p_translateString -
* The string to translate.
*
* @return string
*/
function getGS($p_translateString)
{
global $g_translationStrings, $TOL_Language;
$numFunctionArgs = func_num_args();
if (!isset($g_translationStrings[$p_translateString]) || ($g_translationStrings[$p_translateString]=='')) {
$translatedString = "$p_translateString (*)";
}
else {
$translatedString = $g_translationStrings[$p_translateString];
}
if ($numFunctionArgs > 1) {
for ($i = 1; $i < $numFunctionArgs; $i++){
$name = '$'.$i;
$val = func_get_arg($i);
$translatedString = str_replace($name, $val, $translatedString);
}
}
return $translatedString;
} // fn getGS
/**
* Register a string in the global translation file. (Legacy code for GS files)
*
* @param string $p_value
* @param string $p_key
* @return void
*/
function regGS($p_key, $p_value)
{
global $g_translationStrings;
if (isset($g_translationStrings[$p_key])) {
if ($p_key!='') {
print "The global string is already set in ".$_SERVER[PHP_SELF].": $key<BR>";
}
}
else{
if (substr($p_value, strlen($p_value)-3)==(":".$_REQUEST["TOL_Language"])){
$p_value = substr($p_value, 0, strlen($p_value)-3);
}
$g_translationStrings[$p_key] = $p_value;
}
} // fn regGS
/**
* The Localizer class handles groups of translation tables (LocalizerLanguages).
* This class simply acts as a namespace for a group of static methods.
*/
class Localizer {
/**
* Return the type of files we are currently using, currently
* either 'gs' or 'xml'. If not set in the config file, we will
* do our best to figure out the current mode.
*
* @return mixed
* Will return 'gs' or 'xml' on success, or NULL on failure.
*/
function GetMode()
{
global $g_localizerConfig;
if ($g_localizerConfig['DEFAULT_FILE_TYPE'] != '') {
return $g_localizerConfig['DEFAULT_FILE_TYPE'];
}
$defaultLang = new LocalizerLanguage('globals',
$g_localizerConfig['DEFAULT_LANGUAGE']);
if ($defaultLang->loadGsFile()) {
return 'gs';
}
elseif ($defaultLang->loadXmlFile()) {
return 'xml';
}
else {
return null;
}
} // fn GetMode
/**
* Load the translation strings into a global variable and return them.
*
* @param string $p_prefix -
* Beginning of the file name, before the ".php" extension.
* @param string $p_languageCode
* id of language to load
* @param bool $p_return
* return translation array
*
* @return void
*/
function LoadLanguageFiles($p_prefix, $p_languageCode = null, $p_return = false)
{
global $g_localizerConfig;
if ($p_return) {
static $g_translationStrings;
} else {
global $g_translationStrings;
}
if (is_null($p_languageCode)){
$p_languageCode = $g_localizerConfig['DEFAULT_LANGUAGE'];
}
if (!isset($g_translationStrings)) {
$g_translationStrings = array();
}
$key = $p_prefix."_".$g_localizerConfig['DEFAULT_LANGUAGE'];
if (!isset($g_localizerConfig['LOADED_FILES'][$key])) {
$defaultLang = new LocalizerLanguage($p_prefix, $g_localizerConfig['DEFAULT_LANGUAGE']);
$defaultLang->loadFile(Localizer::GetMode());
$defaultLangStrings = $defaultLang->getTranslationTable();
// Merge default language strings into the translation array.
#$g_translationStrings = array_merge($g_translationStrings, $defaultLangStrings);
$g_translationStrings = Localizer::_arrayValuesMerge($g_translationStrings, $defaultLangStrings);
$g_localizerConfig['LOADED_FILES'][$key] = true;
}
$key = $p_prefix."_".$p_languageCode;
if (!isset($g_localizerConfig['LOADED_FILES'][$key])) {
$userLang = new LocalizerLanguage($p_prefix, $p_languageCode);
$userLang->loadFile(Localizer::GetMode());
$userLangStrings = $userLang->getTranslationTable();
// Merge user strings into translation array.
#$g_translationStrings = array_merge($g_translationStrings, $userLangStrings);
$g_translationStrings = Localizer::_arrayValuesMerge($g_translationStrings, $userLangStrings);
$g_localizerConfig['LOADED_FILES'][$key] = true;
}
if ($p_return) {
return $g_translationStrings;
}
} // fn LoadLanguageFiles
function _arrayValuesMerge($arr1, $arr2)
{
foreach ($arr2 as $k=>$v) {
if (strlen($v)) {
$arr1[$k] = $v;
}
}
return $arr1;
}
/**
* Compare a particular language's keys with the default language set.
*
* @param string $p_prefix -
* The prefix of the language files.
*
* @param array $p_data -
* A set of keys.
*
* @param boolean $p_findExistingKeys -
* Set this to true to return the set of keys (of the keys given) that already exist,
* set this to false to return the set of keys (of the keys given) that do not exist.
*
* @return array
*/
function CompareKeys($p_prefix, $p_data, $p_findExistingKeys = true)
{
global $g_localizerConfig;
$localData = new LocalizerLanguage($p_prefix,
$g_localizerConfig['DEFAULT_LANGUAGE']);
$localData->loadFile(Localizer::GetMode());
$globaldata = new LocalizerLanguage($g_localizerConfig['FILENAME_PREFIX_GLOBAL'],
$g_localizerConfig['DEFAULT_LANGUAGE']);
$globaldata->loadFile(Localizer::GetMode());
$returnValue = array();
foreach ($p_data as $key) {
$globalKeyExists = $globaldata->keyExists($key);
$localKeyExists = $localData->keyExists($key);
if ($p_findExistingKeys && ($globalKeyExists || $localKeyExists)) {
$returnValue[$key] = $key;
}
elseif (!$p_findExistingKeys && !$globalKeyExists && !$localKeyExists) {
$returnValue[$key] = $key;
}
}
return $returnValue;
} // fn CompareKeys
/**
* Search through PHP files and find all the strings that need to be translated.
* @param string $p_directory -
* @return array
*/
function FindTranslationStrings($p_prefix, $p_depth=0)
{
global $g_localizerConfig;
//Start search here
$dir = $g_localizerConfig["mapPrefixToDir"][$p_prefix]['path'];
$depth = $g_localizerConfig["mapPrefixToDir"][$p_prefix]['depth'];
// Scan which files
$filePatterns = $g_localizerConfig['mapPrefixToDir'][$p_prefix]['filePatterns'];
$execludePattern = $g_localizerConfig['mapPrefixToDir'][$p_prefix]['execlPattern'];
if ($g_localizerConfig['DEBUG']) echo "<br>Scan files match ".print_r($filePatterns, 1);
// Scan for what
$funcPatterns = $g_localizerConfig['mapPrefixToDir'][$p_prefix]['funcPatterns'];
if ($g_localizerConfig['DEBUG']) echo "<br>Scan for ".print_r($funcPatterns, 1);
// Get all files in this directory
if ($g_localizerConfig['DEBUG']) echo "<br>Search in: {$g_localizerConfig['BASE_DIR']}$dir Depth: {$depth}";
$files = File_Find::mapTreeMultiple($g_localizerConfig['BASE_DIR'].$dir, $depth);
$files = Localizer::_flatFileList($files);
#print_r($files);
// Get all the Matching files
foreach ($filePatterns as $fp) {
foreach ($files as $name) {
if (preg_match($fp, $name) && !preg_match($execludePattern, $name)) {
$filelist[] = $name;
}
}
reset($files);
}
#print_r($filelist);
// Read in all the PHP files.
$data = array();
foreach ($filelist as $name) {
$data = array_merge($data, file($g_localizerConfig['BASE_DIR'].$dir.'/'.$name));
}
#print_r($data);
// Collect all matches
$matches = array();
foreach ($data as $line) {
foreach ($funcPatterns as $fp => $pos) {
if (preg_match_all($fp, $line, $m)) {
foreach ($m[$pos] as $match) {
#$match = str_replace("\\\\", "\\", $match);
if (strlen($match)) $matches[$match] = $match;
}
}
}
reset($funcPatterns);
}
asort($matches);
#print_r($matches);
return $matches;
} // fn FindTranslationStrings
function _flatFileList($files, $appdir='', $init=TRUE)
{
static $_flatList;
if ($init === TRUE) $_flatList = array();
foreach ($files as $dir => $name) {
if (is_array($name)) {
Localizer::_flatFileList($name, $appdir.'/'.$dir, FALSE);
} else {
$_flatList[] = $appdir.'/'.$name;
}
}
return $_flatList;
}
/**
* Return the set of strings in the code that are not in the translation files.
* @param string $p_directory -
* @return array
*/
function FindMissingStrings($p_prefix)
{
global $g_localizerConfig;
if (empty($p_prefix)) {
return array();
}
$newKeys =& Localizer::FindTranslationStrings($p_prefix);
$missingKeys =& Localizer::CompareKeys($p_prefix, $newKeys, false);
$missingKeys = array_unique($missingKeys);
return $missingKeys;
} // fn FindMissingStrings
/**
* Return the set of strings in the translation files that are not used in the code.
* @param string $p_prefix
* @param string $p_directory -
* @return array
*/
function FindUnusedStrings($p_prefix)
{
global $g_localizerConfig;
if (empty($p_prefix)) {
return array();
}
$existingKeys =& Localizer::FindTranslationStrings($p_prefix);
$localData = new LocalizerLanguage($p_prefix, $g_localizerConfig['DEFAULT_LANGUAGE']);
$localData->loadFile(Localizer::GetMode());
$localTable = $localData->getTranslationTable();
$unusedKeys = array();
foreach ($localTable as $key => $value) {
if (!in_array($key, $existingKeys)) {
$unusedKeys[$key] = $key;
}
}
$unusedKeys = array_unique($unusedKeys);
return $unusedKeys;
} // fn FindUnusedStrings
/**
* Update a set of strings in a language file.
* @param string $p_prefix
* @param string $p_languageCode
* @param array $p_data
*
* @return void
*/
function ModifyStrings($p_prefix, $p_languageId, $p_data)
{
global $g_localizerConfig;
// If we change a string in the default language,
// then all the language files must be updated with the new key.
if ($p_languageId == $g_localizerConfig['DEFAULT_LANGUAGE']) {
$languages = Localizer::GetAllLanguages();
foreach ($languages as $language) {
// Load the language file
$source = new LocalizerLanguage($p_prefix, $language->getLanguageId());
$source->loadFile(Localizer::GetMode());
// For the default language, we set the key & value to be the same.
if ($p_languageId == $language->getLanguageId()) {
foreach ($p_data as $pair) {
$source->updateString($pair['key'], $pair['value'], $pair['value']);
}
}
// For all other languages, we just change the key and keep the old value.
else {
foreach ($p_data as $pair) {
$source->updateString($pair['key'], $pair['value']);
}
}
// Save the file
$source->saveFile(Localizer::GetMode());
}
}
// We only need to change the values in one file.
else {
// Load the language file
$source = new LocalizerLanguage($p_prefix, $p_languageId);
$source->loadFile(Localizer::GetMode());
foreach ($p_data as $pair) {
$source->updateString($pair['key'], $pair['key'], $pair['value']);
}
// Save the file
$source->saveFile(Localizer::GetMode());
}
} // fn ModifyStrings
/**
* Synchronize the positions of the strings to the default language file order.
* @param string $p_prefix
* @return void
*/
function FixPositions($p_prefix)
{
global $g_localizerConfig;
$defaultLanguage = new LocalizerLanguage($p_prefix, $g_localizerConfig['DEFAULT_LANGUAGE']);
$defaultLanguage->loadFile(Localizer::GetMode());
$defaultTranslationTable = $defaultLanguage->getTranslationTable();
$languageIds = Localizer::GetAllLanguages();
foreach ($languageIds as $languageId) {
// Load the language file
$source = new LocalizerLanguage($p_prefix, $languageId);
$source->loadFile(Localizer::GetMode());
$count = 0;
foreach ($defaultTranslationTable as $key => $value) {
$source->moveString($key, $count);
$count++;
}
// Save the file
$source->saveFile(Localizer::GetMode());
}
} // fn FixPositions
/**
* Go through all files matching $p_prefix in $p_directory and add entry(s).
*
* @param string $p_prefix
* @param int $p_position
* @param array $p_newKey
*
* @return void
*/
function AddStringAtPosition($p_prefix, $p_position, $p_newKey)
{
global $g_localizerConfig;
$languages = Localizer::GetAllLanguages();
foreach ($languages as $language) {
$source = new LocalizerLanguage($p_prefix, $language->getLanguageId());
$source->loadFile(Localizer::GetMode());
if (is_array($p_newKey)) {
foreach (array_reverse($p_newKey) as $key) {
if ($language->getLanguageId() == $g_localizerConfig['DEFAULT_LANGUAGE']) {
$source->addString($key, $key, $p_position);
}
else {
$source->addString($key, '', $p_position);
}
}
}
else {
if ($Id == $g_localizerConfig['DEFAULT_LANGUAGE']) {
$source->addString($p_newKey, $p_newKey, $p_position);
}
else {
$source->addString($p_newKey, '', $p_position);
}
}
$source->saveFile(Localizer::GetMode());
}
} // fn AddStringAtPosition
/**
* Go through all files matching $p_prefix remove selected entry.
* @param string $p_prefix
* @param mixed $p_key -
* Can be a string or an array of strings.
* @return void
*/
function RemoveString($p_prefix, $p_key)
{
$languages = Localizer::GetAllLanguages();
foreach ($languages as $language) {
$target = new LocalizerLanguage($p_prefix, $language->getLanguageId());
$target->loadFile(Localizer::GetMode());
if (is_array($p_key)) {
foreach ($p_key as $key) {
$target->deleteString($key);
}
}
else {
$target->deleteString($p_key);
}
$target->saveFile(Localizer::GetMode());
}
} // fn RemoveString
/**
* Go through all files matching $p_prefix swap selected entrys.
*
* @param string $p_prefix
* @param int $p_pos1
* @param int $p_pos2
*
* @return void
*/
function MoveString($p_prefix, $p_pos1, $p_pos2)
{
$languages = Localizer::GetAllLanguages();
foreach ($languages as $language) {
$target = new LocalizerLanguage($p_prefix, $language->getLanguageId());
$target->loadFile(Localizer::GetMode());
$success = $target->moveString($p_pos1, $p_pos2);
$target->saveFile(Localizer::GetMode());
}
} // fn MoveString
/**
* Get all the languages that the interface supports.
*
* When in PHP mode, it will get the list from the database.
* When in XML mode, it will first try to look in the languages.xml file located
* in the current directory, and if it doesnt find that, it will look at the file names
* in the top directory and deduce the languages from that.
*
* @param string $p_mode
* @return array
* An array of LanguageMetadata objects.
*/
function GetAllLanguages($p_mode = null, $p_default=TRUE, $p_completed_only=FALSE)
{
if (is_null($p_mode)) {
$p_mode = Localizer::GetMode();
}
$className = "LocalizerFileFormat_".strtoupper($p_mode);
if (class_exists($className)) {
$object = new $className();
if (method_exists($object, "getLanguages")) {
$languages = $object->getLanguages($p_default, $p_completed_only);
}
}
//$this->m_languageDefs =& $languages;
return $languages;
} // fn GetAllLanguages
/**
* Get a list of all files matching the pattern given.
* Return an array of strings, each the full path name of a file.
* @param string $p_startdir
* @param string $p_pattern
* @return array
*/
function SearchFilesRecursive($p_startdir, $p_pattern)
{
$structure = File_Find::mapTreeMultiple($p_startdir);
// Transform it into a flat structure.
$filelist = array();
foreach ($structure as $dir => $file) {
// it's a directory
if (is_array($file)) {
$filelist = array_merge($filelist,
Localizer::SearchFilesRecursive($p_startdir.'/'.$dir, $p_pattern));
}
else {
// it's a file
if (preg_match($p_pattern, $file)) {
$filelist[] = $p_startdir.'/'.$file;
}
}
}
return $filelist;
} // fn SearchFilesRecursive
/**
* Create a new directory and make a copy of current default language files.
* @param string $p_languageId
* @return void
*/
function CreateLanguageFiles($p_languageId)
{
global $g_localizerConfig;
// Make new directory
if (!mkdir($g_localizerConfig['TRANSLATION_DIR']."/".$p_languageId)) {
return;
}
// Copy files from reference language
// $className = "LocalizerFileFormat_".strtoupper(Localizer::GetMode());
// foreach ($files as $pathname) {
// if ($pathname) {
// $fileNameParts = explode('.', basename($pathname));
// $base = $fileNameParts[0];
// $dir = str_replace($g_localizerConfig['BASE_DIR'], '', dirname($pathname));
// // read the default file
// $defaultLang = new LocalizerLanguage($base, $g_localizerConfig['DEFAULT_LANGUAGE']);
// $defaultLang->loadFile(Localizer::GetMode());
// $defaultLang->clearValues();
// $defaultLang->setLanguageId($p_languageId);
// // if file already exists -> skip
// if (!file_exists($defaultLang->getFilePath())) {
// $defaultLang->saveFile(Localizer::GetMode());
// }
// }
// }
} // fn CreateLanguageFiles
/**
* Go through subdirectorys and delete language files for given Id.
* @param string $p_languageId
* @return void
*/
function DeleteLanguageFiles($p_languageId)
{
global $g_localizerConfig;
$langDir = $g_localizerConfig['TRANSLATION_DIR'].'/'.$p_languageId;
if (!file_exists($langDir)) {
return;
}
$files = File_Find::mapTreeMultiple($langDir, 1);
//echo "<pre>";print_r($files);echo "</pre>";
foreach ($files as $pathname) {
if (file_exists($pathname)) {
echo 'deleteing '.$pathname.'<br>';
//unlink($pathname);
}
}
} // fn DeleteLanguageFiles
} // class Localizer
?>