Implement ChromeVox Next menus.

chrome/browser/resources/chromeos/chromevox/cvox2/background/background.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview The entry point for all ChromeVox2 related code for the
  * background page.
  */
 
 goog.provide('Background');
 goog.provide('global');
 
 goog.require('AutomationPredicate');
 goog.require('AutomationUtil');
 goog.require('ChromeVoxState');
 goog.require('LiveRegions');
 goog.require('NextEarcons');
 goog.require('Output');
 goog.require('Output.EventType');
+goog.require('PanelCommand');
 goog.require('constants');
 goog.require('cursors.Cursor');
 goog.require('cvox.BrailleKeyCommand');
 goog.require('cvox.ChromeVoxEditableTextBase');
 goog.require('cvox.ChromeVoxKbHandler');
 goog.require('cvox.ClassicEarcons');
 goog.require('cvox.ExtensionBridge');
 goog.require('cvox.NavBraille');
 
 goog.scope(function() {
@@ skipping 26 matching lines @@
   this.classicBlacklistRegExp_ = Background.globsToRegExp_(
       chrome.runtime.getManifest()['content_scripts'][0]['exclude_globs']);
 
   /**
    * @type {cursors.Range}
    * @private
    */
   this.currentRange_ = null;
 
   /**
+   * @type {cursors.Range}
+   * @private
+   */
+  this.savedRange_ = null;
+
+  /**
    * Which variant of ChromeVox is active.
    * @type {ChromeVoxMode}
    * @private
    */
   this.mode_ = ChromeVoxMode.COMPAT;
 
   // Manually bind all functions to |this|.
   for (var func in this) {
     if (typeof(this[func]) == 'function')
       this[func] = this[func].bind(this);
@@ skipping 111 matching lines @@
     }.bind(this));
 
     // If switching out of a ChromeVox Next mode, make sure we cancel
     // the progress loading sound just in case.
     if ((this.mode_ === ChromeVoxMode.NEXT ||
          this.mode_ === ChromeVoxMode.FORCE_NEXT) &&
         this.mode_ != mode) {
       cvox.ChromeVox.earcons.cancelEarcon(cvox.Earcon.PAGE_START_LOADING);
     }
 
+    if (mode === ChromeVoxMode.NEXT ||
+        mode === ChromeVoxMode.FORCE_NEXT) {
+      (new PanelCommand(PanelCommandType.ENABLE_MENUS)).send();
+    } else {
+      (new PanelCommand(PanelCommandType.DISABLE_MENUS)).send();
+    }
+
     this.mode_ = mode;
   },
 
   /**
    * Mode refreshes takes into account both |url| and the current ChromeVox
    *    range. The latter gets used to decide if the user is or isn't in web
    *    content. The focused state also needs to be set for this info to be
    *    reliable.
    * @override
    */
@@ skipping 21 matching lines @@
     return this.currentRange_;
   },
 
   /**
    * @override
    */
   setCurrentRange: function(newRange) {
     if (!newRange)
       return;
 
+    var panelUrl = chrome.extension.getURL('cvox2/background/panel.html');
+    if (newRange.start.node.root.docUrl.indexOf(panelUrl) != 0)
+      this.savedRange_ = new cursors.Range(newRange.start, newRange.end);
+
     this.currentRange_ = newRange;
 
     if (this.currentRange_)
       this.currentRange_.start.node.makeVisible();
   },
 
   /** Forces ChromeVox Next to be active for all tabs. */
   forceChromeVoxNextActive: function() {
     this.setMode(ChromeVoxMode.FORCE_NEXT);
   },
@@ skipping 40 matching lines @@
       case 'nextButton':
         dir = Dir.FORWARD;
         pred = AutomationPredicate.button;
         predErrorMsg = 'no_next_button';
         break;
       case 'previousButton':
         dir = Dir.BACKWARD;
         pred = AutomationPredicate.button;
         predErrorMsg = 'no_previous_button';
         break;
