Update Google Input Tools

third_party/google_input_tools/src/chrome/os/inputview/adapter.js

 // Copyright 2014 The ChromeOS IME Authors. All Rights Reserved.
 // limitations under the License.
 // See the License for the specific language governing permissions and
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // distributed under the License is distributed on an "AS-IS" BASIS,
 // Unless required by applicable law or agreed to in writing, software
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // You may obtain a copy of the License at
 // you may not use this file except in compliance with the License.
 // Licensed under the Apache License, Version 2.0 (the "License");
 //
 goog.provide('i18n.input.chrome.inputview.Adapter');
 
 goog.require('goog.events.Event');
 goog.require('goog.events.EventHandler');
 goog.require('goog.events.EventTarget');
 goog.require('goog.events.EventType');
 goog.require('goog.object');
 goog.require('i18n.input.chrome.DataSource');
 goog.require('i18n.input.chrome.inputview.FeatureName');
 goog.require('i18n.input.chrome.inputview.FeatureTracker');
-goog.require('i18n.input.chrome.inputview.GlobalFlags');
 goog.require('i18n.input.chrome.inputview.ReadyState');
 goog.require('i18n.input.chrome.inputview.StateType');
 goog.require('i18n.input.chrome.inputview.events.EventType');
+goog.require('i18n.input.chrome.inputview.events.MessageEvent');
 goog.require('i18n.input.chrome.inputview.events.SurroundingTextChangedEvent');
 goog.require('i18n.input.chrome.message');
 goog.require('i18n.input.chrome.message.ContextType');
