Implement word wrapping and panning in multiline Braille.

chrome/browser/resources/chromeos/chromevox/braille/braille_display_manager.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 Puts text on a braille display.
  *
  */
 
 goog.provide('cvox.BrailleDisplayManager');
@@ skipping 35 matching lines @@
   this.translatedContent_ = new ArrayBuffer(0);
   /**
    * @type {!ArrayBuffer}
    * @private
    */
   this.displayedContent_ = this.translatedContent_;
   /**
    * @type {cvox.PanStrategy}
    * @private
    */
-  this.panStrategy_ = new cvox.WrappingPanStrategy();
+  this.panStrategy_ = new cvox.PanStrategy();
   /**
    * @type {function(!cvox.BrailleKeyEvent, !cvox.NavBraille)}
    * @private
    */
   this.commandListener_ = function() {};
   /**
    * Current display state used for width calculations.  This is different from
    * realDisplayState_ if the braille captions feature is enabled and there is
    * no hardware display connected.  Otherwise, it is the same object
    * as realDisplayState_.
    * @type {!cvox.BrailleDisplayState}
    * @private
    */
   this.displayState_ = {available: false, textRowCount: undefined,
       textColumnCount: undefined};
   /**
    * State reported from the chrome api, reflecting a real hardware
    * display.
    * @type {!cvox.BrailleDisplayState}
    * @private
    */
   this.realDisplayState_ = this.displayState_;
-  /**
-   * @type {!Array<number>}
-   * @private
-   */
-  this.textToBraille_ = [];
-  /**
-   * @type {!Array<number>}
-   * @private
-   */
-  this.brailleToText_ = [];
 
   translatorManager.addChangeListener(function() {
     this.translateContent_(this.content_, this.expansionType_);
   }.bind(this));
 
   chrome.storage.onChanged.addListener(function(changes, area) {
     if (area == 'local' && 'brailleWordWrap' in changes) {
       this.updatePanStrategy_(changes.brailleWordWrap.newValue);
     }
   }.bind(this));