-      case 'nextCheckBox':
+      case 'nextCheckbox':
         dir = Dir.FORWARD;
         pred = AutomationPredicate.checkBox;
         predErrorMsg = 'no_next_checkbox';
         break;
-      case 'previousCheckBox':
+      case 'previousCheckbox':
         dir = Dir.BACKWARD;
         pred = AutomationPredicate.checkBox;
         predErrorMsg = 'no_previous_checkbox';
         break;
       case 'nextComboBox':
         dir = Dir.FORWARD;
         pred = AutomationPredicate.comboBox;
         predErrorMsg = 'no_next_combo_box';
         break;
       case 'previousComboBox':
@@ skipping 55 matching lines @@
         dir = Dir.FORWARD;
         pred = AutomationPredicate.visitedLink;
         predErrorMsg = 'no_next_visited_link';
         break;
       case 'previousVisitedLink':
         dir = Dir.BACKWARD;
         pred = AutomationPredicate.visitedLink;
         predErrorMsg = 'no_previous_visited_link';
         break;
       case 'right':
-      case 'nextElement':
+      case 'nextObject':
         current = current.move(cursors.Unit.DOM_NODE, Dir.FORWARD);
         break;
       case 'left':
-      case 'previousElement':
+      case 'previousObject':
         current = current.move(cursors.Unit.DOM_NODE, Dir.BACKWARD);
         break;
-      case 'goToBeginning':
+      case 'jumpToTop':
         var node =
             AutomationUtil.findNodePost(current.start.node.root,
                                         Dir.FORWARD,
                                         AutomationPredicate.leaf);
         if (node)
           current = cursors.Range.fromNode(node);
         break;
-      case 'goToEnd':
+      case 'jumpToBottom':
         var node =
             AutomationUtil.findNodePost(current.start.node.root,
                                         Dir.BACKWARD,
                                         AutomationPredicate.leaf);
         if (node)
           current = cursors.Range.fromNode(node);
         break;
       case 'forceClickOnCurrentItem':
-      case 'doDefault':
+      case 'performDefaultAction':
         if (this.currentRange_) {
           var actionNode = this.currentRange_.start.node;
           if (actionNode.role == RoleType.inlineTextBox)
             actionNode = actionNode.parent;
           actionNode.doDefault();
         }
         // Skip all other processing; if focus changes, we should get an event
         // for that.
         return false;
-      case 'continuousRead':
+      case 'readFromHere':
         global.isReadingContinuously = true;
         var continueReading = function(prevRange) {
           if (!global.isReadingContinuously || !this.currentRange_)
             return;
 
           new Output().withSpeechAndBraille(
                   this.currentRange_, prevRange, Output.EventType.NAVIGATE)
               .onSpeechEnd(function() { continueReading(prevRange); })
               .go();
           prevRange = this.currentRange_;
           this.setCurrentRange(
               this.currentRange_.move(cursors.Unit.DOM_NODE, Dir.FORWARD));
 
           if (!this.currentRange_ || this.currentRange_.equals(prevRange))
             global.isReadingContinuously = false;
         }.bind(this);
 
         continueReading(null);
         return false;
-      case 'showContextMenu':
+      case 'contextMenu':
         if (this.currentRange_) {
           var actionNode = this.currentRange_.start.node;
           if (actionNode.role == RoleType.inlineTextBox)
             actionNode = actionNode.parent;
           actionNode.showContextMenu();
           return false;
         }
         break;
       case 'showOptionsPage':
         chrome.runtime.openOptionsPage();
@@ skipping 34 matching lines @@
         if (cvox.ChromeVox.isStickyPrefOn)
           chrome.accessibilityPrivate.setKeyboardListener(true, true);
         else
           chrome.accessibilityPrivate.setKeyboardListener(true, false);
         return false;
       case 'passThroughMode':
         cvox.ChromeVox.passThroughMode = true;
         cvox.ChromeVox.tts.speak(
             Msgs.getMsg('pass_through_key'), cvox.QueueMode.QUEUE);
         return true;
