Update Google Input Tools

third_party/google_input_tools/src/chrome/os/inputview/controller.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
@@ skipping 61 matching lines @@
 var InputToolCode = i18n.input.lang.InputToolCode;
 var KeyCodes = i18n.input.chrome.inputview.events.KeyCodes;
 var MenuView = i18n.input.chrome.inputview.elements.content.MenuView;
 var Name = i18n.input.chrome.message.Name;
 var PerfTracker = i18n.input.chrome.inputview.PerfTracker;
 var SizeSpec = i18n.input.chrome.inputview.SizeSpec;
 var SpecNodeName = i18n.input.chrome.inputview.SpecNodeName;
 var StateType = i18n.input.chrome.inputview.StateType;
 var SoundController = i18n.input.chrome.sounds.SoundController;
 var Type = i18n.input.chrome.message.Type;
+var events = i18n.input.chrome.inputview.events;
 var util = i18n.input.chrome.inputview.util;
 
 
 
 /**
  * The controller of the input view keyboard.
  *
  * @param {string} keyset The keyboard keyset.
  * @param {string} languageCode The language code for this keyboard.
  * @param {string} passwordLayout The layout for password box.
@@ skipping 83 matching lines @@
 
   /** @private {!i18n.input.chrome.inputview.ReadyState} */
   this.readyState_ = new i18n.input.chrome.inputview.ReadyState();
 
   /** @private {!i18n.input.chrome.inputview.Adapter} */
   this.adapter_ = new i18n.input.chrome.inputview.Adapter(this.readyState_);
 
   /** @private {!SoundController} */
   this.soundController_ = new SoundController(false);
 
+  /**
+   * Whether or not to commit the next gesture result.
+   *
+   * @private {boolean}
+   */
+  this.commitNextGestureResult_ = false;
+
   /** @private {!i18n.input.chrome.inputview.KeyboardContainer} */
   this.container_ = new i18n.input.chrome.inputview.KeyboardContainer(
       this.adapter_, this.soundController_);
-  this.container_.render();
 
   /**
    * The context type and keyset mapping group by input method id.
    * key: input method id.
    * value: Object
    *    key: context type string.
    *    value: keyset string.
    *
    * @private {!Object.<string, !Object.<string, string>>}
    */
@@ skipping 11 matching lines @@
 
   /**
    * The stats map for input view closing.
    *
    * @type {!Object.<string, !Array.<number>>}
    * @private
    */
   this.statsForClosing_ = {};
 
   /**
+   * The time the last point was accepted.
+   *
+   * @private {number}
+   */
+  this.lastPointTime_ = 0;
+
+  /**
    * The last height sent to window.resizeTo to avoid multiple equivalent calls.
    *
    * @private {number}
    */
   this.lastResizeHeight_ = -1;
 
   /**
    * The activate (show) time stamp for statistics.
    *
    * @type {Date}
@@ skipping 75 matching lines @@
 /**
  * The handwriting input tool code suffix.
  *
  * @const {string}
  * @private
  */
 Controller.HANDWRITING_CODE_SUFFIX_ = '-t-i0-handwrit';
 
 
 /**
+ * The US English compact layout prefix.
+ *
+ * @const {string}
+ * @private
+ */
+Controller.US_COMPACT_PREFIX_ = 'us.compact';
+
+
+/**
+ * Time threshold between samples sent to the back end.
+ *
+ * @const {number}
+ */
+Controller.SUBSAMPLING_TIME_THRESHOLD = 100;
+
+
+/**
  * True if the settings is loaded.
  *
  * @type {boolean}
  */
 Controller.prototype.isSettingReady = false;
 
 
 /**
  * True if the keyboard is set up.
  * Note: This flag is only used for automation testing.
  *
  * @type {boolean}
  */
 Controller.prototype.isKeyboardReady = false;
 
 
 /**
+ * True if the current keyset is the US english compact layout.
+ *
+ * @type {boolean}
+ * @private
+ */
+Controller.prototype.isKeysetUSCompact_ = false;
+
+
+/**
  * The auto repeat timer for backspace hold.
  *
  * @type {goog.async.Delay}
  * @private
  */
 Controller.prototype.backspaceAutoRepeat_;
 
 
 /**
  * The initial keyset determined by inputview url and/or settings.
@@ skipping 83 matching lines @@
 /**
  * The input tool name.
  *
  * @type {string}
  * @private
  */
 Controller.prototype.title_;
 
 
 /**
+ * Whether to return to the standard character keyset after space is touched.
+ *
+ * @type {boolean}
+ * @private
+ */
+Controller.prototype.returnToLetterKeysetOnSpace_ = false;
+
+
+/**
+ * A cache of the previous gesture results.
+ *
+ * @private {!Array.<string>}
+ */
+Controller.prototype.gestureResultsCache_;
+
+
+/**
  * Registers event handlers.
  * @private
  */
 Controller.prototype.registerEventHandler_ = function() {
   this.handler_.
       listen(this.model_,
           EventType.LAYOUT_LOADED,
           this.onLayoutLoaded_).
       listen(this.model_,
           EventType.CONFIG_LOADED,
@@ skipping 14 matching lines @@
           ], this.onPointerEvent_).
       listen(this.pointerHandler_,
           EventType.DRAG,
           this.onDragEvent_).
       listen(window, goog.events.EventType.RESIZE, this.resize).
       listen(this.adapter_,
           EventType.SURROUNDING_TEXT_CHANGED, this.onSurroundingTextChanged_).
       listen(this.adapter_,
           i18n.input.chrome.DataSource.EventType.CANDIDATES_BACK,
           this.onCandidatesBack_).
