323 lines
9.7 KiB
JavaScript
323 lines
9.7 KiB
JavaScript
/* Copyright (c) 2011-2012 Fabien Cazenave, Mozilla.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
/*
|
|
Additional modifications for PDF.js project:
|
|
- Loading resources from <script type='application/l10n'>;
|
|
- Disabling language initialization on page loading;
|
|
- Add fallback argument to the translateString.
|
|
*/
|
|
'use strict';
|
|
|
|
(function(window) {
|
|
var gL10nData = {};
|
|
var gTextData = '';
|
|
var gLanguage = '';
|
|
|
|
// parser
|
|
|
|
function evalString(text) {
|
|
return text.replace(/\\\\/g, '\\')
|
|
.replace(/\\n/g, '\n')
|
|
.replace(/\\r/g, '\r')
|
|
.replace(/\\t/g, '\t')
|
|
.replace(/\\b/g, '\b')
|
|
.replace(/\\f/g, '\f')
|
|
.replace(/\\{/g, '{')
|
|
.replace(/\\}/g, '}')
|
|
.replace(/\\"/g, '"')
|
|
.replace(/\\'/g, "'");
|
|
}
|
|
|
|
function parseProperties(text, lang) {
|
|
var reBlank = /^\s*|\s*$/;
|
|
var reComment = /^\s*#|^\s*$/;
|
|
var reSection = /^\s*\[(.*)\]\s*$/;
|
|
var reImport = /^\s*@import\s+url\((.*)\)\s*$/i;
|
|
|
|
// parse the *.properties file into an associative array
|
|
var currentLang = '*';
|
|
var supportedLang = [];
|
|
var skipLang = false;
|
|
var data = [];
|
|
var match = '';
|
|
var entries = text.replace(reBlank, '').split(/[\r\n]+/);
|
|
for (var i = 0; i < entries.length; i++) {
|
|
var line = entries[i];
|
|
|
|
// comment or blank line?
|
|
if (reComment.test(line))
|
|
continue;
|
|
|
|
// section start?
|
|
if (reSection.test(line)) {
|
|
match = reSection.exec(line);
|
|
currentLang = match[1];
|
|
skipLang = (currentLang != lang) && (currentLang != '*') &&
|
|
(currentLang != lang.substring(0, 2));
|
|
continue;
|
|
} else if (skipLang) {
|
|
continue;
|
|
}
|
|
|
|
// @import rule?
|
|
if (reImport.test(line)) {
|
|
match = reImport.exec(line);
|
|
}
|
|
|
|
// key-value pair
|
|
var tmp = line.split('=');
|
|
if (tmp.length > 1)
|
|
data[tmp[0]] = evalString(tmp[1]);
|
|
}
|
|
|
|
// find the attribute descriptions, if any
|
|
for (var key in data) {
|
|
var id, prop, index = key.lastIndexOf('.');
|
|
if (index > 0) { // attribute
|
|
id = key.substring(0, index);
|
|
prop = key.substr(index + 1);
|
|
} else { // textContent, could be innerHTML as well
|
|
id = key;
|
|
prop = 'textContent';
|
|
}
|
|
if (!gL10nData[id])
|
|
gL10nData[id] = {};
|
|
gL10nData[id][prop] = data[key];
|
|
}
|
|
}
|
|
|
|
function parse(text, lang) {
|
|
gTextData += text;
|
|
// we only support *.properties files at the moment
|
|
return parseProperties(text, lang);
|
|
}
|
|
|
|
// load and parse the specified resource file
|
|
function loadResource(href, lang, onSuccess, onFailure) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', href, true);
|
|
xhr.overrideMimeType('text/plain; charset=utf-8');
|
|
xhr.onreadystatechange = function() {
|
|
if (xhr.readyState == 4) {
|
|
if (xhr.status == 200 || xhr.status == 0) {
|
|
parse(xhr.responseText, lang);
|
|
if (onSuccess)
|
|
onSuccess();
|
|
} else {
|
|
if (onFailure)
|
|
onFailure();
|
|
}
|
|
}
|
|
};
|
|
xhr.send(null);
|
|
}
|
|
|
|
// load and parse all resources for the specified locale
|
|
function loadLocale(lang, callback) {
|
|
clear();
|
|
|
|
// check all <link type="application/l10n" href="..." /> nodes
|
|
// and load the resource files
|
|
var langLinks = document.querySelectorAll('link[type="application/l10n"]');
|
|
var langLinksCount = langLinks.length;
|
|
var langScripts = document.querySelectorAll('script[type="application/l10n"]');
|
|
var langScriptCount = langScripts.length;
|
|
var langCount = langLinksCount + langScriptCount;
|
|
|
|
// start the callback when all resources are loaded
|
|
var onResourceLoaded = null;
|
|
var gResourceCount = 0;
|
|
onResourceLoaded = function() {
|
|
gResourceCount++;
|
|
if (gResourceCount >= langCount) {
|
|
// execute the [optional] callback
|
|
if (callback)
|
|
callback();
|
|
// fire a 'localized' DOM event
|
|
var evtObject = document.createEvent('Event');
|
|
evtObject.initEvent('localized', false, false);
|
|
evtObject.language = lang;
|
|
window.dispatchEvent(evtObject);
|
|
}
|
|
}
|
|
|
|
// load all resource files
|
|
function l10nResourceLink(link) {
|
|
var href = link.href;
|
|
var type = link.type;
|
|
this.load = function(lang, callback) {
|
|
var applied = lang;
|
|
loadResource(href, lang, callback, function() {
|
|
console.warn(href + ' not found.');
|
|
applied = '';
|
|
});
|
|
return applied; // return lang if found, an empty string if not found
|
|
};
|
|
}
|
|
|
|
gLanguage = lang;
|
|
for (var i = 0; i < langLinksCount; i++) {
|
|
var resource = new l10nResourceLink(langLinks[i]);
|
|
var rv = resource.load(lang, onResourceLoaded);
|
|
if (rv != lang) // lang not found, used default resource instead
|
|
gLanguage = '';
|
|
}
|
|
for (var i = 0; i < langScriptCount; i++) {
|
|
var scriptText = langScripts[i].text;
|
|
parse(scriptText, lang);
|
|
onResourceLoaded();
|
|
}
|
|
}
|
|
|
|
// fetch an l10n object, warn if not found
|
|
function getL10nData(key) {
|
|
var data = gL10nData[key];
|
|
if (!data)
|
|
console.warn('[l10n] #' + key + ' missing for [' + gLanguage + ']');
|
|
return data;
|
|
}
|
|
|
|
// replace {{arguments}} with their values
|
|
function substArguments(str, args) {
|
|
var reArgs = /\{\{\s*([a-zA-Z\.]+)\s*\}\}/;
|
|
var match = reArgs.exec(str);
|
|
while (match) {
|
|
if (!match || match.length < 2)
|
|
return str; // argument key not found
|
|
|
|
var arg = match[1];
|
|
var sub = '';
|
|
if (arg in args) {
|
|
sub = args[arg];
|
|
} else if (arg in gL10nData) {
|
|
sub = gL10nData[arg].textContent;
|
|
} else {
|
|
console.warn('[l10n] could not find argument {{' + arg + '}}');
|
|
return str;
|
|
}
|
|
|
|
str = str.substring(0, match.index) + sub +
|
|
str.substr(match.index + match[0].length);
|
|
match = reArgs.exec(str);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// translate a string
|
|
function translateString(key, args, fallback) {
|
|
var data = getL10nData(key);
|
|
if (!data && fallback)
|
|
data = {textContent: fallback};
|
|
if (!data)
|
|
return '{{' + key + '}}';
|
|
return substArguments(data.textContent, args);
|
|
}
|
|
|
|
// translate an HTML element
|
|
function translateElement(element) {
|
|
if (!element || !element.dataset)
|
|
return;
|
|
|
|
// get the related l10n object
|
|
var key = element.dataset.l10nId;
|
|
var data = getL10nData(key);
|
|
if (!data)
|
|
return;
|
|
|
|
// get arguments (if any)
|
|
// TODO: more flexible parser?
|
|
var args;
|
|
if (element.dataset.l10nArgs) try {
|
|
args = JSON.parse(element.dataset.l10nArgs);
|
|
} catch (e) {
|
|
console.warn('[l10n] could not parse arguments for #' + key + '');
|
|
}
|
|
|
|
// translate element
|
|
// TODO: security check?
|
|
for (var k in data)
|
|
element[k] = substArguments(data[k], args);
|
|
}
|
|
|
|
// translate an HTML subtree
|
|
function translateFragment(element) {
|
|
element = element || document.querySelector('html');
|
|
|
|
// check all translatable children (= w/ a `data-l10n-id' attribute)
|
|
var children = element.querySelectorAll('*[data-l10n-id]');
|
|
var elementCount = children.length;
|
|
for (var i = 0; i < elementCount; i++)
|
|
translateElement(children[i]);
|
|
|
|
// translate element itself if necessary
|
|
if (element.dataset.l10nId)
|
|
translateElement(element);
|
|
}
|
|
|
|
// clear all l10n data
|
|
function clear() {
|
|
gL10nData = {};
|
|
gTextData = '';
|
|
gLanguage = '';
|
|
}
|
|
|
|
/*
|
|
// load the default locale on startup
|
|
window.addEventListener('DOMContentLoaded', function() {
|
|
var lang = navigator.language;
|
|
if (navigator.mozSettings) {
|
|
var req = navigator.mozSettings.getLock().get('language.current');
|
|
req.onsuccess = function() {
|
|
loadLocale(req.result['language.current'] || lang, translateFragment);
|
|
};
|
|
req.onerror = function() {
|
|
loadLocale(lang, translateFragment);
|
|
};
|
|
} else {
|
|
loadLocale(lang, translateFragment);
|
|
}
|
|
});
|
|
*/
|
|
|
|
// Public API
|
|
document.mozL10n = {
|
|
// get a localized string
|
|
get: translateString,
|
|
|
|
// get|set the document language and direction
|
|
get language() {
|
|
return {
|
|
// get|set the document language (ISO-639-1)
|
|
get code() { return gLanguage; },
|
|
set code(lang) { loadLocale(lang, translateFragment); },
|
|
|
|
// get the direction (ltr|rtl) of the current language
|
|
get direction() {
|
|
// http://www.w3.org/International/questions/qa-scripts
|
|
// Arabic, Hebrew, Farsi, Pashto, Urdu
|
|
var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
|
|
return (rtlList.indexOf(gLanguage) >= 0) ? 'rtl' : 'ltr';
|
|
}
|
|
};
|
|
}
|
|
};
|
|
})(this);
|