b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
423 lines
14 KiB
JavaScript
Executable file
423 lines
14 KiB
JavaScript
Executable file
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* jshint moz:true */
|
|
/* jshint unused:true */
|
|
/* global InputMethods */
|
|
/* global KeyEvent */
|
|
|
|
// ==================================================================
|
|
// WARNING. THIS FUNCTION USES PRECOMPOSED UNICODE CHARACTERS IN
|
|
// STRING LITERALS. DO NOT NORMALIZE THIS FILE.
|
|
// IF YOU NORMALIZE THIS FILE, THE STRINGS WILL CHANGE AND THE
|
|
// PROGRAM WILL BREAK.
|
|
//
|
|
// The use of precomposed Unicode characters is deliberate. This
|
|
// IM outputs precomposed Vietnamese characters rather than
|
|
// using combining character sequences because Firefox OS
|
|
// has trouble rendering Vietnamese combining character sequences.
|
|
//
|
|
// I considered using Unicode escape sequences instead of the
|
|
// actual Vietnamese characters, but that would have made the code
|
|
// much harder to read, understand, and maintain. Furthermore, I
|
|
// don't think there's much risk that someone will normalize this
|
|
// file.
|
|
//
|
|
// Existing Javascript standards say that all strings should be
|
|
// normalized in NFC format. In practice, no Javascript interpreter
|
|
// does that, and nor should they. There is a proposal to remove
|
|
// that requirement from the next standard, partly out of consider-
|
|
// ation for languages like Vietnamese which usually aren't NFC
|
|
// normalized, and partly to reflect actual practice.
|
|
//
|
|
// http://wiki.ecmascript.org/doku.php?id=strawman:unicode_normalization
|
|
//
|
|
// ==================================================================
|
|
|
|
|
|
|
|
// Like pinyin, Vietnam's writing system (Quốc Ngữ) has fixed rules for
|
|
// what makes a valid syllable.
|
|
|
|
// A syllable consists of:
|
|
// optional initial + vowel cluster + optional final
|
|
|
|
// Not all vowel clusters can occur before all finals.
|
|
// The vowel cluster can optionally carry one of 5 tone marks.
|
|
|
|
// The spelling is fairly regular, but it inherits a few irregularities
|
|
// from Portuguese.
|
|
// * The /k/ sound can be spelt C or K depending on the
|
|
// following vowel. (Or Q before a /w/ glide.)
|
|
// * The initial G becomes GH before E or I (or Ê or Y). Similarly, NG
|
|
// becomes NGH
|
|
// * The /w/ sound at the start of a vowel cluster can be spelt O or U
|
|
// depending on the following vowel. However, after a Q, it is always
|
|
// spelt U, regardless of the following vowel. Basically, the list of
|
|
// valid vowel clusters completely changes after a Q.
|
|
// * The vowel cluster IÊ becomes YÊ at the start of a word. Likewise,
|
|
// IÊU> becomes YÊU.
|
|
|
|
(function() {
|
|
'use strict';
|
|
|
|
var QN = {
|
|
unmarkedVowels: 'AaĂăÂâEeÊêIiOoÔôƠơUuƯưYy',
|
|
|
|
// The elements of this array represent the five marked tones of
|
|
// Vietnamese. (A sixth tone is unmarked.)
|
|
markedVowels: [
|
|
'ÁáẮắẤấÉéẾếÍíÓóỐốỚớÚúỨứÝý', // Sắc Tone
|
|
'ÀàẰằẦầÈèỀềÌìÒòỒồỜờÙùỪừỲỳ', // Huyền Tone
|
|
'ẢảẲẳẨẩẺẻỂểỈỉỎỏỔổỞởỦủỬửỶỷ', // Hỏi Tone
|
|
'ÃãẴẵẪẫẼẽỄễĨĩÕõỖỗỠỡŨũỮữỸỹ', // Ngã Tone
|
|
'ẠạẶặẬậẸẹỆệỊịỌọỘộỢợỤụỰựỴỵ' // Nặng Tone
|
|
],
|
|
|
|
// All the intials except Q (including the null initial).
|
|
// (Any usual Vietnamese syllable can be prefixed with an X
|
|
// when transcribing foreign proper nouns.)
|
|
initialsNotQ: '(x?(?:b|c|ch|d|đ|g|gh|gi|h|k|kh|l|m|n|' +
|
|
'ng|ngh|nh|p|ph|r|s|t|th|tr|v)?)',
|
|
|
|
// All the initials that start with Q.
|
|
initialQ: '(x?q)',
|
|
|
|
// All the finals
|
|
finals: '(c|ch|m|n|ng|nh|p|t)',
|
|
|
|
// These vowel clusters are valid when there is no final
|
|
// (except when the intial is Q)
|
|
nucleusOpen: '(a|e|ê|i|y|o|ô|ơ|u|ư|' + // vowel
|
|
'ai|ay|ăy|oi|ơi|ôi|ui|ưi|' + // vowel + /j/
|
|
'ao|au|âu|eo|êu|iu|ưu|' + // vowel + /w/
|
|
'ia|ua|ưa|' + // diphthong
|
|
'uơi|ươi|' + // diphthong + /j/
|
|
'iêu|yêu|ươu|' + // diphthong + /w/
|
|
'oa|oe|uê|uy|uơ|' + // /w/ + vowel
|
|
'uya|' + // /w/ + diphthong
|
|
'oai|oay|uôi|uây)', // /w/ + vowel + /j/
|
|
|
|
// These vowel clusters are valid before any final,
|
|
// (except when the intial is Q)
|
|
nucleusClosed: '(a|ă|â|e|ê|i|o|ô|ơ|u|ư|' + // vowel
|
|
'iê|yê|uô|uơ|ươ|' + // diphthong
|
|
'oa|oă|uâ|oe|uê|uy|uơ|' + // /w/ + vowel
|
|
'uyê|' + // /w/ + diphthong
|
|
'oo)', // 'oo' only appears in French loan words
|
|
// like 'xoong' (casserole). Some Vietnamese
|
|
// textbooks omit it, but it definitely exists.
|
|
|
|
|
|
// These vowel clusters are valid when there is no final
|
|
// and the initial is Q.
|
|
nucleusOpenAfterQ: '(ua|ue|uê|ui|uy|uơ|' + // /w/ + vowel
|
|
'uya|' + // /w/ + diphthong
|
|
'uai|uay|uây)', // /w/ + vowel + /j/
|
|
|
|
// These vowel clusters are valid before any final,
|
|
// when the initial is Q.
|
|
nucleusClosedAfterQ: '(ua|uă|uâ|ue|uê|ui|uy|uơ|' + // /w/ + vowel
|
|
'uyê)' // /w/ + diphthong
|
|
};
|
|
|
|
var vietWordParser = {
|
|
p1: new RegExp('^' + QN.initialsNotQ + QN.nucleusOpen + '$'),
|
|
p2: new RegExp('^' + QN.initialsNotQ + QN.nucleusClosed + QN.finals + '$'),
|
|
p3: new RegExp('^' + QN.initialQ + QN.nucleusOpenAfterQ + '$'),
|
|
p4: new RegExp('^' + QN.initialQ + QN.nucleusClosedAfterQ + QN.finals +
|
|
'$'),
|
|
|
|
isValidWord: function(word) {
|
|
var w = word.toLowerCase();
|
|
var array = w.match(this.p1) || w.match(this.p2) ||
|
|
w.match(this.p3) || w.match(this.p4);
|
|
|
|
if (!array) {
|
|
return false;
|
|
}
|
|
|
|
var initialCluster = array[1];
|
|
var vowelCluster = array[2];
|
|
var finalCluster = array[3] || '';
|
|
|
|
// G -> GH and NG -> NGH before E/Ê or I/Y
|
|
if (initialCluster.match(/^(g|ng)$/) &&
|
|
vowelCluster.match(/^(e|ê|i|y)/)) {
|
|
return false;
|
|
}
|
|
if (initialCluster.match(/^(gh|ngh)$/) &&
|
|
!vowelCluster.match(/^(e|ê|i|y)/)) {
|
|
return false;
|
|
}
|
|
|
|
// GI can't come before I/Y
|
|
if (initialCluster === 'gi' && vowelCluster.match(/^(i|y)/)) {
|
|
return false;
|
|
}
|
|
|
|
// K before I/Y or E; C otherwise
|
|
if (initialCluster === 'k' && !vowelCluster.match(/^(e|ê|i|y)/)) {
|
|
return false;
|
|
}
|
|
if (initialCluster === 'c' && vowelCluster.match(/^(e|ê|i|y)/)) {
|
|
return false;
|
|
}
|
|
|
|
// IÊ -> YÊ and IÊU -> YÊU when there's no initial
|
|
if (initialCluster === '' && vowelCluster.match(/^iê/)) {
|
|
return false;
|
|
}
|
|
if (initialCluster !== '' && vowelCluster.match(/^yê/)) {
|
|
return false;
|
|
}
|
|
|
|
// The vowel clusters UÂ and UYÊ can only come before T or N.
|
|
if (vowelCluster.match(/^(uâ|uyê)$/) && !finalCluster.match(/^(t|n)$/)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
addToneMarkToVowel: function(vowel, tone) {
|
|
var vowelIndex = QN.unmarkedVowels.indexOf(vowel);
|
|
if (vowelIndex >= 0) {
|
|
return QN.markedVowels[tone][vowelIndex];
|
|
}
|
|
},
|
|
|
|
findTonePosition: function(word) {
|
|
var w = word.toLowerCase();
|
|
|
|
var array = w.match(this.p1) || w.match(this.p2) ||
|
|
w.match(this.p3) || w.match(this.p4);
|
|
|
|
if (!array) {
|
|
return 0;
|
|
}
|
|
|
|
var initialCluster = array[1];
|
|
var vowelCluster = array[2];
|
|
var finalCluster = array[3] || '';
|
|
|
|
// When placing the tone mark, the U in QU should be considered
|
|
// part of the initial, not part of the vowel cluster.
|
|
// It never carries the tone mark.
|
|
if (initialCluster == 'q') {
|
|
initialCluster = 'qu';
|
|
vowelCluster = vowelCluster.substr(1);
|
|
}
|
|
|
|
// Here are the traditional rules for where to place the tone mark:
|
|
// * Vowels with diacritics are preferred over vowels without one.
|
|
// If that doesn't settle it, use these rules:
|
|
// * If the word has three vowels, it goes on the middle one.
|
|
// * If the word has two vowels followed by a consonant, it goes on the
|
|
// last vowel.
|
|
// * If the word ends with two vowels, it goes on the first vowel.
|
|
|
|
// The only time a word can have more than one diacritic is when it
|
|
// contains ươ, which has to be followed by a consonant. By the above
|
|
// rules, that means the ơ gets the diacritic, not the ư.
|
|
|
|
return w.search(/(ơ)/) + 1 ||
|
|
w.search(/(ă|â|ê|ô|ư)/) + 1 ||
|
|
(vowelCluster.length === 3 ? initialCluster.length + 2 :
|
|
finalCluster !== '' ? initialCluster.length + vowelCluster.length :
|
|
initialCluster.length + 1);
|
|
},
|
|
|
|
addHat: function(word) {
|
|
return word.replace('a', 'â').replace('A', 'Â')
|
|
.replace('e', 'ê').replace('E', 'Ê')
|
|
.replace('o', 'ô').replace('O', 'Ô');
|
|
},
|
|
|
|
generateCandidates: function(word) {
|
|
if (!this.isValidWord(word)) {
|
|
return [];
|
|
}
|
|
|
|
// Vietnamese has five tone marks. However, if a word ends
|
|
// in P, T, C, or CH, only the SẮC and NẶNG tones can be used.
|
|
var stopFinal = !!word.match(/(p|t|c|ch)$/i);
|
|
var marks = stopFinal ? [0, 4] : [0, 1, 2, 3, 4];
|
|
|
|
var tonePos = this.findTonePosition(word);
|
|
|
|
var candidates = marks.map((mark) => {
|
|
return word.substr(0, tonePos - 1) +
|
|
this.addToneMarkToVowel(word.charAt(tonePos - 1), mark) +
|
|
word.substr(tonePos);
|
|
});
|
|
|
|
return candidates;
|
|
}
|
|
};
|
|
|
|
var keyboard, buffer = '';
|
|
var capitalize = false;
|
|
var capitalizeNext = false;
|
|
var tentativeSpace = false;
|
|
|
|
var BACKSPACE = 8;
|
|
var HAT = 94;
|
|
|
|
function isBufferEmpty() {
|
|
return buffer === '';
|
|
}
|
|
|
|
function clearBuffer() {
|
|
buffer = '';
|
|
}
|
|
|
|
function addToBuffer(keycode) {
|
|
if (keycode == BACKSPACE) {
|
|
backspace();
|
|
}
|
|
buffer = buffer + String.fromCharCode(keycode);
|
|
}
|
|
|
|
function backspace() {
|
|
if (!isBufferEmpty()) {
|
|
buffer = buffer.substring(0, buffer.length -1);
|
|
keyboard.setComposition(buffer);
|
|
}
|
|
else {
|
|
keyboard.sendKey(KeyEvent.DOM_VK_BACK_SPACE);
|
|
}
|
|
}
|
|
|
|
function inputDone() {
|
|
keyboard.endComposition(buffer);
|
|
clearBuffer();
|
|
}
|
|
|
|
InputMethods.vietnamese = {
|
|
init: init,
|
|
activate: activate,
|
|
deactivate: deactivate,
|
|
click: click,
|
|
select: select
|
|
};
|
|
|
|
function init(interfaceObject) {
|
|
keyboard = interfaceObject;
|
|
}
|
|
|
|
function activate(lang, state) {
|
|
capitalize = !!state.type.match(/^(text|textarea|search)$/);
|
|
tentativeSpace = false;
|
|
|
|
var cursor = state.selectionStart;
|
|
var inputText = state.value;
|
|
|
|
capitalizeNext = false;
|
|
if (capitalize) {
|
|
if (cursor === 0) {
|
|
capitalizeNext = true;
|
|
}
|
|
else {
|
|
var charBeforeCursor = cursor - 1;
|
|
while (charBeforeCursor >= 0 && inputText[charBeforeCursor] == ' ') {
|
|
--charBeforeCursor;
|
|
}
|
|
capitalizeNext = !!inputText[charBeforeCursor].match(/[\!\?\.]/);
|
|
}
|
|
}
|
|
keyboard.setUpperCase(capitalizeNext);
|
|
}
|
|
|
|
function deactivate() {
|
|
if (!isBufferEmpty()) {
|
|
inputDone();
|
|
keyboard.sendCandidates([]);
|
|
}
|
|
}
|
|
|
|
function click(keycode) {
|
|
var s = String.fromCharCode(keycode);
|
|
|
|
var wasTentativeSpace = tentativeSpace;
|
|
tentativeSpace = false;
|
|
|
|
var wasCapitalizeNext = capitalizeNext;
|
|
capitalizeNext = false;
|
|
|
|
// Automatically transform E -> Ê after an I or Y. I find this really handy.
|
|
// And UO -> UÔ
|
|
if (s == 'e' && buffer.match(/(y|i)$/i)) {
|
|
keycode = 'ê'.charCodeAt(0);
|
|
}
|
|
else if (s == 'E' && buffer.match(/(y|i)$/i)) {
|
|
keycode = 'Ê'.charCodeAt(0);
|
|
} else if (s == 'o' && buffer.match(/u$/i)) {
|
|
keycode = 'ô'.charCodeAt(0);
|
|
} else if (s == 'O' && buffer.match(/u$/i)) {
|
|
keycode = 'Ô'.charCodeAt(0);
|
|
}
|
|
|
|
// Letters
|
|
if (s.match(/[A-Za-zĂÂĐÊÔƠUƯ]/i)) {
|
|
addToBuffer(keycode);
|
|
}
|
|
// The special hat key.
|
|
else if (keycode == HAT) {
|
|
buffer = vietWordParser.addHat(buffer);
|
|
}
|
|
// Backspace
|
|
else if (keycode == BACKSPACE) {
|
|
backspace();
|
|
}
|
|
// Handling tentative space
|
|
else if (wasTentativeSpace &&
|
|
(s == '.' || s == ',' || s == '!' || s == '?')) {
|
|
keyboard.sendKey(KeyEvent.DOM_VK_BACK_SPACE);
|
|
keyboard.sendKey(keycode);
|
|
keyboard.sendKey(KeyEvent.DOM_VK_SPACE);
|
|
if (s == '.' || s == '!' || s == '?') {
|
|
capitalizeNext = true;
|
|
}
|
|
}
|
|
// Using spacebar to finish input
|
|
else if (s == ' ' && !isBufferEmpty()) {
|
|
buffer += s;
|
|
tentativeSpace = true;
|
|
inputDone();
|
|
}
|
|
// Punctuation, symbols, other.
|
|
else {
|
|
if (!isBufferEmpty()) {
|
|
inputDone();
|
|
}
|
|
if (s == '.' || s == '!' || s == '?') {
|
|
capitalizeNext = true;
|
|
}
|
|
if (s == ' ') {
|
|
capitalizeNext = wasCapitalizeNext;
|
|
}
|
|
keyboard.sendKey(keycode);
|
|
}
|
|
|
|
if (!isBufferEmpty()) {
|
|
keyboard.setComposition(buffer);
|
|
var candidates = vietWordParser.generateCandidates(buffer);
|
|
keyboard.sendCandidates(candidates);
|
|
} else {
|
|
keyboard.sendCandidates([]);
|
|
}
|
|
|
|
keyboard.setUpperCase(capitalizeNext);
|
|
}
|
|
|
|
function select(s) {
|
|
buffer = s;
|
|
buffer += ' ';
|
|
tentativeSpace = true;
|
|
inputDone();
|
|
keyboard.sendCandidates([]);
|
|
}
|
|
|
|
})();
|