@@ skipping 52 matching lines @@
 };
 
 
 /**
  * @param {!cvox.BrailleDisplayState} newState Display state reported
  *     by the extension API.
  * @private
  */
 cvox.BrailleDisplayManager.prototype.refreshDisplayState_ = function(
     newState) {
-  var oldSize = this.displayState_.textColumnCount *
-                this.displayState_.textRowCount || 0;
+  var oldColumnCount = this.displayState_.textColumnCount || 0;
+  var oldRowCount = this.displayState_.textRowCount || 0;
   this.realDisplayState_ = newState;
   if (newState.available) {
     this.displayState_ = newState;
+    // Update the dimensions of the virtual braille captions display those
+    // of a real physical display when one is plugged in.
+    localStorage['virtualBrailleRows'] = newState.textRowCount;
+    localStorage['virtualBrailleColumns'] = newState.textColumnCount;
   } else {
     this.displayState_ =
         cvox.BrailleCaptionsBackground.getVirtualDisplayState();
   }
-  var newSize = this.displayState_.textColumnCount *
-                this.displayState_.textRowCount || 0;
-  if (oldSize != newSize) {
-    this.panStrategy_.setDisplaySize(newSize);
+  var newColumnCount = this.displayState_.textColumnCount || 0;
+  var newRowCount = this.displayState_.textRowCount || 0;
+  if (oldColumnCount != newColumnCount || oldRowCount != newRowCount) {
+    this.panStrategy_.setDisplaySize(newRowCount, newColumnCount);

[David Tseng, 2016/11/15 17:54:59]

Make the display size a pair i.e.
@type {{rows: number, columns: number}}

[ultimatedbz, 2016/11/19 03:11:58]

Done. The parameters are still the same, but the internal data structure is
changed.

   }
   this.refresh_();
 };
 
 
 /**
  * Called when the state of braille captions changes.
  * @private
  */
 cvox.BrailleDisplayManager.prototype.onCaptionsStateChanged_ = function() {
   // Force reevaluation of the display state based on our stored real
   // hardware display state, meaning that if a real display is connected,
   // that takes precedence over the state from the captions 'virtual' display.
   this.refreshDisplayState_(this.realDisplayState_);
 };
 
 
-/** @private */
+/**
+ * Refreshes what is shown on the physical braille display and the virtual
+ * braille captions display.
+ * @private */
 cvox.BrailleDisplayManager.prototype.refresh_ = function() {
   if (!this.displayState_.available) {
     return;
   }
-  var viewPort = this.panStrategy_.viewPort;
-  var buf = this.displayedContent_.slice(viewPort.start, viewPort.end);
+  var brailleBuf = this.panStrategy_.getCurrentBrailleSlice();

[David Tseng, 2016/11/15 17:54:59]

Slice seems wrong in terms of multiline; maybe call this
getCurrentBrailleViewportContents

[ultimatedbz, 2016/11/19 03:11:58]

Done.

+  var textBuf = this.panStrategy_.getCurrentTextSlice();
   if (this.realDisplayState_.available) {
-    chrome.brailleDisplayPrivate.writeDots(buf, buf.byteLength, 1);
+    chrome.brailleDisplayPrivate.writeDots(brailleBuf,
+        brailleBuf.byteLength, 1);
   }
   if (cvox.BrailleCaptionsBackground.isEnabled()) {
-    var start = this.brailleToTextPosition_(viewPort.start);
-    var end = this.brailleToTextPosition_(viewPort.end);
-    cvox.BrailleCaptionsBackground.setContent(
-        this.content_.text.toString().substring(start, end), buf,
-        this.brailleToText_);
+    cvox.BrailleCaptionsBackground.setContent(textBuf, brailleBuf,
+        this.panStrategy_.brailleToText, this.panStrategy_.offsetsForSlices);
   }
 };
 
-
 /**
  * @param {!cvox.NavBraille} newContent New display content.
  * @param {cvox.ExpandingBrailleTranslator.ExpansionType} newExpansionType
  *     How the value part of of the new content should be expanded
  *     with regards to contractions.
  * @private
  */
 cvox.BrailleDisplayManager.prototype.translateContent_ = function(
     newContent, newExpansionType) {
   var writeTranslatedContent = function(cells, textToBraille, brailleToText) {
     this.content_ = newContent;
     this.expansionType_ = newExpansionType;
-    this.textToBraille_ = textToBraille;
-    this.brailleToText_ = brailleToText;
     var startIndex = this.content_.startIndex;
     var endIndex = this.content_.endIndex;
     var targetPosition;
     if (startIndex >= 0) {
       var translatedStartIndex;
       var translatedEndIndex;
       if (startIndex >= textToBraille.length) {
         // Allow the cells to be extended with one extra cell for
         // a carret after the last character.
         var extCells = new ArrayBuffer(cells.byteLength + 1);
-        new Uint8Array(extCells).set(new Uint8Array(cells));
+        new Uint8Array(extCells).set(cells);
         // Last byte is initialized to 0.
         cells = extCells;
         translatedStartIndex = cells.byteLength - 1;
       } else {
         translatedStartIndex = textToBraille[startIndex];
       }
       if (endIndex >= textToBraille.length) {
         // endIndex can't be past-the-end of the last cell unless
         // startIndex is too, so we don't have to do another
         // extension here.
         translatedEndIndex = cells.byteLength;
       } else {
         translatedEndIndex = textToBraille[endIndex];
       }
       this.translatedContent_ = cells;
       // Copy the translated content to a separate buffer and  add the cursor
       // to it.
       this.displayedContent_ = new ArrayBuffer(cells.byteLength);
-      new Uint8Array(this.displayedContent_).set(new Uint8Array(cells));
+      new Uint8Array(this.displayedContent_).set(cells);
       this.writeCursor_(this.displayedContent_,
                         translatedStartIndex, translatedEndIndex);
       targetPosition = translatedStartIndex;
     } else {
       this.translatedContent_ = this.displayedContent_ = cells;
       targetPosition = 0;
     }
-    this.panStrategy_.setContent(this.translatedContent_, targetPosition);
+    this.panStrategy_.setContent(this.content_.text.toString(),
+        this.translatedContent_, brailleToText);
+
     this.refresh_();
   }.bind(this);
 
   var translator = this.translatorManager_.getExpandingTranslator();
   if (!translator) {
     writeTranslatedContent(new ArrayBuffer(0), [], []);
   } else {
     translator.translate(
         newContent.text,
         newExpansionType,
         writeTranslatedContent);
   }
 };
 
 
 /**
  * @param {cvox.BrailleKeyEvent} event The key event.
  * @private
  */
 cvox.BrailleDisplayManager.prototype.onKeyEvent_ = function(event) {
   switch (event.command) {
     case cvox.BrailleKeyCommand.PAN_LEFT:
       this.panLeft_();
       break;
     case cvox.BrailleKeyCommand.PAN_RIGHT:
       this.panRight_();
       break;
     case cvox.BrailleKeyCommand.ROUTING:
+      /* TODO

[David Tseng, 2016/11/15 17:54:59]

The goal is to get this cl checked in, so please restore this block and support
at least the single line case.

[ultimatedbz, 2016/11/15 19:31:57]

I do intend to complete this block, but for the time being, I wanted to get
something up for initial review. It's in a TODO block to signify that I'm still
not done with this method. Do you have any suggestions as to how I should go
about doing this in the future? Either explicitly saying I'm going to do this
later on, or to not submit this cl until everything is complete?

[David Tseng, 2016/11/15 21:36:38]

I would not accept this cl without this working as it did before. You should
never comment out code like this as much as it might make things easier.

Routing is just another way of addressing a braille display's physical cells. If
I have a 40-cell display and click on the 20th cell, Brltty will send an event
which eventually gets here. The question is, how to address that position into
the viewport.

If I panned 40 cells forward, you would obviously offset the above by 40 giving
us 60.

In a multiline world, and your current implementation, how would you translate a
hardware key press over a cell into a valid position within your  Offset by
start * columns?viewport and keep the single line case working as it did before?

[ultimatedbz, 2016/11/15 21:58:09]

I think you are assuming that I want to commit the code like this, but what I'm
saying is that I am going to get this commented code completed before trying to
get this cl accepted. I'm not looking for you the accept everything as it is
right now, rather i'd like you to ignore the TODO's and focus on reviewing the
code that are no in TODO's. Sorry for the confusion.

As for the last question, the current implementation definitely does not support
per-cell routing, so I'll need to add an offset of some sort.

[ultimatedbz, 2016/11/19 03:11:58]

As per our offline conversation, I will leave the TODO but uncomment out this
part of the code!

[ultimatedbz, 2016/11/19 03:11:58]

I just implemented a solution to your problem. I'm going to do 
event.displayPosition = this.brailleToTextPosition_(
           event.displayPosition + this.panStrategy_.viewPort.firstRow *
this.panStrategy_.displaySize.columns);
I can explain in person!

       event.displayPosition = this.brailleToTextPosition_(
           event.displayPosition + this.panStrategy_.viewPort.start);
       // fall through
+      // */
     default:
       this.commandListener_(event, this.content_);
       break;
   }
 };
 
 
 /**
  * Shift the display by one full display size and refresh the content.
  * Sends the appropriate command if the display is already at the leftmost
@@ skipping 57 matching lines @@
 /**
  * Returns the text position corresponding to an absolute braille position,
  * that is not accounting for the current pan position.
  * @private
  * @param {number} braillePosition Braille position relative to the startof
  *        the translated content.
  * @return {number} The mapped position in code units.
  */
 cvox.BrailleDisplayManager.prototype.brailleToTextPosition_ =
     function(braillePosition) {
-  var mapping = this.brailleToText_;
+  // TODO I'll need to support this function
+  var mapping = this.panStrategy_.brailleToText;
   if (braillePosition < 0) {
     // This shouldn't happen.
     console.error('WARNING: Braille position < 0: ' + braillePosition);
     return 0;
   } else if (braillePosition >= mapping.length) {
     // This happens when the user clicks on the right part of the display
     // when it is not entirely filled with content.  Allow addressing the
     // position after the last character.
     return this.content_.text.length;
   } else {
     return mapping[braillePosition];
   }
 };
 
 
 /**
  * @param {boolean} wordWrap
  * @private
  */
 cvox.BrailleDisplayManager.prototype.updatePanStrategy_ = function(wordWrap) {
-  var newStrategy = wordWrap ? new cvox.WrappingPanStrategy() :
-      new cvox.FixedPanStrategy();
-  newStrategy.setDisplaySize(this.displayState_.textColumnCount || 0);
-  newStrategy.setContent(this.translatedContent_,
-                         this.panStrategy_.viewPort.start);
-  this.panStrategy_ = newStrategy;
+  this.panStrategy_.setPanStrategy(wordWrap);
   this.refresh_();
 };