b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
1274 lines
43 KiB
JavaScript
1274 lines
43 KiB
JavaScript
/* -*- Mode: js; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
|
|
/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
|
|
/* global PAGE_INDEX_DEFAULT, InputMethods, KeyEvent, PromiseStorage */
|
|
|
|
'use strict';
|
|
|
|
/*
|
|
* This latin input method provides four forms of input assistance:
|
|
*
|
|
* 1) word suggestions
|
|
*
|
|
* 2) auto correction
|
|
*
|
|
* 3) auto capitalization
|
|
*
|
|
* 4) punctuation assistance by converting space space to period space
|
|
* and by transposing space followed by punctuation.
|
|
*
|
|
* These input modifications are controlled by the type and inputmode
|
|
* properties of the input element that has the focus. If inputmode is
|
|
* "verbatim" then the input method does not modify the user's input in any
|
|
* way. See getInputMode() for a description of input modes.
|
|
*
|
|
* TODO:
|
|
*
|
|
* when deciding whether to autocorrect, if the first 2 choices are
|
|
* a prefix of one another, then consider the ratio of 1st to 3rd instead
|
|
* of 1st to second possibly? If there different forms of the same word
|
|
* and that word is the most likely, then substitute it?
|
|
*
|
|
* add a per-language settings-based list of customizable corrections?
|
|
*
|
|
* Display an X icon in the suggestions line to give the user a way
|
|
* to dismiss an autocorrection? (Easier than space, backspace, space).
|
|
*
|
|
* Display a + icon in the suggestions line to give the user a way to
|
|
* add the current input to a personal word list so it doesn't get
|
|
* auto-corrected?
|
|
*
|
|
* Use color somehow to indicate that a word is properly spelled?
|
|
*
|
|
* Make the phone vibrate when it makes an automatic corection?
|
|
*/
|
|
(function() {
|
|
// Register ourselves in the keyboard's set of input methods
|
|
// The functions used here are all defined below
|
|
InputMethods.latin = {
|
|
init: init,
|
|
activate: activate,
|
|
deactivate: deactivate,
|
|
displaysCandidates: displaysCandidates,
|
|
click: click,
|
|
select: select,
|
|
dismissSuggestions: dismissSuggestions,
|
|
setLayoutPage: setLayoutPage,
|
|
setLayoutParams: setLayoutParams,
|
|
setLanguage: setLanguage,
|
|
stateChange: stateChange,
|
|
generateNearbyKeyMap: findNearbyKeys
|
|
};
|
|
|
|
// This is the object that is passed to init().
|
|
// We use the methods of this object to communicate with the keyboard.
|
|
var keyboard;
|
|
|
|
// If defined, this is a worker thread that produces word suggestions for us
|
|
var worker;
|
|
|
|
// PromiseStorage for access to indexedDB for user dictionary
|
|
var dbStore;
|
|
|
|
// These variables are the input method's state. Most of them are
|
|
// passed to the activate() method or are derived in that method.
|
|
var language; // The user's language
|
|
var inputMode; // The inputmode we're using: see getInputMode()
|
|
var capitalizing; // Are we auto-capitalizing for this activation?
|
|
var suggesting; // Are we offering suggestions for this activation?
|
|
var correcting; // Are we auto-correcting user input?
|
|
var punctuating; // Are we offering punctuation assistance?
|
|
var inputText; // The input text
|
|
var cursor; // The insertion position
|
|
var selection; // The end of the selection, if there is one, or 0
|
|
var lastSpaceTimestamp; // If the last key was a space, this is the timestamp
|
|
var layoutParams; // Parameters passed to setLayoutParams
|
|
var nearbyKeyMap; // Map keys to nearby keys
|
|
var serializedNearbyKeyMap; // A stringified version of the above
|
|
var idleTimer; // Used by deactivate
|
|
var suggestionsTimer; // Used by updateSuggestions;
|
|
var autoCorrection; // Correction to make if next input is space
|
|
var revertTo; // Revert to this on backspace after autocorrect
|
|
var revertFrom; // Revert away from this on backspace
|
|
var disableOnRevert; // Do we disable auto correction when reverting?
|
|
var correctionDisabled; // Temporarily diabled after reverting?
|
|
var currentPage; // The current layout page
|
|
var gotNormalKey; // Indicate if we got a normal key in an alt page
|
|
|
|
// Terminate the worker when the keyboard is inactive for this long.
|
|
var WORKER_TIMEOUT = 30000; // 30 seconds of idle time
|
|
|
|
// If we get an autorepeating key is sent to us, don't offer suggestions
|
|
// for this long, until we're pretty certain that the autorepeat
|
|
// has stopped.
|
|
var AUTOREPEAT_DELAY = 250;
|
|
|
|
// Some keycodes that we use
|
|
var SPACE = KeyEvent.DOM_VK_SPACE;
|
|
var BACKSPACE = KeyEvent.DOM_VK_BACK_SPACE;
|
|
var RETURN = KeyEvent.DOM_VK_RETURN;
|
|
var PERIOD = 46;
|
|
var QUESTION = 63;
|
|
var EXCLAMATION = 33;
|
|
var COMMA = 44;
|
|
var COLON = 58;
|
|
var SEMICOLON = 59;
|
|
var ATPERSAND = 64;
|
|
var DOUBLEQUOTE = 34;
|
|
var CLOSEPAREN = 41;
|
|
// all whitespace characters
|
|
// U+FFFC place holder is added to white space
|
|
// this enables suggestions
|
|
// when cursor is before place holder.
|
|
var WS = /^[\s\ufffc]+$/;
|
|
|
|
// word separator characters
|
|
// U+FFFC is the placeholder character for non-text object
|
|
var WORDSEP = /^[\s.,?!;:\ufffc]+$/;
|
|
|
|
var DOUBLE_SPACE_TIME = 700; // ms between spaces to convert to ". "
|
|
|
|
// Don't offer to autocorrect unless we're reasonably certain that the
|
|
// user wants this correction. The first suggested word must be at least
|
|
// this much more highly weighted than the second suggested word.
|
|
var AUTO_CORRECT_THRESHOLD = 1.30;
|
|
|
|
// Append a suffix when a suggestion was picked. In general, we
|
|
// use space in Latin script as word divider.
|
|
var SUGGESTION_SUFFIX = ' ';
|
|
|
|
// If the length doesn't match between input and first suggestion.
|
|
// The min. frequency the first suggestion needs to have if we turn it into
|
|
// an autocorrect action
|
|
var MIN_LENGTH_MISMATCH_THRESHOLD = 5;
|
|
|
|
var USER_DICT_DB_NAME = 'UserDictLatin';
|
|
|
|
// Predictions from user dictionary need to have weight larger than this in
|
|
// order to take precedence over built-in dictionary predictions
|
|
var USER_DICT_PREDICTION_BUMP_THRESHOLD = 1;
|
|
|
|
// If this promise exists, that means we are
|
|
// currently loading the new dictionary.
|
|
var getDictionaryDataPromise = null;
|
|
|
|
// The promise for getting user dictionary from PromiseStorage
|
|
var getUserDictionaryBlobPromise = null;
|
|
|
|
// keyboard.js calls this to pass us the interface object we need
|
|
// to communicate with it
|
|
function init(interfaceObject) {
|
|
keyboard = interfaceObject;
|
|
|
|
dbStore = new PromiseStorage(USER_DICT_DB_NAME);
|
|
dbStore.start();
|
|
}
|
|
|
|
// Given the type property and inputmode attribute of a form element,
|
|
// this function returns the inputmode that this IM should use. The
|
|
// return value will be one of these strings:
|
|
//
|
|
// 'verbatim': don't alter the user's input at all
|
|
// 'latin': offer word suggestions/corrections, but no capitalization
|
|
// 'latin-prose': offer word suggestions and capitalization
|
|
//
|
|
function getInputMode(type, mode) {
|
|
// For text, textarea and search types, use the requested inputmode
|
|
// if it is valid and supported except numeric/digit mode. For
|
|
// numeric/digit mode, we return verbatim since no typing assitance
|
|
// is required. Otherwise default to latin for text and search and to
|
|
// latin-prose for textarea. For all other form fields, use verbatim mode
|
|
// so we never alter input.
|
|
switch (type) {
|
|
case 'text':
|
|
case 'textarea':
|
|
case 'search':
|
|
switch (mode) {
|
|
case 'verbatim':
|
|
case 'latin':
|
|
case 'latin-prose':
|
|
return mode;
|
|
case 'numeric':
|
|
case 'digit':
|
|
return 'verbatim';
|
|
default:
|
|
return (type === 'textarea') ? 'latin-prose' : 'latin';
|
|
}
|
|
break;
|
|
default:
|
|
return 'verbatim';
|
|
}
|
|
}
|
|
|
|
// This gets called whenever the keyboard pops up to tell us everything
|
|
// we need to provide useful typing assistance. It also gets called whenever
|
|
// the user taps on an input field to move the cursor. That means that there
|
|
// may be multiple calls to activate() without calls to deactivate between
|
|
// them.
|
|
function activate(lang, state, options) {
|
|
inputMode = getInputMode(state.type, state.inputmode);
|
|
inputText = state.text;
|
|
cursor = state.selectionStart;
|
|
if (state.selectionEnd > state.selectionStart) {
|
|
selection = state.selectionEnd;
|
|
} else {
|
|
selection = 0;
|
|
}
|
|
|
|
// Figure out what kind of input assistance we're providing for this
|
|
// activation.
|
|
capitalizing = punctuating = (inputMode === 'latin-prose');
|
|
suggesting = (options.suggest && inputMode !== 'verbatim');
|
|
correcting = (options.correct && inputMode !== 'verbatim');
|
|
|
|
// Some layouts (like French) need to disable punctuation autocorrection
|
|
// all the time.
|
|
if (options.correctPunctuation === false) {
|
|
punctuating = false;
|
|
}
|
|
|
|
// Reset our state
|
|
lastSpaceTimestamp = 0;
|
|
autoCorrection = null;
|
|
revertTo = revertFrom = '';
|
|
disableOnRevert = false;
|
|
correctionDisabled = false;
|
|
currentPage = PAGE_INDEX_DEFAULT;
|
|
gotNormalKey = false;
|
|
|
|
// The keyboard isn't idle anymore, so clear the timer
|
|
if (idleTimer) {
|
|
clearTimeout(idleTimer);
|
|
idleTimer = null;
|
|
}
|
|
|
|
// Start off with the correct capitalization
|
|
updateCapitalization();
|
|
|
|
// Get user dictionary blob.
|
|
getUserDictionaryBlobPromise =
|
|
dbStore.getItem('dictblob').then(function(blob) {
|
|
// If worker is there, tell it we have a (new) user dictionary blob,
|
|
// since setLanguage() may be bypassed due to language not changing.
|
|
// (User dictionary is langauge-neutral.)
|
|
// Do pass the argument if blob is undefined (no user dictionary words),
|
|
// Since the worker needs to know if user has deleted all words.
|
|
// Worker will bypass UserDictionary prediction as needed.
|
|
// |undefined| can't be Transferred so we'll need to check for it.
|
|
if (worker) {
|
|
worker.postMessage({
|
|
cmd: 'setUserDictionary',
|
|
args: [blob]
|
|
}, typeof blob === 'undefined' ? undefined : [blob]);
|
|
}
|
|
|
|
return blob;
|
|
})['catch'](function(e) {
|
|
e && console.error('latin.js', e);
|
|
});
|
|
|
|
// If we are going to offer suggestions, ensure that there is a worker
|
|
// thread created and that it knows what language we're using, and then
|
|
// start things off by requesting a first batch of suggestions.
|
|
if (suggesting || correcting) {
|
|
if (!worker || lang !== language) {
|
|
setLanguage(lang); // This calls updateSuggestions
|
|
} else {
|
|
updateSuggestions();
|
|
}
|
|
}
|
|
}
|
|
|
|
function deactivate() {
|
|
if (!worker || idleTimer) {
|
|
return;
|
|
}
|
|
idleTimer = setTimeout(terminateWorker, WORKER_TIMEOUT);
|
|
}
|
|
|
|
function terminateWorker() {
|
|
if (idleTimer) {
|
|
clearTimeout(idleTimer);
|
|
idleTimer = null;
|
|
}
|
|
if (worker) {
|
|
worker.terminate();
|
|
worker = null;
|
|
keyboard.sendCandidates([]); // Clear any displayed suggestions
|
|
autoCorrection = null; // and forget any pending correction.
|
|
}
|
|
}
|
|
|
|
function setLanguage(newlang) {
|
|
// If there is no worker and no language, or if there is a worker and
|
|
// the language has not changed, then there is nothing to do here.
|
|
if ((!worker && !newlang) || (worker && newlang === language)) {
|
|
return;
|
|
}
|
|
|
|
language = newlang;
|
|
|
|
// If there is a worker, and no new language, then kill the worker
|
|
if (worker && !newlang) {
|
|
terminateWorker();
|
|
return;
|
|
}
|
|
|
|
// Built-in dictionary is a hard requirement, i.e. if it is undefined, we
|
|
// reset ourselves.
|
|
// User dictionary is not a hard requirement. We swallow any abnormal
|
|
// situation there at activate(), to make sure Promise.all() doesn't fail
|
|
// on its rejection.
|
|
getDictionaryDataPromise = Promise.all([
|
|
keyboard.getData('dictionaries/' + newlang + '.dict'),
|
|
getUserDictionaryBlobPromise
|
|
]);
|
|
|
|
getDictionaryDataPromise
|
|
.then(function(values) {
|
|
getDictionaryDataPromise = null;
|
|
|
|
var builtInDict = values[0];
|
|
var userDict = values[1];
|
|
|
|
if (!builtInDict) {
|
|
console.error(
|
|
'latin.js: dictionary is specified but can\'t be loaded.');
|
|
language = undefined;
|
|
|
|
terminateWorker();
|
|
return;
|
|
}
|
|
|
|
setLanguageSync(newlang, builtInDict, userDict);
|
|
})['catch'](function(e) { // workaround gjslint error
|
|
e && console.error('latin.js', e);
|
|
|
|
getDictionaryDataPromise = null;
|
|
language = undefined;
|
|
terminateWorker();
|
|
})['catch'](function(e) { e && console.error(e); });
|
|
}
|
|
|
|
function setLanguageSync(newlang, dictData, userDict) {
|
|
// If we get here, then we have to create a worker and set its language
|
|
// or change the language of an existing worker.
|
|
if (!worker) {
|
|
// If we haven't created the worker before, do it now
|
|
worker = new Worker('js/imes/latin/worker.js');
|
|
if (layoutParams && nearbyKeyMap) {
|
|
worker.postMessage({ cmd: 'setNearbyKeys', args: [nearbyKeyMap]});
|
|
}
|
|
|
|
worker.onmessage = function(e) {
|
|
switch (e.data.cmd) {
|
|
case 'log':
|
|
console.log(e.data.message);
|
|
break;
|
|
case 'error':
|
|
console.error(e.data.message);
|
|
// If the error was a result of our setLanguage call, then
|
|
// kill the worker because it can't do anything without
|
|
// a valid dictionary.
|
|
if (e.data.message.startsWith('setLanguage')) {
|
|
terminateWorker();
|
|
}
|
|
break;
|
|
case 'predictions':
|
|
// The worker is suggesting words: ask the keyboard to display them
|
|
handleSuggestions(e.data.input, e.data.suggestions);
|
|
break;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Tell the worker what language we're using and also pass the dictionary
|
|
// data.
|
|
// |undefined| can't be Transferred so we'll need to check for it.
|
|
worker.postMessage({
|
|
cmd: 'setLanguage',
|
|
args: [language, dictData, userDict]
|
|
}, typeof userDict === 'undefined' ? [dictData] : [dictData, userDict]);
|
|
|
|
// And now that we've changed the language, ask for new suggestions
|
|
updateSuggestions();
|
|
}
|
|
|
|
function displaysCandidates() {
|
|
// If we are suggesting for the language,
|
|
// we should always display the condidate panel.
|
|
return !!(suggesting && language);
|
|
}
|
|
|
|
/*
|
|
* The keyboard calls this method to tell us about user input.
|
|
*
|
|
* What we do with the input depends on various things:
|
|
*
|
|
* - whether we are suggesting, correcting, punctuating and/or capitalizing:
|
|
* these are controlled by settings, input mode and input type
|
|
*
|
|
* - whether there is a selected region in the input field
|
|
*
|
|
* - whether there is an auto-correction ready (when input is space
|
|
* or punctuation).
|
|
*
|
|
* - whether the last action was an autocorrection (when input is backspace)
|
|
*
|
|
* - the cursor position (affects suggestions, capitalization, etc.)
|
|
*
|
|
* If there is a selection just handle simple insertions and deletions
|
|
* with no extra behavior. (I think)
|
|
*
|
|
* If input is a space or punctuation:
|
|
*
|
|
* If there is a autocorrection ready, and we are correcting and
|
|
* the cursor is at the end of a word, make the correction
|
|
*
|
|
* If the previous character is a space, fix the punctuation. Note that
|
|
* this only works for a subset of the punctuation characters.
|
|
*
|
|
* Otherwise just insert it.
|
|
*
|
|
* If we're correcting and corrections are temporarily diabled, turn them
|
|
* back on.
|
|
*
|
|
* If input is a backspace:
|
|
*
|
|
* If we just did an auto-correction, revert it and turn off corrections
|
|
* until the next space or punctuation character.
|
|
*
|
|
* If we just inserted a suggested word that the user selected, revert
|
|
* the insertion, but don't disable autocorrect.
|
|
*
|
|
* Should we undo punctuation corrections this way, too?
|
|
*
|
|
* Otherwise, just delete the character before the cursor
|
|
*
|
|
* For any other input character, just insert it.
|
|
*
|
|
* Reset the backspace reversion state
|
|
*
|
|
* Update the capitalization state, if we're capitalizing
|
|
*/
|
|
function click(keyCode, repeat) {
|
|
// If the key is anything other than a backspace, forget about any
|
|
// previous changes that we would otherwise revert.
|
|
if (keyCode !== BACKSPACE) {
|
|
revertTo = revertFrom = '';
|
|
disableOnRevert = false;
|
|
}
|
|
|
|
var handler;
|
|
|
|
if (selection) {
|
|
// If there is selected text, don't do anything fancy here.
|
|
handler = handleKey(keyCode);
|
|
} else {
|
|
switch (keyCode) {
|
|
case SPACE: // This list of characters matches the WORDSEP regexp
|
|
case RETURN:
|
|
case PERIOD:
|
|
case QUESTION:
|
|
case EXCLAMATION:
|
|
case COMMA:
|
|
case COLON:
|
|
case SEMICOLON:
|
|
case DOUBLEQUOTE:
|
|
case CLOSEPAREN:
|
|
// These keys may trigger word or punctuation corrections
|
|
handler = handleCorrections(keyCode);
|
|
correctionDisabled = false;
|
|
break;
|
|
|
|
case BACKSPACE:
|
|
handler = handleBackspace(repeat);
|
|
break;
|
|
|
|
default:
|
|
handler = handleKey(keyCode);
|
|
}
|
|
}
|
|
|
|
// After the next key is resolved, we could update the state here.
|
|
return handler.then(function() {
|
|
// handleCorrections() above or it is now out of date, so clear it
|
|
// so it doesn't get used later
|
|
autoCorrection = null;
|
|
|
|
// And update the keyboard capitalization state, if necessary
|
|
updateCapitalization();
|
|
|
|
// If we're offering suggestions, ask the worker to make them now
|
|
updateSuggestions(repeat);
|
|
|
|
// Exit symbol layout mode after space or return key is pressed.
|
|
var isNonDefaultPage = currentPage !== PAGE_INDEX_DEFAULT;
|
|
var isSpace = keyCode === SPACE;
|
|
var isReturn = keyCode === RETURN;
|
|
var isAtpersand = keyCode === ATPERSAND;
|
|
var keyResetLayout = (isSpace && gotNormalKey) || isReturn || isAtpersand;
|
|
if (isNonDefaultPage && keyResetLayout) {
|
|
keyboard.setLayoutPage(PAGE_INDEX_DEFAULT);
|
|
}
|
|
|
|
// Next space key will change the layout
|
|
if (keyCode !== SPACE) {
|
|
gotNormalKey = true;
|
|
}
|
|
|
|
lastSpaceTimestamp = (keyCode === SPACE) ? Date.now() : 0;
|
|
}, function() {
|
|
// the previous sendKey or replaceSurroundingText has been rejected,
|
|
// No need to update the state.
|
|
})['catch'](function(e) { // ['catch'] for gjslint error
|
|
// Print the error and make sure inputSequencePromise always resolves.
|
|
console.error(e);
|
|
});
|
|
}
|
|
|
|
// Handle any key (including backspace) and do the right thing even if
|
|
// there is a selection in the text field. This method does not perform
|
|
// auto-correction or auto-punctuation.
|
|
function handleKey(keycode, repeat) {
|
|
// Generate the key event
|
|
return keyboard.sendKey(keycode, repeat).then(function() {
|
|
// First, update our internal state
|
|
if (keycode === BACKSPACE) {
|
|
if (selection) {
|
|
// backspace while a region is selected erases the selection
|
|
// and leaves the cursor at the selection start
|
|
inputText = inputText.substring(0, cursor) +
|
|
inputText.substring(selection);
|
|
selection = 0;
|
|
} else if (cursor > 0) {
|
|
cursor--;
|
|
inputText = inputText.substring(0, cursor) +
|
|
inputText.substring(cursor + 1);
|
|
|
|
// If we have temporarily disabled auto correction for the current
|
|
// word and we've just backspaced over the entire word, then we can
|
|
// re-enabled it again
|
|
if (correctionDisabled && !wordBeforeCursor()) {
|
|
correctionDisabled = false;
|
|
}
|
|
}
|
|
} else {
|
|
if (selection) {
|
|
inputText =
|
|
inputText.substring(0, cursor) +
|
|
String.fromCharCode(keycode) +
|
|
inputText.substring(selection);
|
|
selection = 0;
|
|
} else {
|
|
inputText =
|
|
inputText.substring(0, cursor) +
|
|
String.fromCharCode(keycode) +
|
|
inputText.substring(cursor);
|
|
}
|
|
cursor++;
|
|
}
|
|
}, function() {
|
|
// sendKey got canceled, keep state the same
|
|
});
|
|
}
|
|
|
|
// Assuming that the word before the cursor is oldWord, send a
|
|
// minimal number of key events to change it to newWord in the text
|
|
// field. Also update our internal state to match the new textfield
|
|
// content and cursor position.
|
|
function replaceBeforeCursor(oldWord, newWord) {
|
|
var oldWordLen = oldWord.length;
|
|
var replPromise =
|
|
keyboard.replaceSurroundingText(newWord, -oldWordLen, oldWordLen);
|
|
|
|
return replPromise.then(function() {
|
|
// Now update internal state
|
|
inputText =
|
|
inputText.substring(0, cursor - oldWordLen) +
|
|
newWord +
|
|
inputText.substring(cursor);
|
|
cursor += newWord.length - oldWordLen;
|
|
});
|
|
}
|
|
|
|
// If we just did auto correction or auto punctuation, then backspace
|
|
// should undo it. Otherwise it is just an ordinary backspace.
|
|
function handleBackspace(repeat) {
|
|
// If we made a correction and haven't changed it at all yet,
|
|
// then revert it.
|
|
var len = revertFrom ? revertFrom.length : 0;
|
|
if (len && cursor >= len &&
|
|
inputText.substring(cursor - len, cursor) === revertFrom) {
|
|
|
|
// Revert the content of the text field
|
|
return replaceBeforeCursor(revertFrom, revertTo).then(function() {
|
|
// If the change we just reverted was an auto-correction then
|
|
// temporarily disable auto correction until the next space
|
|
if (disableOnRevert) {
|
|
correctionDisabled = true;
|
|
}
|
|
|
|
revertFrom = revertTo = '';
|
|
disableOnRevert = false;
|
|
});
|
|
}
|
|
else {
|
|
return handleKey(BACKSPACE, repeat);
|
|
}
|
|
}
|
|
|
|
// This function is called when the user types space, return or a punctuation
|
|
// character. It performs auto correction or auto punctuation or just
|
|
// inserts the character.
|
|
function handleCorrections(keycode) {
|
|
if (correcting && autoCorrection && !correctionDisabled && atWordEnd() &&
|
|
wordBeforeCursor() !== autoCorrection) {
|
|
return autoCorrect(keycode);
|
|
}
|
|
else if (punctuating && cursor >= 2 &&
|
|
isWhiteSpace(inputText[cursor - 1]) &&
|
|
inputText[cursor - 1].charCodeAt(0) !== KeyEvent.DOM_VK_RETURN &&
|
|
!WORDSEP.test(inputText[cursor - 2]))
|
|
{
|
|
return autoPunctuate(keycode);
|
|
}
|
|
else {
|
|
return handleKey(keycode);
|
|
}
|
|
}
|
|
|
|
// Perform an autocorrection. Assumes that all pre-conditions for
|
|
// auto-correction have been met.
|
|
function autoCorrect(keycode) {
|
|
// Get the word before the cursor
|
|
var currentWord = wordBeforeCursor();
|
|
|
|
// Figure out the auto correction text
|
|
var newWord = autoCorrection;
|
|
|
|
// Make the correction
|
|
return replaceBeforeCursor(currentWord, newWord).then(function() {
|
|
// Remember the change we just made so we can revert it if the
|
|
// user types backspace
|
|
revertTo = currentWord;
|
|
revertFrom = newWord;
|
|
disableOnRevert = true;
|
|
}).then(function() {
|
|
// Send the keycode as separate key event because it may get canceled
|
|
return handleKey(keycode).then(function() {
|
|
revertFrom += String.fromCharCode(keycode);
|
|
});
|
|
});
|
|
}
|
|
|
|
// Auto punctuate, converting space punctuation to punctuation space
|
|
// or converting space space to period space if the two spaces were
|
|
// close enough together. Assumes that pre-conditions for auto punctuation
|
|
// have been met.
|
|
function autoPunctuate(keycode) {
|
|
switch (keycode) {
|
|
case SPACE:
|
|
if (Date.now() - lastSpaceTimestamp < DOUBLE_SPACE_TIME) {
|
|
return fixPunctuation(PERIOD, SPACE);
|
|
} else {
|
|
return handleKey(keycode);
|
|
}
|
|
break;
|
|
|
|
case PERIOD:
|
|
case QUESTION:
|
|
case EXCLAMATION:
|
|
case COMMA:
|
|
return fixPunctuation(keycode);
|
|
|
|
default:
|
|
// colon and semicolon don't auto-punctuate because they're
|
|
// used after spaces for smileys.
|
|
return handleKey(keycode);
|
|
}
|
|
|
|
// In both the space space and the space period case we call this function
|
|
// Second argument is the character reverting to if cancelling auto
|
|
// punctuation
|
|
// If the second argument is omitted, assume it is the same as the first
|
|
function fixPunctuation(keycode, revertToKeycode) {
|
|
return keyboard.sendKey(BACKSPACE)
|
|
.then(function() {
|
|
return keyboard.sendKey(keycode);
|
|
})
|
|
.then(function() {
|
|
return keyboard.sendKey(SPACE);
|
|
})
|
|
.then(function() {
|
|
var newtext = String.fromCharCode(keycode) + ' ';
|
|
inputText = inputText.substring(0, cursor - 1) +
|
|
newtext +
|
|
inputText.substring(cursor);
|
|
cursor++;
|
|
|
|
// Remember this change so we can revert it on backspace
|
|
revertTo = ' ' + String.fromCharCode(revertToKeycode || keycode);
|
|
revertFrom = newtext;
|
|
disableOnRevert = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
// When the worker thread sends us a batch of suggestions, deal
|
|
// with them here.
|
|
function handleSuggestions(input, suggestions) {
|
|
// If we didn't get any suggestions just send the empty array to
|
|
// clear any suggestions that are currently displayed. Do the same
|
|
// if the word before the cursor has changed since we requested
|
|
// these suggestions. That is, if the user has typed faster than we could
|
|
// offer suggestions, ignore them.
|
|
if (suggestions.length === 0 || wordBeforeCursor() !== input) {
|
|
keyboard.sendCandidates([]); // Clear any displayed suggestions
|
|
return;
|
|
}
|
|
|
|
// If input is ucase, then make all suggestions ucase as well.
|
|
// Ignore input.length of 1, it never gets autocorrected anyway
|
|
if (input.length > 1 && isUpperCase(input)) {
|
|
for (var ix = 0; ix < suggestions.length; ix++) {
|
|
suggestions[ix][0] = suggestions[ix][0].toUpperCase();
|
|
}
|
|
}
|
|
|
|
// We show no more than 3 suggestions; but we'd like to keep at least one
|
|
// suggestion from user dictionary, if its weight is less than 1. However,
|
|
// that suggestion can still be dropped if it matches the user input.
|
|
// User dictionary suggestion is identified by suggestion[2] === true.
|
|
|
|
var inputDefinedInUserDict = false;
|
|
// See if the user's input is a valid word on the list of suggestions
|
|
var inputIsSuggestion = false;
|
|
var inputWeight = 0;
|
|
var inputIndex;
|
|
for (inputIndex = 0; inputIndex < suggestions.length; inputIndex++) {
|
|
if (suggestions[inputIndex][0] === input) {
|
|
inputIsSuggestion = true;
|
|
inputDefinedInUserDict = !!suggestions[inputIndex][2];
|
|
inputWeight = suggestions[inputIndex][1];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// We never want to display the user's input as a suggestion so
|
|
// remove it from the list if it is there.
|
|
if (inputIsSuggestion) {
|
|
suggestions.splice(inputIndex, 1);
|
|
}
|
|
|
|
// If we don't have any suggestions we're done
|
|
if (suggestions.length === 0) {
|
|
keyboard.sendCandidates([]); // Clear any displayed suggestions
|
|
return;
|
|
}
|
|
|
|
//
|
|
// If there was an exact match for the user input in the suggestions
|
|
// it has already been removed. Now we need to loop through again
|
|
// looking for approximate matches and bump those to the start of the
|
|
// list. A word is an approximate match if all the letters match
|
|
// when we ignore case, apostrophes and hyphens. The assumption here
|
|
// is that the user is not expected to have to use the shift key or
|
|
// the alternate forms menu or the punctuation menus. If they type all
|
|
// the right letters, a matching word should have higher priority than
|
|
// a non-matching word. In particular this code ensures that "im" gets
|
|
// autocorrected to "I'm" instead of "in" and "id" gets autocorrected to
|
|
// "I'd" instead of "is". (Bug 1164421)
|
|
//
|
|
// XXX In English, apostrophes and hyphens are the only punctuation that
|
|
// commonly occurs within words. If other wordlists include other
|
|
// punctuation, we may need to add them to the regular expression below.
|
|
//
|
|
// XXX In the future, we might want to generalize this to consider
|
|
// accented forms when looking for approximate matches. If "jose"
|
|
// was autocorrecting to "hose" instead of "José", for example, then
|
|
// we might need to extend the definition of an approximate match here.
|
|
// For now, I don't have any examples of corrections that are coming
|
|
// out incorrectly for accented letters, though, so am keeping this
|
|
// simple.
|
|
//
|
|
// We loop backward through the suggestions, bumping any approximate
|
|
// match to the start of the list. This ensures that the highest ranked
|
|
// approximate match comes before lower ranked approximate matches,
|
|
// and all approximate matches come before non-matching suggestions.
|
|
//
|
|
var i = suggestions.length - 1;
|
|
var approximateMatches = 0; // how many approximate matches we've bumped
|
|
var lcInput = input.toLowerCase();
|
|
while(i > approximateMatches) {
|
|
if (suggestions[i][0].toLowerCase().replace(/[-']/g, '') === lcInput) {
|
|
// If this suggestion was an approximate match for the users input..
|
|
var match = suggestions[i]; // get the match,
|
|
suggestions.splice(i, 1); // remove it,
|
|
suggestions.unshift(match); // and put it back at the start.
|
|
approximateMatches++; // Increment this instead of i-- here.
|
|
}
|
|
else {
|
|
i--; // if not an approximate match move to next suggestion
|
|
}
|
|
}
|
|
|
|
// Make sure we have no more than three words
|
|
if (suggestions.length > 3) {
|
|
// We want to keep at least a user dictionary word here (if the heighest
|
|
// user dictionary word has weight >= 1).
|
|
// If for the first two suggestions we see one from user dictionary, or
|
|
// if we dropped a user dict suggestion above (matching user input),
|
|
// we can just append the third suggestion.
|
|
// Otherwise, we'll need to search through the remaining suggestions and
|
|
// append the first user-dict suggestion we find (that has weight >= 1);
|
|
// if we can't find any suitable user-dict suggestions, we just append
|
|
// the third suggestion (i.e. whatever that has the largest frequency
|
|
// in the remaining suggestions).
|
|
|
|
var trimmedSuggestions = suggestions.slice(0, 2);
|
|
|
|
var userDictionaryWordEncountered =
|
|
inputDefinedInUserDict ||
|
|
(!!suggestions[0][2]) ||
|
|
(!!suggestions[1][2]);
|
|
|
|
if (userDictionaryWordEncountered) {
|
|
trimmedSuggestions.push(suggestions[2]);
|
|
} else {
|
|
userDictionaryWordEncountered =
|
|
suggestions.slice(2).some(function(suggestion) {
|
|
if (suggestion[2] && suggestion[1] >=
|
|
USER_DICT_PREDICTION_BUMP_THRESHOLD) {
|
|
trimmedSuggestions.push(suggestion);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
if (!userDictionaryWordEncountered) {
|
|
trimmedSuggestions.push(suggestions[2]);
|
|
}
|
|
}
|
|
|
|
suggestions = trimmedSuggestions;
|
|
}
|
|
|
|
// Now get an array of just the suggested words
|
|
var words = suggestions.map(function(x) { return x[0]; });
|
|
|
|
// see whether words[0] and input have same length
|
|
var lengthMismatch;
|
|
switch (Math.abs(input.length - words[0].length)) {
|
|
case 0:
|
|
lengthMismatch = false;
|
|
break;
|
|
case 1:
|
|
lengthMismatch = suggestions[0][1] < MIN_LENGTH_MISMATCH_THRESHOLD;
|
|
break;
|
|
default:
|
|
lengthMismatch = true;
|
|
break;
|
|
}
|
|
|
|
// Decide whether the first word is going to be an autocorrection.
|
|
// If the user's input is already a valid word, then don't
|
|
// autocorrect unless the first suggested word is more common than
|
|
// the input. Note that if the first suggested word has a higher
|
|
// weight even after whatever penalty is applied for not matching
|
|
// exactly, then it is significantly more common than the actual input.
|
|
// (This rule means that "ill" will autocorrect to "I'll",
|
|
// "wont" to "won't", etc.)
|
|
// Also, don't autocorrect if the input is a single letter and
|
|
// the first word is more than a single letter. (But still autocorrect
|
|
// "i" to "I")
|
|
if (correcting &&
|
|
!correctionDisabled &&
|
|
(!inputIsSuggestion ||
|
|
suggestions[0][1] > inputWeight * AUTO_CORRECT_THRESHOLD) &&
|
|
(input.length > 1 || words[0].length === 1) &&
|
|
!lengthMismatch) {
|
|
// Remember the word to use if the next character is a space.
|
|
autoCorrection = words[0];
|
|
// Mark the auto-correction so the renderer can highlight it
|
|
words[0] = '*' + words[0];
|
|
}
|
|
else {
|
|
autoCorrection = null;
|
|
}
|
|
|
|
keyboard.sendCandidates(words);
|
|
}
|
|
|
|
//
|
|
// If the user selects one of the suggestions offered by this input method
|
|
// the keyboard calls this method to tell us it has been selected.
|
|
// We have to delete the current word, insert this new word, and
|
|
// update our internal state to match.
|
|
// word: the text displayed as the suggestion, might contain ellipsis
|
|
// data: the actual data we need to output
|
|
//
|
|
function select(word, data) {
|
|
var oldWord = wordBeforeCursor();
|
|
// A word divider is expected to append to the word when the
|
|
// suggestion is selected.
|
|
var newWord = data + SUGGESTION_SUFFIX;
|
|
|
|
// The user has selected a suggestion, so we don't need to display
|
|
// them anymore. Note that calling this function resets all the
|
|
// autocorrect state. We'll reset much of that state below after
|
|
// the word has been replace with the new one.
|
|
dismissSuggestions();
|
|
|
|
return replaceBeforeCursor(oldWord, newWord).then(function() {
|
|
// Remember the change we just made so we can revert it if the
|
|
// next key is a backspace. If the word is reverted we disable
|
|
// autocorrection for this word.
|
|
revertFrom = newWord;
|
|
revertTo = oldWord;
|
|
|
|
// And update the keyboard capitalization state, if necessary
|
|
updateCapitalization();
|
|
});
|
|
}
|
|
|
|
function dismissSuggestions() {
|
|
// Clear the list of candidates
|
|
keyboard.sendCandidates([]);
|
|
|
|
// Get rid of any autocorrection that is pending and reset the rest
|
|
// of our state, too.
|
|
lastSpaceTimestamp = 0;
|
|
autoCorrection = null;
|
|
revertTo = revertFrom = '';
|
|
disableOnRevert = false;
|
|
correctionDisabled = false;
|
|
}
|
|
|
|
function setLayoutPage(page) {
|
|
if (currentPage === PAGE_INDEX_DEFAULT) {
|
|
// we don't want to reset gotNormalKey if we're already in an alternative
|
|
// layout.
|
|
gotNormalKey = false;
|
|
}
|
|
|
|
currentPage = page;
|
|
}
|
|
|
|
function setLayoutParams(params) {
|
|
layoutParams = params;
|
|
|
|
// We don't need to update the nearbyKeys when using number/digit layout.
|
|
if (inputMode === 'verbatim') {
|
|
return;
|
|
}
|
|
|
|
// XXX We call nearbyKeys() every time the keyboard pops up.
|
|
// Maybe it would be better to compute it once in keyboard.js and
|
|
// cache it.
|
|
|
|
// We get called every time the keyboard case changes. Don't bother
|
|
// passing this data to the prediction engine if nothing has changed.
|
|
var newmap = findNearbyKeys(params);
|
|
var serialized = JSON.stringify(newmap);
|
|
if (serialized === serializedNearbyKeyMap) {
|
|
return;
|
|
}
|
|
|
|
nearbyKeyMap = newmap;
|
|
serializedNearbyKeyMap = serialized;
|
|
if (worker) {
|
|
worker.postMessage({ cmd: 'setNearbyKeys', args: [nearbyKeyMap]});
|
|
// Ask for new suggestions since the new layout may affect them.
|
|
// (When switching from QWERTY to Dvorak, e.g.)
|
|
updateSuggestions();
|
|
}
|
|
}
|
|
|
|
function findNearbyKeys(layout) {
|
|
var nearbyKeys = {};
|
|
var keys = layout.keyArray;
|
|
|
|
// Make sure that all the keycodes are lowercase, not uppercase
|
|
for (var p = 0; p < keys.length; ++p) {
|
|
keys[p].code =
|
|
String.fromCharCode(keys[p].code).toLowerCase().charCodeAt(0);
|
|
}
|
|
|
|
// For each key, calculate the keys nearby.
|
|
for (var n = 0; n < keys.length; ++n) {
|
|
var key1 = keys[n];
|
|
if (SpecialKey(key1)) {
|
|
continue;
|
|
}
|
|
var nearby = {};
|
|
for (var m = 0; m < keys.length; ++m) {
|
|
if (m === n) {
|
|
continue; // don't compare a key to itself
|
|
}
|
|
var key2 = keys[m];
|
|
if (SpecialKey(key2)) {
|
|
continue;
|
|
}
|
|
var d = distance(key1, key2);
|
|
if (d !== 0) {
|
|
nearby[key2.code] = d;
|
|
}
|
|
}
|
|
nearbyKeys[key1.code] = nearby;
|
|
}
|
|
|
|
return nearbyKeys;
|
|
|
|
// Compute the inverse square distance between the center point of
|
|
// two keys, using the radius of the key (where radius is defined
|
|
// as the distance from the center of key1 to a corner of key1)
|
|
// as the unit of measure. If the distance is greater than 2.5
|
|
// times the radius return 0 instead.
|
|
function distance(key1, key2) {
|
|
var cx1 = key1.x + key1.width / 2;
|
|
var cy1 = key1.y + key1.height / 2;
|
|
var cx2 = key2.x + key2.width / 2;
|
|
var cy2 = key2.y + key2.height / 2;
|
|
var radius = Math.sqrt(key1.width * key1.width / 4 +
|
|
key1.height * key1.height / 4);
|
|
|
|
var dx = (cx1 - cx2) / radius;
|
|
var dy = (cy1 - cy2) / radius;
|
|
// We calculate distance from center to center, but this gives
|
|
// too high of a penalty to vertical keys, so normalize dx/dy
|
|
dy /= (key1.height / key1.width);
|
|
var distanceSquared = dx * dx + dy * dy;
|
|
|
|
if (distanceSquared < 1) {
|
|
console.warn('Keys too close',
|
|
JSON.stringify(key1), JSON.stringify(key2));
|
|
return 0;
|
|
}
|
|
|
|
if (distanceSquared > 2.5 * 2.5) {
|
|
return 0;
|
|
} else {
|
|
return 1 / distanceSquared;
|
|
}
|
|
}
|
|
|
|
// Determine whether the key is a special character or a regular letter.
|
|
// Special characters include backspace (8), return (13), and space (32).
|
|
function SpecialKey(key) {
|
|
switch (key.code) {
|
|
case 0:
|
|
case KeyEvent.DOM_VK_BACK_SPACE:
|
|
case KeyEvent.DOM_VK_CAPS_LOCK:
|
|
case KeyEvent.DOM_VK_RETURN:
|
|
case KeyEvent.DOM_VK_ALT:
|
|
case KeyEvent.DOM_VK_SPACE:
|
|
return true;
|
|
default: // anything else is not special
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
function updateSuggestions(repeat) {
|
|
// If the user hasn't enabled suggestions, or if they're not appropriate
|
|
// for this input type, or are turned off by the input mode, do nothing
|
|
if (!suggesting && !correcting) {
|
|
return;
|
|
}
|
|
|
|
// If there is no dictionary language, do nothing
|
|
if (!language) {
|
|
return;
|
|
}
|
|
|
|
// If we are still loading the dictionary, do nothing
|
|
if (getDictionaryDataPromise) {
|
|
return;
|
|
}
|
|
|
|
// This shouldn't happen -- we previously allow layout to be selected
|
|
// without the dictionary, but the build script has since prevent that.
|
|
if (!worker) {
|
|
console.error('latin.js: called updateSuggestions() w/o an worker.');
|
|
|
|
return;
|
|
}
|
|
|
|
// If we deferred suggestions because of a key repeat, clear that timer
|
|
if (suggestionsTimer) {
|
|
clearTimeout(suggestionsTimer);
|
|
suggestionsTimer = null;
|
|
}
|
|
|
|
// If we're still repeating, reset the repeat timer.
|
|
if (repeat) {
|
|
suggestionsTimer = setTimeout(updateSuggestions, AUTOREPEAT_DELAY);
|
|
return;
|
|
}
|
|
|
|
// If we're not at the end of a word, we want to clear any suggestions
|
|
// that might already be there
|
|
if (!atWordEnd()) {
|
|
if (suggesting) {
|
|
keyboard.sendCandidates([]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
var word = wordBeforeCursor();
|
|
if (word) { // Defend against bug 879572 even though I can't reproduce it
|
|
worker.postMessage({cmd: 'predict', args: [word]});
|
|
}
|
|
}
|
|
|
|
function updateCapitalization() {
|
|
// If either the input mode or the input type is one that doesn't
|
|
// want capitalization, then don't alter the state of the keyboard.
|
|
// We however want to reset the shift key state triggered by the user,
|
|
// regardless of the layout page the user is currently on.
|
|
if (!capitalizing) {
|
|
keyboard.setUpperCase({
|
|
isUpperCase: false
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Set the keyboard to uppercase or lowercase depending
|
|
// on the text around the cursor:
|
|
//
|
|
// 1) If the cursor is at the start of the field: uppercase
|
|
//
|
|
// 2) If there is a non space character immediately before the cursor:
|
|
// lowercase
|
|
//
|
|
// 3) If the first non-space character before the cursor is . ? or !:
|
|
// uppercase
|
|
//
|
|
// 4) Otherwise: lowercase
|
|
//
|
|
if (cursor === 0) {
|
|
keyboard.setUpperCase({
|
|
isUpperCase: true
|
|
});
|
|
}
|
|
else if (!isWhiteSpace(inputText.substring(cursor - 1, cursor))) {
|
|
keyboard.setUpperCase({
|
|
isUpperCase: false
|
|
});
|
|
}
|
|
else if (atSentenceStart()) {
|
|
keyboard.setUpperCase({
|
|
isUpperCase: true
|
|
});
|
|
}
|
|
else {
|
|
keyboard.setUpperCase({
|
|
isUpperCase: false
|
|
});
|
|
}
|
|
}
|
|
|
|
// Return true if all characters of s are uppercase. A character
|
|
// is uppercase if toLowerCase() on that character is returns something
|
|
// different than the character
|
|
function isUpperCase(s) {
|
|
var lc = s.toLowerCase();
|
|
for (var i = 0, n = s.length; i < n; i++) {
|
|
if (s[i] === lc[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isWhiteSpace(s) {
|
|
return WS.test(s);
|
|
}
|
|
|
|
// We only offer suggestions if the cursor is at the end of a word
|
|
// The character before the cursor must be a word character and
|
|
// the cursor must be at the end of the input or the character after
|
|
// must be whitespace. If there is a selection we never return true.
|
|
function atWordEnd() {
|
|
// If there is a selection we never want suggestions
|
|
if (selection) {
|
|
return false;
|
|
}
|
|
|
|
// If we're not at the end of the line and the character after the
|
|
// cursor is not whitespace, don't offer a suggestion
|
|
// Note that we purposely use WS here, not WORDSEP.
|
|
if (cursor < inputText.length && !WS.test(inputText[cursor])) {
|
|
return false;
|
|
}
|
|
|
|
// If the cursor is at position 0 then we're not at the end of a word
|
|
if (cursor <= 0) {
|
|
return false;
|
|
}
|
|
|
|
// We're at the end of a word if the character before the cursor is
|
|
// not a word separator character
|
|
var c = inputText[cursor - 1];
|
|
return !WORDSEP.test(c);
|
|
}
|
|
|
|
// Get the word before the cursor. Assumes that atWordEnd() is true
|
|
function wordBeforeCursor() {
|
|
for (var firstletter = cursor - 1; firstletter >= 0; firstletter--) {
|
|
if (WORDSEP.test(inputText[firstletter])) {
|
|
break;
|
|
}
|
|
}
|
|
firstletter++;
|
|
|
|
// firstletter is now the position of the start of the word and cursor is
|
|
// the end of the word
|
|
return inputText.substring(firstletter, cursor);
|
|
}
|
|
|
|
function atSentenceStart() {
|
|
var i = cursor - 1;
|
|
|
|
if (i === -1) { // This is the empty string case
|
|
return true;
|
|
}
|
|
|
|
// Verify that the position before the cursor is whitespace
|
|
if (!isWhiteSpace(inputText[i--])) {
|
|
return false;
|
|
}
|
|
// Now skip any additional whitespace before that
|
|
while (i >= 0 && isWhiteSpace(inputText[i])) {
|
|
i--;
|
|
}
|
|
|
|
if (i < 0) { // whitespace all the way back to the end of the string
|
|
return true;
|
|
}
|
|
|
|
var c = inputText[i];
|
|
return c === '.' || c === '?' || c === '!';
|
|
}
|
|
|
|
function stateChange(state) {
|
|
// TODO: Remove this and actually compare the state properties with
|
|
// the internal states.
|
|
if (state.ownAction) {
|
|
return;
|
|
}
|
|
|
|
cursor = state.selectionStart;
|
|
selection = (state.selectionEnd > state.selectionStart) ?
|
|
state.selectionEnd : 0;
|
|
inputText = state.text;
|
|
|
|
dismissSuggestions();
|
|
updateSuggestions();
|
|
}
|
|
|
|
if (!('PAGE_INDEX_DEFAULT' in window)) {
|
|
window.PAGE_INDEX_DEFAULT = null;
|
|
}
|
|
}());
|