+      listen(this.adapter_,
+          i18n.input.chrome.DataSource.EventType.GESTURES_BACK,
+          this.onGesturesBack_).
       listen(this.adapter_, EventType.URL_CHANGED, this.onURLChanged_).
       listen(this.adapter_, EventType.CONTEXT_FOCUS, this.onContextFocus_).
       listen(this.adapter_, EventType.CONTEXT_BLUR, this.onContextBlur_).
       listen(this.adapter_, EventType.VISIBILITY_CHANGE,
           this.onVisibilityChange_).
       listen(this.adapter_, EventType.SETTINGS_READY, this.onSettingsReady_).
-      listen(this.adapter_, Type.UPDATE_SETTINGS, this.onUpdateSettings_).
-      listen(this.adapter_, Type.FRONT_TOGGLE_LANGUAGE_STATE,
-          this.onUpdateToggleLanguateState_).
-      listen(this.adapter_, Type.VOICE_STATE_CHANGE, this.onVoiceStateChange_).
+      listen(this.adapter_, EventType.UPDATE_SETTINGS, this.onUpdateSettings_).
+      listen(this.adapter_, EventType.FRONT_TOGGLE_LANGUAGE_STATE,
+          this.onUpdateToggleLanguageState_).
+      listen(this.adapter_, EventType.VOICE_STATE_CHANGE,
+          this.onVoiceStateChange_).
       listen(this.adapter_, EventType.REFRESH, this.onRefresh_);
 };
 
 
 /**
  * Handler for voice module state change.
  *
- * @param {!i18n.input.chrome.message.Event} e .
+ * @param {!events.MessageEvent} e .
  * @private
  */
 Controller.prototype.onVoiceStateChange_ = function(e) {
   if (!e.msg[Name.VOICE_STATE]) {
     this.container_.candidateView.switchToIcon(
         CandidateView.IconType.VOICE, true);
     this.container_.voiceView.stop();
   }
 };
 
