BufferLine rewrite [WIP]

src/browser/TestUtils.test.ts

@@ -220,6 +220,9 @@ export class MockBuffer implements IBuffer {
   public addMarker(y: number): IMarker {
     throw new Error('Method not implemented.');
   }
+  public splitLine(row: number, col: number): void {
+    throw new Error('Method not implemented.');
+  }
   public isCursorInViewport!: boolean;
   public lines!: ICircularList<IBufferLine>;
   public ydisp!: number;
@@ -240,6 +243,9 @@ export class MockBuffer implements IBuffer {
   public getWrappedRangeForLine(y: number): { first: number, last: number } {
     return Buffer.prototype.getWrappedRangeForLine.apply(this, arguments as any);
   }
+  public reflowRegion(startRow: number, endRow: number, maxRows: number): boolean {
+    throw new Error('Method not implemented.');
+  }
   public nextStop(x?: number): number {
     throw new Error('Method not implemented.');
   }
@@ -264,6 +270,9 @@ export class MockBuffer implements IBuffer {
   public clearAllMarkers(): void {
     throw new Error('Method not implemented.');
   }
+  public setWrapped(row: number, value: boolean): void {
+    throw new Error('Method not implemented.');
+  }
 }
 
 export class MockRenderer implements IRenderer {

src/browser/public/Terminal.ts

@@ -28,6 +28,7 @@ export class Terminal extends Disposable implements ITerminalApi {
   private _parser: IParser | undefined;
   private _buffer: BufferNamespaceApi | undefined;
   private _publicOptions: Required<ITerminalOptions>;
+  public logOutput: boolean = false;
 
   constructor(options?: ITerminalOptions & ITerminalInitOnlyOptions) {
     super();
@@ -224,6 +225,14 @@ export class Terminal extends Disposable implements ITerminalApi {
     this._core.clear();
   }
   public write(data: string | Uint8Array, callback?: () => void): void {
+    if (this.logOutput && data instanceof Uint8Array) {
+      const thisAny = this as any;
+      if (! thisAny._decoder) {
+        thisAny._decoder = new TextDecoder(); // label = "utf-8");
+      }
+      const str = thisAny._decoder.decode(data, { stream:true });
+      console.log('write: '+JSON.stringify(str));
+    }
     this._core.write(data, callback);
   }
   public writeln(data: string | Uint8Array, callback?: () => void): void {

src/browser/renderer/dom/DomRendererRowFactory.test.ts

@@ -405,7 +405,7 @@ describe('DomRendererRowFactory', () => {
     });
 
     it('should handle BCE correctly', () => {
-      const nullCell = lineData.loadCell(0, new CellData());
+      const nullCell = CellData.fromChar(' ');
       nullCell.bg = Attributes.CM_P16 | 1;
       lineData.setCell(2, nullCell);
       nullCell.bg = Attributes.CM_P16 | 2;
@@ -418,7 +418,7 @@ describe('DomRendererRowFactory', () => {
     });
 
     it('should handle BCE for multiple cells', () => {
-      const nullCell = lineData.loadCell(0, new CellData());
+      const nullCell = CellData.fromChar(' ');
       nullCell.bg = Attributes.CM_P16 | 1;
       lineData.setCell(0, nullCell);
       let spans = rowFactory.createRow(lineData, 0, false, undefined, undefined, 0, false, 5, EMPTY_WIDTH, -1, -1);
@@ -451,7 +451,7 @@ describe('DomRendererRowFactory', () => {
       lineData.setCell(1, CellData.fromCharData([DEFAULT_ATTR, '€', 1, '€'.charCodeAt(0)]));
       lineData.setCell(2, CellData.fromCharData([DEFAULT_ATTR, 'c', 1, 'c'.charCodeAt(0)]));
       lineData.setCell(3, CellData.fromCharData([DEFAULT_ATTR, '語', 2, 'c'.charCodeAt(0)]));
-      lineData.setCell(4, CellData.fromCharData([DEFAULT_ATTR, '𝄞', 1, 'c'.charCodeAt(0)]));
+      lineData.setCell(5, CellData.fromCharData([DEFAULT_ATTR, '𝄞', 1, 'c'.charCodeAt(0)]));
       const spans = rowFactory.createRow(lineData, 0, false, undefined, undefined, 0, false, 5, EMPTY_WIDTH, -1, -1);
       assert.equal(extractHtml(spans),
         '<span>a</span><span style="letter-spacing: 3px;">€</span><span>c語</span><span style="letter-spacing: -2px;">𝄞</span>'
@@ -502,7 +502,7 @@ describe('DomRendererRowFactory', () => {
   }
 
   function createEmptyLineData(cols: number): IBufferLine {
-    const lineData = new BufferLine(cols);
+    const lineData = BufferLine.make(cols);
     for (let i = 0; i < cols; i++) {
       lineData.setCell(i, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]));
     }

src/browser/renderer/dom/DomRendererRowFactory.ts

@@ -10,7 +10,6 @@ import { CellData } from 'common/buffer/CellData';
 import { ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
 import { channels, color } from 'common/Color';
 import { ICharacterJoinerService, ICoreBrowserService, IThemeService } from 'browser/services/Services';
-import { JoinedCellData } from 'browser/services/CharacterJoinerService';
 import { treatGlyphAsBackgroundColor } from 'browser/renderer/shared/RendererUtils';
 import { AttributeData } from 'common/buffer/AttributeData';
 import { WidthCache } from 'browser/renderer/dom/WidthCache';
@@ -44,7 +43,7 @@ export class DomRendererRowFactory {
 
   constructor(
     private readonly _document: Document,
-    @ICharacterJoinerService private readonly _characterJoinerService: ICharacterJoinerService,
+    @ICharacterJoinerService private readonly _characterJoinerService: ICharacterJoinerService, // FIXME remove
     @IOptionsService private readonly _optionsService: IOptionsService,
     @ICoreBrowserService private readonly _coreBrowserService: ICoreBrowserService,
     @ICoreService private readonly _coreService: ICoreService,
@@ -71,9 +70,9 @@ export class DomRendererRowFactory {
     linkStart: number,
     linkEnd: number
   ): HTMLSpanElement[] {
+    const cell = this._workCell;
 
     const elements: HTMLSpanElement[] = [];
-    const joinedRanges = this._characterJoinerService.getJoinedCharacters(row);
     const colors = this._themeService.colors;
 
     let lineLength = lineData.getNoBgTrimmedLength();
@@ -97,21 +96,21 @@ export class DomRendererRowFactory {
 
     for (let x = 0; x < lineLength; x++) {
       lineData.loadCell(x, this._workCell);
-      let width = this._workCell.getWidth();
+      const width = this._workCell.getWidth();
 
       // The character to the left is a wide character, drawing is owned by the char at x-1
       if (width === 0) {
         continue;
       }
 
       // If true, indicates that the current character(s) to draw were joined.
-      let isJoined = false;
-      let lastCharX = x;
+      const isJoined = false;
+      const lastCharX = x;
 
       // Process any joined character ranges as needed. Because of how the
       // ranges are produced, we know that they are valid for the characters
       // and attributes of our input.
-      let cell = this._workCell;
+      /*
       if (joinedRanges.length > 0 && x === joinedRanges[0][0]) {
         isJoined = true;
         const range = joinedRanges.shift()!;
@@ -130,6 +129,7 @@ export class DomRendererRowFactory {
         // Recalculate width
         width = cell.getWidth();
       }
+      */
 
       const isInSelection = this._isCellInSelection(x, row);
       const isCursorCell = isCursorRow && x === cursorX;

src/browser/services/CharacterJoinerService.test.ts

@@ -22,7 +22,7 @@ describe('CharacterJoinerService', () => {
     lines.set(2, lineData([['a -> b -', 0xFFFFFFFF], ['> c -> d', 0]]));
 
     lines.set(3, lineData([['no joined ranges']]));
-    lines.set(4, new BufferLine(0));
+    lines.set(4, BufferLine.make(0));
     lines.set(5, lineData([['a', 0x11111111], [' -> b -> c -> '], ['d', 0x22222222]]));
     const line6 = lineData([['wi']]);
     line6.resize(line6.length + 1, CellData.fromCharData([0, '￥', 2, '￥'.charCodeAt(0)]));
@@ -267,7 +267,7 @@ describe('CharacterJoinerService', () => {
 type IPartialLineData = ([string] | [string, number]);
 
 function lineData(data: IPartialLineData[]): IBufferLine {
-  const tline = new BufferLine(0);
+  const tline = BufferLine.make(0);
   for (let i = 0; i < data.length; ++i) {
     const line = data[i][0];
     const attr = (data[i][1] || 0) as number;

src/browser/services/CharacterJoinerService.ts

@@ -11,6 +11,7 @@ import { CellData } from 'common/buffer/CellData';
 import { IBufferService } from 'common/services/Services';
 import { ICharacterJoinerService } from 'browser/services/Services';
 
+// FIXME should probably just use plain CellData
 export class JoinedCellData extends AttributeData implements ICellData {
   private _width: number;
   // .content carries no meaning for joined CellData, simply nullify it

src/browser/services/SelectionService.test.ts

@@ -55,15 +55,15 @@ describe('SelectionService', () => {
   });
 
   function stringToRow(text: string): IBufferLine {
-    const result = new BufferLine(text.length);
+    const result = BufferLine.make(text.length);
     for (let i = 0; i < text.length; i++) {
       result.setCell(i, CellData.fromCharData([0, text.charAt(i), 1, text.charCodeAt(i)]));
     }
     return result;
   }
 
   function stringArrayToRow(chars: string[]): IBufferLine {
-    const line = new BufferLine(chars.length);
+    const line = BufferLine.make(chars.length);
     chars.map((c, idx) => line.setCell(idx, CellData.fromCharData([0, c, 1, c.charCodeAt(0)])));
     return line;
   }
@@ -118,7 +118,7 @@ describe('SelectionService', () => {
         [0, 'o', 1, 'o'.charCodeAt(0)],
         [0, 'o', 1, 'o'.charCodeAt(0)]
       ];
-      const line = new BufferLine(data.length);
+      const line = BufferLine.make(data.length);
       for (let i = 0; i < data.length; ++i) line.setCell(i, CellData.fromCharData(data[i]));
       buffer.lines.set(0, line);
       // Ensure wide characters take up 2 columns
@@ -193,7 +193,7 @@ describe('SelectionService', () => {
     it('should expand upwards or downards for wrapped lines', () => {
       buffer.lines.set(0, stringToRow('                 foo'));
       buffer.lines.set(1, stringToRow('bar                 '));
-      buffer.lines.get(1)!.isWrapped = true;
+      buffer.setWrapped(1, true);
       selectionService.selectWordAt([1, 1]);
       assert.equal(selectionService.selectionText, 'foobar');
       selectionService.model.clearSelection();
@@ -207,10 +207,10 @@ describe('SelectionService', () => {
       buffer.lines.set(2, stringToRow('bbbbbbbbbbbbbbbbbbbb'));
       buffer.lines.set(3, stringToRow('cccccccccccccccccccc'));
       buffer.lines.set(4, stringToRow('bar                 '));
-      buffer.lines.get(1)!.isWrapped = true;
-      buffer.lines.get(2)!.isWrapped = true;
-      buffer.lines.get(3)!.isWrapped = true;
-      buffer.lines.get(4)!.isWrapped = true;
+      buffer.setWrapped(1, true);
+      buffer.setWrapped(2, true);
+      buffer.setWrapped(3, true);
+      buffer.setWrapped(4, true);
       selectionService.selectWordAt([18, 0]);
       assert.equal(selectionService.selectionText, expectedText);
       selectionService.model.clearSelection();
@@ -349,8 +349,8 @@ describe('SelectionService', () => {
     it('should select the entire wrapped line', () => {
       buffer.lines.set(0, stringToRow('foo'));
       const line2 = stringToRow('bar');
-      line2.isWrapped = true;
       buffer.lines.set(1, line2);
+      buffer.setWrapped(1, true);
       selectionService.selectLineAt(0);
       assert.equal(selectionService.selectionText, 'foobar', 'The selected text is correct');
       assert.deepEqual(selectionService.model.selectionStart, [0, 0]);

src/browser/services/SelectionService.ts

@@ -864,7 +864,7 @@ export class SelectionService extends Disposable implements ISelectionService {
       }
 
       // Expand the string in both directions until a space is hit
-      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine.loadCell(startCol - 1, this._workCell))) {
+      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine.loadCell(startCol - 1, this._workCell) as CellData)) {
         bufferLine.loadCell(startCol - 1, this._workCell);
         const length = this._workCell.getChars().length;
         if (this._workCell.getWidth() === 0) {
@@ -880,7 +880,7 @@ export class SelectionService extends Disposable implements ISelectionService {
         startIndex--;
         startCol--;
       }
-      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine.loadCell(endCol + 1, this._workCell))) {
+      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine.loadCell(endCol + 1, this._workCell) as CellData)) {
         bufferLine.loadCell(endCol + 1, this._workCell);
         const length = this._workCell.getChars().length;
         if (this._workCell.getWidth() === 2) {

src/common/InputHandler.test.ts

@@ -452,18 +452,16 @@
       );
 
       // fill display with a's
-      for (let i = 0; i < bufferService.rows; ++i) await inputHandler.parseP(Array(bufferService.cols + 1).join('a'));
+      const a_repeat_cols = Array(bufferService.cols + 1).join('a');
+      for (let i = 0; i < bufferService.rows; ++i) await inputHandler.parseP(a_repeat_cols);
 
       // params [0] - right and below erase
       bufferService.buffer.y = 5;
       bufferService.buffer.x = 40;
       inputHandler.eraseInDisplay(Params.fromArray([0]));
       assert.deepEqual(termContent(bufferService, false), [
-        Array(bufferService.cols + 1).join('a'),
-        Array(bufferService.cols + 1).join('a'),
-        Array(bufferService.cols + 1).join('a'),
-        Array(bufferService.cols + 1).join('a'),
-        Array(bufferService.cols + 1).join('a'),
+        a_repeat_cols, a_repeat_cols, a_repeat_cols,
+        a_repeat_cols, a_repeat_cols,
         Array(40 + 1).join('a') + Array(bufferService.cols - 40 + 1).join(' '),
         Array(bufferService.cols + 1).join(' ')
       ]);
@@ -1885,17 +1883,19 @@
       assert.equal(cell.isUnderlineColorDefault(), false);
 
       // eAttrs in buffer pos 0 and 1 should be the same object
-      assert.equal(
-        (bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[0],
-        (bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[1]
-      );
+      const line0 = bufferService.buffer!.lines.get(0)!;
+      line0.loadCell(0, cell);
+      const ext0 = cell.extended;
+      line0.loadCell(1, cell);
+      const ext1 = cell.extended;
+      assert.equal(ext0, ext1);
       // should not have written eAttr for pos 2 in the buffer
-      assert.equal((bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[2], undefined);
+      line0.loadCell(2, cell);
+      assert.isFalse(cell.hasExtendedAttrs() !== 0);
       // eAttrs in buffer pos 1 and pos 3 must be different objs
-      assert.notEqual(
-        (bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[1],
-        (bufferService.buffer!.lines.get(0)! as any)._extendedAttrs[3]
-      );
+      line0.loadCell(3, cell);
+      const ext3 = cell.extended;
+      assert.notEqual(ext1, ext3);
     });
   });
   describe('DECSTR', () => {