Support output of heading levels.

chrome/browser/resources/chromeos/chromevox/cvox2/background/output.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 Provides output services for ChromeVox.
  */
 
 goog.provide('Output');
 goog.provide('Output.EventType');
@@ skipping 136 matching lines @@
       speak: '$if($checked, @describe_checkbox_checked($name), ' +
           '@describe_checkbox_unchecked($name)) ' +
           '$if($checked, ' +
               '$earcon(CHECK_ON, @input_type_checkbox), ' +
               '$earcon(CHECK_OFF, @input_type_checkbox))'
     },
     dialog: {
       enter: '$name $role'
     },
     heading: {
-      enter: '@aria_role_heading',
-      speak: '@aria_role_heading $name='
+      enter: '@aria_role_heading -$hierarchicalLevel',

[Peter Lundblad, 2015/04/02 09:43:54]

Need to add this prefix to the documentation in the
constructor.
Not sure I like the minus prefix, however, it looks like some kind
of exclusion.  Would a plus sign (as a connector rather than prefix or suffix)
be an option?
another alternative would be to turn this around and make comma
split the utterances and make the default be to not split. For braille,
comma could then just insert whiespace and the default would be to ignore
whitespace in the string.
Or we could have a more verbose named token (such as '$nosplit') to not make
this domain specific language too obscure.

+      speak: '@aria_role_heading -$hierarchicalLevel $name='
     },
     inlineTextBox: {
       speak: '$value='
     },
     link: {
       enter: '$name= $visited $earcon(LINK, @tag_link)=',
       stay: '$name= $visited @tag_link',
       speak: '$name= $visited $earcon(LINK, @tag_link)='
     },
     list: {
-      enter: '@aria_role_list @list_with_items($parentChildCount)'
+      enter: '@aria_role_list -@list_with_items($parentChildCount)'
     },
     listItem: {
       enter: '$role'
     },
     menuItem: {
       speak: '$if($haspopup, @describe_menu_item_with_submenu($name), ' +
           '@describe_menu_item($name)) ' +
           '@describe_index($indexInParent, $parentChildCount)'
     },
     menuListOption: {
@@ skipping 286 matching lines @@
 
     // Hacky way to support args.
     if (typeof(format) == 'string') {
       format = format.replace(/([,:])\W/g, '$1');
       tokens = format.split(' ');
     } else {
       tokens = [format];
     }
 
     tokens.forEach(function(token) {
-      // Always split at the beginning of each token for speech.
-      var splitOptions = {};
-      splitOptions.annotation = new Output.StringSplit();
-      this.addToSpannable_(buff, new cvox.Spannable(), splitOptions);
-
       // Ignore empty tokens.
       if (!token)
         return;
 
       // Parse the token.
       var tree;
       if (typeof(token) == 'string')
         tree = this.createParseTree(token);
       else
         tree = token;
 
       // Obtain the operator token.
       token = tree.value;
 
       // Set suffix options.
       var options = {};
       options.ifEmpty = token[token.length - 1] == '=';
       if (options.ifEmpty)
         token = token.substring(0, token.length - 1);
 
       // Process token based on prefix.
       var prefix = token[0];
       token = token.slice(1);
 
+      // Split up the utterance if there isn't a continuation prefix.
+      if (prefix == '-') {

[Peter Lundblad, 2015/04/02 09:43:54]

There's an implicit ordering of prefixes here.  Should we try to write some
grammar
for this language before it grows out of hand?

[David Tseng, 2015/04/02 23:50:49]

You're probably right. I can take a look at some js based parser generators so
we can replace most of this file's parsing logic with just an input grammar.

+        prefix = token[0];
+        token = token.slice(1);
+        options.needsPrefix = true;
+      } else {
+        var splitOptions = {};
+        splitOptions.annotation = new Output.StringSplit();
+        this.addToSpannable_(buff, new cvox.Spannable(), splitOptions);
+      }
+
       if (opt_exclude[token])
         return;
 
       // All possible tokens based on prefix.
       if (prefix == '$') {
         options.annotation = token;
         if (token == 'value') {
           var text = node.attributes.value;
           if (text !== undefined) {
             var offset = buff.getLength();
@@ skipping 57 matching lines @@
             console.error('Missing role info for ' + node.role);
           }
           if (earconId) {
             options.annotation = new Output.Action(function() {
               cvox.ChromeVox.earcons.playEarcon(
                   cvox.AbstractEarcons[earconId]);
             });
           }
           this.addToSpannable_(buff, msg, options);
         } else if (node.attributes[token]) {
-          this.addToSpannable_(buff, node.attributes[token], options);
+          var value = node.attributes[token];
+          if (typeof(value) != 'string')
+            value = String(value);
+          this.addToSpannable_(buff, value, options);
         } else if (node.state[token]) {
           this.addToSpannable_(buff, token, options);
         } else if (tree.firstChild) {
           // Custom functions.
           if (token == 'if') {
             var cond = tree.firstChild;
             var attrib = cond.value.slice(1);
             if (node.attributes[attrib] || node.state[attrib])
               this.format_(node, cond.nextSibling, buff);
             else
@@ skipping 173 matching lines @@
       endIndex++;
     this.addToSpannable_(
         buff, range.getStart().getText().substring(startIndex, endIndex));
   },
 
   /**
    * Adds to the given buffer with proper delimiters added.
    * @param {!cvox.Spannable} spannable
    * @param {string|!cvox.Spannable} value
    * @param {{ifEmpty: (boolean|undefined),
-   *      annotation: *}=} opt_options
+   *          annotation: *,
+   *          needsPrefix: (boolean|undefined)}=} opt_options
    */
   addToSpannable_: function(spannable, value, opt_options) {
-    opt_options = opt_options || {ifEmpty: false, annotation: undefined};
+    opt_options = opt_options ||
+        {ifEmpty: false, annotation: undefined, needsPrefix: false};
     if ((!value || value.length == 0) && !opt_options.annotation)
       return;
 
     var spannableToAdd = new cvox.Spannable(value, opt_options.annotation);
     if (spannable.getLength() == 0) {
       spannable.append(spannableToAdd);
       return;
     }
 
     if (opt_options.ifEmpty &&
         opt_options.annotation &&
         (spannable.getSpanStart(opt_options.annotation) != undefined ||
             spannable.getSpanStart(
                 Output.ATTRIBUTE_ALIAS[opt_options.annotation]) != undefined))
       return;
 
     // Figure out if we need to add the spacing prefix.
-    var needsPrefix = this.formatOptions_.braille;
+    var needsPrefix = this.formatOptions_.braille || opt_options.needsPrefix;
     if (needsPrefix) {
       needsPrefix = value instanceof cvox.Spannable ?
           value.getLength() > 0 : value.length > 0;
     }
     var prefixed = new cvox.Spannable(needsPrefix ? Output.SPACE : '');
     prefixed.append(spannableToAdd);
     spannable.append(prefixed);
   },
 
   /**
@@ skipping 30 matching lines @@
     }
 
     if (currentNode != root)
       throw 'Unbalanced parenthesis.';
 
     return root;
   }
 };
 
 });  // goog.scope