+      case 'openChromeVoxMenus':
+        (new PanelCommand(PanelCommandType.OPEN_MENUS)).send();
+        break;
+      case 'decreaseTtsRate':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.RATE, false);
+        break;
+      case 'increaseTtsRate':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.RATE, true);
+        break;
+      case 'decreaseTtsPitch':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.PITCH, false);
+        break;
+      case 'increaseTtsPitch':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.PITCH, true);
+        break;
+      case 'decreaseTtsVolume':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.VOLUME, false);
+        break;
+      case 'increaseTtsVolume':
+        this.increaseOrDecreaseSpeechProperty_(cvox.AbstractTts.VOLUME, true);
+        break;
       default:
         return true;
     }
 
     if (pred) {
       var node = AutomationUtil.findNextNode(
           current.getBound(dir).node, dir, pred);
 
       if (node) {
         current = cursors.Range.fromNode(node);
       } else {
         if (predErrorMsg) {
           cvox.ChromeVox.tts.speak(Msgs.getMsg(predErrorMsg),
                                    cvox.QueueMode.FLUSH);
         }
         return false;
       }
     }
 
-    if (current) {
-      // TODO(dtseng): Figure out what it means to focus a range.
-      var actionNode = current.start.node;
-      if (actionNode.role == RoleType.inlineTextBox)
-        actionNode = actionNode.parent;
-
-      // Iframes, when focused, causes the child webArea to fire focus event.
-      // This can result in getting stuck when navigating backward.
-      if (actionNode.role != RoleType.iframe && !actionNode.state.focused)
-        actionNode.focus();
-
-      var prevRange = this.currentRange_;
-      this.setCurrentRange(current);
-
-      new Output().withSpeechAndBraille(
-              this.currentRange_, prevRange, Output.EventType.NAVIGATE)
-          .withQueueMode(cvox.QueueMode.FLUSH)
-          .go();
-    }
+    if (current)
+      this.navigateToRange_(current);
 
     return false;
   },
 
   /**
+   * Increase or decrease a speech property and make an announcement.
+   * @param {string} propertyName The name of the property to change.
+   * @param {boolean} increase If true, increases the property value by one
+   *     step size, otherwise decreases.
+   */
+  increaseOrDecreaseSpeechProperty_: function(propertyName, increase) {
+    cvox.ChromeVox.tts.increaseOrDecreaseProperty(propertyName, increase);
+    var announcement;
+    var valueAsPercent = Math.round(
+        cvox.ChromeVox.tts.propertyToPercentage(propertyName) * 100);
+    switch (propertyName) {
+      case cvox.AbstractTts.RATE:
+        announcement = Msgs.getMsg('announce_rate', [valueAsPercent]);
+        break;
+      case cvox.AbstractTts.PITCH:
+        announcement = Msgs.getMsg('announce_pitch', [valueAsPercent]);
+        break;
+      case cvox.AbstractTts.VOLUME:
+        announcement = Msgs.getMsg('announce_volume', [valueAsPercent]);
+        break;
+    }
+    if (announcement) {
+      cvox.ChromeVox.tts.speak(
+          announcement, cvox.QueueMode.FLUSH,
+          cvox.AbstractTts.PERSONALITY_ANNOTATION);
+    }
+  },
+
+  /**
+   * Navigate to the given range - it both sets the range and outputs it.
+   * @param {!cursors.Range} range The new range.
+   * @private
+   */
+  navigateToRange_: function(range) {
+    // TODO(dtseng): Figure out what it means to focus a range.
+    var actionNode = range.start.node;
+    if (actionNode.role == RoleType.inlineTextBox)
+      actionNode = actionNode.parent;
+
+    // Iframes, when focused, causes the child webArea to fire focus event.
+    // This can result in getting stuck when navigating backward.
+    if (actionNode.role != RoleType.iframe && !actionNode.state.focused)
+      actionNode.focus();
+
+    var prevRange = this.currentRange_;
+    this.setCurrentRange(range);
+
+    new Output().withSpeechAndBraille(
+        range, prevRange, Output.EventType.NAVIGATE)
+        .withQueueMode(cvox.QueueMode.FLUSH)
+        .go();
+  },
+
+  /**
    * Handles key down events.
    * @param {Event} evt The key down event to process.
    * @return {boolean} True if the default action should be performed.
    */
   onKeyDown: function(evt) {
     evt.stickyMode = cvox.ChromeVox.isStickyModeOn() && cvox.ChromeVox.isActive;
     if (cvox.ChromeVox.passThroughMode)
       return false;
 
     if (this.mode_ != ChromeVoxMode.CLASSIC &&
@@ skipping 37 matching lines @@
    * @param {!cvox.BrailleKeyEvent} evt
    * @param {!cvox.NavBraille} content
    * @return {boolean} True if evt was processed.
    */
   onBrailleKeyEvent: function(evt, content) {
     if (this.mode_ === ChromeVoxMode.CLASSIC)
       return false;
 
     switch (evt.command) {
       case cvox.BrailleKeyCommand.PAN_LEFT:
-        this.onGotCommand('previousElement');
+        this.onGotCommand('previousObject');
         break;
       case cvox.BrailleKeyCommand.PAN_RIGHT:
-        this.onGotCommand('nextElement');
+        this.onGotCommand('nextObject');
         break;
       case cvox.BrailleKeyCommand.LINE_UP:
         this.onGotCommand('previousLine');
         break;
       case cvox.BrailleKeyCommand.LINE_DOWN:
         this.onGotCommand('nextLine');
         break;
       case cvox.BrailleKeyCommand.TOP:
-        this.onGotCommand('goToBeginning');
+        this.onGotCommand('jumpToTop');
         break;
       case cvox.BrailleKeyCommand.BOTTOM:
-        this.onGotCommand('goToEnd');
+        this.onGotCommand('jumpToBottom');
         break;
       case cvox.BrailleKeyCommand.ROUTING:
         this.brailleRoutingCommand_(
             content.text,
             // Cast ok since displayPosition is always defined in this case.
             /** @type {number} */ (evt.displayPosition));
         break;
       default:
         return false;
     }
@@ skipping 90 matching lines @@
             target: 'next',
             isClassicEnabled: isClassicEnabled
           });
         } else if (action == 'onCommand') {
           this.onGotCommand(msg['command']);
         } else if (action == 'flushNextUtterance') {
           Output.flushNextSpeechUtterance();
         }
         break;
     }
-  }
+  },
+
+  /**
+   * Restore the range to the last range that was *not* in the ChromeVox
+   * panel. This is used when the ChromeVox Panel closes.
+   */
+  restoreCurrentRange: function() {
+    if (this.savedRange_) {
+      var containingWebView = this.savedRange_.start.node;
+      while (containingWebView && containingWebView.role != RoleType.webView)
+        containingWebView = containingWebView.parent;
+      if (containingWebView)
+        containingWebView.focus();
+
+      this.navigateToRange_(this.savedRange_);
+      this.savedRange_ = null;
+    }
+  },
 };
 
 /**
  * Converts a list of globs, as used in the extension manifest, to a regular
  * expression that matches if and only if any of the globs in the list matches.
  * @param {!Array<string>} globs
  * @return {!RegExp}
  * @private
  */
 Background.globsToRegExp_ = function(globs) {
   return new RegExp('^(' + globs.map(function(glob) {
     return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
         .replace(/\*/g, '.*')
         .replace(/\?/g, '.');
   }).join('|') + ')$');
 };
 
 /** @type {Background} */
 global.backgroundObj = new Background();
 
 });  // goog.scope