-goog.require('i18n.input.chrome.message.Event');
 goog.require('i18n.input.chrome.message.Name');
 goog.require('i18n.input.chrome.message.Type');
 
 goog.scope(function() {
 var CandidatesBackEvent = i18n.input.chrome.DataSource.CandidatesBackEvent;
 var ContextType = i18n.input.chrome.message.ContextType;
 var FeatureTracker = i18n.input.chrome.inputview.FeatureTracker;
 var FeatureName = i18n.input.chrome.inputview.FeatureName;
+var GesturesBackEvent = i18n.input.chrome.DataSource.GesturesBackEvent;
 var Name = i18n.input.chrome.message.Name;
+var State = i18n.input.chrome.inputview.ReadyState.State;
 var Type = i18n.input.chrome.message.Type;
+var events = i18n.input.chrome.inputview.events;
 
 
 
 /**
  * The adapter for interview.
  *
  * @param {!i18n.input.chrome.inputview.ReadyState} readyState .
  * @extends {goog.events.EventTarget}
  * @constructor
  */
@@ skipping 81 matching lines @@
 
 /** @type {boolean} */
 Adapter.prototype.isChromeVoxOn = false;
 
 
 /** @type {string} */
 Adapter.prototype.textBeforeCursor = '';
 
 
 /** @type {boolean} */
-Adapter.prototype.isQPInputView = true;
+Adapter.prototype.isFloating = false;
 
 
 /**
   * Whether the background controller is on switching.
   *
   * @private {boolean}
   */
 Adapter.prototype.isBgControllerSwitching_ = false;
 
 
 /**
  * Callback for updating settings.
  *
  * @param {!Object} message .
  * @private
  */
 Adapter.prototype.onUpdateSettings_ = function(message) {
   this.screen = message[Name.SCREEN];
   this.queryCurrentSite();
   this.contextType = /** @type {string} */ (message[Name.CONTEXT_TYPE]);
   // Resets the flag, since when inputview receive the update setting response,
   // it means the background switching is done.
   this.isBgControllerSwitching_ = false;
-  this.dispatchEvent(new i18n.input.chrome.message.Event(Type.UPDATE_SETTINGS,
-      message));
+  this.dispatchEvent(
+      new events.MessageEvent(events.EventType.UPDATE_SETTINGS, message));
 };
 
 
 /**
  * Sets the modifier states.
  *
  * @param {i18n.input.chrome.inputview.StateType} stateType .
  * @param {boolean} enable True to enable the state, false otherwise.
  */
 Adapter.prototype.setModifierState = function(stateType, enable) {
@@ skipping 49 matching lines @@
  */
 Adapter.prototype.sendKeyDownEvent = function(key, code, opt_keyCode,
     opt_spatialData) {
   this.sendKeyEvent_([this.generateKeyboardEvent_(
       goog.events.EventType.KEYDOWN, key, code, opt_keyCode,
       opt_spatialData)]);
 };
 
 
 /**
+ * Sets whether gesture editing is in progress.
+ *
+ * @param {boolean} inProgress
+ * @param {?boolean=} opt_isSwipe Whether it was triggered by a swipe.
+ */
+Adapter.prototype.setGestureEditingInProgress = function(inProgress,
+    opt_isSwipe) {
+  chrome.runtime.sendMessage(
+      goog.object.create(
+          Name.TYPE, Type.SET_GESTURE_EDITING,
+          Name.IN_PROGRESS, inProgress,
+          Name.IS_SWIPE, opt_isSwipe));
+};
+
+
+/**
+ * Sends a gesture typing event to the backend for decoding.
+ *
+ * @param {!Array.<!i18n.input.chrome.inputview.elements.content.
+ *                 GestureCanvasView.Point>} gestureData The gesture data
+ *                 (trail) to send.
+ */
+Adapter.prototype.sendGestureEvent = function(gestureData) {
+  chrome.runtime.sendMessage(
+      goog.object.create(Name.TYPE, Type.SEND_GESTURE_EVENT, Name.GESTURE_DATA,
+          gestureData));
+};
+
+
+/**
  * Simulates to send 'keyup' event.
  *
  * @param {string} key
  * @param {string} code
  * @param {number=} opt_keyCode The key code.
  * @param {!Object=} opt_spatialData .
  */
 Adapter.prototype.sendKeyUpEvent = function(key, code, opt_keyCode,
     opt_spatialData) {
   this.sendKeyEvent_([this.generateKeyboardEvent_(
       goog.events.EventType.KEYUP, key, code, opt_keyCode, opt_spatialData)]);
 };
 
 
 /**
  * Use {@code chrome.input.ime.sendKeyEvents} to simulate key events.
  *
  * @param {!Array.<!Object.<string, string|boolean>>} keyData .
  * @private
  */
 Adapter.prototype.sendKeyEvent_ = function(keyData) {
   chrome.runtime.sendMessage(
       goog.object.create(Name.TYPE, Type.SEND_KEY_EVENT, Name.KEY_DATA,
           keyData));
 };
 
 
 /**
+ * Sends an updated keyboard layout to the backend gesture typing decoder.
+ *
+ * @param {?Object} keyboardLayout The keyboard layout object to send.
+ */
+Adapter.prototype.sendKeyboardLayout = function(keyboardLayout) {
+  chrome.runtime.sendMessage(
+      goog.object.create(Name.TYPE, Type.SEND_KEYBOARD_LAYOUT,
+          Name.KEYBOARD_LAYOUT, keyboardLayout));
+};
+
+
+/**
  * Generates a {@code ChromeKeyboardEvent} by given values.
  *
  * @param {string} type .
  * @param {string} key The key.
  * @param {string} code The code.
  * @param {number=} opt_keyCode The key code.
  * @param {!Object=} opt_spatialData .
  * @param {!Object.<{ctrl: boolean, shift: boolean}>=} opt_modifiers .
  * @return {!Object.<string, string|boolean>}
  * @private
@@ skipping 75 matching lines @@
  * True if it is a password box.
  *
  * @return {boolean} .
  */
 Adapter.prototype.isPasswordBox = function() {
   return this.contextType == 'password';
 };
 
 
 /**
- * True to enable gesture deletion.
+ * Whether the floating virtual keyboard feature is enabled.
  *
  * @return {boolean}
  */
-Adapter.prototype.isGestureDeletionEnabled = function() {
-  // TODO: Omni bar sends wrong anchor/focus when autocompleting
-  // URLs. Re-enable when that is fixed.
-  if (this.contextType == ContextType.URL) {
+Adapter.prototype.isFloatingVirtualKeyboardEnabled = function() {
+  // This feature depends on setMode API. The api is a private API and may not
+  // be available all the time.
+  if (!inputview || !inputview.setMode) {
     return false;
   }
-  return this.features.isEnabled(FeatureName.GESTURE_DELETION);
+  return this.features.isEnabled(FeatureName.FLOATING_VIRTUAL_KEYBOARD);
 };
 
 
-/**
- * True to enable gesture typing.
- *
- * @return {boolean}
- */
-Adapter.prototype.isGestureTypingEnabled = function() {
-  return this.features.isEnabled(FeatureName.GESTURE_TYPING);
-};
-
-
 /**
  * Callback when blurs in the context.
  *
  * @private
  */
 Adapter.prototype.onContextBlur_ = function() {
   this.contextType = '';
   this.dispatchEvent(new goog.events.Event(i18n.input.chrome.inputview.events.
       EventType.CONTEXT_BLUR));
 };
@@ skipping 65 matching lines @@
     this.isBgControllerSwitching_ = true;
     chrome.runtime.sendMessage(goog.object.create(
         Name.TYPE, Type.CONNECT,
         Name.VISIBILITY, this.isVisible));
   }).bind(this));
 };
 
 
 /**
  * Loads the keyboard settings.
- *
- * @param {string} languageCode The language code.
  */
-Adapter.prototype.initialize = function(languageCode) {
+Adapter.prototype.initialize = function() {
   if (chrome.accessibilityFeatures &&
       chrome.accessibilityFeatures.spokenFeedback) {
     chrome.accessibilityFeatures.spokenFeedback.get({}, (function(details) {
       this.isChromeVoxOn = details['value'];
     }).bind(this));
     chrome.accessibilityFeatures.spokenFeedback.onChange.addListener((function(
         details) {
           if (!this.isChromeVoxOn && details['value']) {
             this.dispatchEvent(new goog.events.Event(
                 i18n.input.chrome.inputview.events.EventType.REFRESH));
           }
           this.isChromeVoxOn = details['value'];
         }).bind(this));
   }
 
   this.initBackground_();
 
-  var StateType = i18n.input.chrome.inputview.ReadyState.StateType;
   if (window.inputview) {
     inputview.getKeyboardConfig((function(config) {
       this.isA11yMode = !!config['a11ymode'];
       this.features.initialize(config);
-      this.readyState_.markStateReady(StateType.KEYBOARD_CONFIG_READY);
+      this.isVoiceInputEnabled =
+          this.features.isEnabled(FeatureName.VOICE_INPUT);
+      this.readyState_.markStateReady(State.KEYBOARD_CONFIG_READY);
       this.maybeDispatchSettingsReadyEvent_();
     }).bind(this));
     inputview.getInputMethods((function(inputMethods) {
       // Only show globe key to switching between IMEs when there are more
       // than one IME.
       this.showGlobeKey = inputMethods.length > 1;
-      this.readyState_.markStateReady(StateType.IME_LIST_READY);
-      this.maybeDispatchSettingsReadyEvent_();
-    }).bind(this));
-    inputview.getInputMethodConfig((function(config) {
-      this.isQPInputView = !!config['isNewQPInputViewEnabled'] ||
-          !!config['isNewMDInputViewEnabled'];
-      var voiceEnabled = config['isVoiceInputEnabled'];
-      if (goog.isDef(voiceEnabled)) {
-        this.isVoiceInputEnabled = !!voiceEnabled;
-      }
-      i18n.input.chrome.inputview.GlobalFlags.isQPInputView =
-          this.isQPInputView;
-      this.readyState_.markStateReady(StateType.INPUT_METHOD_CONFIG_READY);
+      this.readyState_.markStateReady(State.IME_LIST_READY);
       this.maybeDispatchSettingsReadyEvent_();
     }).bind(this));
   } else {
-    this.readyState_.markStateReady(StateType.IME_LIST_READY);
-    this.readyState_.markStateReady(StateType.KEYBOARD_CONFIG_READY);
-    this.readyState_.markStateReady(StateType.INPUT_METHOD_CONFIG_READY);
+    this.readyState_.markStateReady(State.IME_LIST_READY);
+    this.readyState_.markStateReady(State.KEYBOARD_CONFIG_READY);
   }
 
   this.maybeDispatchSettingsReadyEvent_();
 };
 
 
 /**
  * Dispatch event SETTINGS_READY if all required bits are flipped.
  *
  * @private
  */
 Adapter.prototype.maybeDispatchSettingsReadyEvent_ = function() {
-  var StateType = i18n.input.chrome.inputview.ReadyState.StateType;
   var states = [
-    StateType.KEYBOARD_CONFIG_READY,
-    StateType.IME_LIST_READY,
-    StateType.INPUT_METHOD_CONFIG_READY];
+    State.KEYBOARD_CONFIG_READY,
+    State.IME_LIST_READY];
   var ready = true;
   for (var i = 0; i < states.length; i++) {
     ready = ready && this.readyState_.isReady(states[i]);
   }
   if (ready) {
     window.setTimeout((function() {
       this.dispatchEvent(new goog.events.Event(
           i18n.input.chrome.inputview.events.EventType.SETTINGS_READY));
     }).bind(this), 0);
   }
@@ skipping 46 matching lines @@
  * Callback for visibility change on the input view window.
  *
  * @private
  */
 Adapter.prototype.onVisibilityChange_ = function() {
   this.isVisible = !document.webkitHidden;
   this.dispatchEvent(new goog.events.Event(i18n.input.chrome.inputview.
       events.EventType.VISIBILITY_CHANGE));
   chrome.runtime.sendMessage(goog.object.create(
       Name.TYPE, Type.VISIBILITY_CHANGE,
-      Name.VISIBILITY, !document.webkitHidden,
-      Name.WORKSPACE_HEIGHT, screen.height - window.innerHeight));
+      Name.VISIBILITY, !document.webkitHidden));
 };
 
 
 /**
  * Sends request for completion.
  *
  * @param {string} query .
  * @param {!Object=} opt_spatialData .
  */
 Adapter.prototype.sendCompletionRequest = function(query, opt_spatialData) {
@@ skipping 23 matching lines @@
  *
  * @param {string} text .
  */
 Adapter.prototype.commitText = function(text) {
   chrome.runtime.sendMessage(goog.object.create(
       Name.TYPE, Type.COMMIT_TEXT, Name.TEXT, text));
 };
 
 
 /**
+ * Commits the gesture result.
+ *
+ * @param {string} text .
+ */
+Adapter.prototype.commitGestureResult = function(text) {
+  chrome.runtime.sendMessage(goog.object.create(
+      Name.TYPE, Type.CONFIRM_GESTURE_RESULT, Name.TEXT, text));
+};
+
+
+/**
  * Sets the language.
  *
  * @param {string} language .
  */
 Adapter.prototype.setLanguage = function(language) {
   chrome.runtime.sendMessage(goog.object.create(
       Name.TYPE, Type.SET_LANGUAGE, Name.LANGUAGE, language));
 };
 
 
 /**
  * Callbck when completion is back.
  *
  * @param {!Object} message .
  * @private
  */
 Adapter.prototype.onCandidatesBack_ = function(message) {
   var source = message['source'] || '';
   var candidates = message['candidates'] || [];
   this.dispatchEvent(new CandidatesBackEvent(source, candidates));
 };
 
 
 /**
+ * Callbck when completion is back.
+ *
+ * @param {!Object} message .
+ * @private
+ */
+Adapter.prototype.onGesturesBack_ = function(message) {
+  var results = message[Name.GESTURE_RESULTS];
+  this.dispatchEvent(new GesturesBackEvent(results));
+};
+
+
+/**
  * Hides the keyboard.
  */
 Adapter.prototype.hideKeyboard = function() {
   chrome.input.ime.hideInputView();
 };
 
 
 /**
  * Sends DOUBLE_CLICK_ON_SPACE_KEY message.
  */
@@ skipping 40 matching lines @@
   switch (type) {
     case Type.CANDIDATES_BACK:
       this.onCandidatesBack_(msg);
       break;
     case Type.CONTEXT_FOCUS:
       this.onContextFocus_(msg);
       break;
     case Type.CONTEXT_BLUR:
       this.onContextBlur_();
       break;
+    case Type.GESTURES_BACK:
+      this.onGesturesBack_(msg);
+      break;
     case Type.SURROUNDING_TEXT_CHANGED:
       this.onSurroundingTextChanged_(request[Name.TEXT],
           request[Name.ANCHOR],
           request[Name.FOCUS]);
       break;
     case Type.UPDATE_SETTINGS:
       this.onUpdateSettings_(msg);
       break;
     case Type.VOICE_STATE_CHANGE:
+      this.dispatchEvent(
+          new events.MessageEvent(events.EventType.VOICE_STATE_CHANGE,
+              msg));
+      break;
     case Type.HWT_NETWORK_ERROR:
+      this.dispatchEvent(
+          new events.MessageEvent(events.EventType.HWT_NETWORK_ERROR,
+              msg));
+      break;
     case Type.FRONT_TOGGLE_LANGUAGE_STATE:
-      this.dispatchEvent(new i18n.input.chrome.message.Event(type, msg));
+      this.dispatchEvent(
+          new events.MessageEvent(events.EventType.FRONT_TOGGLE_LANGUAGE_STATE,
+              msg));
       break;
   }
 };
 
 
 /**
  * Sends the voice state to background.
  *
  * @param {boolean} state .
  */
@@ skipping 41 matching lines @@
  * Unset the inputtool
  */
 Adapter.prototype.unsetController = function() {
   chrome.runtime.sendMessage(
       goog.object.create(
           Name.TYPE,
           Type.UNSET_CONTROLLER));
 };
 });  // goog.scope