@@ skipping 22 matching lines @@
       keysetMap[context] = newKeyset;
     }
   }
   keysetMap[ContextType.DEFAULT] = this.initialKeyset_ = newKeyset;
 };
 
 
 /**
  * Callback for updating settings.
  *
- * @param {!i18n.input.chrome.message.Event} e .
+ * @param {!events.MessageEvent} e .
  * @private
  */
 Controller.prototype.onUpdateSettings_ = function(e) {
   var settings = this.model_.settings;
   if (goog.isDef(e.msg['autoSpace'])) {
     settings.autoSpace = e.msg['autoSpace'];
   }
   if (goog.isDef(e.msg['autoCapital'])) {
     settings.autoCapital = e.msg['autoCapital'];
   }
   if (goog.isDef(e.msg['candidatesNavigation'])) {
     settings.candidatesNavigation = e.msg['candidatesNavigation'];
     this.container_.candidateView.setNavigation(settings.candidatesNavigation);
   }
   if (goog.isDef(e.msg[Name.KEYSET])) {
     this.setDefaultKeyset_(e.msg[Name.KEYSET]);
   }
   if (goog.isDef(e.msg['enableLongPress'])) {
     settings.enableLongPress = e.msg['enableLongPress'];
   }
   if (goog.isDef(e.msg['doubleSpacePeriod'])) {
     settings.doubleSpacePeriod = e.msg['doubleSpacePeriod'];
   }
   if (goog.isDef(e.msg['soundOnKeypress'])) {
     settings.soundOnKeypress = e.msg['soundOnKeypress'];
     this.soundController_.setEnabled(settings.soundOnKeypress);
   }
+  if (goog.isDef(e.msg['gestureEditing'])) {
+    settings.gestureEditing = e.msg['gestureEditing'];
+    var enabled = settings.gestureEditing && !this.adapter_.isA11yMode;
+    this.container_.swipeView.enabled = enabled;
+    this.container_.selectView.setSettingsEnabled(enabled);
+  }
+  if (goog.isDef(e.msg['gestureTyping'])) {
+    settings.gestureTyping = e.msg['gestureTyping'];
+  } else {
+    settings.gestureTyping = false;
+  }
   this.perfTracker_.tick(PerfTracker.TickName.BACKGROUND_SETTINGS_FETCHED);
   this.model_.stateManager.contextType = this.adapter_.contextType;
   this.maybeCreateViews_();
 };
 
 
 /**
  * Callback for url changed.
  *
  * @private
  */
 Controller.prototype.onURLChanged_ = function() {
   this.container_.candidateView.setToolbarVisible(this.shouldShowToolBar_());
 };
 
 
 /**
  * Callback for setting ready.
  *
  * @private
  */
 Controller.prototype.onSettingsReady_ = function() {
   if (this.isSettingReady) {
     return;
   }
 
   this.isSettingReady = true;
+  // Don't render container twice.
+  if (!this.container_.isInDocument()) {
+    this.container_.render();
+  }
   var keysetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
   var newKeyset = '';
   if (this.adapter_.isA11yMode) {
     newKeyset = util.getConfigName(keysetMap[ContextType.DEFAULT]);
   } else {
     newKeyset = /** @type {string} */ (this.model_.settings.
         getPreference(util.getConfigName(keysetMap[ContextType.DEFAULT])));
   }
   if (!this.adapter_.features.isEnabled(FeatureName.EXPERIMENTAL) &&
       keysetMap[ContextType.DEFAULT] ==
       'zhuyin.compact.qwerty') {
     newKeyset = 'zhuyin';
   }
   if (newKeyset) {
     this.setDefaultKeyset_(newKeyset);
   }
-  this.container_.selectView.setVisible(
-      this.adapter_.features.isEnabled(FeatureName.GESTURE_SELECTION));
+  this.container_.selectView.setSettingsEnabled(
+      this.model_.settings.gestureEditing && !this.adapter_.isA11yMode);
   // Loads resources in case the default keyset is changed.
   this.loadAllResources_();
   this.maybeCreateViews_();
 };
 
 
 /**
+ * Returns whether or not the gesture typing feature is enabled.
+ *
+ * @return {boolean}
+ * @private
+ */
+Controller.prototype.gestureTypingEnabled_ = function() {
+  return this.isKeysetUSCompact_ && this.model_.settings.gestureTyping &&
+      !this.adapter_.isA11yMode && !this.adapter_.isChromeVoxOn;
+};
+
+
+/**
+ * Returns the time threshold for subsampling, in ms.
+ *
+ * @return {number}
+ * @private
+ */
+Controller.prototype.subsamplingThreshold_ = function() {
+  return Controller.SUBSAMPLING_TIME_THRESHOLD;
+};
+
+
+/**
  * Gets the data for spatial module.
  *
  * @param {!i18n.input.chrome.inputview.elements.content.SoftKey} key .
  * @param {number} x The x-offset of the touch point.
  * @param {number} y The y-offset of the touch point.
  * @return {!Object} .
  * @private
  */
 Controller.prototype.getSpatialData_ = function(key, x, y) {
   var items = [];
@@ skipping 89 matching lines @@
     this.stopBackspaceAutoRepeat_();
   }
 
   if (e.view) {
     this.handlePointerAction_(e.view, e);
   }
 };
 
 
 /**
+ * Sends the last stroke from the gesture canvas view to the gesture decoder, if
+ * the last point was added past a time threshold.
+ *
+ * @param {boolean=} opt_force Whether or not to force send the gesture event.
+ * @private
+ */
+Controller.prototype.maybeSendLastStroke_ = function(opt_force) {
+  // Subsample by returning early if the previous point was added too recently.
+  var currentTime = Date.now();
+  if (!opt_force && currentTime - this.lastPointTime_ <
+      this.subsamplingThreshold_()) {
+    return;
+  } else {
+    this.lastPointTime_ = currentTime;
+  }
+  var lastStroke = this.container_.gestureCanvasView.getLastStroke();
+  if (lastStroke) {
+    // This call will set up the necessary callbacks the decoder will use to
+    // communicate back to this class.
+    this.adapter_.sendGestureEvent(lastStroke.points);
+  }
+};
+
+
+/**
  * Handles the drag events. Generally, this will forward the event details to
  * the components that handle drawing, decoding, etc.
  *
  * @param {!i18n.input.chrome.inputview.events.DragEvent} e .
  * @private
  */
 Controller.prototype.onDragEvent_ = function(e) {
-  if (this.adapter_.isGestureTypingEnabled() && e.type == EventType.DRAG) {
+  if (this.gestureTypingEnabled_() && e.type == EventType.DRAG &&
+      !this.container_.swipeView.isVisible()) {
     this.container_.gestureCanvasView.addPoint(e);
+    if (e.view && this.container_.gestureCanvasView.isGesturing) {
+      // Ensure the last touched key is not highlighted.
+      e.view.setHighlighted(false);
+      this.maybeSendLastStroke_();
+    }
     return;
   }
 };
 
 
 /**
  * Handles the swipe action.
  *
  * @param {!i18n.input.chrome.inputview.elements.Element} view The view, for
  *     swipe event, the view would be the soft key which starts the swipe.
@@ skipping 75 matching lines @@
           this.currentKeyset_;
       // TODO: remember handwriting keyset.
       this.switchToKeyset(Controller.HANDWRITING_VIEW_CODE_);
       break;
 
     case CommandEnum.OPEN_SETTING:
       if (window.inputview) {
         inputview.openSettings();
       }
       break;
+
+    case CommandEnum.FLOATING:
+      if (inputview.setMode) {
+        inputview.setMode('FLOATING');
+        this.adapter_.isFloating = true;
+        this.container_.candidateView.setFloatingVKButtonsVisible(true);
+        this.resize();
+        setTimeout(function() {
+          var x = Math.floor((screen.width - window.innerWidth) / 2);
+          window.moveTo(x, window.screenY);
+        }, 0);
+      }
+      break;
+
+    case CommandEnum.DOCKING:
+      if (inputview.setMode) {
+        inputview.setMode('FULL_WIDTH');
+        this.adapter_.isFloating = false;
+        this.container_.candidateView.setFloatingVKButtonsVisible(false);
+      }
+      break;
+
   }
 };
 
 
 /**
  * Handles the pointer action.
  *
  * @param {!i18n.input.chrome.inputview.elements.Element} view The view.
  * @param {!i18n.input.chrome.inputview.events.PointerEvent} e .
  * @private
  */
 Controller.prototype.handlePointerAction_ = function(view, e) {
-  if (this.adapter_.isGestureTypingEnabled() &&
-      e.type == EventType.POINTER_DOWN) {
-    this.container_.gestureCanvasView.startStroke(e);
-  }
+  if (this.gestureTypingEnabled_() && !this.container_.swipeView.isVisible()) {
+    if (e.type == EventType.POINTER_DOWN) {
+      this.container_.gestureCanvasView.startStroke(e);
+      view.setHighlighted(false);
+    }
 
-  if (this.adapter_.isGestureTypingEnabled() &&
-      e.type == EventType.POINTER_UP) {
-    this.container_.gestureCanvasView.endStroke(e);
-  }
+    // Determine if the gestureCanvasView was handling a gesture before calling
+    // endStroke, as it ends the current gesture.
+    var wasGesturing = this.container_.gestureCanvasView.isGesturing;
+    if (e.type == EventType.POINTER_UP && wasGesturing) {
+      this.container_.gestureCanvasView.endStroke(e);
+      this.maybeSendLastStroke_(true);
+      this.commitNextGestureResult_ = true;
+    }
 
-  // Do not trigger other actives when gesturing.
-  if (this.adapter_.isGestureTypingEnabled() &&
-      this.container_.gestureCanvasView.isGesturing) {
-    return;
+    // Do not trigger other activities when gesturing.
+    if (wasGesturing) {
+      if (e.type == EventType.POINTER_OVER) {
+        view.setHighlighted(false);
+      }
+      return;
+    }
   }
 
   // Listen for DOUBLE_CLICK as well to capture secondary taps on the spacebar.
   if (e.type == EventType.POINTER_UP || e.type == EventType.DOUBLE_CLICK) {
     this.recordStatsForClosing_(
         'InputMethod.VirtualKeyboard.TapCount', 1, 4095, 4096);
   }
 
   if (e.type == EventType.SWIPE) {
     e =  /** @type {!i18n.input.chrome.inputview.events.SwipeEvent} */ (e);
@@ skipping 37 matching lines @@
       if (e.type == EventType.POINTER_UP) {
         this.showCandidates_(this.candidatesInfo_.source,
             this.candidatesInfo_.candidates,
             Controller.CandidatesOperation.SHRINK);
         this.soundController_.onKeyUp(view.type);
       }
       return;
     case ElementType.CANDIDATE:
       view = /** @type {!i18n.input.chrome.inputview.elements.content.
           Candidate} */ (view);
+      if (view.candidateType == CandidateType.TOOLTIP)
+        return;
       if (e.type == EventType.POINTER_UP) {
         if (view.candidateType == CandidateType.CANDIDATE) {
           this.adapter_.selectCandidate(view.candidate);
         } else if (view.candidateType == CandidateType.NUMBER) {
-          this.adapter_.commitText(view.candidate[Name.CANDIDATE]);
+          this.adapter_.sendKeyDownAndUpEvent(
+              view.candidate[Name.CANDIDATE], '');
         }
         this.container_.cleanStroke();
         this.soundController_.onKeyUp(ElementType.CANDIDATE);
       }
       if (e.type == EventType.POINTER_OUT || e.type == EventType.POINTER_UP) {
         view.setHighlighted(false);
       } else if (e.type == EventType.POINTER_DOWN ||
           e.type == EventType.POINTER_OVER) {
         view.setHighlighted(true);
       }
@@ skipping 44 matching lines @@
         if (!this.container_.currentKeysetView.isDragging && view.text != '') {
           this.adapter_.commitText(view.text);
           this.soundController_.onKeyUp(view.type);
         }
       }
       return;
 
     case ElementType.HWT_PRIVACY_GOT_IT:
       // Broadcasts the handwriting privacy confirmed message to let canvas
       // view handle it.
-      this.adapter_.dispatchEvent(new goog.events.Event(
-          Type.HWT_PRIVACY_GOT_IT));
+      if (e.type == EventType.POINTER_UP) {
+        this.adapter_.dispatchEvent(new goog.events.Event(
+            Type.HWT_PRIVACY_GOT_IT));
+      }
       return;
 
     case ElementType.VOICE_PRIVACY_GOT_IT:
       // Broadcasts the voice privacy confirmed message to let voice
       // view handle it.
-      this.adapter_.dispatchEvent(new goog.events.Event(
-          Type.VOICE_PRIVACY_GOT_IT));
+      if (e.type == EventType.POINTER_UP) {
+        this.adapter_.dispatchEvent(new goog.events.Event(
+            Type.VOICE_PRIVACY_GOT_IT));
+      }
       return;
 
     case ElementType.VOICE_VIEW:
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.sendVoiceViewStateChange(false);
         this.container_.candidateView.switchToIcon(
             CandidateView.IconType.VOICE, true);
         this.container_.voiceView.stop();
       }
       return;
     case ElementType.SWIPE_VIEW:
       this.stopBackspaceAutoRepeat_();
       if (e.type == EventType.POINTER_UP ||
           e.type == EventType.POINTER_OUT) {
         this.clearUnstickyState_();
       }
       return;
+    case ElementType.DRAG:
+      if (e.type == EventType.POINTER_DOWN && this.container_.floatingView) {
+        this.container_.floatingView.show();
+      }
+      return;
+    case ElementType.FLOATING_VIEW:
+      if (e.type == EventType.POINTER_UP && this.container_.floatingView) {
+        this.container_.floatingView.hide();
+      }
+      return;
+    case ElementType.RESIZE:
+      if (e.type == EventType.POINTER_UP) {
+        goog.dom.classlist.toggle(this.container_.getElement(), Css.SMALL);
+        this.resize();
+      }
+      return;
     case ElementType.CUT:
     case ElementType.COPY:
     case ElementType.PASTE:
     case ElementType.BOLD:
     case ElementType.ITALICS:
     case ElementType.UNDERLINE:
     case ElementType.REDO:
     case ElementType.UNDO:
     case ElementType.SELECT_ALL:
       view.setHighlighted(e.type == EventType.POINTER_DOWN ||
@@ skipping 117 matching lines @@
       key = /** @type {!i18n.input.chrome.inputview.elements.content.
           FunctionalKey} */(softKey);
       if (e.type == EventType.POINTER_DOWN) {
         this.backspaceTick_();
       } else if (e.type == EventType.POINTER_UP || e.type == EventType.
           POINTER_OUT) {
         if (!this.container_.swipeView.isVisible()) {
           this.stopBackspaceAutoRepeat_();
         }
       }
+      this.returnToLetterKeysetOnSpace_ = false;
       break;
 
     case ElementType.TAB_KEY:
       key = /** @type {!i18n.input.chrome.inputview.elements.content.
           FunctionalKey} */ (softKey);
       if (e.type == EventType.POINTER_DOWN) {
         this.adapter_.sendKeyDownEvent('\u0009', KeyCodes.TAB);
       } else if (e.type == EventType.POINTER_UP) {
         this.adapter_.sendKeyUpEvent('\u0009', KeyCodes.TAB);
       }
+      this.returnToLetterKeysetOnSpace_ = false;
       break;
 
     case ElementType.ENTER_KEY:
       key = /** @type {!i18n.input.chrome.inputview.elements.content.
           FunctionalKey} */ (softKey);
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.sendKeyDownAndUpEvent('\u000D', KeyCodes.ENTER);
       }
       break;
 
@@ skipping 44 matching lines @@
           this.currentKeyset_ != Controller.HANDWRITING_VIEW_CODE_ &&
           this.currentKeyset_ != Controller.EMOJI_VIEW_CODE_;
       if (e.type == EventType.POINTER_UP || (!doubleSpacePeriod && e.type ==
           EventType.DOUBLE_CLICK_END)) {
         this.adapter_.sendKeyDownAndUpEvent(key.getCharacter(),
             KeyCodes.SPACE);
         this.clearUnstickyState_();
       } else if (e.type == EventType.DOUBLE_CLICK && doubleSpacePeriod) {
         this.adapter_.doubleClickOnSpaceKey();
       }
+      if (this.returnToLetterKeysetOnSpace_) {
+        // Return to the letter keyset.
+        this.switchToKeyset(key.toKeyset);
+        this.returnToLetterKeysetOnSpace_ = false;
+      }
       break;
 
     case ElementType.SWITCHER_KEY:
       key = /** @type {!i18n.input.chrome.inputview.elements.content.
           SwitcherKey} */ (softKey);
       if (e.type == EventType.POINTER_UP) {
         this.recordStatsForClosing_(
             'InputMethod.VirtualKeyboard.LayoutSwitch', 1, 25, 25);
         if (this.isSubKeyset_(key.toKeyset, this.currentKeyset_)) {
           this.model_.stateManager.reset();
           this.container_.update();
           this.updateContextModifierState_();
           this.container_.menuView.hide();
         } else {
           this.resetAll();
         }
         // Switch to the specific keyboard.
         this.switchToKeyset(key.toKeyset);
         if (key.record) {
           this.model_.settings.savePreference(
               util.getConfigName(key.toKeyset),
               key.toKeyset);
         }
       }
+      this.returnToLetterKeysetOnSpace_ = false;
       break;
 
     case ElementType.COMPACT_KEY:
       key = /** @type {!i18n.input.chrome.inputview.elements.content.
           CompactKey} */(softKey);
       if (e.type == EventType.LONG_PRESS) {
         this.container_.altDataView.show(
             key, goog.i18n.bidi.isRtlLanguage(this.languageCode_),
             e.identifier);
       } else if (e.type == EventType.POINTER_UP) {
         this.model_.stateManager.triggerChording();
         var ch = key.getActiveCharacter();
         if (ch.length == 1) {
           this.adapter_.sendKeyDownAndUpEvent(key.getActiveCharacter(), '', 0,
               this.getSpatialData_(key, e.x, e.y));
         } else if (ch.length > 1) {
           // Some compact keys contains more than 1 characters, such as '.com',
           // 'http://', etc. Those keys should trigger a direct commit text
           // instead of key events.
           this.adapter_.commitText(ch);
         }
         this.clearUnstickyState_();
         key.flickerredCharacter = '';
+        if (this.currentKeyset_.indexOf('symbol') != -1) {
+          // If this is the symbol keyset, a space as the next input should
+          // switch us to the standard keyset.
+          this.returnToLetterKeysetOnSpace_ = true;
+        }
       }
       break;
 
     case ElementType.HIDE_KEYBOARD_KEY:
       var defaultKeyset = this.getActiveKeyset_();
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.hideKeyboard();
         if (this.currentKeyset_ != defaultKeyset) {
           this.switchToKeyset(defaultKeyset);
         }
@@ skipping 16 matching lines @@
             this.languageCode_ == 'ko') {
           // Hides 'switch to compact' for zhuyin when not in experimental env.
           enableCompact = false;
         }
         var hasHwt = !this.adapter_.isPasswordBox() &&
             !Controller.DISABLE_HWT && goog.object.contains(
             InputToolCode, this.getHwtInputToolCode_());
         var hasEmoji = !this.adapter_.isPasswordBox();
         var enableSettings = this.shouldEnableSettings() &&
             !!window.inputview && !!inputview.openSettings;
+        var enableFVK = this.adapter_.isFloatingVirtualKeyboardEnabled();
         this.adapter_.getInputMethods(function(inputMethods) {
           this.container_.menuView.show(key, defaultFullKeyset, isCompact,
               enableCompact, this.currentInputMethod_, inputMethods, hasHwt,
-              enableSettings, hasEmoji, this.adapter_.isA11yMode);
+              enableSettings, hasEmoji, this.adapter_.isA11yMode, enableFVK,
+              this.adapter_.isFloating);
         }.bind(this));
       }
       break;
 
     case ElementType.GLOBE_KEY:
       if (e.type == EventType.POINTER_UP) {
         this.adapter_.clearModifierStates();
         this.adapter_.setModifierState(
             i18n.input.chrome.inputview.StateType.ALT, true);
         this.adapter_.sendKeyDownAndUpEvent(
@@ skipping 100 matching lines @@
   this.clearCandidates_();
   this.container_.cleanStroke();
   this.model_.stateManager.reset();
   this.container_.update();
   this.updateContextModifierState_();
   this.resize();
   this.container_.expandedCandidateView.close();
   this.container_.menuView.hide();
   this.container_.swipeView.reset();
   this.container_.altDataView.hide();
+  this.container_.gesturePreviewView.hide();
+  if (this.container_.floatingView) {
+    this.container_.floatingView.hide();
+  }
 };
 
 
 /**
  * Returns whether the toolbar should be shown.
  *
  * @return {boolean}
  * @private
  */
 Controller.prototype.shouldShowToolBar_ = function() {
@@ skipping 137 matching lines @@
  */
 Controller.prototype.onCandidatesBack_ = function(e) {
   this.candidatesInfo_ = new i18n.input.chrome.inputview.CandidatesInfo(
       e.source, e.candidates);
   this.showCandidates_(e.source, e.candidates, Controller.CandidatesOperation.
       NONE);
 };
 
 
 /**
+ * Callback for gestures results event.
+ *
+ * @param {!i18n.input.chrome.DataSource.GesturesBackEvent} e .
+ * @private
+ */
+Controller.prototype.onGesturesBack_ = function(e) {
+  if (!this.commitNextGestureResult_ &&
+      goog.array.equals(e.results, this.gestureResultsCache_)) {
+    // If gesture results have not updated, do not transmit to the UI.
+    return;
+  } else {
+    this.gestureResultsCache_ = e.results;
+  }
+  var bestResult = e.results[0];
+  if (this.container_.gesturePreviewView) {
+    this.container_.gesturePreviewView.show(bestResult);
+  }
+  // TODO: Resolve a race where multiple decoder results return after this flag
+  // is set to true.
+  if (this.commitNextGestureResult_) {
+    // Commit the best result.
+    this.adapter_.commitGestureResult(bestResult);
+    this.commitNextGestureResult_ = false;
+    this.gestureResultsCache_ = [];
+  }
+  this.showGestureCandidates_(e.results.slice(1));
+};
+
+
+/**
+ * Shows the gesture results as candidates.
+ *
+ * @param {!Array<string>} results The gesture results to show.
+ * @private
+ */
+Controller.prototype.showGestureCandidates_ = function(results) {
+  // Convert the results to the candidate format.
+  var candidates = [];
+  for (var i = 0; i < results.length; ++i) {
+    var candidate = {};
+    candidate[Name.CANDIDATE] = results[i];
+    candidate[Name.CANDIDATE_ID] = i;
+    candidate[Name.IS_EMOJI] = false;
+    candidate[Name.MATCHED_LENGTHS] = 0;
+    candidates.push(candidate);
+  }
+  // The source is empty as this is a gesture and not a series of key presses.
+  this.showCandidates_('', candidates, Controller.CandidatesOperation.NONE);
+};
+
+
+/**
  * Shows the candidates to the candidate view.
  *
  * @param {string} source The source text.
  * @param {!Array.<!Object>} candidates The candidate text list.
  * @param {Controller.CandidatesOperation} operation .
  * @private
  */
 Controller.prototype.showCandidates_ = function(source, candidates,
     operation) {
   var state = !!source ? ExpandedCandidateView.State.COMPLETION_CORRECTION :
@@ skipping 57 matching lines @@
   this.container_.candidateView.clearCandidates();
   this.container_.expandedCandidateView.close();
   this.container_.expandedCandidateView.state = ExpandedCandidateView.State.
       NONE;
   if (this.container_.currentKeysetView) {
     this.container_.currentKeysetView.setVisible(true);
   }
 
   if (this.currentKeyset_ == Controller.HANDWRITING_VIEW_CODE_ ||
       this.currentKeyset_ == Controller.EMOJI_VIEW_CODE_) {
-    if (!this.adapter_.isQPInputView) {
-      this.container_.candidateView.switchToIcon(
-          CandidateView.IconType.BACK, true);
-    } else {
-      this.container_.candidateView.switchToIcon(
-          CandidateView.IconType.VOICE, false);
-      this.container_.candidateView.switchToIcon(
-          CandidateView.IconType.EXPAND_CANDIDATES, false);
-    }
+    this.container_.candidateView.switchToIcon(
+        CandidateView.IconType.VOICE, false);
+    this.container_.candidateView.switchToIcon(
+        CandidateView.IconType.EXPAND_CANDIDATES, false);
   } else {
     this.container_.candidateView.switchToIcon(CandidateView.IconType.VOICE,
         this.adapter_.isVoiceInputEnabled);
   }
 };
 
 
 /**
  * Callback when the layout is loaded.
  *
@@ skipping 110 matching lines @@
     this.statistics_.recordLayout(keyset, this.adapter_.isA11yMode);
     this.perfTracker_.tick(PerfTracker.TickName.KEYBOARD_SHOWN);
     this.perfTracker_.stop();
   } else {
     // Sets the current keyset for delay switching.
     this.currentKeyset_ = keyset;
     if (keyset != Controller.EMOJI_VIEW_CODE_) {  // Emoji is temp keyset.
       this.contextTypeToKeysetMap_[this.currentInputMethod_][contextType] =
           keyset;
     }
-    if (this.adapter_.isQPInputView &&
-        goog.array.contains(Controller.MATERIAL_KEYSETS_, keyset)) {
-      this.loadResource_('m-' + keyset);
-    } else {
-      this.loadResource_(keyset);
-    }
+    this.loadResource_(keyset);
   }
+
+  // TODO: The 'us' part of this code is a workaround an issue where other xkb
+  // languages seem to be sharing options between each other.
+  this.isKeysetUSCompact_ =
+      this.currentKeyset_.indexOf(Controller.US_COMPACT_PREFIX_) >= 0;
+  // If we're switching to a new keyset, we don't want spacebar to trigger
+  // another keyset switch.
+  this.returnToLetterKeysetOnSpace_ = false;
 };
 
 
 /**
  * Callback when the configuration is loaded.
  *
  * @param {!i18n.input.chrome.inputview.events.ConfigLoadedEvent} e The event.
  * @private
  */
 Controller.prototype.onConfigLoaded_ = function(e) {
   if (this.isDisposed()) {
     return;
   }
   var data = e.data;
   var keyboardCode = data[i18n.input.chrome.inputview.SpecNodeName.ID];
   this.keysetDataMap_[keyboardCode] = data;
   this.perfTracker_.tick(PerfTracker.TickName.KEYSET_LOADED);
   var context = data[i18n.input.chrome.inputview.SpecNodeName.ON_CONTEXT];
   if (context && !this.adapter_.isA11yMode) {
     var keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
     if (!keySetMap) {
       keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_] = {};
     }
     keySetMap[context] = keyboardCode;
   }
 
   var layoutId = data[i18n.input.chrome.inputview.SpecNodeName.LAYOUT];
-  if (this.adapter_.isQPInputView) {
-    layoutId = 'm-' + layoutId;
-    data[i18n.input.chrome.inputview.SpecNodeName.LAYOUT] = layoutId;
-  }
+  data[i18n.input.chrome.inputview.SpecNodeName.LAYOUT] = layoutId;
   var layoutData = this.layoutDataMap_[layoutId];
   if (layoutData) {
     this.maybeCreateViews_();
   } else {
     this.model_.loadLayout(layoutId);
   }
 };
 
 
 /**
  * Resizes the whole UI.
  *
- * @param {boolean=} opt_ignoreWindowResize .
+ * @param {boolean=} opt_preventResizeTo True if prevent calling
+ *     window.resizeTo. Used in tests and local UI debug.
  */
-Controller.prototype.resize = function(opt_ignoreWindowResize) {
+Controller.prototype.resize = function(opt_preventResizeTo) {
   var height;
+  var width;
   var widthPercent;
   var candidateViewHeight;
   var isLandScape = screen.width > screen.height;
   if (isLandScape) {
     goog.dom.classlist.addRemove(this.container_.getElement(),
         Css.PORTRAIT, Css.LANDSCAPE);
   } else {
     goog.dom.classlist.addRemove(this.container_.getElement(),
         Css.LANDSCAPE, Css.PORTRAIT);
   }
@@ skipping 17 matching lines @@
       if (isWideScreen) {
         widthPercent = spec['LANDSCAPE_WIDE_SCREEN'];
       } else {
         widthPercent = spec['LANDSCAPE'];
       }
     } else {
       widthPercent = spec['PORTRAIT'];
     }
     candidateViewHeight = SizeSpec.NON_A11Y_CANDIDATE_VIEW_HEIGHT;
   }
+  width = this.adapter_.isFloating ?
+      Math.floor(screen.width * widthPercent) : screen.width;
+  widthPercent = this.adapter_.isFloating ? 1.0 : widthPercent;
+  if (goog.dom.classlist.contains(this.container_.getElement(), Css.SMALL)) {
+    height = SizeSpec.SMALL_SIZE_HEIGHT;
+    width = SizeSpec.SMALL_SIZE_WIDTH;
+    candidateViewHeight = SizeSpec.SMALL_SIZE_CANDIDATE_VIEW_HEIGHT;
+  }
 
-  if (window.innerHeight != height && !opt_ignoreWindowResize) {
-    if (this.lastResizeHeight_ != height) {
+  if ((window.innerHeight != height || window.innerWidth != width) &&
+      !opt_preventResizeTo) {
+    if (this.lastResizeHeight_ != height || window.innerWidth != width) {
       this.lastResizeHeight_ = height;
-      window.resizeTo(screen.width, height);
+      window.resizeTo(width, height);
     }
     return;
   }
 
-  this.container_.setContainerSize(screen.width, height, widthPercent,
+  this.container_.setContainerSize(width, height, widthPercent,
       candidateViewHeight);
   this.container_.candidateView.setToolbarVisible(this.shouldShowToolBar_());
   if (this.container_.currentKeysetView) {
     this.isKeyboardReady = true;
   }
+
+  // Transmit the new layout to the decoder.
+  if (this.gestureTypingEnabled_()) {
+    this.adapter_.sendKeyboardLayout(
+        this.container_.currentKeysetView.getKeyboardLayoutForGesture());
+  }
 };
 
 
 /**
  * Loads the resources, for currentKeyset, passwdKeyset, handwriting,
  * emoji, etc.
  *
  * @private
  */
 Controller.prototype.loadAllResources_ = function() {
@@ skipping 62 matching lines @@
     title) {
   this.perfTracker_.restart();
   this.adapter_.getCurrentInputMethod(function(currentInputMethod) {
     // TODO: remove this hack as soon as the manifest is fixed in chromium.
     if (languageCode == 'ko') {
       if (currentInputMethod.indexOf('hangul_2set') > 0) {
         keyset = 'm17n:ko_2set';
       }
     }
     this.languageCode_ = languageCode;
-    this.currentInputMethod_ = currentInputMethod;
+    // If can't get the current input method, set the original keyset as
+    // current input method.
+    this.currentInputMethod_ = currentInputMethod || keyset;
     var keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_];
     if (!keySetMap) {
       keySetMap = this.contextTypeToKeysetMap_[this.currentInputMethod_] = {};
     }
     keySetMap[ContextType.PASSWORD] = passwordLayout;
     keySetMap[ContextType.DEFAULT] = keyset;
 
     this.initialKeyset_ = keyset;
     this.title_ = title;
     this.isSettingReady = false;
     this.model_.settings = new i18n.input.chrome.inputview.Settings();
     this.model_.stateManager.isEnMode = false;
-    this.adapter_.initialize(languageCode ? languageCode.split('-')[0] : '');
+    this.adapter_.initialize();
     this.loadAllResources_();
     this.switchToKeyset(this.getActiveKeyset_());
 
     // Set language attribute and font of body.
     document.body.setAttribute('lang', this.languageCode_);
     goog.dom.classlist.add(document.body, Css.FONT);
   }.bind(this));
 };
 
 
@@ skipping 113 matching lines @@
     this.statsForClosing_[name][0] += count;
     this.statsForClosing_[name][1] = max;
     this.statsForClosing_[name][2] = bucketCount;
   }
 };
 
 
 /**
  * Handles language state changing event.
  *
- * @param {!i18n.input.chrome.message.Event} e .
+ * @param {!events.MessageEvent} e .
  * @private
  */
-Controller.prototype.onUpdateToggleLanguateState_ = function(e) {
+Controller.prototype.onUpdateToggleLanguageState_ = function(e) {
   if (this.adapter_.isA11yMode || this.currentKeyset_.indexOf('.compact') < 0) {
     // e.msg value means whether is Chinese mode now.
     if (this.model_.stateManager.isEnMode == e.msg) {
       this.model_.stateManager.isEnMode = !e.msg;
       this.container_.currentKeysetView.update();
     }
   } else {
     var pos = this.currentKeyset_.indexOf('en.compact');
     var toKeyset;
     if (pos > 0) { // Means en mode
       if (e.msg) { // Needs switch cn mode
         toKeyset = this.currentKeyset_.replace('en.compact', 'compact');
       }
     } else {
       if (!e.msg) { // Needs switch en mode
         toKeyset = this.currentKeyset_.replace('compact', 'en.compact');
       }
     }
     if (toKeyset) {
       this.resetAll();
       this.switchToKeyset(toKeyset);
     }
   }
 };
 });  // goog.scope