EmulatorView: fix linkification on non-basic lines

Linkification currently assumes that each char in the array representing
the line maps one-to-one onto a screen column.  However, this is
demonstrably false in a Unicode environment, where one screen column can
take an arbitrary number of chars (surrogate pairs and/or combining
characters) and one char can take two screen columns (East Asian wide
characters in the BMP).  As a result, links end up misplaced on lines
where these more advanced Unicode features are in use.

To fix this, we need to properly determine the screen columns the link
spans, taking into account the above; unfortunately, there appears to be
no way short of iterating over the entire line up to that point to
discover this.  To lessen the performance hit, we add support to
UnicodeTranscript and TranscriptScreen to allow EmulatorView to
determine if scanning the entire line is necessary and only scan the
line if we must.

Author: steven676

libraries/emulatorview/src/jackpal/androidterm/emulatorview/EmulatorView.java

@@ -266,31 +266,59 @@ private boolean startsWith(CharSequence s, int start, int end,
     private int createLinks(int row)
     {
         TranscriptScreen transcriptScreen = mEmulator.getScreen();
-        char [] result = transcriptScreen.getScriptLine(row);
+        char [] line = transcriptScreen.getScriptLine(row);
         int lineCount = 1;
 
         //Nothing to do if there's no text.
-        if(result == null)
+        if(line == null)
             return lineCount;
 
-        SpannableStringBuilder textToLinkify = new SpannableStringBuilder(new String(result));
+        /* If this is not a basic line, the array returned from getScriptLine()
+         * could have arbitrary garbage at the end -- find the point at which
+         * the line ends and only include that in the text to linkify.
+         *
+         * XXX: The fact that the array returned from getScriptLine() on a
+         * basic line contains no garbage is an implementation detail -- the
+         * documented behavior explicitly allows garbage at the end! */
+        int lineLen;
+        boolean textIsBasic = transcriptScreen.isBasicLine(row);
+        if (textIsBasic) {
+            lineLen = line.length;
+        } else {
+            // The end of the valid data is marked by a NUL character
+            for (lineLen = 0; line[lineLen] != 0; ++lineLen);
+        }
+
+        SpannableStringBuilder textToLinkify = new SpannableStringBuilder(new String(line, 0, lineLen));
 
         boolean lineWrap = transcriptScreen.getScriptLineWrap(row);
 
         //While the current line has a wrap
         while (lineWrap)
         {
             //Get next line
-            result = transcriptScreen.getScriptLine(row + lineCount);
+            int nextRow = row + lineCount;
+            line = transcriptScreen.getScriptLine(nextRow);
 
             //If next line is blank, don't try and append
-            if(result == null)
+            if(line == null)
                 break;
 
-            textToLinkify.append(new String(result));
+            boolean lineIsBasic = transcriptScreen.isBasicLine(nextRow);
+            if (textIsBasic && !lineIsBasic) {
+                textIsBasic = lineIsBasic;
+            }
+            if (lineIsBasic) {
+                lineLen = line.length;
+            } else {
+                // The end of the valid data is marked by a NUL character
+                for (lineLen = 0; line[lineLen] != 0; ++lineLen);
+            }
+
+            textToLinkify.append(new String(line, 0, lineLen));
 
             //Check if line after next is wrapped
-            lineWrap = transcriptScreen.getScriptLineWrap(row + lineCount);
+            lineWrap = transcriptScreen.getScriptLineWrap(nextRow);
             ++lineCount;
         }
 
@@ -299,14 +327,16 @@ private int createLinks(int row)
         URLSpan [] urls = textToLinkify.getSpans(0, textToLinkify.length(), URLSpan.class);
         if(urls.length > 0)
         {
+            int columns = mColumns;
+
             //re-index row to 0 if it is negative
             int screenRow = row - mTopRow;
 
             //Create and initialize set of links
             URLSpan [][] linkRows = new URLSpan[lineCount][];
             for(int i=0; i<lineCount; ++i)
             {
-                linkRows[i] = new URLSpan[mColumns];
+                linkRows[i] = new URLSpan[columns];
                 Arrays.fill(linkRows[i], null);
             }
 
@@ -317,11 +347,52 @@ private int createLinks(int row)
                 int spanStart = textToLinkify.getSpanStart(url);
                 int spanEnd = textToLinkify.getSpanEnd(url);
 
-                //Build accurate indices for multi-line links
-                int startRow = spanStart / mColumns;
-                int startCol = spanStart % mColumns;
-                int endRow   = spanEnd   / mColumns;
-                int endCol   = spanEnd   % mColumns;
+                // Build accurate indices for links
+                int startRow;
+                int startCol;
+                int endRow;
+                int endCol;
+                if (textIsBasic) {
+                    // Basic line -- can assume one char per column
+                    startRow = spanStart / mColumns;
+                    startCol = spanStart % mColumns;
+                    endRow   = spanEnd   / mColumns;
+                    endCol   = spanEnd   % mColumns;
+                } else {
+                    /* Iterate over the line to get starting and ending columns
+                     * for this span */
+                    startRow = 0;
+                    startCol = 0;
+                    for (int i = 0; i < spanStart; ++i) {
+                        char c = textToLinkify.charAt(i);
+                        if (Character.isHighSurrogate(c)) {
+                            ++i;
+                            startCol += UnicodeTranscript.charWidth(c, textToLinkify.charAt(i));
+                        } else {
+                            startCol += UnicodeTranscript.charWidth(c);
+                        }
+                        if (startCol >= columns) {
+                            ++startRow;
+                            startCol %= columns;
+                        }
+                    }
+
+                    endRow = startRow;
+                    endCol = startCol;
+                    for (int i = spanStart; i < spanEnd; ++i) {
+                        char c = textToLinkify.charAt(i);
+                        if (Character.isHighSurrogate(c)) {
+                            ++i;
+                            endCol += UnicodeTranscript.charWidth(c, textToLinkify.charAt(i));
+                        } else {
+                            endCol += UnicodeTranscript.charWidth(c);
+                        }
+                        if (endCol >= columns) {
+                            ++endRow;
+                            endCol %= columns;
+                        }
+                    }
+                }
 
                 //Fill linkRows with the URL where appropriate
                 for(int i=startRow; i <= endRow; ++i)

libraries/emulatorview/src/jackpal/androidterm/emulatorview/TranscriptScreen.java

@@ -433,7 +433,7 @@ public void resize(int columns, int rows, int style) {
      * @param row The row index to be queried
      * @return The line of text at this row index
      */
-    public char[] getScriptLine(int row)
+    char[] getScriptLine(int row)
     {
         try
         {
@@ -454,8 +454,20 @@ public char[] getScriptLine(int row)
      * @param row The row to check for line-wrap status
      * @return The line wrap status of the row provided
      */
-    public boolean getScriptLineWrap(int row)
+    boolean getScriptLineWrap(int row)
     {
         return mData.getLineWrap(row);
     }
+
+    /**
+     * Get whether the line at this index is "basic" (contains only BMP
+     * characters of width 1).
+     */
+    boolean isBasicLine(int row) {
+        if (mData != null) {
+            return mData.isBasicLine(row);
+        } else {
+            return true;
+        }
+    }
 }

libraries/emulatorview/src/jackpal/androidterm/emulatorview/UnicodeTranscript.java

@@ -650,6 +650,14 @@ public StyleRow getLineColor(int row) {
         return getLineColor(row, 0, mColumns);
     }
 
+    boolean isBasicLine(int row) {
+        if (row < -mActiveTranscriptRows || row > mScreenRows-1) {
+            throw new IllegalArgumentException();
+        }
+
+        return (mLines[externalToInternalRow(row)] instanceof char[]);
+    }
+
     public boolean getChar(int row, int column) {
         return getChar(row, column, 0);
     }