diff --git a/src/browser/TestUtils.test.ts b/src/browser/TestUtils.test.ts index cf878cbc9a..39516f72f5 100644 --- a/src/browser/TestUtils.test.ts +++ b/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; 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 { diff --git a/src/browser/public/Terminal.ts b/src/browser/public/Terminal.ts index 3b4309437f..3d5a05c3f1 100644 --- a/src/browser/public/Terminal.ts +++ b/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; + 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 { diff --git a/src/browser/renderer/dom/DomRendererRowFactory.test.ts b/src/browser/renderer/dom/DomRendererRowFactory.test.ts index 14c4ade147..68ebe4e121 100644 --- a/src/browser/renderer/dom/DomRendererRowFactory.test.ts +++ b/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), 'a€c語𝄞' @@ -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])); } diff --git a/src/browser/renderer/dom/DomRendererRowFactory.ts b/src/browser/renderer/dom/DomRendererRowFactory.ts index 96d3f171bd..ac1f06031a 100644 --- a/src/browser/renderer/dom/DomRendererRowFactory.ts +++ b/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(); @@ -99,7 +98,7 @@ 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) { @@ -118,6 +117,7 @@ export class DomRendererRowFactory { // 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] && isValidJoinRange) { const range = joinedRanges.shift()!; @@ -149,6 +149,7 @@ export class DomRendererRowFactory { width = cell.getWidth(); } } + */ const isInSelection = this._isCellInSelection(x, row); const isCursorCell = isCursorRow && x === cursorX; diff --git a/src/browser/services/CharacterJoinerService.test.ts b/src/browser/services/CharacterJoinerService.test.ts index 6b5326d939..044b13dedf 100644 --- a/src/browser/services/CharacterJoinerService.test.ts +++ b/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; diff --git a/src/browser/services/CharacterJoinerService.ts b/src/browser/services/CharacterJoinerService.ts index ca4f1984e3..53cc3d48d6 100644 --- a/src/browser/services/CharacterJoinerService.ts +++ b/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 diff --git a/src/browser/services/SelectionService.test.ts b/src/browser/services/SelectionService.test.ts index 67158def09..80bc1d6762 100644 --- a/src/browser/services/SelectionService.test.ts +++ b/src/browser/services/SelectionService.test.ts @@ -55,7 +55,7 @@ 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)])); } @@ -63,7 +63,7 @@ describe('SelectionService', () => { } 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 @@ -190,10 +190,10 @@ describe('SelectionService', () => { selectionService.selectWordAt([15, 0]); assert.equal(selectionService.selectionText, 'ij"'); }); - it('should expand upwards or downards for wrapped lines', () => { + it('should expand upwards or downwards 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]); diff --git a/src/browser/services/SelectionService.ts b/src/browser/services/SelectionService.ts index 9da8ab5d49..0a78c21f11 100644 --- a/src/browser/services/SelectionService.ts +++ b/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) { diff --git a/src/common/CircularList.ts b/src/common/CircularList.ts index a46faca300..7fc782158e 100644 --- a/src/common/CircularList.ts +++ b/src/common/CircularList.ts @@ -153,14 +153,16 @@ export class CircularList extends Disposable implements ICircularList { * @param deleteCount The number of elements to delete. * @param items The items to insert. */ - public splice(start: number, deleteCount: number, ...items: T[]): void { + public spliceNoTrim(start: number, deleteCount: number, items: T[], fireEvents: boolean = true): void { // Delete items if (deleteCount) { for (let i = start; i < this._length - deleteCount; i++) { this._array[this._getCyclicIndex(i)] = this._array[this._getCyclicIndex(i + deleteCount)]; } this._length -= deleteCount; - this.onDeleteEmitter.fire({ index: start, amount: deleteCount }); + if (fireEvents) { + this.onDeleteEmitter.fire({ index: start, amount: deleteCount }); + } } // Add items @@ -170,20 +172,24 @@ export class CircularList extends Disposable implements ICircularList { for (let i = 0; i < items.length; i++) { this._array[this._getCyclicIndex(start + i)] = items[i]; } - if (items.length) { + if (items.length && fireEvents) { this.onInsertEmitter.fire({ index: start, amount: items.length }); } - - // Adjust length as needed - if (this._length + items.length > this._maxLength) { - const countToTrim = (this._length + items.length) - this._maxLength; + this._length += items.length; + } + public trimIfNeeded(): void { + if (this._length > this._maxLength) { + const countToTrim = this._length - this._maxLength; this._startIndex += countToTrim; this._length = this._maxLength; this.onTrimEmitter.fire(countToTrim); - } else { - this._length += items.length; } } + public splice(start: number, deleteCount: number, ...items: T[]): void { + this.spliceNoTrim(start, deleteCount, items); + // Adjust length as needed + this.trimIfNeeded(); + } /** * Trims a number of items from the start of the list. diff --git a/src/common/InputHandler.test.ts b/src/common/InputHandler.test.ts index 78ce646ad6..d7cbdc3f93 100644 --- a/src/common/InputHandler.test.ts +++ b/src/common/InputHandler.test.ts @@ -483,18 +483,16 @@ describe('InputHandler', () => { ); // 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(' ') ]); @@ -1916,17 +1914,19 @@ describe('InputHandler', () => { 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', () => { diff --git a/src/common/InputHandler.ts b/src/common/InputHandler.ts index 0e1511739c..02de73635f 100644 --- a/src/common/InputHandler.ts +++ b/src/common/InputHandler.ts @@ -4,7 +4,7 @@ * @license MIT */ -import { IInputHandler, IAttributeData, IDisposable, IWindowOptions, IColorEvent, IParseStack, ColorIndex, ColorRequestType, SpecialColorIndex } from 'common/Types'; +import { IInputHandler, IBufferLine, IAttributeData, IDisposable, IWindowOptions, IColorEvent, IParseStack, ColorIndex, ColorRequestType, SpecialColorIndex } from 'common/Types'; import { C0, C1 } from 'common/data/EscapeSequences'; import { CHARSETS, DEFAULT_CHARSET } from 'common/data/Charsets'; import { EscapeSequenceParser } from 'common/parser/EscapeSequenceParser'; @@ -124,6 +124,8 @@ export class InputHandler extends Disposable implements IInputHandler { private _dirtyRowTracker: IDirtyRowTracker; protected _windowTitleStack: string[] = []; protected _iconNameStack: string[] = []; + public get precedingJoinState(): number { return this._parser.precedingJoinState; } + public set precedingJoinState(value: number) { this._parser.precedingJoinState = value; } private _curAttrData: IAttributeData = DEFAULT_ATTR_DATA.clone(); public getAttrData(): IAttributeData { return this._curAttrData; } @@ -175,7 +177,7 @@ export class InputHandler extends Disposable implements IInputHandler { private readonly _optionsService: IOptionsService, private readonly _oscLinkService: IOscLinkService, private readonly _coreMouseService: ICoreMouseService, - private readonly _unicodeService: IUnicodeService, + public readonly unicodeService: IUnicodeService, private readonly _parser: IEscapeSequenceParser = new EscapeSequenceParser() ) { super(); @@ -507,145 +509,57 @@ export class InputHandler extends Disposable implements IInputHandler { } public print(data: Uint32Array, start: number, end: number): void { - let code: number; - let chWidth: number; - const charset = this._charsetService.charset; - const screenReaderMode = this._optionsService.rawOptions.screenReaderMode; - const cols = this._bufferService.cols; - const wraparoundMode = this._coreService.decPrivateModes.wraparound; - const insertMode = this._coreService.modes.insertMode; const curAttr = this._curAttrData; let bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!; - + const wraparoundMode = this._coreService.decPrivateModes.wraparound; + const cols = this._bufferService.cols; this._dirtyRowTracker.markDirty(this._activeBuffer.y); - - // handle wide chars: reset start_cell-1 if we would overwrite the second cell of a wide char - if (this._activeBuffer.x && end - start > 0 && bufferRow.getWidth(this._activeBuffer.x - 1) === 2) { - bufferRow.setCellFromCodepoint(this._activeBuffer.x - 1, 0, 1, curAttr); - } - - let precedingJoinState = this._parser.precedingJoinState; - for (let pos = start; pos < end; ++pos) { - code = data[pos]; - - // get charset replacement character - // charset is only defined for ASCII, therefore we only - // search for an replacement char if code < 127 - if (code < 127 && charset) { - const ch = charset[String.fromCharCode(code)]; - if (ch) { - code = ch.charCodeAt(0); - } - } - - const currentInfo = this._unicodeService.charProperties(code, precedingJoinState); - chWidth = UnicodeService.extractWidth(currentInfo); - const shouldJoin = UnicodeService.extractShouldJoin(currentInfo); - const oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0; - precedingJoinState = currentInfo; - - if (screenReaderMode) { - this._onA11yChar.fire(stringFromCodePoint(code)); - } - if (this._getCurrentLinkId()) { - this._oscLinkService.addLineToLink(this._getCurrentLinkId(), this._activeBuffer.ybase + this._activeBuffer.y); - } - - // goto next line if ch would overflow - // NOTE: To avoid costly width checks here, - // the terminal does not allow a cols < 2. - if (this._activeBuffer.x + chWidth - oldWidth > cols) { - // autowrap - DECAWM - // automatically wraps to the beginning of the next line - if (wraparoundMode) { - const oldRow = bufferRow; - let oldCol = this._activeBuffer.x - oldWidth; - this._activeBuffer.x = oldWidth; - this._activeBuffer.y++; - if (this._activeBuffer.y === this._activeBuffer.scrollBottom + 1) { - this._activeBuffer.y--; - this._bufferService.scroll(this._eraseAttrData(), true); - } else { - if (this._activeBuffer.y >= this._bufferService.rows) { - this._activeBuffer.y = this._bufferService.rows - 1; - } - // The line already exists (eg. the initial viewport), mark it as a - // wrapped line - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = true; - } - // row changed, get it again - bufferRow = this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!; - if (oldWidth > 0 && bufferRow instanceof BufferLine) { - // Combining character widens 1 column to 2. - // Move old character to next line. - bufferRow.copyCellsFrom(oldRow as BufferLine, - oldCol, 0, oldWidth, false); - } - // clear left over cells to the right - while (oldCol < cols) { - oldRow.setCellFromCodepoint(oldCol++, 0, 1, curAttr); - } + // if (charset) replace character; FIXME ok to do it in-place? + let col = (bufferRow as BufferLine).insertText(this._activeBuffer.x, data, start, end, curAttr, this, this._coreService); + while (col > cols) { + // autowrap - DECAWM + // automatically wraps to the beginning of the next line + if (wraparoundMode) { + const oldRow = bufferRow as BufferLine; + // this._activeBuffer.x = oldWidth; + const buffer = this._activeBuffer + if (buffer.y === this._activeBuffer.scrollBottom) { + this._bufferService.scroll(this._eraseAttrData(), true); + buffer.splitLine(buffer.y, col); } else { - this._activeBuffer.x = cols - 1; - if (chWidth === 2) { - // FIXME: check for xterm behavior - // What to do here? We got a wide char that does not fit into last cell - continue; + buffer.y++; + if (this._activeBuffer.y >= this._bufferService.rows) { + buffer.y = this._bufferService.rows - 1; + // FIXME overwrite last line - not implemented + col = cols; + } else { + buffer.splitLine(buffer.y, col); } } - } - - // insert combining char at last cursor position - // this._activeBuffer.x should never be 0 for a combining char - // since they always follow a cell consuming char - // therefore we can test for this._activeBuffer.x to avoid overflow left - if (shouldJoin && this._activeBuffer.x) { - const offset = bufferRow.getWidth(this._activeBuffer.x - 1) ? 1 : 2; - // if empty cell after fullwidth, need to go 2 cells back - // it is save to step 2 cells back here - // since an empty cell is only set by fullwidth chars - bufferRow.addCodepointToCell(this._activeBuffer.x - offset, - code, chWidth); - for (let delta = chWidth - oldWidth; --delta >= 0; ) { - bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr); + bufferRow = this._activeBuffer.lines.get(buffer.ybase + buffer.y)!; + // usually same as cols, but may be less in case of wide characters. + const prevCols = (bufferRow as BufferLine).logicalStartColumn() - oldRow.logicalStartColumn(); + col = col - prevCols; + // row changed, get it again + /* + if (oldWidth > 0 && bufferRow instanceof BufferLine) { + // Combining character widens 1 column to 2. + // Move old character to next line. + bufferRow.copyCellsFrom(oldRow as BufferLine, + oldCol, 0, oldWidth, false); } - continue; - } - - // insert mode: move characters to right - if (insertMode) { - // right shift cells according to the width - bufferRow.insertCells(this._activeBuffer.x, chWidth - oldWidth, this._activeBuffer.getNullCell(curAttr)); - // test last cell - since the last cell has only room for - // a halfwidth char any fullwidth shifted there is lost - // and will be set to empty cell - if (bufferRow.getWidth(cols - 1) === 2) { - bufferRow.setCellFromCodepoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr); - } - } - - // write current char to buffer and advance cursor - bufferRow.setCellFromCodepoint(this._activeBuffer.x++, code, chWidth, curAttr); - - // fullwidth char - also set next cell to placeholder stub and advance cursor - // for graphemes bigger than fullwidth we can simply loop to zero - // we already made sure above, that this._activeBuffer.x + chWidth will not overflow right - if (chWidth > 0) { - while (--chWidth) { - // other than a regular empty cell a cell following a wide char has no width - bufferRow.setCellFromCodepoint(this._activeBuffer.x++, 0, 0, curAttr); + // clear left over cells to the right + while (oldCol < cols) { + oldRow.setCellFromCodepoint(oldCol++, 0, 1, curAttr); } + */ + // col = ...; + } else { + // FIXME delete excess + break; } } - - this._parser.precedingJoinState = precedingJoinState; - - // handle wide chars: reset cell to the right if it is second cell of a wide char - if (this._activeBuffer.x < cols && end - start > 0 && bufferRow.getWidth(this._activeBuffer.x) === 0 && !bufferRow.hasContent(this._activeBuffer.x)) { - bufferRow.setCellFromCodepoint(this._activeBuffer.x, 0, 1, curAttr); - } - - this._dirtyRowTracker.markDirty(this._activeBuffer.y); + this._activeBuffer.x = col; } /** @@ -725,7 +639,7 @@ export class InputHandler extends Disposable implements IInputHandler { // reprint is common, especially on resize. Note that the windowsMode wrapped line heuristics // can mess with this so windowsMode should be disabled, which is recommended on Windows build // 21376 and above. - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, false); } // If the end of the line is hit, prevent this action from wrapping around to the next line. if (this._activeBuffer.x >= this._bufferService.cols) { @@ -789,7 +703,7 @@ export class InputHandler extends Disposable implements IInputHandler { && this._activeBuffer.y > this._activeBuffer.scrollTop && this._activeBuffer.y <= this._activeBuffer.scrollBottom && this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)?.isWrapped) { - this._activeBuffer.lines.get(this._activeBuffer.ybase + this._activeBuffer.y)!.isWrapped = false; + this._activeBuffer.setWrapped(this._activeBuffer.ybase + this._activeBuffer.y, false); this._activeBuffer.y--; this._activeBuffer.x = this._bufferService.cols - 1; // find last taken cell - last cell can have 3 different states: @@ -1142,15 +1056,19 @@ export class InputHandler extends Disposable implements IInputHandler { * @param respectProtect Whether to respect the protection attribute (DECSCA). */ private _eraseInBufferLine(y: number, start: number, end: number, clearWrap: boolean = false, respectProtect: boolean = false): void { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; - line.replaceCells( - start, - end, - this._activeBuffer.getNullCell(this._eraseAttrData()), - respectProtect - ); - if (clearWrap) { - line.isWrapped = false; + const row = this._activeBuffer.ybase + y; + if (clearWrap && start === 0) { + this._activeBuffer.setWrapped(row, false); + } + if (clearWrap && end === Infinity) { + this._activeBuffer.setWrapped(row + 1, false); + } + const line = this._activeBuffer.lines.get(row) as BufferLine; + const fill = this._activeBuffer.getNullCell(this._eraseAttrData()); + if (! respectProtect) { + line.eraseCells(start, end, fill); + } else { + line.replaceCells(start, end, fill, respectProtect); } } @@ -1159,12 +1077,18 @@ export class InputHandler extends Disposable implements IInputHandler { * the terminal and the isWrapped property is set to false. * @param y row index */ - private _resetBufferLine(y: number, respectProtect: boolean = false): void { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y); + private _resetBufferLine(row: number, respectProtect: boolean = false): void { + const buffer = this._activeBuffer; + const line = buffer.lines.get(row); if (line) { - line.fill(this._activeBuffer.getNullCell(this._eraseAttrData()), respectProtect); - this._bufferService.buffer.clearMarkers(this._activeBuffer.ybase + y); - line.isWrapped = false; + const eraseAttrs = this._eraseAttrData(); + if (! respectProtect) { + (line as BufferLine).eraseCells(0, this._bufferService.cols, eraseAttrs); + } else { + line.fill(this._activeBuffer.getNullCell(eraseAttrs), respectProtect); + } + buffer.clearMarkers(row); + buffer.setWrapped(row, false); } } @@ -1194,16 +1118,22 @@ export class InputHandler extends Disposable implements IInputHandler { */ public eraseInDisplay(params: IParams, respectProtect: boolean = false): boolean { this._restrictCursor(this._bufferService.cols); - let j; + // When erasing wrapped lines, we do less copying if we go bottom up. + let j; let x; let y; + const buffer = this._activeBuffer; switch (params.params[0]) { case 0: - j = this._activeBuffer.y; + y = buffer.y; + x = buffer.x; + j = this._bufferService.rows; this._dirtyRowTracker.markDirty(j); - this._eraseInBufferLine(j++, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect); - for (; j < this._bufferService.rows; j++) { - this._resetBufferLine(j, respectProtect); + this._dirtyRowTracker.markDirty(y); + while (--j > y || (j === y && x === 0)) { + this._resetBufferLine(buffer.ybase + j, respectProtect); + } + if (x > 0) { + this._eraseInBufferLine(y, x, Infinity, false, respectProtect); } - this._dirtyRowTracker.markDirty(j); break; case 1: j = this._activeBuffer.y; @@ -1212,10 +1142,10 @@ export class InputHandler extends Disposable implements IInputHandler { this._eraseInBufferLine(j, 0, this._activeBuffer.x + 1, true, respectProtect); if (this._activeBuffer.x + 1 >= this._bufferService.cols) { // Deleted entire previous line. This next line can no longer be wrapped. - this._activeBuffer.lines.get(j + 1)!.isWrapped = false; + this._activeBuffer.setWrapped(j + 1, false); } while (j--) { - this._resetBufferLine(j, respectProtect); + this._resetBufferLine(buffer.ybase + j, respectProtect); } this._dirtyRowTracker.markDirty(0); break; @@ -1283,13 +1213,13 @@ export class InputHandler extends Disposable implements IInputHandler { this._restrictCursor(this._bufferService.cols); switch (params.params[0]) { case 0: - this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, this._bufferService.cols, this._activeBuffer.x === 0, respectProtect); + this._eraseInBufferLine(this._activeBuffer.y, this._activeBuffer.x, Infinity, this._activeBuffer.x === 0, respectProtect); break; case 1: this._eraseInBufferLine(this._activeBuffer.y, 0, this._activeBuffer.x + 1, false, respectProtect); break; case 2: - this._eraseInBufferLine(this._activeBuffer.y, 0, this._bufferService.cols, true, respectProtect); + this._eraseInBufferLine(this._activeBuffer.y, 0, Infinity, true, respectProtect); break; } this._dirtyRowTracker.markDirty(this._activeBuffer.y); @@ -1474,9 +1404,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + const line = this._activeBuffer.lines.get(row)!; line.deleteCells(0, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; + this._activeBuffer.setWrapped(row, false); } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1507,9 +1438,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + this._activeBuffer.setWrapped(row, false); + const line = this._activeBuffer.lines.get(row)!; line.insertCells(0, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1530,9 +1462,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + this._activeBuffer.setWrapped(row, false); + const line = this._activeBuffer.lines.get(row)!; line.insertCells(this._activeBuffer.x, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1553,9 +1486,10 @@ export class InputHandler extends Disposable implements IInputHandler { } const param = params.params[0] || 1; for (let y = this._activeBuffer.scrollTop; y <= this._activeBuffer.scrollBottom; ++y) { - const line = this._activeBuffer.lines.get(this._activeBuffer.ybase + y)!; + const row = this._activeBuffer.ybase + y; + this._activeBuffer.setWrapped(row, false); + const line = this._activeBuffer.lines.get(row)!; line.deleteCells(this._activeBuffer.x, param, this._activeBuffer.getNullCell(this._eraseAttrData())); - line.isWrapped = false; } this._dirtyRowTracker.markRangeDirty(this._activeBuffer.scrollTop, this._activeBuffer.scrollBottom); return true; @@ -1892,7 +1826,6 @@ export class InputHandler extends Disposable implements IInputHandler { */ if (this._optionsService.rawOptions.windowOptions.setWinLines) { this._bufferService.resize(132, this._bufferService.rows); - this._onRequestReset.fire(); } break; case 6: @@ -2130,7 +2063,6 @@ export class InputHandler extends Disposable implements IInputHandler { */ if (this._optionsService.rawOptions.windowOptions.setWinLines) { this._bufferService.resize(80, this._bufferService.rows); - this._onRequestReset.fire(); } break; case 6: @@ -2647,8 +2579,9 @@ export class InputHandler extends Disposable implements IInputHandler { break; case 6: // cursor position - const y = this._activeBuffer.y + 1; - const x = this._activeBuffer.x + 1; + const buffer = this._activeBuffer; + const y = buffer.y + 1; + const x = Math.min(buffer.x + 1, this._bufferService.cols); this._coreService.triggerDataEvent(`${C0.ESC}[${y};${x}R`); break; } @@ -2832,6 +2765,11 @@ export class InputHandler extends Disposable implements IInputHandler { } const second = (params.length > 1) ? params.params[1] : 0; switch (params.params[0]) { + case 8: // resize + const newRows = params.params[1] || this._bufferService.rows; + const newCols = params.params[2] || this._bufferService.cols; + this._bufferService.resize(newCols, newRows); + break; case 14: // GetWinSizePixels, returns CSI 4 ; height ; width t if (second !== 2) { this._onRequestWindowsOptionsReport.fire(WindowsOptionsReportType.GET_WIN_SIZE_PIXELS); @@ -3367,7 +3305,7 @@ export class InputHandler extends Disposable implements IInputHandler { const line = this._activeBuffer.lines.get(row); if (line) { line.fill(cell); - line.isWrapped = false; + this._activeBuffer.setWrapped(row, false); } } this._dirtyRowTracker.markAllDirty(); diff --git a/src/common/Types.ts b/src/common/Types.ts index c254d330d1..e0e0ac0bb4 100644 --- a/src/common/Types.ts +++ b/src/common/Types.ts @@ -4,7 +4,7 @@ */ import { IDeleteEvent, IInsertEvent } from 'common/CircularList'; -import { Attributes, UnderlineStyle } from 'common/buffer/Constants'; // eslint-disable-line no-unused-vars +import { Attributes, StyleFlags, UnderlineStyle } from 'common/buffer/Constants'; // eslint-disable-line no-unused-vars import { IBufferSet } from 'common/buffer/Types'; import { IParams } from 'common/parser/Types'; import { ICoreMouseService, ICoreService, IOptionsService, IUnicodeService } from 'common/services/Services'; @@ -101,6 +101,7 @@ export interface ICharset { [key: string]: string | undefined; } +// Deprecated export type CharData = [number, string, number, number]; export interface IColor { @@ -136,12 +137,12 @@ export interface IOscLinkData { export interface IAttributeData { /** * "fg" is a 32-bit unsigned integer that stores the foreground color of the cell in the 24 least - * significant bits and additional flags in the remaining 8 bits. + * significant bits and additional flags in the remaining 8 bits. @deprecated */ fg: number; /** * "bg" is a 32-bit unsigned integer that stores the background color of the cell in the 24 least - * significant bits and additional flags in the remaining 8 bits. + * significant bits and additional flags in the remaining 8 bits. @deprecated */ bg: number; /** @@ -164,6 +165,10 @@ export interface IAttributeData { isProtected(): number; isOverline(): number; + getFg(): number; // 26 bits including CM_MASK + getBg(): number; // 26 bits including CM_MASK + getStyleFlags(): StyleFlags; + /** * The color mode of the foreground color which determines how to decode {@link getFgColor}, * possible values include {@link Attributes.CM_DEFAULT}, {@link Attributes.CM_P16}, @@ -224,21 +229,20 @@ export interface ICellData extends IAttributeData { */ export interface IBufferLine { length: number; - isWrapped: boolean; + /** If the previous line wrapped (overflows) into the current line. */ + readonly isWrapped: boolean; get(index: number): CharData; set(index: number, value: CharData): void; loadCell(index: number, cell: ICellData): ICellData; setCell(index: number, cell: ICellData): void; setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void; - addCodepointToCell(index: number, codePoint: number, width: number): void; + addCodepointToCell(index: number, codePoint: number, width: number): void; // DEPRECATED insertCells(pos: number, n: number, ch: ICellData): void; deleteCells(pos: number, n: number, fill: ICellData): void; replaceCells(start: number, end: number, fill: ICellData, respectProtect?: boolean): void; resize(cols: number, fill: ICellData): boolean; cleanupMemory(): number; fill(fillCellData: ICellData, respectProtect?: boolean): void; - copyFrom(line: IBufferLine): void; - clone(): IBufferLine; getTrimmedLength(): number; getNoBgTrimmedLength(): number; translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string; @@ -449,6 +453,8 @@ export type IColorEvent = (IColorReportRequest | IColorSetRequest | IColorRestor */ export interface IInputHandler { onTitleChange: Event; + readonly unicodeService: IUnicodeService; + precedingJoinState: number; parse(data: string | Uint8Array, promiseResult?: boolean): void | Promise; print(data: Uint32Array, start: number, end: number): void; diff --git a/src/common/WindowsMode.ts b/src/common/WindowsMode.ts index 7cff094b2c..7234180e28 100644 --- a/src/common/WindowsMode.ts +++ b/src/common/WindowsMode.ts @@ -20,8 +20,9 @@ export function updateWindowsModeWrappedState(bufferService: IBufferService): vo const line = bufferService.buffer.lines.get(bufferService.buffer.ybase + bufferService.buffer.y - 1); const lastChar = line?.get(bufferService.cols - 1); - const nextLine = bufferService.buffer.lines.get(bufferService.buffer.ybase + bufferService.buffer.y); + const nextRow = bufferService.buffer.ybase + bufferService.buffer.y; + const nextLine = bufferService.buffer.lines.get(nextRow); if (nextLine && lastChar) { - nextLine.isWrapped = (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE && lastChar[CHAR_DATA_CODE_INDEX] !== WHITESPACE_CELL_CODE); + bufferService.buffer.setWrapped(nextRow, lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE && lastChar[CHAR_DATA_CODE_INDEX] !== WHITESPACE_CELL_CODE); } } diff --git a/src/common/buffer/AttributeData.ts b/src/common/buffer/AttributeData.ts index 6221fb81d2..d40e19a29d 100644 --- a/src/common/buffer/AttributeData.ts +++ b/src/common/buffer/AttributeData.ts @@ -4,7 +4,7 @@ */ import { IAttributeData, IColorRGB, IExtendedAttrs } from 'common/Types'; -import { Attributes, FgFlags, BgFlags, UnderlineStyle, ExtFlags } from 'common/buffer/Constants'; +import { Attributes, FgFlags, BgFlags, UnderlineStyle, StyleFlags, ExtFlags } from 'common/buffer/Constants'; export class AttributeData implements IAttributeData { public static toColorRGB(value: number): IColorRGB { @@ -48,10 +48,19 @@ export class AttributeData implements IAttributeData { public isStrikethrough(): number { return this.fg & FgFlags.STRIKETHROUGH; } public isProtected(): number { return this.bg & BgFlags.PROTECTED; } public isOverline(): number { return this.bg & BgFlags.OVERLINE; } + public getStyleFlags(): StyleFlags { return ((this.fg & 0xFC000000) >>> 24) | ((this.bg & 0xFC000000) >> 16); } + public setStyleFlags(flags: StyleFlags): void { + this.fg = (this.fg & 0x03ffffff) | ((flags << 24) & 0xFC000000); + this.bg = (this.bg & 0x03ffffff) | ((flags << 16) & 0xFC000000); + } // color modes public getFgColorMode(): number { return this.fg & Attributes.CM_MASK; } public getBgColorMode(): number { return this.bg & Attributes.CM_MASK; } + public getFg(): number { return this.fg & Attributes.CM_COLOR_MASK; } + public getBg(): number { return this.bg & Attributes.CM_COLOR_MASK; } + public setFg(fg: number): void { this.fg = (fg & 0x3ffffff) | (this.fg & 0xfc000000); } + public setBg(bg: number): void { this.bg = (bg & 0x3ffffff) | (this.bg & 0xfc000000); } public isFgRGB(): boolean { return (this.fg & Attributes.CM_MASK) === Attributes.CM_RGB; } public isBgRGB(): boolean { return (this.bg & Attributes.CM_MASK) === Attributes.CM_RGB; } public isFgPalette(): boolean { return (this.fg & Attributes.CM_MASK) === Attributes.CM_P16 || (this.fg & Attributes.CM_MASK) === Attributes.CM_P256; } diff --git a/src/common/buffer/Buffer.test.ts b/src/common/buffer/Buffer.test.ts index 39cffb4900..e064d39b07 100644 --- a/src/common/buffer/Buffer.test.ts +++ b/src/common/buffer/Buffer.test.ts @@ -68,40 +68,40 @@ describe('Buffer', () => { describe('wrapped', () => { it('should return a range for the first row', () => { buffer.fillViewportRows(); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 1 }); }); it('should return a range for a middle row wrapping upwards', () => { buffer.fillViewportRows(); - buffer.lines.get(12)!.isWrapped = true; + buffer.setWrapped(12, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 11, last: 12 }); }); it('should return a range for a middle row wrapping downwards', () => { buffer.fillViewportRows(); - buffer.lines.get(13)!.isWrapped = true; + buffer.setWrapped(13, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 13 }); }); it('should return a range for a middle row wrapping both ways', () => { buffer.fillViewportRows(); - buffer.lines.get(11)!.isWrapped = true; - buffer.lines.get(12)!.isWrapped = true; - buffer.lines.get(13)!.isWrapped = true; - buffer.lines.get(14)!.isWrapped = true; + buffer.setWrapped(11, true); + buffer.setWrapped(12, true); + buffer.setWrapped(13, true); + buffer.setWrapped(14, true); assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 10, last: 14 }); }); it('should return a range for the last row', () => { buffer.fillViewportRows(); - buffer.lines.get(23)!.isWrapped = true; + buffer.setWrapped(23, true); assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 1), { first: 22, last: 23 }); }); it('should return a range for a row that wraps upward to first row', () => { buffer.fillViewportRows(); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); assert.deepEqual(buffer.getWrappedRangeForLine(1), { first: 0, last: 1 }); }); it('should return a range for a row that wraps downward to last row', () => { buffer.fillViewportRows(); - buffer.lines.get(buffer.lines.length - 1)!.isWrapped = true; + buffer.setWrapped(buffer.lines.length - 1, true); assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 2), { first: 22, last: 23 }); }); }); @@ -454,8 +454,8 @@ describe('Buffer', () => { assert.equal(buffer.lines.get(1)!.translateToString(), '0123456789'); assert.equal(buffer.lines.get(2)!.translateToString(), 'klmnopqrst'); assert.equal(firstMarker.line, 0, 'first marker should remain unchanged'); - assert.equal(secondMarker.line, 1, 'second marker should be restored to it\'s original line'); - assert.equal(thirdMarker.line, 2, 'third marker should be restored to it\'s original line'); + assert.equal(secondMarker.line, 1, 'second marker should be restored to its original line'); + assert.equal(thirdMarker.line, 2, 'third marker should be restored to its original line'); assert.equal(firstMarker.isDisposed, false); assert.equal(secondMarker.isDisposed, false); assert.equal(thirdMarker.isDisposed, false); @@ -526,7 +526,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // "ab " (wrapped) // "cd" @@ -557,7 +557,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(i, [0, '', 0, 0]); buffer.lines.get(1)!.set(i, [0, '', 0, 0]); } - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // 汉语汉语汉语 (wrapped) // 汉语汉语汉语 @@ -584,7 +584,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // "ab " (wrapped) // "cd" @@ -618,7 +618,7 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(i, [0, '', 0, 0]); buffer.lines.get(1)!.set(i, [0, '', 0, 0]); } - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); // Buffer: // 汉语汉语汉语 (wrapped) // 汉语汉语汉语 @@ -673,17 +673,17 @@ describe('Buffer', () => { buffer.lines.get(0)!.set(1, [0, 'b', 1, 'b'.charCodeAt(0)]); buffer.lines.get(1)!.set(0, [0, 'c', 1, 'c'.charCodeAt(0)]); buffer.lines.get(1)!.set(1, [0, 'd', 1, 'd'.charCodeAt(0)]); - buffer.lines.get(1)!.isWrapped = true; + buffer.setWrapped(1, true); buffer.lines.get(2)!.set(0, [0, 'e', 1, 'e'.charCodeAt(0)]); buffer.lines.get(2)!.set(1, [0, 'f', 1, 'f'.charCodeAt(0)]); buffer.lines.get(3)!.set(0, [0, 'g', 1, 'g'.charCodeAt(0)]); buffer.lines.get(3)!.set(1, [0, 'h', 1, 'h'.charCodeAt(0)]); - buffer.lines.get(3)!.isWrapped = true; + buffer.setWrapped(3, true); buffer.lines.get(4)!.set(0, [0, 'i', 1, 'i'.charCodeAt(0)]); buffer.lines.get(4)!.set(1, [0, 'j', 1, 'j'.charCodeAt(0)]); buffer.lines.get(5)!.set(0, [0, 'k', 1, 'k'.charCodeAt(0)]); buffer.lines.get(5)!.set(1, [0, 'l', 1, 'l'.charCodeAt(0)]); - buffer.lines.get(5)!.isWrapped = true; + buffer.setWrapped(5, true); }); describe('viewport not yet filled', () => { it('should move the cursor up and add empty lines', () => { @@ -740,9 +740,16 @@ describe('Buffer', () => { it('should adjust the viewport and keep ydisp = ybase', () => { buffer.ydisp = 10; buffer.resize(4, 10); - assert.equal(buffer.y, 9); - assert.equal(buffer.ydisp, 7); - assert.equal(buffer.ybase, 7); + assert.equal(buffer.ybase + buffer.y, 16); + if (false) { + // Old _reflowLargerAdjustViewport modifies ybase and ydisp + // but the logic seems wrong. ??? + assert.equal(buffer.ydisp, 7); + assert.equal(buffer.ybase, 7); + } else { + assert.equal(buffer.ydisp, 10); + assert.equal(buffer.ybase, 10); + } assert.equal(buffer.lines.length, 17); for (let i = 0; i < 10; i++) { assert.equal(buffer.lines.get(i)!.translateToString(), ' '); @@ -1104,7 +1111,7 @@ describe('Buffer', () => { describe ('translateBufferLineToString', () => { it('should handle selecting a section of ascii text', () => { - const line = new BufferLine(4); + const line = BufferLine.make(4); line.setCell(0, CellData.fromCharData([ 0, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(1, CellData.fromCharData([ 0, 'b', 1, 'b'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([ 0, 'c', 1, 'c'.charCodeAt(0)])); @@ -1116,7 +1123,7 @@ describe('Buffer', () => { }); it('should handle a cut-off double width character by including it', () => { - const line = new BufferLine(3); + const line = BufferLine.make(3); line.setCell(0, CellData.fromCharData([ 0, '語', 2, 35486 ])); line.setCell(1, CellData.fromCharData([ 0, '', 0, 0])); line.setCell(2, CellData.fromCharData([ 0, 'a', 1, 'a'.charCodeAt(0)])); @@ -1127,7 +1134,7 @@ describe('Buffer', () => { }); it('should handle a zero width character in the middle of the string by not including it', () => { - const line = new BufferLine(3); + const line = BufferLine.make(3); line.setCell(0, CellData.fromCharData([ 0, '語', 2, '語'.charCodeAt(0) ])); line.setCell(1, CellData.fromCharData([ 0, '', 0, 0])); line.setCell(2, CellData.fromCharData([ 0, 'a', 1, 'a'.charCodeAt(0)])); @@ -1144,7 +1151,7 @@ describe('Buffer', () => { }); it('should handle single width emojis', () => { - const line = new BufferLine(2); + const line = BufferLine.make(2); line.setCell(0, CellData.fromCharData([ 0, '😁', 1, '😁'.charCodeAt(0) ])); line.setCell(1, CellData.fromCharData([ 0, 'a', 1, 'a'.charCodeAt(0)])); buffer.lines.set(0, line); @@ -1157,7 +1164,7 @@ describe('Buffer', () => { }); it('should handle double width emojis', () => { - const line = new BufferLine(2); + const line = BufferLine.make(2); line.setCell(0, CellData.fromCharData([ 0, '😁', 2, '😁'.charCodeAt(0) ])); line.setCell(1, CellData.fromCharData([ 0, '', 0, 0])); buffer.lines.set(0, line); @@ -1168,7 +1175,7 @@ describe('Buffer', () => { const str2 = buffer.translateBufferLineToString(0, true, 0, 2); assert.equal(str2, '😁'); - const line2 = new BufferLine(3); + const line2 = BufferLine.make(3); line2.setCell(0, CellData.fromCharData([ 0, '😁', 2, '😁'.charCodeAt(0) ])); line2.setCell(1, CellData.fromCharData([ 0, '', 0, 0])); line2.setCell(2, CellData.fromCharData([ 0, 'a', 1, 'a'.charCodeAt(0)])); diff --git a/src/common/buffer/Buffer.ts b/src/common/buffer/Buffer.ts index 81ab156b57..b0dc76d8fb 100644 --- a/src/common/buffer/Buffer.ts +++ b/src/common/buffer/Buffer.ts @@ -7,8 +7,7 @@ import { CircularList, IInsertEvent } from 'common/CircularList'; import { IdleTaskQueue } from 'common/TaskQueue'; import { IAttributeData, IBufferLine, ICellData, ICharset } from 'common/Types'; import { ExtendedAttrs } from 'common/buffer/AttributeData'; -import { BufferLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine'; -import { getWrappedLineTrimmedLength, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from 'common/buffer/BufferReflow'; +import { BufferLine, LogicalBufferLine, WrappedBufferLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine'; import { CellData } from 'common/buffer/CellData'; import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from 'common/buffer/Constants'; import { Marker } from 'common/buffer/Marker'; @@ -29,6 +28,7 @@ export class Buffer implements IBuffer { public lines: CircularList; public ydisp: number = 0; public ybase: number = 0; + /** Row number, relative to ybase. */ public y: number = 0; public x: number = 0; public scrollBottom: number; @@ -38,6 +38,11 @@ export class Buffer implements IBuffer { public savedX: number = 0; public savedCurAttrData = DEFAULT_ATTR_DATA.clone(); public savedCharset: ICharset | undefined = DEFAULT_CHARSET; + /** Reflow may be needed for line indexes less than lastReflowNeeded. + * I.e. if i >= lastReflowNeeded then lines.get(i).reflowNeeded is false. + * Lines later in the buffer are more likly to be visible and hence + * have been updated. */ + public lastReflowNeeded: number = 0; public markers: Marker[] = []; private _nullCell: ICellData = CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); private _whitespaceCell: ICellData = CellData.fromCharData([0, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_WIDTH, WHITESPACE_CELL_CODE]); @@ -85,7 +90,7 @@ export class Buffer implements IBuffer { } public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine { - return new BufferLine(this._bufferService.cols, this.getNullCell(attr), isWrapped); + return BufferLine.make(this._bufferService.cols, this.getNullCell(attr), isWrapped); } public get hasScrollback(): boolean { @@ -113,6 +118,41 @@ export class Buffer implements IBuffer { return correctBufferLength > MAX_BUFFER_SIZE ? MAX_BUFFER_SIZE : correctBufferLength; } + public splitLine(row: number, col: number): void { // FIXME col is unused + const bufferService = this._bufferService; + const curRow = this.lines.get(this.ybase + row - 1) as BufferLine; + const nextRow = this.lines.get(this.ybase + row) as BufferLine; + let startColumn = curRow.logicalStartColumn() + bufferService.cols; + // FIXME: nextRow.logicalLine().deleteCellsOnly(bufferService.cols - col); + let newRow; + if (nextRow.isWrapped) { + newRow = nextRow as WrappedBufferLine; + } else { + newRow = new WrappedBufferLine(curRow); + // append nextRow contents to end of curRow.logicalLine() + this.lines.set(this.ybase + row, newRow); + } + const content = curRow.moveToLineColumn(startColumn); + newRow.setStartFromCache(curRow, startColumn, content); + } + + public setWrapped(absrow: number, value: boolean): void { + const line = this.lines.get(absrow); + if (! line || line.isWrapped === value) + {return;} + if (value) { + const prevRow = this.lines.get(absrow - 1) as BufferLine; + const curRow = line as LogicalBufferLine; + const newRow = curRow.setWrapped(prevRow); + this.lines.set(absrow, newRow); + } else { + const prevRow = this.lines.get(absrow - 1) as BufferLine; + const curRow = line as WrappedBufferLine; + const newRow = curRow.asUnwrapped(prevRow); + this.lines.set(absrow, newRow); + } + } + /** * Fills the buffer's viewport with blank lines. */ @@ -161,9 +201,18 @@ export class Buffer implements IBuffer { this.lines.maxLength = newMaxLength; } - // if (this._cols > newCols) { - // console.log('increase!'); - // } + if (this._cols !== newCols) { + const nlines = this.lines.length; + for (let i = 0; i < nlines; i++) { + const line = this.lines.get(i); + line && (line.length = newCols); + if (line instanceof LogicalBufferLine + && (line.nextRowSameLine || line.logicalWidth > newCols)) { + line.reflowNeeded = true; + this.lastReflowNeeded = Math.max(i, this.lastReflowNeeded); + } + } + } // The following adjustments should only happen if the buffer has been // initialized/filled. @@ -182,9 +231,9 @@ export class Buffer implements IBuffer { for (let y = this._rows; y < newRows; y++) { if (this.lines.length < newRows + this.ybase) { if (this._optionsService.rawOptions.windowsMode || this._optionsService.rawOptions.windowsPty.backend !== undefined || this._optionsService.rawOptions.windowsPty.buildNumber !== undefined) { - // Just add the new missing rows on Windows as conpty reprints the screen with it's + // Just add the new missing rows on Windows as conpty reprints the screen with its // view of the world. Once a line enters scrollback for conpty it remains there - this.lines.push(new BufferLine(newCols, nullCell)); + this.lines.push(BufferLine.make(newCols, nullCell)); } else { if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) { // There is room above the buffer and there are no empty elements below the line, @@ -198,7 +247,7 @@ export class Buffer implements IBuffer { } else { // Add a blank line if there is no buffer left at the top to scroll to, or if there // are blank lines after the cursor - this.lines.push(new BufferLine(newCols, nullCell)); + this.lines.push(BufferLine.make(newCols, nullCell)); } } } @@ -233,7 +282,7 @@ export class Buffer implements IBuffer { } // Make sure that the cursor stays on screen - this.x = Math.min(this.x, newCols - 1); + this.x = Math.min(this.x, newCols); this.y = Math.min(this.y, newRows - 1); if (addToY) { this.y += addToY; @@ -245,52 +294,27 @@ export class Buffer implements IBuffer { this.scrollBottom = newRows - 1; - if (this._isReflowEnabled) { - this._reflow(newCols, newRows); - - // Trim the end of the line off if cols shrunk - if (this._cols > newCols) { - for (let i = 0; i < this.lines.length; i++) { - // +boolean for fast 0 or 1 conversion - dirtyMemoryLines += +this.lines.get(i)!.resize(newCols, nullCell); - } - } - } - + const lazyReflow = false; // FUTURE - change to true? + const reflowNow = this._isReflowEnabled && this._cols !== newCols && ! lazyReflow; this._cols = newCols; this._rows = newRows; - - this._memoryCleanupQueue.clear(); - // schedule memory cleanup only, if more than 10% of the lines are affected - if (dirtyMemoryLines > 0.1 * this.lines.length) { - this._memoryCleanupPosition = 0; - this._memoryCleanupQueue.enqueue(() => this._batchedMemoryCleanup()); - } - } - - private _memoryCleanupQueue = new IdleTaskQueue(); - private _memoryCleanupPosition = 0; - - private _batchedMemoryCleanup(): boolean { - let normalRun = true; - if (this._memoryCleanupPosition >= this.lines.length) { - // cleanup made it once through all lines, thus rescan in loop below to also catch shifted - // lines, which should finish rather quick if there are no more cleanups pending - this._memoryCleanupPosition = 0; - normalRun = false; - } - let counted = 0; - while (this._memoryCleanupPosition < this.lines.length) { - counted += this.lines.get(this._memoryCleanupPosition++)!.cleanupMemory(); - // cleanup max 100 lines per batch - if (counted > 100) { - return true; + this.reflowRegion(reflowNow ? 0 : this.ydisp, this.lines.length, + reflowNow? -1 : newRows); + // Reduce max length if needed after adjustments, this is done after as it + // would otherwise cut data from the bottom of the buffer. + if (newMaxLength < this.lines.maxLength) { + // Trim from the top of the buffer and adjust ybase and ydisp. + const amountToTrim = this.lines.length - newMaxLength; + if (amountToTrim > 0) { + this.setWrapped(amountToTrim, false); + this.lines.trimStart(amountToTrim); + this.ybase = Math.max(this.ybase - amountToTrim, 0); + this.ydisp = Math.max(this.ydisp - amountToTrim, 0); + this.savedY = Math.max(this.savedY - amountToTrim, 0); } + this.lines.maxLength = newMaxLength; } - // normal runs always need another rescan afterwards - // if we made it here with normalRun=false, we are in a final run - // and can end the cleanup task for sure - return normalRun; + this._fixupPosition(); } private get _isReflowEnabled(): boolean { @@ -301,225 +325,199 @@ export class Buffer implements IBuffer { return this._hasScrollback && !this._optionsService.rawOptions.windowsMode; } - private _reflow(newCols: number, newRows: number): void { - if (this._cols === newCols) { + public reflowRegion(startRow: number, endRow: number, maxRows: number): void { + if (startRow > this.lastReflowNeeded) { return; } - - // Iterate through rows, ignore the last one as it cannot be wrapped - if (newCols > this._cols) { - this._reflowLarger(newCols, newRows); - } else { - this._reflowSmaller(newCols, newRows); + if (endRow >= this.lastReflowNeeded) { + this.lastReflowNeeded = startRow; } - } - - private _reflowLarger(newCols: number, newRows: number): void { - const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine; - const toRemove: number[] = reflowLargerGetLinesToRemove(this.lines, this._cols, newCols, this.ybase + this.y, this.getNullCell(DEFAULT_ATTR_DATA), reflowCursorLine); - if (toRemove.length > 0) { - const newLayoutResult = reflowLargerCreateNewLayout(this.lines, toRemove); - reflowLargerApplyNewLayout(this.lines, newLayoutResult.layout); - this._reflowLargerAdjustViewport(newCols, newRows, newLayoutResult.countRemoved); + const newCols = this._cols; + while (startRow > 0 && this.lines.get(startRow)?.isWrapped) { + startRow--; + if (maxRows >= 0) { maxRows++; } } - } - - private _reflowLargerAdjustViewport(newCols: number, newRows: number, countRemoved: number): void { - const nullCell = this.getNullCell(DEFAULT_ATTR_DATA); - // Adjust viewport based on number of items removed - let viewportAdjustments = countRemoved; - while (viewportAdjustments-- > 0) { - if (this.ybase === 0) { - if (this.y > 0) { - this.y--; + // POSSIBLE OPTIMIZATION: Don't need to allocate newRows if no lines + // require more rows than before. So better to allocate newRows lazily. + const newRows: BufferLine[] = []; + const yDispOld = this.ydisp; + const yBaseOld = this.ybase; + const yAbsOld = yBaseOld + this.y; + let yAbs = yAbsOld; + const ySavedOld = this.savedY; + let ySaved = ySavedOld; + let deltaSoFar = 0; + // Record buffer insert/delete events + const insertEvents: IInsertEvent[] = []; + let oldRows: (IBufferLine|undefined)[] = []; + for (let j = 0; j < this.lines.length; j++) { oldRows.push(this.lines.get(j));} + for (let row = startRow; row < endRow;) { + if (maxRows >= 0 && newRows.length > maxRows) { + endRow = row; + break; + } + const line = this.lines.get(row) as BufferLine; + newRows.push(line); + if (line instanceof LogicalBufferLine && line.reflowNeeded) { + let curRow: BufferLine = line; + + let logicalX, logicalSavedX = this.savedX; + let oldWrapCount = 0; // number of following wrapped lines + let nextRow = curRow; + for (; ; oldWrapCount++) { + if (yAbsOld === row + oldWrapCount) { + logicalX = nextRow.logicalStartColumn() + this.x; + } + if (ySavedOld === row + oldWrapCount) { + logicalSavedX = nextRow.logicalStartColumn() + this.savedX; + } + if (! nextRow.nextRowSameLine || row + oldWrapCount + 1 >= endRow) { + break; + } + nextRow = nextRow.nextRowSameLine; } - if (this.lines.length < newRows) { - // Add an extra row at the bottom of the viewport - this.lines.push(new BufferLine(newCols, nullCell)); + const lineRow = row; + row++; + const newWrapStart = newRows.length; + line.reflowNeeded = false; + let startCol = 0; + const dataLength = line.dataLength(); + + // Loop over new WrappedBufferLines for current LogicalBufferLine, + // based on newCols width. Re-use old WrappedBufferLine if available. + for (;;) { + const endCol = startCol + newCols; + const content = line.moveToLineColumn(endCol); + const idata = line._cachedDataIndex(); + if (idata >= dataLength) { + curRow.nextRowSameLine = undefined; + break; + } + const newRow1 = row < endRow && this.lines.get(row); + const newRow = newRow1 instanceof WrappedBufferLine + ? (row++, newRow1) + : new WrappedBufferLine(curRow); + newRow.setStartFromCache(line, endCol, content); + startCol = newRow.startColumn; + newRows.push(newRow); + curRow = newRow; } - } else { - if (this.ydisp === this.ybase) { - this.ydisp--; + // Skip old WrappedBufferLines that we no longer need. + while (row < endRow + && this.lines.get(row) instanceof WrappedBufferLine) { + row++; } - this.ybase--; - } - } - this.savedY = Math.max(this.savedY - countRemoved, 0); - } - - private _reflowSmaller(newCols: number, newRows: number): void { - const reflowCursorLine = this._optionsService.rawOptions.reflowCursorLine; - const nullCell = this.getNullCell(DEFAULT_ATTR_DATA); - // Gather all BufferLines that need to be inserted into the Buffer here so that they can be - // batched up and only committed once - const toInsert = []; - let countToInsert = 0; - // Go backwards as many lines may be trimmed and this will avoid considering them - for (let y = this.lines.length - 1; y >= 0; y--) { - // Check whether this line is a problem - let nextLine = this.lines.get(y) as BufferLine; - if (!nextLine || !nextLine.isWrapped && nextLine.getTrimmedLength() <= newCols) { - continue; - } - - // Gather wrapped lines and adjust y to be the starting line - const wrappedLines: BufferLine[] = [nextLine]; - while (nextLine.isWrapped && y > 0) { - nextLine = this.lines.get(--y) as BufferLine; - wrappedLines.unshift(nextLine); - } - - if (!reflowCursorLine) { - // If these lines contain the cursor don't touch them, the program will handle fixing up - // wrapped lines with the cursor - const absoluteY = this.ybase + this.y; - if (absoluteY >= y && absoluteY < y + wrappedLines.length) { - continue; + const newWrapCount = newRows.length - newWrapStart; + if (yBaseOld >= lineRow && yBaseOld <= lineRow + oldWrapCount) { + this.ybase = lineRow + deltaSoFar + + Math.min(yBaseOld - lineRow, newWrapCount); } - } - - const lastLineLength = wrappedLines[wrappedLines.length - 1].getTrimmedLength(); - const destLineLengths = reflowSmallerGetNewLineLengths(wrappedLines, this._cols, newCols); - const linesToAdd = destLineLengths.length - wrappedLines.length; - let trimmedLines: number; - if (this.ybase === 0 && this.y !== this.lines.length - 1) { - // If the top section of the buffer is not yet filled - trimmedLines = Math.max(0, this.y - this.lines.maxLength + linesToAdd); - } else { - trimmedLines = Math.max(0, this.lines.length - this.lines.maxLength + linesToAdd); - } - - // Add the new lines - const newLines: BufferLine[] = []; - for (let i = 0; i < linesToAdd; i++) { - const newLine = this.getBlankLine(DEFAULT_ATTR_DATA, true) as BufferLine; - newLines.push(newLine); - } - if (newLines.length > 0) { - toInsert.push({ - // countToInsert here gets the actual index, taking into account other inserted items. - // using this we can iterate through the list forwards - start: y + wrappedLines.length + countToInsert, - newLines - }); - countToInsert += newLines.length; - } - wrappedLines.push(...newLines); - - // Copy buffer data to new locations, this needs to happen backwards to do in-place - let destLineIndex = destLineLengths.length - 1; // Math.floor(cellsNeeded / newCols); - let destCol = destLineLengths[destLineIndex]; // cellsNeeded % newCols; - if (destCol === 0) { - destLineIndex--; - destCol = destLineLengths[destLineIndex]; - } - let srcLineIndex = wrappedLines.length - linesToAdd - 1; - let srcCol = lastLineLength; - while (srcLineIndex >= 0) { - const cellsToCopy = Math.min(srcCol, destCol); - if (wrappedLines[destLineIndex] === undefined) { - // Sanity check that the line exists, this has been known to fail for an unknown reason - // which would stop the reflow from happening if an exception would throw. - break; + if (yDispOld >= lineRow && yDispOld <= lineRow + oldWrapCount) { + this.ydisp = lineRow + deltaSoFar + + Math.min(yDispOld - lineRow, newWrapCount); } - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol - cellsToCopy, destCol - cellsToCopy, cellsToCopy, true); - destCol -= cellsToCopy; - if (destCol === 0) { - destLineIndex--; - destCol = destLineLengths[destLineIndex]; + if (logicalX !== undefined) { // update cursor x and y + let i = newWrapStart; + while (i < newRows.length && newRows[i].logicalStartColumn() <= logicalX) { i++; } + yAbs = startRow + i - 1 + deltaSoFar; + this.x = logicalX - newRows[i-1].logicalStartColumn(); } - srcCol -= cellsToCopy; - if (srcCol === 0) { - srcLineIndex--; - const wrappedLinesIndex = Math.max(srcLineIndex, 0); - srcCol = getWrappedLineTrimmedLength(wrappedLines, wrappedLinesIndex, this._cols); + if (logicalSavedX !== undefined) { // update cursor savedX and savedY + let i = newWrapStart; + while (i < newRows.length && newRows[i].logicalStartColumn() <= logicalSavedX) { i++; } + ySaved = startRow + i - 1 + deltaSoFar; + this.savedX = logicalSavedX - newRows[i-1].logicalStartColumn(); } - } - - // Null out the end of the line ends if a wide character wrapped to the following line - for (let i = 0; i < wrappedLines.length; i++) { - if (destLineLengths[i] < newCols) { - wrappedLines[i].setCell(destLineLengths[i], nullCell); + if (newWrapCount != oldWrapCount) { + // Create insert events for later + insertEvents.push({ + index: lineRow + deltaSoFar + 1, + amount: newWrapCount - oldWrapCount + }); + } + deltaSoFar += newWrapCount - oldWrapCount; + } else { + if (row + deltaSoFar === yBaseOld) { this.ybase = yBaseOld + deltaSoFar; } + if (row + deltaSoFar === yDispOld) { this.ydisp = yDispOld + deltaSoFar; } + if (row === yAbsOld) { + yAbs += deltaSoFar; + } + if (row === ySavedOld) { + ySaved += deltaSoFar; } + row++; } - - // Adjust viewport as needed - let viewportAdjustments = linesToAdd - trimmedLines; - while (viewportAdjustments-- > 0) { - if (this.ybase === 0) { - if (this.y < newRows - 1) { - this.y++; - this.lines.pop(); - } else { - this.ybase++; - this.ydisp++; - } - } else { - // Ensure ybase does not exceed its maximum value - if (this.ybase < Math.min(this.lines.maxLength, this.lines.length + countToInsert) - newRows) { - if (this.ybase === this.ydisp) { - this.ydisp++; - } - this.ybase++; - } + } + if (deltaSoFar !== 0) { + if (yAbsOld >= endRow) { yAbs += deltaSoFar; } + if (ySavedOld >= endRow) { ySaved += deltaSoFar; } + if (yBaseOld >= endRow) { this.ybase = yBaseOld + deltaSoFar; } + if (yDispOld >= endRow) { this.ydisp = yDispOld + deltaSoFar; } + } + this.y = yAbs - this.ybase; + this.savedY = ySaved; + const oldLinesCount = this.lines.length; + let trimNeeded = oldLinesCount + newRows.length - (endRow - startRow) + - this.lines.maxLength; + if (trimNeeded > 0) { + this.ybase -= trimNeeded; + this.ydisp -= trimNeeded; + if (trimNeeded > startRow) { + const trimNew = trimNeeded - startRow; + const firstNewRow = newRows[trimNew]; + if (firstNewRow instanceof WrappedBufferLine) { + newRows[trimNew] = firstNewRow.asUnwrapped(/*PREVIOUS*/); } + newRows.splice(0, trimNew); + trimNeeded -= trimNew; } - this.savedY = Math.min(this.savedY + linesToAdd, this.ybase + newRows - 1); } - - // Rearrange lines in the buffer if there are any insertions, this is done at the end rather - // than earlier so that it's a single O(n) pass through the buffer, instead of O(n^2) from many - // costly calls to CircularList.splice. - if (toInsert.length > 0) { - // Record buffer insert events and then play them back backwards so that the indexes are - // correct - const insertEvents: IInsertEvent[] = []; - - // Record original lines so they don't get overridden when we rearrange the list - const originalLines: BufferLine[] = []; - for (let i = 0; i < this.lines.length; i++) { - originalLines.push(this.lines.get(i) as BufferLine); + this.lines.spliceNoTrim(startRow, endRow - startRow, newRows, false); + if (trimNeeded > 0) { + this.setWrapped(trimNeeded,false); + this.lines.trimIfNeeded(); + } + // Update markers + const insertCount = insertEvents.length; + for (let i = 0; i < insertCount; i++) { + const event = insertEvents[i]; + if (event.amount < 0) { + event.amount = - event.amount; + this.lines.onDeleteEmitter.fire(event); + } else { + this.lines.onInsertEmitter.fire(event); } - const originalLinesLength = this.lines.length; - - let originalLineIndex = originalLinesLength - 1; - let nextToInsertIndex = 0; - let nextToInsert = toInsert[nextToInsertIndex]; - this.lines.length = Math.min(this.lines.maxLength, this.lines.length + countToInsert); - let countInsertedSoFar = 0; - for (let i = Math.min(this.lines.maxLength - 1, originalLinesLength + countToInsert - 1); i >= 0; i--) { - if (nextToInsert && nextToInsert.start > originalLineIndex + countInsertedSoFar) { - // Insert extra lines here, adjusting i as needed - for (let nextI = nextToInsert.newLines.length - 1; nextI >= 0; nextI--) { - this.lines.set(i--, nextToInsert.newLines[nextI]); - } - i++; + } + this._fixupPosition(); + } - // Create insert events for later - insertEvents.push({ - index: originalLineIndex + 1, - amount: nextToInsert.newLines.length - }); + private _fixupPosition(): void { + const cols = this._cols; + const rows = this._rows; - countInsertedSoFar += nextToInsert.newLines.length; - nextToInsert = toInsert[++nextToInsertIndex]; - } else { - this.lines.set(i, originalLines[originalLineIndex--]); - } - } - - // Update markers - let insertCountEmitted = 0; - for (let i = insertEvents.length - 1; i >= 0; i--) { - insertEvents[i].index += insertCountEmitted; - this.lines.onInsertEmitter.fire(insertEvents[i]); - insertCountEmitted += insertEvents[i].amount; - } - const amountToTrim = Math.max(0, originalLinesLength + countToInsert - this.lines.maxLength); - if (amountToTrim > 0) { - this.lines.onTrimEmitter.fire(amountToTrim); - } + let ilast = this.lines.length - 1; + while (ilast >= rows && this.ybase + this.y = rows) { + const adjust = this.y - rows + 1; + this.ydisp += adjust; + this.ybase += adjust; + this.y -= adjust; } + while (this.lines.length < rows) { + this.lines.push(new LogicalBufferLine(cols)); + } + const adjust = this.lines.length - this.ybase - rows; + if (adjust > 0) { + this.ybase += adjust; + this.y -= adjust; + } + const yy=this.ydisp; + this.ydisp = Math.max(0, Math.min(this.ydisp, this.lines.length)); } /** @@ -659,4 +657,40 @@ export class Buffer implements IBuffer { this.markers.splice(this.markers.indexOf(marker), 1); } } + + // for DEBUGGING + public noteError(msg: string): void { + console.log('ERROR: ' + msg); + } + + // for DEBUGGING + public checkLines(report = this.noteError): void { + const nlines = this.lines.length; + let prevRow: IBufferLine | undefined; + let logicalLine; + for (let i = 0; i < nlines; i++) { + const curRow = this.lines.get(i); + if (curRow instanceof LogicalBufferLine) { + if (curRow.isWrapped) { report('wrapped should not be set'); } + logicalLine = curRow; + } else if (curRow instanceof WrappedBufferLine) { + if (curRow.logicalLine() !== logicalLine) { + report('wrapped line points to wrong logical line') + } + if (! curRow.isWrapped) { report('wrapped should be set'); } + if (prevRow instanceof BufferLine) { + if (prevRow.nextRowSameLine !== curRow) { + report('bad previous nextRowSameLine'); + } + if (prevRow.logicalStartColumn() > curRow.logicalStartColumn()) + { report('bad logicalStartColumn'); } + } else { + report('bad previous line before Wrapped'); + } + } else if (! curRow) { + report('undefined line in lines list'); + } + prevRow = curRow; + } + } } diff --git a/src/common/buffer/BufferLine.test.ts b/src/common/buffer/BufferLine.test.ts index 9d08c2bef6..4302ba181e 100644 --- a/src/common/buffer/BufferLine.test.ts +++ b/src/common/buffer/BufferLine.test.ts @@ -5,23 +5,16 @@ import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR, Content, UnderlineStyle, BgFlags, Attributes, FgFlags } from 'common/buffer/Constants'; import { BufferLine } from 'common/buffer//BufferLine'; import { CellData } from 'common/buffer/CellData'; -import { CharData, IBufferLine } from '../Types'; +import { CharData, IBufferLine, IExtendedAttrs } from '../Types'; import { assert } from 'chai'; import { AttributeData } from 'common/buffer/AttributeData'; - -class TestBufferLine extends BufferLine { - public get combined(): {[index: number]: string} { - return this._combined; - } - - public toArray(): CharData[] { - const result = []; - for (let i = 0; i < this.length; ++i) { - result.push(this.loadCell(i, new CellData()).getAsCharData()); - } - return result; +function lineToArray(line: IBufferLine): CharData[] { + const result = []; + for (let i = 0; i < line.length; ++i) { + result.push(line.loadCell(i, new CellData()).getAsCharData()); } + return result; } describe('AttributeData', () => { @@ -162,178 +155,149 @@ describe('CellData', () => { describe('BufferLine', function(): void { it('ctor', function(): void { - let line: IBufferLine = new TestBufferLine(0); + let line: IBufferLine = BufferLine.make(0); assert.equal(line.length, 0); assert.equal(line.isWrapped, false); - line = new TestBufferLine(10); + line = BufferLine.make(10); assert.equal(line.length, 10); assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); assert.equal(line.isWrapped, false); - line = new TestBufferLine(10, undefined, true); + line = BufferLine.make(10, undefined, true); assert.equal(line.length, 10); assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); assert.equal(line.isWrapped, true); - line = new TestBufferLine(10, CellData.fromCharData([123, 'a', 456, 'a'.charCodeAt(0)]), true); + line = BufferLine.make(10, CellData.fromCharData([123, 'a', 1, 'a'.charCodeAt(0)]), true); assert.equal(line.length, 10); - assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [123, 'a', 456, 'a'.charCodeAt(0)]); + assert.deepEqual(line.loadCell(0, new CellData()).getAsCharData(), [123, 'a', 1, 'a'.charCodeAt(0)]); assert.equal(line.isWrapped, true); }); it('insertCells', function(): void { - const line = new TestBufferLine(3); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.insertCells(1, 3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), [ - [1, 'a', 0, 'a'.charCodeAt(0)], - [4, 'd', 0, 'd'.charCodeAt(0)], - [4, 'd', 0, 'd'.charCodeAt(0)] + const line = BufferLine.make(3); + line.setCell(0, CellData.fromChar('a', 1, 1)); + line.setCell(1, CellData.fromChar('b', 1, 2)); + line.setCell(2, CellData.fromChar('c', 1, 3)); + line.insertCells(1, 3, CellData.fromChar('d', 1, 4)); + assert.deepEqual(lineToArray(line), [ + [1, 'a', 1, 'a'.charCodeAt(0)], + [4, 'd', 1, 'd'.charCodeAt(0)], + [4, 'd', 1, 'd'.charCodeAt(0)] ]); + (line as any).xyz = 0; }); it('deleteCells', function(): void { - const line = new TestBufferLine(5); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)])); - line.deleteCells(1, 2, CellData.fromCharData([6, 'f', 0, 'f'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), [ - [1, 'a', 0, 'a'.charCodeAt(0)], - [4, 'd', 0, 'd'.charCodeAt(0)], - [5, 'e', 0, 'e'.charCodeAt(0)], - [6, 'f', 0, 'f'.charCodeAt(0)], - [6, 'f', 0, 'f'.charCodeAt(0)] + const line = BufferLine.make(5); + line.setCell(0, CellData.fromChar('a', 1, 1)); + line.setCell(1, CellData.fromChar('b', 1, 2)); + line.setCell(2, CellData.fromChar('c', 1, 3)); + line.setCell(3, CellData.fromChar('d', 1, 4)); + line.setCell(4, CellData.fromChar('e', 1, 5)); + line.deleteCells(1, 2, CellData.fromChar('f', 1, 6)); + assert.deepEqual(lineToArray(line), [ + [1, 'a', 1, 'a'.charCodeAt(0)], + [4, 'd', 1, 'd'.charCodeAt(0)], + [5, 'e', 1, 'e'.charCodeAt(0)], + [6, 'f', 1, 'f'.charCodeAt(0)], + [6, 'f', 1, 'f'.charCodeAt(0)] ]); }); it('replaceCells', function(): void { - const line = new TestBufferLine(5); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)])); - line.replaceCells(2, 4, CellData.fromCharData([6, 'f', 0, 'f'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), [ - [1, 'a', 0, 'a'.charCodeAt(0)], - [2, 'b', 0, 'b'.charCodeAt(0)], - [6, 'f', 0, 'f'.charCodeAt(0)], - [6, 'f', 0, 'f'.charCodeAt(0)], - [5, 'e', 0, 'e'.charCodeAt(0)] + const line = BufferLine.make(5); + line.setCell(0, CellData.fromChar('a', 1, 1)); + line.setCell(1, CellData.fromChar('b', 1, 2)); + line.setCell(2, CellData.fromChar('c', 1, 3)); + line.setCell(3, CellData.fromChar('d', 1, 4)); + line.setCell(4, CellData.fromChar('e', 1, 5)); + line.replaceCells(2, 4, CellData.fromChar('f', 1, 6)); + assert.deepEqual(lineToArray(line), [ + [1, 'a', 1, 'a'.charCodeAt(0)], + [2, 'b', 1, 'b'.charCodeAt(0)], + [6, 'f', 1, 'f'.charCodeAt(0)], + [6, 'f', 1, 'f'.charCodeAt(0)], + [5, 'e', 1, 'e'.charCodeAt(0)] ]); }); it('fill', function(): void { - const line = new TestBufferLine(5); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)])); - line.fill(CellData.fromCharData([123, 'z', 0, 'z'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), [ - [123, 'z', 0, 'z'.charCodeAt(0)], - [123, 'z', 0, 'z'.charCodeAt(0)], - [123, 'z', 0, 'z'.charCodeAt(0)], - [123, 'z', 0, 'z'.charCodeAt(0)], - [123, 'z', 0, 'z'.charCodeAt(0)] + const line = BufferLine.make(5); + line.setCell(0, CellData.fromChar('a', 1, 1)); + line.setCell(1, CellData.fromChar('b', 1, 2)); + line.setCell(2, CellData.fromChar('c', 1, 3)); + line.setCell(3, CellData.fromChar('d', 1, 4)); + line.setCell(4, CellData.fromChar('e', 1, 5)); + line.fill(CellData.fromChar('z', 1, 123)); + assert.deepEqual(lineToArray(line), [ + [123, 'z', 1, 'z'.charCodeAt(0)], + [123, 'z', 1, 'z'.charCodeAt(0)], + [123, 'z', 1, 'z'.charCodeAt(0)], + [123, 'z', 1, 'z'.charCodeAt(0)], + [123, 'z', 1, 'z'.charCodeAt(0)] ]); }); - it('clone', function(): void { - const line = new TestBufferLine(5, undefined, true); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)])); - const line2 = line.clone(); - assert.deepEqual(TestBufferLine.prototype.toArray.apply(line2), line.toArray()); - assert.equal(line2.length, line.length); - assert.equal(line2.isWrapped, line.isWrapped); - }); - it('copyFrom', function(): void { - const line = new TestBufferLine(5); - line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)])); - line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)])); - line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)])); - line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)])); - const line2 = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), true); - line2.copyFrom(line); - assert.deepEqual(line2.toArray(), line.toArray()); - assert.equal(line2.length, line.length); - assert.equal(line2.isWrapped, line.isWrapped); - }); it('should support combining chars', function(): void { // CHAR_DATA_CODE_INDEX resembles current behavior in InputHandler.print // --> set code to the last charCodeAt value of the string // Note: needs to be fixed once the string pointer is in place - const line = new TestBufferLine(2, CellData.fromCharData([1, 'e\u0301', 0, '\u0301'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), [[1, 'e\u0301', 0, '\u0301'.charCodeAt(0)], [1, 'e\u0301', 0, '\u0301'.charCodeAt(0)]]); - const line2 = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, '\u0301'.charCodeAt(0)]), true); - line2.copyFrom(line); - assert.deepEqual(line2.toArray(), line.toArray()); - const line3 = line.clone(); - assert.deepEqual(TestBufferLine.prototype.toArray.apply(line3), line.toArray()); + const line = BufferLine.make(2, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)])); + assert.deepEqual(lineToArray(line), [[1, 'e\u0301', 1, '\u0301'.charCodeAt(0)], [1, 'e\u0301', 1, '\u0301'.charCodeAt(0)]]); }); describe('resize', function(): void { it('enlarge(false)', function(): void { - const line = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); - line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), (Array(10) as any).fill([1, 'a', 0, 'a'.charCodeAt(0)])); + const line = BufferLine.make(5, CellData.fromChar('a', 1, 1), false); + line.resize(10, CellData.fromChar('a', 1, 1)); + assert.deepEqual(lineToArray(line), (Array(10) as any).fill([1, 'a', 1, 'a'.charCodeAt(0)])); }); it('enlarge(true)', function(): void { - const line = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); - line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), (Array(10) as any).fill([1, 'a', 0, 'a'.charCodeAt(0)])); + const line = BufferLine.make(5, CellData.fromChar('a', 1, 1), false); + line.resize(10, CellData.fromChar('a', 1, 1)); + assert.deepEqual(lineToArray(line), (Array(10) as any).fill([1, 'a', 1, 'a'.charCodeAt(0)])); }); it('shrink(true) - should apply new size', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); - line.resize(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), (Array(5) as any).fill([1, 'a', 0, 'a'.charCodeAt(0)])); + const line = BufferLine.make(10, CellData.fromChar('a', 1, 1)); + line.resize(5, CellData.fromChar('a', 1, 1)); + assert.deepEqual(lineToArray(line), (Array(5) as any).fill([1, 'a', 1, 'a'.charCodeAt(0)])); }); it('shrink to 0 length', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); + const line = BufferLine.make(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); line.resize(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); - assert.deepEqual(line.toArray(), (Array(0) as any).fill([1, 'a', 0, 'a'.charCodeAt(0)])); + assert.deepEqual(lineToArray(line), (Array(0) as any).fill([1, 'a', 0, 'a'.charCodeAt(0)])); }); it('should remove combining data on replaced cells after shrinking then enlarging', () => { - const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); + const line = BufferLine.make(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false); line.set(2, [ 0, '😁', 1, '😁'.charCodeAt(0) ]); line.set(9, [ 0, '😁', 1, '😁'.charCodeAt(0) ]); assert.equal(line.translateToString(), 'aa😁aaaaaa😁'); - assert.equal(Object.keys(line.combined).length, 2); + // assert.equal(Object.keys(line.combined).length, 2); line.resize(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aa😁aa'); line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aa😁aaaaaaa'); - assert.equal(Object.keys(line.combined).length, 1); + // assert.equal(Object.keys(line.combined).length, 1); }); }); describe('getTrimLength', function(): void { it('empty line', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); assert.equal(line.getTrimmedLength(), 0); }); it('ASCII', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.getTrimmedLength(), 3); }); it('surrogate', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)])); assert.equal(line.getTrimmedLength(), 3); }); it('combining', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)])); assert.equal(line.getTrimmedLength(), 3); }); it('fullwidth', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)])); line.setCell(3, CellData.fromCharData([0, '', 0, 0])); @@ -342,7 +306,7 @@ describe('BufferLine', function(): void { }); describe('translateToString with and w\'o trimming', function(): void { it('empty line', function(): void { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); const columns: number[] = []; assert.equal(line.translateToString(false, undefined, undefined, columns), ' '); assert.deepEqual(columns, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); @@ -351,7 +315,7 @@ describe('BufferLine', function(): void { }); it('ASCII', function(): void { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(4, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); @@ -372,7 +336,7 @@ describe('BufferLine', function(): void { }); it('surrogate', function(): void { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)])); line.setCell(4, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)])); @@ -392,7 +356,7 @@ describe('BufferLine', function(): void { }); it('combining', function(): void { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)])); line.setCell(4, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)])); @@ -412,7 +376,7 @@ describe('BufferLine', function(): void { }); it('fullwidth', function(): void { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)])); line.setCell(3, CellData.fromCharData([0, '', 0, 0])); @@ -441,7 +405,7 @@ describe('BufferLine', function(): void { }); it('space at end', function(): void { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); line.setCell(4, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); @@ -457,7 +421,7 @@ describe('BufferLine', function(): void { // sanity check - broken line with invalid out of bound null width cells // this can atm happen with deleting/inserting chars in inputhandler by "breaking" // fullwidth pairs --> needs to be fixed after settling BufferLine impl - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); assert.equal(line.translateToString(false, undefined, undefined, columns), ' '); assert.deepEqual(columns, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); assert.equal(line.translateToString(true, undefined, undefined, columns), ''); @@ -465,7 +429,7 @@ describe('BufferLine', function(): void { }); it('should work with endCol=0', () => { const columns: number[] = []; - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(true, 0, 0, columns), ''); assert.deepEqual(columns, [0]); @@ -473,7 +437,7 @@ describe('BufferLine', function(): void { }); describe('addCharToCell', () => { it('should set width to 1 for empty cell', () => { - const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); line.addCodepointToCell(0, '\u0301'.charCodeAt(0), 0); const cell = line.loadCell(0, new CellData()); // chars contains single combining char @@ -483,8 +447,8 @@ describe('BufferLine', function(): void { assert.equal(cell.isCombined(), 0); }); it('should add char to combining string in cell', () => { - const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); - const cell = line .loadCell(0, new CellData()); + const line = BufferLine.make(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const cell = line.loadCell(0, new CellData()); cell.setFromCharData([123, 'e\u0301', 1, 'e\u0301'.charCodeAt(1)]); line.setCell(0, cell); line.addCodepointToCell(0, '\u0301'.charCodeAt(0), 0); @@ -496,7 +460,7 @@ describe('BufferLine', function(): void { assert.equal(cell.isCombined(), Content.IS_COMBINED_MASK); }); it('should create combining string on taken cell', () => { - const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); + const line = BufferLine.make(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false); const cell = line .loadCell(0, new CellData()); cell.setFromCharData([123, 'e', 1, 'e'.charCodeAt(1)]); line.setCell(0, cell); @@ -517,7 +481,7 @@ describe('BufferLine', function(): void { } } it('insert - wide char at pos', () => { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.insertCells(9, 1, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), '￥￥￥￥ a'); @@ -527,7 +491,7 @@ describe('BufferLine', function(): void { assert.equal(line.translateToString(), ' a ￥￥￥a'); }); it('insert - wide char at end', () => { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.insertCells(0, 3, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aaa￥￥￥ '); @@ -537,7 +501,7 @@ describe('BufferLine', function(): void { assert.equal(line.translateToString(), 'aaa aa ￥ '); }); it('delete', () => { - const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + const line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.deleteCells(0, 1, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' ￥￥￥￥a'); @@ -547,62 +511,67 @@ describe('BufferLine', function(): void { assert.equal(line.translateToString(), ' ￥￥aaaaa'); }); it('replace - start at 0', () => { - let line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + let line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 1, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'a ￥￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aa￥￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 3, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aaa ￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 8, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aaaaaaaa￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 9, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aaaaaaaaa '); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(0, 10, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), 'aaaaaaaaaa'); }); it('replace - start at 1', () => { - let line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + let line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' a￥￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 3, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' aa ￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 4, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' aaa￥￥￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 8, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' aaaaaaa￥'); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 9, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' aaaaaaaa '); - line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); + line = BufferLine.make(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false); populate(line); line.replaceCells(1, 10, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)])); assert.equal(line.translateToString(), ' aaaaaaaaa'); }); }); describe('extended attributes', () => { + function extendedAttributes(line: BufferLine, index: number): IExtendedAttrs | undefined { + const cell = new CellData(); + line.loadCell(index, cell); + return cell.hasExtendedAttrs() !== 0 ? cell.extended : undefined; + } it('setCells', function(): void { - const line = new TestBufferLine(5); - const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); + const line = BufferLine.make(5); + const cell = CellData.fromChar('a', 1, 1); // no eAttrs line.setCell(0, cell); @@ -624,25 +593,25 @@ describe('BufferLine', function(): void { cell.bg &= ~BgFlags.HAS_EXTENDED; line.setCell(4, cell); - assert.deepEqual(line.toArray(), [ - [1, 'a', 0, 'a'.charCodeAt(0)], - [1, 'a', 0, 'a'.charCodeAt(0)], - [1, 'A', 0, 'A'.charCodeAt(0)], - [1, 'A', 0, 'A'.charCodeAt(0)], - [1, 'A', 0, 'A'.charCodeAt(0)] + assert.deepEqual(lineToArray(line), [ + [1, 'a', 1, 'a'.charCodeAt(0)], + [1, 'a', 1, 'a'.charCodeAt(0)], + [1, 'A', 1, 'A'.charCodeAt(0)], + [1, 'A', 1, 'A'.charCodeAt(0)], + [1, 'A', 1, 'A'.charCodeAt(0)] ]); - assert.equal((line as any)._extendedAttrs[0], undefined); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[3].underlineStyle, UnderlineStyle.DOTTED); - assert.equal((line as any)._extendedAttrs[4], undefined); + assert.equal(extendedAttributes(line, 0), undefined); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 3)?.underlineStyle, UnderlineStyle.DOTTED); + assert.equal(extendedAttributes(line, 4)?.underlineStyle, undefined); // should be ref to the same object - assert.equal((line as any)._extendedAttrs[1], (line as any)._extendedAttrs[2]); + assert.equal(extendedAttributes(line, 1), extendedAttributes(line, 2)); // should be a different obj - assert.notEqual((line as any)._extendedAttrs[1], (line as any)._extendedAttrs[3]); + assert.notEqual(extendedAttributes(line, 1), extendedAttributes(line, 3)); }); it('loadCell', () => { - const line = new TestBufferLine(5); + const line = BufferLine.make(5); const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); // no eAttrs line.setCell(0, cell); @@ -665,55 +634,49 @@ describe('BufferLine', function(): void { cell.bg &= ~BgFlags.HAS_EXTENDED; line.setCell(4, cell); - const cell0 = new CellData(); - line.loadCell(0, cell0); - const cell1 = new CellData(); - line.loadCell(1, cell1); - const cell2 = new CellData(); - line.loadCell(2, cell2); - const cell3 = new CellData(); - line.loadCell(3, cell3); - const cell4 = new CellData(); - line.loadCell(4, cell4); - - assert.equal(cell0.extended.underlineStyle, UnderlineStyle.NONE); - assert.equal(cell1.extended.underlineStyle, UnderlineStyle.CURLY); - assert.equal(cell2.extended.underlineStyle, UnderlineStyle.CURLY); - assert.equal(cell3.extended.underlineStyle, UnderlineStyle.DOTTED); - assert.equal(cell4.extended.underlineStyle, UnderlineStyle.NONE); - assert.equal(cell1.extended, cell2.extended); - assert.notEqual(cell2.extended, cell3.extended); + const ext0 = extendedAttributes(line, 0); + const ext1 = extendedAttributes(line, 1); + const ext2 = extendedAttributes(line, 2); + const ext3 = extendedAttributes(line, 3); + const ext4 = extendedAttributes(line, 4); + assert.equal(ext0?.underlineStyle, undefined); // UnderlineStyle.NONE + assert.equal(ext1?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(ext2?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(ext3?.underlineStyle, UnderlineStyle.DOTTED); + assert.equal(ext4?.underlineStyle, undefined); // UnderlineStyle.NONE + assert.equal(ext1, ext2); + assert.notEqual(ext2, ext3); }); it('fill', () => { - const line = new TestBufferLine(3); + const line = BufferLine.make(3); const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); cell.extended.underlineStyle = UnderlineStyle.CURLY; cell.bg |= BgFlags.HAS_EXTENDED; line.fill(cell); - assert.equal((line as any)._extendedAttrs[0].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 0)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.CURLY); }); it('insertCells', () => { - const line = new TestBufferLine(5); + const line = BufferLine.make(5); const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); cell.extended.underlineStyle = UnderlineStyle.CURLY; cell.bg |= BgFlags.HAS_EXTENDED; line.insertCells(1, 3, cell); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[3].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[4], undefined); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 3)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 4), undefined); cell.extended = cell.extended.clone(); cell.extended.underlineStyle = UnderlineStyle.DOTTED; line.insertCells(2, 2, cell); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.DOTTED); - assert.equal((line as any)._extendedAttrs[3].underlineStyle, UnderlineStyle.DOTTED); - assert.equal((line as any)._extendedAttrs[4].underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.DOTTED); + assert.equal(extendedAttributes(line, 3)?.underlineStyle, UnderlineStyle.DOTTED); + assert.equal(extendedAttributes(line, 4)?.underlineStyle, UnderlineStyle.CURLY); }); it('deleteCells', () => { - const line = new TestBufferLine(5); + const line = BufferLine.make(5); const fillCell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); fillCell.extended.underlineStyle = UnderlineStyle.CURLY; fillCell.bg |= BgFlags.HAS_EXTENDED; @@ -721,14 +684,14 @@ describe('BufferLine', function(): void { fillCell.extended = fillCell.extended.clone(); fillCell.extended.underlineStyle = UnderlineStyle.DOUBLE; line.deleteCells(1, 3, fillCell); - assert.equal((line as any)._extendedAttrs[0].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.DOUBLE); - assert.equal((line as any)._extendedAttrs[3].underlineStyle, UnderlineStyle.DOUBLE); - assert.equal((line as any)._extendedAttrs[4].underlineStyle, UnderlineStyle.DOUBLE); + assert.equal(extendedAttributes(line, 0)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.DOUBLE); + assert.equal(extendedAttributes(line, 3)?.underlineStyle, UnderlineStyle.DOUBLE); + assert.equal(extendedAttributes(line, 4)?.underlineStyle, UnderlineStyle.DOUBLE); }); it('replaceCells', () => { - const line = new TestBufferLine(5); + const line = BufferLine.make(5); const fillCell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); fillCell.extended.underlineStyle = UnderlineStyle.CURLY; fillCell.bg |= BgFlags.HAS_EXTENDED; @@ -736,75 +699,11 @@ describe('BufferLine', function(): void { fillCell.extended = fillCell.extended.clone(); fillCell.extended.underlineStyle = UnderlineStyle.DOUBLE; line.replaceCells(1, 3, fillCell); - assert.equal((line as any)._extendedAttrs[0].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[1].underlineStyle, UnderlineStyle.DOUBLE); - assert.equal((line as any)._extendedAttrs[2].underlineStyle, UnderlineStyle.DOUBLE); - assert.equal((line as any)._extendedAttrs[3].underlineStyle, UnderlineStyle.CURLY); - assert.equal((line as any)._extendedAttrs[4].underlineStyle, UnderlineStyle.CURLY); - }); - it('clone', () => { - const line = new TestBufferLine(5); - const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); - // no eAttrs - line.setCell(0, cell); - - // some underline style - cell.extended.underlineStyle = UnderlineStyle.CURLY; - cell.bg |= BgFlags.HAS_EXTENDED; - line.setCell(1, cell); - - // same eAttr, different codepoint - cell.content = 65; // 'A' - line.setCell(2, cell); - - // different eAttr - cell.extended = cell.extended.clone(); - cell.extended.underlineStyle = UnderlineStyle.DOTTED; - line.setCell(3, cell); - - // no eAttrs again - cell.bg &= ~BgFlags.HAS_EXTENDED; - line.setCell(4, cell); - - const nLine = line.clone(); - assert.equal((nLine as any)._extendedAttrs[0], (line as any)._extendedAttrs[0]); - assert.equal((nLine as any)._extendedAttrs[1], (line as any)._extendedAttrs[1]); - assert.equal((nLine as any)._extendedAttrs[2], (line as any)._extendedAttrs[2]); - assert.equal((nLine as any)._extendedAttrs[3], (line as any)._extendedAttrs[3]); - assert.equal((nLine as any)._extendedAttrs[4], (line as any)._extendedAttrs[4]); - }); - it('copyFrom', () => { - const initial = new TestBufferLine(5); - const cell = CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]); - // no eAttrs - initial.setCell(0, cell); - - // some underline style - cell.extended.underlineStyle = UnderlineStyle.CURLY; - cell.bg |= BgFlags.HAS_EXTENDED; - initial.setCell(1, cell); - - // same eAttr, different codepoint - cell.content = 65; // 'A' - initial.setCell(2, cell); - - // different eAttr - cell.extended = cell.extended.clone(); - cell.extended.underlineStyle = UnderlineStyle.DOTTED; - initial.setCell(3, cell); - - // no eAttrs again - cell.bg &= ~BgFlags.HAS_EXTENDED; - initial.setCell(4, cell); - - const line = new TestBufferLine(5); - line.fill(CellData.fromCharData([1, 'b', 0, 'b'.charCodeAt(0)])); - line.copyFrom(initial); - assert.equal((line as any)._extendedAttrs[0], (initial as any)._extendedAttrs[0]); - assert.equal((line as any)._extendedAttrs[1], (initial as any)._extendedAttrs[1]); - assert.equal((line as any)._extendedAttrs[2], (initial as any)._extendedAttrs[2]); - assert.equal((line as any)._extendedAttrs[3], (initial as any)._extendedAttrs[3]); - assert.equal((line as any)._extendedAttrs[4], (initial as any)._extendedAttrs[4]); + assert.equal(extendedAttributes(line, 0)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 1)?.underlineStyle, UnderlineStyle.DOUBLE); + assert.equal(extendedAttributes(line, 2)?.underlineStyle, UnderlineStyle.DOUBLE); + assert.equal(extendedAttributes(line, 3)?.underlineStyle, UnderlineStyle.CURLY); + assert.equal(extendedAttributes(line, 4)?.underlineStyle, UnderlineStyle.CURLY); }); }); }); diff --git a/src/common/buffer/BufferLine.ts b/src/common/buffer/BufferLine.ts index ee3481a24e..53e3818ca8 100644 --- a/src/common/buffer/BufferLine.ts +++ b/src/common/buffer/BufferLine.ts @@ -3,39 +3,27 @@ * @license MIT */ -import { CharData, IAttributeData, IBufferLine, ICellData, IExtendedAttrs } from 'common/Types'; +import { CharData, IInputHandler, IAttributeData, IBufferLine, ICellData, IExtendedAttrs } from 'common/Types'; import { AttributeData } from 'common/buffer/AttributeData'; import { CellData } from 'common/buffer/CellData'; -import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from 'common/buffer/Constants'; -import { stringFromCodePoint } from 'common/input/TextDecoder'; +import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, StyleFlags, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR , UnderlineStyle } from 'common/buffer/Constants'; +import { stringFromCodePoint, utf32ToString } from 'common/input/TextDecoder'; +import { UnicodeService } from 'common/services/UnicodeService'; +import { ICoreService } from 'common/services/Services'; -/** - * buffer memory layout: - * - * | uint32_t | uint32_t | uint32_t | - * | `content` | `FG` | `BG` | - * | wcwidth(2) comb(1) codepoint(21) | flags(8) R(8) G(8) B(8) | flags(8) R(8) G(8) B(8) | - */ - - -/** typed array slots taken by one cell */ -const CELL_SIZE = 3; +export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData()); -/** - * Cell member indices. - * - * Direct access: - * `content = data[column * CELL_SIZE + Cell.CONTENT];` - * `fg = data[column * CELL_SIZE + Cell.FG];` - * `bg = data[column * CELL_SIZE + Cell.BG];` +/** Column count within current visible row. + * The left-most column is column 0. */ -const enum Cell { - CONTENT = 0, - FG = 1, // currently simply holds all known attrs - BG = 2 // currently unused -} +type RowColumn = number; -export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData()); +/** Column count within current logical line. + * If the display is 80 columns wide, then LineColumn of the left-most + * character of the first wrapped line would normally be 80. + * (It might be 79 if the character at column 79 is double-width.) + */ +type LineColumn = number; // Work variables to avoid garbage collection let $startIndex = 0; @@ -43,135 +31,516 @@ let $startIndex = 0; /** Factor when to cleanup underlying array buffer after shrinking. */ const CLEANUP_THRESHOLD = 2; -/** - * Typed array based bufferline implementation. - * - * There are 2 ways to insert data into the cell buffer: - * - `setCellFromCodepoint` + `addCodepointToCell` - * Use these for data that is already UTF32. - * Used during normal input in `InputHandler` for faster buffer access. - * - `setCell` - * This method takes a CellData object and stores the data in the buffer. - * Use `CellData.fromCharData` to create the CellData object (e.g. from JS string). - * - * To retrieve data from the buffer use either one of the primitive methods - * (if only one particular value is needed) or `loadCell`. For `loadCell` in a loop - * memory allocs / GC pressure can be greatly reduced by reusing the CellData object. - */ -export class BufferLine implements IBufferLine { - protected _data: Uint32Array; - protected _combined: {[index: number]: string} = {}; - protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {}; - public length: number; +const enum DataKind { // 4 bits + FG = 1, // lower 26 bits is RGB foreground color and CM_MASK + BG = 2, // lower 26 bits is RGB background color and CM_MASK + STYLE_FLAGS = 3, // lower 28 bits is StyleFlags - constructor(cols: number, fillCellData?: ICellData, public isWrapped: boolean = false) { - this._data = new Uint32Array(cols * CELL_SIZE); - const cell = fillCellData || CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]); - for (let i = 0; i < cols; ++i) { - this.setCell(i, cell); + SKIP_COLUMNS = 7, // empty ("null") columns (28 bit count) + // The following have a 21-bit codepoint value in the low-order bits + CHAR_W1 = 8, // single-non-compound, 1 column wide + CHAR_W2 = 9, // single-non-compound, 2 columns wide + // CLUSTER_START_xx have a 7=bit for number of CONTINUED entries + CLUSTER_START_W1 = 10, // start of non-trivial cluster, 1 column wide + CLUSTER_START_W2 = 11, // start of non-trivial cluster, 2 columns wide + CLUSTER_CONTINUED = 12 // continuation of cluster +} + +const NULL_DATA_WORD = DataKind.SKIP_COLUMNS << 28; + +export abstract class BufferLine implements IBufferLine { + /** Number of logical columns */ + public length: number = 0; + public abstract get isWrapped(): boolean; + public abstract cleanupMemory(): number; + + public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void { + // full branching on respectProtect==true, hopefully getting fast JIT for standard case + if (respectProtect) { + if (start && this.getWidth(start - 1) === 2 && !this.isProtected(start - 1)) { + this.setCellFromCodepoint(start - 1, 0, 1, fillCellData); + } + if (end < this.length && this.getWidth(end - 1) === 2 && !this.isProtected(end)) { + this.setCellFromCodepoint(end, 0, 1, fillCellData); + } + while (start < end && start < this.length) { + if (!this.isProtected(start)) { + this.setCell(start, fillCellData); + } + start++; + } + return; + } + + // handle fullwidth at start: reset cell one to the left if start is second cell of a wide char + if (start && this.getWidth(start - 1) === 2) { + this.setCellFromCodepoint(start - 1, 0, 1, fillCellData); + } + // handle fullwidth at last cell + 1: reset to empty cell if it is second part of a wide char + if (end < this.length && this.getWidth(end - 1) === 2) { + this.setCellFromCodepoint(end, 0, 1, fillCellData); + } + + while (start < end && start < this.length) { + this.setCell(start++, fillCellData); } - this.length = cols; } /** - * Get cell data CharData. + * Set cell data from CharData. * @deprecated */ - public get(index: number): CharData { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; - const cp = content & Content.CODEPOINT_MASK; - return [ - this._data[index * CELL_SIZE + Cell.FG], - (content & Content.IS_COMBINED_MASK) - ? this._combined[index] - : (cp) ? stringFromCodePoint(cp) : '', - content >> Content.WIDTH_SHIFT, - (content & Content.IS_COMBINED_MASK) - ? this._combined[index].charCodeAt(this._combined[index].length - 1) - : cp - ]; + public set(index: number, value: CharData): void { + this.setCell(index, CellData.fromCharData(value)); } /** - * Set cell data from CharData. - * @deprecated + * primitive getters + * use these when only one value is needed, otherwise use `loadCell` */ - public set(index: number, value: CharData): void { - this._data[index * CELL_SIZE + Cell.FG] = value[CHAR_DATA_ATTR_INDEX]; - if (value[CHAR_DATA_CHAR_INDEX].length > 1) { - this._combined[index] = value[1]; - this._data[index * CELL_SIZE + Cell.CONTENT] = index | Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); - } else { - this._data[index * CELL_SIZE + Cell.CONTENT] = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); + + /** + * Get codepoint of the cell. @deprecated + * To be in line with `code` in CharData this either returns + * a single UTF32 codepoint or the last codepoint of a combined string. + */ + public getCodePoint(index: number): number { + return this.loadCell(index, new CellData()).getCode(); + } + + /** Returns the string content of the cell. @deprecated */ + public getString(index: number): string { + const cell = new CellData(); + this.loadCell(index, cell); + return cell.getChars(); + } + + /** Get state of protected flag. @deprecated */ + public isProtected(index: number): number { + return this.loadCell(index, new CellData()).bg & BgFlags.PROTECTED; + } + + static make(cols: number, fillCellData?: ICellData, isWrapped: boolean = false): BufferLine { + const line = new LogicalBufferLine(cols, fillCellData); + if (isWrapped) { + const wline = new WrappedBufferLine(line); + if (fillCellData) { wline.replaceCells(0, cols, fillCellData); } + return wline; } + return line; + } + + /** From a Uint23 in _data, extract the DataKind bits. */ + public static wKind(word: number): DataKind { return word >>> 28; } + public static wKindIsText(kind: DataKind): boolean { return kind >= DataKind.CHAR_W1 && kind <= DataKind.CLUSTER_CONTINUED; } + public static wKindIsTextOrSkip(kind: DataKind): boolean { return kind >= DataKind.SKIP_COLUMNS && kind <= DataKind.CLUSTER_CONTINUED; } + /* Return 1 or 2 assuming wKindIsText(kind). */ + public static wTextWidth(kind: DataKind): number { return (kind & 1) + 1; } + /** From a Uint23 in _data, extract length of string within _text. + * Only for SKIP_COLUMNS. */ + public static wSkipCount(word: number): number { return word & 0xfffff; } + /** Number of following CLUSTER_CONTINUED words. + * Valid if wKindIsText(wKind(word)). Zero if CHAR_W1 or CHAR_W2. + */ + public static wContinuedCount(word: number): number { return (word >> 21) & 0x3F} + public static wSet1(kind: DataKind, value: number): number { + return (kind << 28) | (value & 0x0fffffff); + } + nextRowSameLine: WrappedBufferLine | undefined; + + /** The "current" index into the _data array. + * The index must be either dataLength() or wKindIsTextOrSkip must be true. + * (The index never points to a CLUSTER_CONTINUED item.) + */ + _cachedDataIndex(): number { return this.logicalLine()._cache1 >>> 16; } + /** The logical column number corresponding to _cachedDataIndex(). */ + _cachedColumn(): LineColumn { return this.logicalLine()._cache1 & 0xFFFF; } + protected abstract _cachedColumnInRow(): RowColumn; + // private _cachedColOffset(): number { return this._cache3 >> 24; } // UNUSED + abstract _cachedBg(): number; + abstract _cachedFg(): number; + // An index (in data()) of a STYLE_FLAGS entry; -1 if none. + _cachedStyleFlagsIndex(): number { return this.logicalLine()._cache4; } + protected _cacheReset(): void { const line = this.logicalLine(); line._cache1 = 0; line._cache2 = 0; line._cache3 = 0; line._cache4 = -1; } + protected _cacheSetFgBg(fg: number, bg: number): void { const line = this.logicalLine(); line._cache2 = bg; line._cache3 = fg; } + protected _cacheSetStyleFlagsIndex(index: number): void { this.logicalLine()._cache4 = index; } + protected _cacheSetColumnDataIndex(column: LineColumn, dataIndex: number): void { this.logicalLine()._cache1 = (dataIndex << 16) | (column & 0xFFFF); } + + /*public setStartFromCacheX(wrapRow: WrappedBufferLine, column: LineColumn): void { + wrapRow.startColumn = column; + wrapRow.startIndex = this._cachedDataIndex(); + wrapRow.startIndexColumn = this._cachedColumn(); + wrapRow.startBg = this._cachedBg(); + wrapRow.startFg = this._cachedFg(); + wrapRow.startStyle = this._cachedStyleFlagsIndex(); + }*/ + + // Length of data() array. + abstract dataLength(): number; + + public abstract logicalLine(): LogicalBufferLine; + public abstract logicalStartColumn(): LineColumn; + protected abstract data(): Uint32Array; + abstract resizeData(size: number): void; + abstract addEmptyDataElements(position: number, count: number, insertBeforeEnd?: boolean): void; + protected shouldCleanupMemory(): boolean { + return this.dataLength() * CLEANUP_THRESHOLD < this.data().length; } + /** * primitive getters * use these when only one value is needed, otherwise use `loadCell` */ public getWidth(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT; + return this.moveToColumn(index) >>> Content.WIDTH_SHIFT; } /** Test whether content has width. */ public hasWidth(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.WIDTH_MASK; + return this.moveToColumn(index) & Content.WIDTH_MASK; } /** Get FG cell component. */ public getFg(index: number): number { - return this._data[index * CELL_SIZE + Cell.FG]; + this.moveToColumn(index); + const styleIndex = this._cachedStyleFlagsIndex(); + const styleWord = styleIndex < 0 ? 0 : this.data()[styleIndex]; + return this._cachedFg() | ((styleWord << 24) & Attributes.STYLE_BITS_MASK); } - /** Get BG cell component. */ + /** Get BG cell component. @deprecated */ public getBg(index: number): number { - return this._data[index * CELL_SIZE + Cell.BG]; + this.moveToColumn(index); + const styleIndex = this._cachedStyleFlagsIndex(); + const styleWord = styleIndex < 0 ? 0 : this.data()[styleIndex]; + return this._cachedBg() | ((styleWord << 16) & Attributes.STYLE_BITS_MASK); } /** - * Test whether contains any chars. + * Test whether contains any chars. @deprecated * Basically an empty has no content, but other cells might differ in FG/BG * from real empty cells. */ public hasContent(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK; + return this.moveToColumn(index) & Content.HAS_CONTENT_MASK; + } + + /** Test whether the cell contains a combined string. */ + public isCombined(index: number): number { + return this.moveToColumn(index) & Content.IS_COMBINED_MASK; + } + + public showRowData(): string { + return (this instanceof WrappedBufferLine ? '(wrapped)' : '') + + this.showData(this.logicalStartColumn(), this.nextRowSameLine ? this.nextRowSameLine?.logicalStartColumn() : Infinity); + } + /* Human-readable display of data() array, for debugging */ + public showData(startColumn = 0, endColumn = Infinity): string { + let s = ''; + let curColumn = 0; + const data = this.data(); + const lline = this.logicalLine(); + for (let i = 0; i < this.dataLength() && curColumn < endColumn; i++) { + const word = data[i]; + const kind = BufferLine.wKind(word); + let code: string | number = kind; + const wnum = word & 0xfffffff; + let nextColumn = curColumn; + let skip = curColumn < startColumn; + switch (kind) { + case DataKind.FG: code = 'FG'; break; + case DataKind.BG: code = 'BG'; break; + case DataKind.STYLE_FLAGS: code = 'STYLE'; break; + case DataKind.SKIP_COLUMNS: code = 'SKIP'; + nextColumn += wnum; + skip = nextColumn <= startColumn; + break; + case DataKind.CLUSTER_START_W1: code = 'CL1'; nextColumn += 1; break; + case DataKind.CLUSTER_START_W2: code = 'CL2'; nextColumn += 2; break; + case DataKind.CLUSTER_CONTINUED: code = 'CL_CONT'; break; + case DataKind.CHAR_W1: code = 'C1'; nextColumn += 1; break; + case DataKind.CHAR_W2: code = 'C2'; nextColumn += 2; break; + } + + if (! skip) { + if (s) { + s += ', '; + } + let value; + if (kind === DataKind.CHAR_W1 || kind === DataKind.CHAR_W2) { + let count = 1; + const w = nextColumn - curColumn; + while (curColumn + count * w < endColumn && i + count < this.dataLength() && BufferLine.wKind(this.data()[i + count]) === kind) { + count++; + } + let str; + if (count === 1) { + str = stringFromCodePoint(word & 0x1fffff); + } else { + str = utf32ToString(this.data(), i, i + count); + code = code + '*' + count; + i += count - 1; + } + value = JSON.stringify(str); + nextColumn = curColumn + count * w; + } else if (kind === DataKind.CLUSTER_START_W1 + || kind === DataKind.CLUSTER_START_W2 + || kind === DataKind.CLUSTER_CONTINUED) { + value = '#' + (word & 0x1fffff).toString(16); + } else if (kind === DataKind.BG || kind === DataKind.FG) { + value = (wnum >> 24) + '#' + (wnum & 0xffffff).toString(16); + } else if (kind === DataKind.STYLE_FLAGS) { + value = '#' + (wnum & 0xfffffff).toString(16); + if (wnum & StyleFlags.HAS_EXTENDED) { + const extended = lline._extendedAttrs[i]; + if (! extended) { value += " (missing ext)"; } + else { + switch (extended.underlineStyle) { + case UnderlineStyle.SINGLE: value += " us:SINGLE"; break; + case UnderlineStyle.DOUBLE: value += " us:DOUBLE"; break; + case UnderlineStyle.CURLY: value += " us:CURLY"; break; + case UnderlineStyle.DOTTED: value += " us:DOTTED"; break; + case UnderlineStyle.DASHED: value += " us:DASHED"; break; + } + } + } + } else if (kind === DataKind.SKIP_COLUMNS) { + value = nextColumn <= endColumn ? wnum + : `${endColumn - curColumn} of ${wnum}`; + } else { + value = wnum.toString(); + } + s += code + ': ' + value; + if (curColumn < startColumn) { + s += ` offset ${startColumn - curColumn}`; + } + } + curColumn = nextColumn; + } + return `[${s}]`; + } + + /** Check invariants. Useful for debugging. */ + _check(): void { + function error(str: string): void { + console.log('ERROR: '+str); + } + const data = this.data(); + if (this.dataLength() < 0 || this.dataLength() > data.length) + {error('bad _dataLength');} + if (this.dataLength() === 2 && BufferLine.wKind(data[0]) === DataKind.SKIP_COLUMNS && BufferLine.wKind(data[1]) === DataKind.BG) { + error('SKIP followed by BG'); + } + if (this.dataLength() === 1 && data[0] === BufferLine.wSet1(DataKind.BG, 0)) { + error('default BG only'); + } + for (let idata = 0; idata < this.dataLength(); idata++) { + const word = data[idata]; + const kind = BufferLine.wKind(word); + switch (kind) { + case DataKind.FG: + case DataKind.BG: + break; + case DataKind.STYLE_FLAGS: + if ((word & StyleFlags.HAS_EXTENDED) != 0 + && ! this.logicalLine()._extendedAttrs[idata]) { + error("missed ExtendedAttributes") + } + break; + case DataKind.SKIP_COLUMNS: + break; + case DataKind.CHAR_W1: + case DataKind.CHAR_W2: + case DataKind.CLUSTER_START_W1: + case DataKind.CLUSTER_START_W2: + case DataKind.CLUSTER_CONTINUED: + break; + default: + error('invalid _dataKind'); + } + } + } /** - * Get codepoint of the cell. - * To be in line with `code` in CharData this either returns - * a single UTF32 codepoint or the last codepoint of a combined string. + * Get cell data CharData. + * @deprecated */ - public getCodePoint(index: number): number { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; - if (content & Content.IS_COMBINED_MASK) { - return this._combined[index].charCodeAt(this._combined[index].length - 1); - } - return content & Content.CODEPOINT_MASK; + public get(index: number): CharData { + return this.loadCell(index, new CellData()).getAsCharData(); } - /** Test whether the cell contains a combined string. */ - public isCombined(index: number): number { - return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.IS_COMBINED_MASK; + public clusterEnd(idata: number): number { + // FIXME do we need to handle more than 7 bits of CLUSTED_CONTINUED? + return idata + 1 + BufferLine.wContinuedCount(this.data()[idata]); } - /** Returns the string content of the cell. */ - public getString(index: number): string { - const content = this._data[index * CELL_SIZE + Cell.CONTENT]; - if (content & Content.IS_COMBINED_MASK) { - return this._combined[index]; + public insertCells(pos: number, n: number, fillCellData: ICellData): void { + // FIXME handle if start or end in middle of wide character. + const width = this.length; + if (pos >= width) { + return; } - if (content & Content.CODEPOINT_MASK) { - return stringFromCodePoint(content & Content.CODEPOINT_MASK); + if (pos + n < width) { + const endpos = width - n; + this.moveToColumn(endpos, 2); + const idata = this._cachedDataIndex(); + const colOffset = this._cachedColumn(); + this.logicalLine().deleteCellsOnly(idata, n); + } else { + n = width - pos; } - // return empty string for empty cells - return ''; + this.insertCellsOnly(pos, n, fillCellData); } - /** Get state of protected flag. */ - public isProtected(index: number): number { - return this._data[index * CELL_SIZE + Cell.BG] & BgFlags.PROTECTED; + private insertCellsOnly(pos: RowColumn, n: number, fillCellData: ICellData): void { + if (!(fillCellData.content & Content.IS_COMBINED_MASK) + && fillCellData.getWidth() === 1) { + // Optimization + this.preInsert(this.logicalStartColumn() + pos, fillCellData); + const idata = this._cachedDataIndex(); + const code = fillCellData.getCode(); + if (code === NULL_CELL_CODE) { + this.addEmptyDataElements(idata, 1, true); + this.data()[idata] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, n); + } else { + this.addEmptyDataElements(idata, n); + for (let i = 0; i < n; ++i) { + this.data()[idata+i] = BufferLine.wSet1(DataKind.CHAR_W1, code); + } + } + } else { + this.moveToColumn(this.logicalStartColumn() + pos); + const idata = this._cachedDataIndex(); + this.addEmptyDataElements(idata, 1); + this.data()[idata] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, n); + for (let i = 0; i < n; ++i) { + this.setCell(pos + i, fillCellData); + } + } + } + + /** Move to column 'index', which is a RowColumn. + * Return encoded 'content'. + * @param index Goal column. + * @param splitIfNeeded. As in moveToLineColumn. + */ + public moveToColumn(index: RowColumn, splitIfNeeded: number = 0): number { + const endColumn = this.nextRowSameLine ? this.nextRowSameLine.logicalStartColumn() : Infinity; + return this.moveToLineColumn(index + this.logicalStartColumn(), splitIfNeeded, endColumn); + } + + /** Move to column 'index', which is a LineColumn. + * Return encoded 'content' (code value with width and possible IS_COMBINED_MARK) of following character, if any. + * If index is the middle of a multi-column character: leaves the position before the character; + * the return value specifices the code value 0 and the width 0. + * If index is in the middle of a SKIP_COLUMNS: leaves the position cache before the SKIP_COLUMNS; + * the return value specifices the code value 0 and width 1. + * If index would take us past _dataLength: Set the position to _dataLength; + * the return value specifices the code value 0 and width 1. + * @param index The goal, as a LineColumn. + * @param splitIfNeeded. If splitIfNeeded > 0 and the goal is in the middle + * of a double-wide character, replace letter by two SKIP-COLUMNS entries. + * If splitIfNeeded >= 2 and goal is in middle of SKIP_COLUMNS or + * after end of the row, split or add a SKIP_COLUMNS entry. + * If splitIfNeeded >= 3, stop early, before style words. + * @param endColumn Don't move past this LineColumn. + * Used mainly to limit movement to the current row. + */ + public moveToLineColumn(index: LineColumn, splitIfNeeded: number = 0, endColumn = Infinity): number { + const stopEarly = splitIfNeeded >= 3; + let curColumn = this._cachedColumn(); + if (index < curColumn) { + // FIXME can sometimes do better + this._cacheReset(); + curColumn = this._cachedColumn(); + } + let idata = this._cachedDataIndex(); + let fg = this._cachedFg(); + let bg = this._cachedBg(); + let styleFlagsIndex = this._cachedStyleFlagsIndex(); + let todo = index - curColumn; + let word; + let kind; + let content = 0; + while (stopEarly ? todo > 0 : todo >= 0) { + if (idata >= this.dataLength() || curColumn >= endColumn) { + word = NULL_DATA_WORD; + kind = DataKind.SKIP_COLUMNS; + content = (NULL_CELL_WIDTH << Content.WIDTH_SHIFT) | NULL_CELL_CODE; + if (splitIfNeeded > 1 && todo > 0) { + this.addEmptyDataElements(idata, 1); + this.data()[idata++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, todo); + curColumn += todo; + } + break; + } + let nextColumn = curColumn; + word = this.data()[idata]; + kind = BufferLine.wKind(word); + let w; + switch (kind) { + case DataKind.FG: + fg = word & 0x3FFFFFF; + idata++; + break; + case DataKind.BG: + bg = word & 0x3FFFFFF; + idata++; + break; + case DataKind.STYLE_FLAGS: + styleFlagsIndex = idata; + idata++; + break; + case DataKind.SKIP_COLUMNS: + w = BufferLine.wSkipCount(word); + nextColumn = curColumn + w; + if (todo >= w) { + todo -= w; + idata++; + curColumn += w; + } else { + if (splitIfNeeded > 1 && todo < w) { + this.addEmptyDataElements(idata, 1); + this.data()[idata++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, todo); + this.data()[idata] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, w - todo); + curColumn += todo; + } + content = (NULL_CELL_WIDTH << Content.WIDTH_SHIFT) | NULL_CELL_CODE; + todo = -1; + } + break; + case DataKind.CHAR_W1: + case DataKind.CHAR_W2: + case DataKind.CLUSTER_START_W1: + case DataKind.CLUSTER_START_W2: + w = BufferLine.wTextWidth(kind); + nextColumn = curColumn + w; + const clEnd = idata + 1 + BufferLine.wContinuedCount(word); + if (todo >= w) { + todo -= w; + curColumn = nextColumn; + idata = clEnd; + } else { + if (splitIfNeeded > 0 && index !== curColumn) { + this.addEmptyDataElements(idata, 2 - (clEnd - idata)); + this.data()[idata++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, 1); + this.data()[idata] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, 1); + curColumn++; + } + content = index !== curColumn ? 0 + : kind <= DataKind.CHAR_W2 ? (w << Content.WIDTH_SHIFT) | (word & 0x1fffff) + : (w << Content.WIDTH_SHIFT) | Content.IS_COMBINED_MASK; + todo = -1; + } + break; + } + } + this._cacheSetColumnDataIndex(curColumn, idata); + this._cacheSetFgBg(fg, bg); + this._cacheSetStyleFlagsIndex(styleFlagsIndex); + return content; } /** @@ -179,165 +548,349 @@ export class BufferLine implements IBufferLine { * to GC as it significantly reduced the amount of new objects/references needed. */ public loadCell(index: number, cell: ICellData): ICellData { - $startIndex = index * CELL_SIZE; - cell.content = this._data[$startIndex + Cell.CONTENT]; - cell.fg = this._data[$startIndex + Cell.FG]; - cell.bg = this._data[$startIndex + Cell.BG]; - if (cell.content & Content.IS_COMBINED_MASK) { - cell.combinedData = this._combined[index]; + const cursor = cell as CellData; + const content = this.moveToColumn(index); + cursor.content = content; + cursor.setFg(this._cachedFg()); + cursor.content = content; + cursor.setFg(this._cachedFg()); + cursor.setBg(this._cachedBg()); + const styleFlagsIndex = this._cachedStyleFlagsIndex(); + const word = styleFlagsIndex < 0 ? 0 : this.data()[styleFlagsIndex]; + cursor.setStyleFlags(word); + if ((word & StyleFlags.HAS_EXTENDED) !== 0) { + cursor.extended = this.logicalLine()._extendedAttrs[styleFlagsIndex]!; } - if (cell.bg & BgFlags.HAS_EXTENDED) { - cell.extended = this._extendedAttrs[index]!; + if (content & Content.IS_COMBINED_MASK) { + // FIXME do this lazily, in CellData.getChars + const idata = this._cachedDataIndex(); + const str = utf32ToString(this.data(), idata, this.clusterEnd(idata)); + cursor.combinedData = str; } return cell; } - /** - * Set data at `index` to `cell`. + public deleteCells(pos: RowColumn, n: number, fillCellData: ICellData): void { + this.moveToColumn(pos, 2); + const idata = this._cachedDataIndex(); + const curColumn = this._cachedColumn(); + this.logicalLine().deleteCellsOnly(idata, n); + this.insertCellsOnly(this.length - n, n, fillCellData); // FIXME logical + } + + /** Insert attributes as necesssary into data array. + * Cached position will be adjusted to at index but with specified attributes. */ - public setCell(index: number, cell: ICellData): void { - if (cell.content & Content.IS_COMBINED_MASK) { - this._combined[index] = cell.combinedData; + protected preInsert(index: LineColumn, attrs: IAttributeData, extendToEnd: boolean = false): boolean { + this.moveToLineColumn(index, 3); + let idata = this._cachedDataIndex(); + // set attributes + const newFg = attrs.getFg(); + const newBg = attrs.getBg(); + const newStyle = attrs.getStyleFlags(); + let oldFg = this._cachedFg(); + let oldBg = this._cachedBg(); + const styleFlagsIndex = this._cachedStyleFlagsIndex(); + let oldStyle = styleFlagsIndex < 0 ? 0 : (this.data()[styleFlagsIndex] & 0xfffffff); + let data = this.data(); + const extendedAttrs = this.logicalLine()._extendedAttrs; + const idata0 = idata; + let dataLength = this.dataLength(); + // Optimization - if followed by fg or bg elements matching attrs, just adjust data index. + for (; idata < dataLength; idata++) { + const word = data[idata]; + let done = true; + switch (BufferLine.wKind(word)) { + case DataKind.BG: + if ((word & 0x3ffffff) === newBg) { + oldBg = newBg; + done = false; + } + break; + case DataKind.FG: + if ((word & 0x3ffffff) === newFg) { + oldFg = newFg; + done = false; + } + break; + // FIXME StyleFlags + } + if (done) { + break; + } } - if (cell.bg & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[index] = cell.extended; + let needFg = newFg !== oldFg; + let needBg = newBg !== oldBg; + let oldExt = (oldStyle & StyleFlags.HAS_EXTENDED) && extendedAttrs[styleFlagsIndex]; + let newExt = (newStyle & StyleFlags.HAS_EXTENDED) && attrs.extended; + let needStyle = newStyle !== oldStyle || oldExt !== newExt; + const add1 = extendToEnd ? 1 : 2; + let add = (needBg?add1:0) + (needFg?add1:0) + (needStyle?add1:0); + if (add) { + add = (needBg?add1:0) + (needFg?add1:0) + (needStyle?add1:0); + this.addEmptyDataElements(idata, add - (idata0 - idata)); + data = this.data(); + if (needFg) { + data[idata++] = BufferLine.wSet1(DataKind.FG, newFg); + } + if (needBg) { + data[idata++] = BufferLine.wSet1(DataKind.BG, newBg); + } + if (needStyle) { + if (newStyle & StyleFlags.HAS_EXTENDED) + {extendedAttrs[idata] = attrs.extended;} + this._cacheSetStyleFlagsIndex(idata); + data[idata++] = BufferLine.wSet1(DataKind.STYLE_FLAGS, newStyle); + } + this._cacheSetColumnDataIndex(index, idata); + let xdata = idata; // FIXME + if (! extendToEnd) { + if (needFg) { + data[xdata++] = BufferLine.wSet1(DataKind.FG, oldFg); + } + if (needStyle) { + if ((oldStyle & StyleFlags.HAS_EXTENDED) !== 0 && oldExt) + {extendedAttrs[xdata] = oldExt;} + data[xdata++] = BufferLine.wSet1(DataKind.STYLE_FLAGS, oldStyle); + } + if (needBg) { + data[xdata++] = BufferLine.wSet1(DataKind.BG, oldBg); + } + } + this._cacheSetFgBg(newFg, newBg); + } else if (idata > idata0) { + this._cacheSetColumnDataIndex(index, idata); } - this._data[index * CELL_SIZE + Cell.CONTENT] = cell.content; - this._data[index * CELL_SIZE + Cell.FG] = cell.fg; - this._data[index * CELL_SIZE + Cell.BG] = cell.bg; + return add > 0; } - /** - * Set cell data from input handler. - * Since the input handler see the incoming chars as UTF32 codepoints, - * it gets an optimized access method. + /** Insert characters from 'data' (from 'start' to 'end'). + * @return The ending column. This may be more than the available width, + * in which case the caller is responsible for wrapping. */ - public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void { - if (attrs.bg & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[index] = attrs.extended; + public insertText(index: RowColumn, data: Uint32Array, start: number, end: number, attrs: IAttributeData, inputHandler: IInputHandler, coreService: ICoreService): RowColumn { + const insertMode = coreService.modes.insertMode; + const wraparoundMode = coreService.decPrivateModes.wraparound; + let lstart = this.logicalStartColumn(); + let lindex = index + lstart; + const add = this.preInsert(lindex, attrs); + lstart = this.logicalStartColumn(); + lindex = index + lstart; + let curColumn = this._cachedColumn(); + const lline = this.logicalLine(); + const startColumn: LineColumn = curColumn; + let idata = this._cachedDataIndex(); + let precedingJoinState = inputHandler.precedingJoinState; + let inext; + if (add || idata === this.dataLength() || lindex === curColumn) + {inext = idata;} + else { + const kind = BufferLine.wKind(this.data()[idata]); + if (BufferLine.wKindIsText(kind)) + {inext = this.clusterEnd(idata);} + else + {inext = idata;} } - this._data[index * CELL_SIZE + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT); - this._data[index * CELL_SIZE + Cell.FG] = attrs.fg; - this._data[index * CELL_SIZE + Cell.BG] = attrs.bg; - } + // FIXME optimize of overwriting simple text in-place + this.addEmptyDataElements(inext, end - start); - /** - * Add a codepoint to a cell from input handler. - * During input stage combining chars with a width of 0 follow and stack - * onto a leading char. Since we already set the attrs - * by the previous `setDataFromCodePoint` call, we can omit it here. - */ - public addCodepointToCell(index: number, codePoint: number, width: number): void { - let content = this._data[index * CELL_SIZE + Cell.CONTENT]; - if (content & Content.IS_COMBINED_MASK) { - // we already have a combined string, simply add - this._combined[index] += stringFromCodePoint(codePoint); - } else { - if (content & Content.CODEPOINT_MASK) { - // normal case for combining chars: - // - move current leading char + new one into combined string - // - set combined flag - this._combined[index] = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint); - content &= ~Content.CODEPOINT_MASK; // set codepoint in buffer to 0 - content |= Content.IS_COMBINED_MASK; + let cellColumn = curColumn; + let chWidth = 0; + for (let i = start; i < end; i++) { + // inext is the insertion point for the current codepoint + // idata is the start of the most recent character or cluster, + // assuming all codepoints from idata until inext are the same cluster. + // If there is no preceding character/cluster that can be added to, + // then idata === inext. + const code = data[i]; + const currentInfo = inputHandler.unicodeService.charProperties(code, precedingJoinState); + chWidth = UnicodeService.extractWidth(currentInfo); + const shouldJoin = UnicodeService.extractShouldJoin(currentInfo); + const oldWidth = shouldJoin ? UnicodeService.extractWidth(precedingJoinState) : 0; + precedingJoinState = currentInfo; + let kind; + if (shouldJoin) { + kind = chWidth === 2 ? DataKind.CLUSTER_START_W2 : DataKind.CLUSTER_START_W1; + const oldCount = (this.data()[idata] >> 21) & 0x3F; + const startChar = this.data()[idata] & 0x1FFFFF; + // FIXME check for count overflow; + this.data()[idata] = BufferLine.wSet1(kind, + startChar + ((oldCount + 1) << 21)); + kind = DataKind.CLUSTER_CONTINUED; + curColumn += chWidth - oldWidth; } else { - // should not happen - we actually have no data in the cell yet - // simply set the data in the cell buffer with a width of 1 - content = codePoint | (1 << Content.WIDTH_SHIFT); + kind = chWidth === 2 ? DataKind.CHAR_W2 : DataKind.CHAR_W1; + idata = inext; + cellColumn = curColumn; + curColumn += chWidth; } + this.data()[inext++] = BufferLine.wSet1(kind, code); } - if (width) { - content &= ~Content.WIDTH_MASK; - content |= width << Content.WIDTH_SHIFT; + const lastChar = idata; + inputHandler.precedingJoinState = precedingJoinState; + if (insertMode) { + let deleteStartColumn = lstart + this.length; + this.moveToLineColumn(deleteStartColumn, 1); + inext = this._cachedDataIndex(); + this.logicalLine().deleteCellsOnly(inext, curColumn - startColumn); + } else if (idata < this.dataLength()) { + this.logicalLine().deleteCellsOnly(inext, curColumn - startColumn); } - this._data[index * CELL_SIZE + Cell.CONTENT] = content; - } - - public insertCells(pos: number, n: number, fillCellData: ICellData): void { - pos %= this.length; - - // handle fullwidth at pos: reset cell one to the left if pos is second cell of a wide char - if (pos && this.getWidth(pos - 1) === 2) { - this.setCellFromCodepoint(pos - 1, 0, 1, fillCellData); + curColumn -= lstart; + if (curColumn > this.length && ! wraparoundMode) { + this.moveToColumn(this.length - chWidth); + idata = this._cachedDataIndex(); + this.addEmptyDataElements(idata, idata - lastChar); + } else { + this._cacheSetColumnDataIndex(cellColumn, idata); } + return curColumn; + } - if (n < this.length - pos) { - const cell = new CellData(); - for (let i = this.length - pos - n - 1; i >= 0; --i) { - this.setCell(pos + n + i, this.loadCell(pos + i, cell)); - } - for (let i = 0; i < n; ++i) { - this.setCell(pos + i, fillCellData); + public eraseCells(start: RowColumn, end: RowColumn, attrs: IAttributeData): void { + const startColumn = this.logicalStartColumn(); + end = Math.min(end, this.length); + const count = end - start; + start += startColumn; + end += startColumn; + this.moveToLineColumn(start, 2); + let idata = this._cachedDataIndex(); + const lline = this.logicalLine(); + lline.deleteCellsOnly(idata, count); + this.preInsert(start, attrs, end === Infinity); + idata = this._cachedDataIndex(); + const data = this.data(); + if (idata > 0 && BufferLine.wKind(data[idata-1]) === DataKind.SKIP_COLUMNS) { + const skipped = BufferLine.wSkipCount(data[idata - 1]); + if (idata === this.dataLength()) { + end = start - skipped; + idata--; + lline._dataLength = idata; + } else { + if (this instanceof WrappedBufferLine && idata === this.startIndex) { + this.startIndex--; + this.startIndexColumn -= skipped; + } + data[idata-1] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, skipped + count); } } else { - for (let i = pos; i < this.length; ++i) { - this.setCell(i, fillCellData); + if (idata === this.dataLength()) { + return; } + this.addEmptyDataElements(idata, 1); + data[idata++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, count); } - - // handle fullwidth at line end: reset last cell if it is first cell of a wide char - if (this.getWidth(this.length - 1) === 2) { - this.setCellFromCodepoint(this.length - 1, 0, 1, fillCellData); - } + this._cacheSetColumnDataIndex(end, idata); } - public deleteCells(pos: number, n: number, fillCellData: ICellData): void { - pos %= this.length; - if (n < this.length - pos) { - const cell = new CellData(); - for (let i = 0; i < this.length - pos - n; ++i) { - this.setCell(pos + i, this.loadCell(pos + n + i, cell)); + /** + * Set data at `index` to `cell`. + */ + public setCell(index: number, cell: ICellData): void { + const width = cell.getWidth(); + if (cell.content & Content.IS_COMBINED_MASK) { + const str = cell.combinedData; + const nstr = str.length; + const arr = new Uint32Array(nstr); + let istr = 0; + let iarr = 0; + while (istr < nstr) { + const cp = str.codePointAt(istr) || 0; + arr[iarr++] += cp; + istr += cp >= 0x10000 ? 2 : 1; } - for (let i = this.length - n; i < this.length; ++i) { - this.setCell(i, fillCellData); + if (iarr <= 1) { + this.setCellFromCodepoint(index, iarr > 0 ? arr[0] : NULL_CELL_CODE, width, cell); + } else { + const lindex = index + this.logicalStartColumn(); + const add = this.preInsert(lindex, cell); // FIXME + let curColumn = this._cachedColumn(); + let idata = this._cachedDataIndex(); + let inext = idata; + let cellColumn = curColumn; + const kind = width === 2 ? DataKind.CLUSTER_START_W2 : DataKind.CLUSTER_START_W1; + idata = inext; + cellColumn = curColumn; + curColumn += width; + this.addEmptyDataElements(inext, iarr); + this.data()[inext++] = BufferLine.wSet1(kind, arr[0] + ((iarr - 1) << 21)); + for (let i = 1; i < iarr; i++) { + this.data()[inext++] = BufferLine.wSet1(DataKind.CLUSTER_CONTINUED, arr[i]); + } + this._cacheSetColumnDataIndex(cellColumn, idata); + if (idata < this.dataLength()) { + this.logicalLine().deleteCellsOnly(inext, width); + } } } else { - for (let i = pos; i < this.length; ++i) { - this.setCell(i, fillCellData); - } - } - - // handle fullwidth at pos: - // - reset pos-1 if wide char - // - reset pos if width==0 (previous second cell of a wide char) - if (pos && this.getWidth(pos - 1) === 2) { - this.setCellFromCodepoint(pos - 1, 0, 1, fillCellData); - } - if (this.getWidth(pos) === 0 && !this.hasContent(pos)) { - this.setCellFromCodepoint(pos, 0, 1, fillCellData); + this.setCellFromCodepoint(index, cell.getCode(), width, cell); } } - public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void { - // full branching on respectProtect==true, hopefully getting fast JIT for standard case - if (respectProtect) { - if (start && this.getWidth(start - 1) === 2 && !this.isProtected(start - 1)) { - this.setCellFromCodepoint(start - 1, 0, 1, fillCellData); - } - if (end < this.length && this.getWidth(end - 1) === 2 && !this.isProtected(end)) { - this.setCellFromCodepoint(end, 0, 1, fillCellData); - } - while (start < end && start < this.length) { - if (!this.isProtected(start)) { - this.setCell(start, fillCellData); - } - start++; + public setCellFromCodepoint(index: RowColumn, codePoint: number, width: number, attrs: IAttributeData): void { + if (codePoint === NULL_CELL_CODE) { + if (width === 0) { + // i.e. combining character + // FIXME - usually a no-op + } else { + this.eraseCells(index, index + 1, attrs); } return; } - - // handle fullwidth at start: reset cell one to the left if start is second cell of a wide char - if (start && this.getWidth(start - 1) === 2) { - this.setCellFromCodepoint(start - 1, 0, 1, fillCellData); + const lindex = index + this.logicalStartColumn(); + const add = this.preInsert(lindex, attrs); // FIXME + let curColumn = this._cachedColumn(); + let idata = this._cachedDataIndex(); + let inext; + if (add || idata === this.dataLength() || lindex === curColumn) + {inext = idata;} + else { + const kind = BufferLine.wKind(this.data()[idata]); + if (BufferLine.wKindIsText(kind)) + {inext = this.clusterEnd(idata);} + else + {inext = idata;} } - // handle fullwidth at last cell + 1: reset to empty cell if it is second part of a wide char - if (end < this.length && this.getWidth(end - 1) === 2) { - this.setCellFromCodepoint(end, 0, 1, fillCellData); + let cellColumn = curColumn; + const kind = width === 2 ? DataKind.CHAR_W2 : DataKind.CHAR_W1; + idata = inext; + cellColumn = curColumn; + curColumn += width; + // FIXME optimize of overwriting simple text in-place + this.addEmptyDataElements(inext, 1); + this.data()[inext++] = BufferLine.wSet1(kind, codePoint); + this._cacheSetColumnDataIndex(cellColumn, idata); + if (idata < this.dataLength()) { + this.logicalLine().deleteCellsOnly(inext, width); } + } - while (start < end && start < this.length) { - this.setCell(start++, fillCellData); + // DEPRECATED + public addCodepointToCell(index: number, codePoint: number, width: number): void { + const cell = this.loadCell(index, new CellData()); + let content = cell.content; + if (cell.content & Content.IS_COMBINED_MASK) { + cell.combinedData += stringFromCodePoint(codePoint); + } else { + if (content & Content.CODEPOINT_MASK) { + // normal case for combining chars: + // - move current leading char + new one into combined string + // - set combined flag + cell.combinedData = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint); + content &= ~Content.CODEPOINT_MASK; // set codepoint in buffer to 0 + content |= Content.IS_COMBINED_MASK; + } else { + // should not happen - we actually have no data in the cell yet + // simply set the data in the cell buffer with a width of 1 + content = codePoint | (1 << Content.WIDTH_SHIFT); + } } + if (width) { + content &= ~Content.WIDTH_MASK; + content |= width << Content.WIDTH_SHIFT; + } + cell.content = content; + this.setCell(index, cell); } /** @@ -346,28 +899,32 @@ export class BufferLine implements IBufferLine { * to hold the new buffer line data. * Returns a boolean indicating, whether a `cleanupMemory` call would free * excess memory (true after shrinking > CLEANUP_THRESHOLD). + * NOTE only used for testing? */ public resize(cols: number, fillCellData: ICellData): boolean { if (cols === this.length) { - return this._data.length * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength; + return this.shouldCleanupMemory(); } - const uint32Cells = cols * CELL_SIZE; + const uint32Cells = cols * 2; // FIXME if (cols > this.length) { - if (this._data.buffer.byteLength >= uint32Cells * 4) { + /* + if (this.data().buffer.byteLength >= uint32Cells * 4) { // optimization: avoid alloc and data copy if buffer has enough room - this._data = new Uint32Array(this._data.buffer, 0, uint32Cells); + this.data() = new Uint32Array(this.data().buffer, 0, uint32Cells); } else { // slow path: new alloc and full data copy const data = new Uint32Array(uint32Cells); - data.set(this._data); - this._data = data; + data.set(this.data()); + this.data() = data; } + */ for (let i = this.length; i < cols; ++i) { this.setCell(i, fillCellData); } } else { // optimization: just shrink the view on existing buffer - this._data = this._data.subarray(0, uint32Cells); + /* + this.data() = this.data().subarray(0, uint32Cells); // Remove any cut off combined data const keys = Object.keys(this._combined); for (let i = 0; i < keys.length; i++) { @@ -383,169 +940,547 @@ export class BufferLine implements IBufferLine { if (key >= cols) { delete this._extendedAttrs[key]; } - } + } + */ } this.length = cols; - return uint32Cells * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength; + return this.shouldCleanupMemory(); } - /** - * Cleanup underlying array buffer. - * A cleanup will be triggered if the array buffer exceeds the actual used - * memory by a factor of CLEANUP_THRESHOLD. - * Returns 0 or 1 indicating whether a cleanup happened. - */ - public cleanupMemory(): number { - if (this._data.length * 4 * CLEANUP_THRESHOLD < this._data.buffer.byteLength) { - const data = new Uint32Array(this._data.length); - data.set(this._data); - this._data = data; - return 1; - } - return 0; + /** fill a line with fillCharData */ + public fill(fillCellData: ICellData, respectProtect?: boolean): void { + this.replaceCells(0, this.length, fillCellData, respectProtect); } - /** fill a line with fillCharData */ - public fill(fillCellData: ICellData, respectProtect: boolean = false): void { - // full branching on respectProtect==true, hopefully getting fast JIT for standard case - if (respectProtect) { - for (let i = 0; i < this.length; ++i) { - if (!this.isProtected(i)) { - this.setCell(i, fillCellData); - } + public getTrimmedLength(countBackground: boolean = false, logical: boolean = false): number { + let cols = 0; + let skipped = 0; + const startIndex = !logical && this instanceof WrappedBufferLine + ? this.startIndex : 0; + const data = this.data(); + const dlen = this.dataLength(); + const endColumn = this.nextRowSameLine && ! logical ? this.nextRowSameLine.startColumn : Infinity; + const startColumn = !logical && this instanceof WrappedBufferLine ? this.startColumn : 0; + let bg = this._cachedBg(); // FIXME ? + let bgCol = 0; + let col = startColumn; + for (let idata = startIndex; col < endColumn && idata < dlen; idata++) { + const word = data[idata]; + const kind = BufferLine.wKind(word); + const w = kind === DataKind.CHAR_W2 || kind === DataKind.CLUSTER_START_W2 ? 2 : 1; + let wcols = 0; + switch (kind) { + case DataKind.BG: + bg = word & 0x3ffffff; + bgCol = cols + skipped; + break; + case DataKind.FG: + case DataKind.STYLE_FLAGS: + break; + case DataKind.SKIP_COLUMNS: + let skip = BufferLine.wSkipCount(word); + if (idata === startIndex && this instanceof WrappedBufferLine) { + skip -= this.startColumn - this.startIndexColumn; + } + col += skip; + skipped += skip; + break; + case DataKind.CLUSTER_START_W1: + case DataKind.CLUSTER_START_W2: + idata += BufferLine.wContinuedCount(word); + wcols = w; + break; + case DataKind.CHAR_W1: + case DataKind.CHAR_W2: + wcols = w; + break; + case DataKind.CLUSTER_CONTINUED: + break; // should be skipped + } + col += wcols; + if (wcols) { + cols += skipped + wcols; + skipped = 0; } - return; } - this._combined = {}; - this._extendedAttrs = {}; - for (let i = 0; i < this.length; ++i) { - this.setCell(i, fillCellData); + if (countBackground) { + cols += skipped; + cols = bg ? this.length : Math.max(cols, bgCol); } + return cols; } - /** alter to a full copy of line */ - public copyFrom(line: BufferLine): void { - if (this.length !== line.length) { - this._data = new Uint32Array(line._data); - } else { - // use high speed copy if lengths are equal - this._data.set(line._data); + public getNoBgTrimmedLength(): number { + return this.getTrimmedLength(true); + } + + public translateToString(trimRight: boolean = false, startCol: number = 0, endCol: number = -1, outColumns?: number[], skipReplace: string = WHITESPACE_CELL_CHAR): string { + const lineStart = this.logicalStartColumn(); + let logicalEndColumn = endCol >= 0 ? lineStart + endCol + : this.nextRowSameLine ? this.nextRowSameLine.logicalStartColumn() + : lineStart + this.length; + if (trimRight) { + logicalEndColumn = Math.min(logicalEndColumn, lineStart + this.getTrimmedLength()); } - this.length = line.length; - this._combined = {}; - for (const el in line._combined) { - this._combined[el] = line._combined[el]; + + let s = this.logicalLine().translateLogicalToString(false, lineStart + startCol, logicalEndColumn, outColumns, skipReplace); + if (!trimRight && endCol < 0) { s += ' '.repeat(this.length - logicalEndColumn + lineStart)} + if (outColumns && lineStart !== 0) { + for (let i = outColumns.length; --i >= 0; ) { + outColumns[i] -= lineStart; + } } - this._extendedAttrs = {}; - for (const el in line._extendedAttrs) { - this._extendedAttrs[el] = line._extendedAttrs[el]; + return s; + } +} + +export class LogicalBufferLine extends BufferLine implements IBufferLine { + protected _data: Uint32Array; + // Each item in _data is a 4-bit DataKind and 28 bits data. + _dataLength: number = 0; // active length of _data array + /** Width in collumns if there is no line-wrapping. */ + public get logicalWidth(): number { return this.getTrimmedLength(false, true); } + //logicalWidth: number = 0; // FIXME needs work updating this + public reflowNeeded: boolean = false; + + // Key is index in _data array that has STYLE_FLAGS kind with HAS_EXTENDED. + _extendedAttrs: IExtendedAttrs[] = []; + + // Maybe move these to to Buffer? Would save space. but with API complications. + _cache1: number = 0; + _cache2: number = 0; + _cache3: number = 0; + _cache4: number = -1; + + constructor(cols: number, fillCellData?: ICellData, src?: WrappedBufferLine, startIndex: number = 0, data: Uint32Array = new Uint32Array(cols)) { + super(); + // MAYBE: const buffer = new ArrayBuffer(0, { maxByteLength: 6 * cols }); + // const buffer = new ArrayBuffer(4 * cols, { maxByteLength: 6 * cols }); + this.length = cols; + if (src) { + const lline = src.logicalLine(); + const oldStart = startIndex; + this._data = lline._data.slice(oldStart); + this._dataLength = lline._dataLength - oldStart; + this._extendedAttrs = lline._extendedAttrs.slice(oldStart); + if (fillCellData) { this.preInsert(0, fillCellData); } + } else { + this._data = data; + this._dataLength = 0; + if (fillCellData) { this.replaceCells(0, this.length, fillCellData, false); } } - this.isWrapped = line.isWrapped; } + public override logicalLine(): LogicalBufferLine { return this; } + public override logicalStartColumn(): LineColumn { return 0; } + override data(): Uint32Array { return this._data; } + override dataLength(): number { return this._dataLength; } + override _cachedBg(): number { return this._cache2; } + override _cachedFg(): number { return this._cache3; } + public get isWrapped(): boolean { return false; } - /** create a new clone */ - public clone(): IBufferLine { - const newLine = new BufferLine(0); - newLine._data = new Uint32Array(this._data); - newLine.length = this.length; - for (const el in this._combined) { - newLine._combined[el] = this._combined[el]; + protected _cachedColumnInRow(): RowColumn { return (this.logicalLine()._cache1 & 0xFFFF); } + + /** Creates a new LogicalBufferLine but reuses old _data buffer. + * The oldLine_data buffer is resized to _dataLength, + * while the old _data buffer is reused for the new line. + */ + public static makeAndTrim(cols: number, fillCellData?: ICellData, oldRow?: IBufferLine): LogicalBufferLine { + if (oldRow) { + const oldLine = (oldRow as BufferLine).logicalLine(); + if (oldLine._data.length > oldLine._dataLength) { + const oldData = oldLine._data; + oldLine._data = oldData.slice(0, oldLine._dataLength); + const newLine = new LogicalBufferLine(cols, undefined, undefined, 0, oldData); + newLine._data = oldData; + if (fillCellData) { newLine.preInsert(0, fillCellData); } + return newLine; + } } - for (const el in this._extendedAttrs) { - newLine._extendedAttrs[el] = this._extendedAttrs[el]; + return new LogicalBufferLine(cols, fillCellData); + } + + // count can be negative + addEmptyDataElements(position: number, count: number, insertBeforeEnd?: boolean) { + const oldDataLength = this._dataLength; + this.resizeData(oldDataLength + count); + if (count < 0) { + this.data().copyWithin(position, position - count, oldDataLength); + } else { + this.data().copyWithin(position + count, position, oldDataLength); + } + this._dataLength += count; + for (let next = this.nextRowSameLine; next; next = next.nextRowSameLine) { + if (count < 0 ? next.startIndex >= position - count: insertBeforeEnd ? next.startIndex >= position : next.startIndex > position) + {next.startIndex += count;} + } + if (count < 0) { + this._extendedAttrs.copyWithin(position, position - count, oldDataLength); + } else { + this._extendedAttrs.length = this._dataLength + this._extendedAttrs.copyWithin(position + count, position, oldDataLength); + } + if (this._extendedAttrs.length > this._dataLength) { + this._extendedAttrs.length = this._dataLength; } - newLine.isWrapped = this.isWrapped; - return newLine; } - public getTrimmedLength(): number { - for (let i = this.length - 1; i >= 0; --i) { - if ((this._data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK)) { - return i + (this._data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT); - } + resizeData(size: number): void { + if (size > this.data().length) { + // buffer = new ArrayBuffer(buffer.byteLength, { maxByteLength: 6 * size }); + const dataNew = new Uint32Array((3 * size) >> 1); // FIXME + dataNew.set(this._data); + this.logicalLine()._data = dataNew; } - return 0; } - public getNoBgTrimmedLength(): number { - for (let i = this.length - 1; i >= 0; --i) { - if ((this._data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK) || (this._data[i * CELL_SIZE + Cell.BG] & Attributes.CM_MASK)) { - return i + (this._data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT); - } + /** + * Cleanup underlying array buffer. + * A cleanup will be triggered if the array buffer exceeds the actual used + * memory by a factor of CLEANUP_THRESHOLD. + * Returns 0 or 1 indicating whether a cleanup happened. + */ + public cleanupMemory(): number { + if (this.shouldCleanupMemory()) { + const data = new Uint32Array(this.dataLength()); + data.set(this.data()); + this._data = data; + return 1; } return 0; } - public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void { - const srcData = src._data; - if (applyInReverse) { - for (let cell = length - 1; cell >= 0; cell--) { - for (let i = 0; i < CELL_SIZE; i++) { - this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i]; - } - if (srcData[(srcCol + cell) * CELL_SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[destCol + cell] = src._extendedAttrs[srcCol + cell]; - } + // FIXME doesn't properly handle if delete range starts or ends in middle + // of wide character + /** Internal - delete n columns, with no adjust at end of line. + * idata0 - index in _data array of start of deletion. + * n - number of columns to delete. + */ + deleteCellsOnly(idata0: number, n: number): void { + let todo = n; + const data = this.data(); + let idata = idata0; + let dskipFirst = idata; let dskipLast = -1; let w; + let fgValue = -1; // cursor.getFg(); + let bgValue = -1; // cursor.getBg(); + let styleValue = -1; + let extended = undefined; // cursor.getStyleFlags(); // FIXME handle extendedattrs + + // Move start backwards before style entries. + // The goal is to remove no-longer needed style entries. + while (idata > 0) { + let skipItem = true; + const word = data[idata-1]; + switch (BufferLine.wKind(word)) { + case DataKind.BG: bgValue = word & 0x3ffffff; break; + case DataKind.FG: fgValue = word & 0x3ffffff; break; + case DataKind.STYLE_FLAGS: + styleValue = word & 0xfffffff; + extended = (word & StyleFlags.HAS_EXTENDED) !== 0 && this._extendedAttrs[idata - 1]; + break; + default: skipItem = false; } - } else { - for (let cell = 0; cell < length; cell++) { - for (let i = 0; i < CELL_SIZE; i++) { - this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i]; - } - if (srcData[(srcCol + cell) * CELL_SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) { - this._extendedAttrs[destCol + cell] = src._extendedAttrs[srcCol + cell]; - } + if (skipItem) { + idata--; + dskipFirst = idata; + dskipLast = idata0-1; + } else { + break; } } - // Move any combined data over as needed, FIXME: repeat for extended attrs - const srcCombinedKeys = Object.keys(src._combined); - for (let i = 0; i < srcCombinedKeys.length; i++) { - const key = parseInt(srcCombinedKeys[i], 10); - if (key >= srcCol) { - this._combined[key - srcCol + destCol] = src._combined[key]; + let skipNeeded = 0; + for (; todo > 0 && idata < this.dataLength(); idata++) { + const word = data[idata]; + const kind = BufferLine.wKind(word); + switch (kind) { + case DataKind.FG: + fgValue = word & 0x3ffffff; + dskipLast = idata; + break; + case DataKind.BG: + bgValue = word & 0x3ffffff; + dskipLast = idata; + break; + case DataKind.STYLE_FLAGS: + dskipLast = idata; + styleValue = word & 0xfffffff; + extended = (word & StyleFlags.HAS_EXTENDED) !== 0 && this._extendedAttrs[idata]; + break; + case DataKind.SKIP_COLUMNS: + const wlen = BufferLine.wSkipCount(word); + if (wlen <= todo) { // FIXME + dskipLast = idata; + todo -= wlen; + } else { + const delta = Math.min(todo, wlen); + this.data()[idata] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, wlen - delta); + todo -= delta; + } + break; + case DataKind.CHAR_W1: + case DataKind.CHAR_W2: + w = kind - DataKind.CHAR_W1; // 0, or 1 if wide characters + dskipLast = idata; + todo -= 1 << w; + if (todo < 0) { skipNeeded = -todo; } + break; + case DataKind.CLUSTER_START_W1: + case DataKind.CLUSTER_START_W2: + w = kind - DataKind.CLUSTER_START_W1; // 0, or 1 if wide characters + const clEnd = this.clusterEnd(idata); + idata = clEnd; + dskipLast = idata; + todo -= (1 << w); + break; } } + idata0 = dskipFirst; + if (bgValue >= 0) { + this.data()[idata0++] = BufferLine.wSet1(DataKind.BG, bgValue); + } + if (fgValue >= 0 && idata0 !== this._dataLength) { + this.data()[idata0++] = BufferLine.wSet1(DataKind.FG, fgValue); + } + if (styleValue >= 0 && idata0 !== this._dataLength) { + if ((styleValue & StyleFlags.HAS_EXTENDED) !== 0 && extended) { + if (! extended) throw(new Error("missing extended")); + this._extendedAttrs[idata0] = extended; + } + this.data()[idata0++] = BufferLine.wSet1(DataKind.STYLE_FLAGS, styleValue); + } + if (skipNeeded > 0) { + this.data()[idata0++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, skipNeeded); + } + if (dskipLast >= 0) { + const dcount = dskipLast + 1 - idata0; + this.addEmptyDataElements(idata0, - dcount); + } } - /** - * Translates the buffer line to a string. - * - * @param trimRight Whether to trim any empty cells on the right. - * @param startCol The column to start the string (0-based inclusive). - * @param endCol The column to end the string (0-based exclusive). - * @param outColumns if specified, this array will be filled with column numbers such that - * `returnedString[i]` is displayed at `outColumns[i]` column. `outColumns[returnedString.length]` - * is where the character following `returnedString` will be displayed. - * - * When a single cell is translated to multiple UTF-16 code units (e.g. surrogate pair) in the - * returned string, the corresponding entries in `outColumns` will have the same column number. - */ - public translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string { - startCol = startCol ?? 0; - endCol = endCol ?? this.length; - if (trimRight) { - endCol = Math.min(endCol, this.getTrimmedLength()); + public setWrapped(previousLine: BufferLine): WrappedBufferLine { + const column = this.logicalStartColumn() + previousLine.length; + const content = previousLine.moveToLineColumn(column); + const neededPadding = column - previousLine._cachedColumn(); + const startLine = previousLine.logicalLine(); + let startLength = startLine._dataLength; + const padWithSpaces = false; // use spaces or SKIP_COLUMNS? + let padLength = neededPadding <= 0 ? 0 : padWithSpaces ? neededPadding : 1; + startLine.resizeData(this._dataLength + startLength + padLength); + if (neededPadding > 0) { + if (padWithSpaces) { + while (--padLength >= 0) { + startLine._data[startLength++] = BufferLine.wSet1(DataKind.CHAR_W1, 32); + } + } else { + startLine._data[startLength++] = BufferLine.wSet1(DataKind.SKIP_COLUMNS, neededPadding); + } + } + startLine._data.set(this._data.subarray(0, this._dataLength), startLength); + startLine._dataLength = startLength + this._dataLength; + for (let i = this._extendedAttrs.length; --i >= 0; ) { + const attr = this._extendedAttrs[i]; + if (attr) { startLine._extendedAttrs[startLength + i] = attr; } } + const newRow = new WrappedBufferLine(previousLine); + newRow.nextRowSameLine = this.nextRowSameLine; + newRow.setStartFromCache(startLine, column, content); + for (let following = this.nextRowSameLine; following; + following = following?.nextRowSameLine) { + following.startColumn += newRow.startColumn; + following.startIndexColumn += newRow.startIndexColumn; + following.startIndex += newRow.startIndex; + } + return newRow; + } + + public translateLogicalToString(trimRight: boolean = false, startCol: number = 0, endCol: number = Infinity, outColumns?: number[], skipReplace: string = WHITESPACE_CELL_CHAR): string { if (outColumns) { outColumns.length = 0; } - let result = ''; - while (startCol < endCol) { - const content = this._data[startCol * CELL_SIZE + Cell.CONTENT]; - const cp = content & Content.CODEPOINT_MASK; - const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR; - result += chars; - if (outColumns) { - for (let i = 0; i < chars.length; ++i) { - outColumns.push(startCol); + let s = ''; + let col = 0; + // assuming skipReplace is ' ' or ''. + const skipReplaceLength = skipReplace.length; + let pendingSkips = 0; + let pendingStart = -1; + let pendingLength = 0; + const data = this.data(); + function emitPendingSkips(): void { + if (pendingSkips > 0) { + s += skipReplace.repeat(pendingSkips); + if (outColumns) { + const col0 = col - pendingSkips; + for (let i = 0; i < pendingSkips; ++i) { + outColumns.push(col0 + i * skipReplaceLength); + } } + pendingSkips = 0; } - startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by at least 1 + } + for (let idata = 0; idata < this.dataLength() && col < endCol; idata++) { + const word = this.data()[idata]; + const kind = BufferLine.wKind(word); + const wide = kind === DataKind.CHAR_W2 || kind === DataKind.CLUSTER_START_W2 ? 1 : 0; + let wcols; + switch (kind) { + case DataKind.FG: + case DataKind.BG: + case DataKind.STYLE_FLAGS: + break; + case DataKind.SKIP_COLUMNS: + let wlen = BufferLine.wSkipCount(word); + if (col + wlen > startCol) { + if (col < startCol) { + wlen -= startCol - col; + col = startCol; + } + if (col + wlen > endCol) { + wlen = endCol - col; + } + pendingSkips += wlen; + } + col += wlen; + break; + case DataKind.CHAR_W1: + case DataKind.CHAR_W2: + case DataKind.CLUSTER_START_W1: + case DataKind.CLUSTER_START_W2: + const wcols = BufferLine.wTextWidth(kind); + const ncontinued = BufferLine.wContinuedCount(word); + if (col >= startCol && col < endCol) { + emitPendingSkips(); + const t = utf32ToString(data, idata, idata + ncontinued + 1); + if (outColumns) { + for (let i = t.length; --i >= 0; ) { outColumns.push(col); } + } + s += t; + } + idata += ncontinued; + col += wcols; + break; + } + } + if (col < startCol) { col = startCol; } + if (! trimRight && col < endCol && endCol !== Infinity) { + pendingSkips += endCol - col; + col = endCol; + } + if (! trimRight) { + //col += pendingSkips; + emitPendingSkips(); } if (outColumns) { - outColumns.push(startCol); + outColumns.push(col); + } + return s; + } + + /** for debugging */ + getText(skipReplace: string = ' '): string { + return this.translateLogicalToString(true, 0, this.length, undefined, skipReplace); + } +} + +export class WrappedBufferLine extends BufferLine implements IBufferLine { + _logicalLine: LogicalBufferLine; + + /** Number of logical columns in previous rows. + * Also: logical column number (column number assuming infinitely-wide + * terminal) corresponding to the start of this row. + * If R is 0 for the previous LogicalBufferLine, R is 1 for first + * WrappedBufferLine and so on, startColumn will *usually* be N*W + * (where W is the width of the terminal in columns) but may be slightly + * different when a wide character at column W-1 must wrap "early". + */ + startColumn: LineColumn = 0; + + /** Index in data array containing first column. + * If _data[startIndex] is a SKIP_COLUMNS, some columns might be the + * end of the previous row, and some might be the current row. + * In that case, startColumn-startIndexColumn is the number of columns + * in the previous row. + */ + startIndex: number = 0; + + /** Column number corresponding to startIndex. + * Usually the same as startColumn, but may be less if startIndex refers to a SKIP_COLUMNS. + */ + startIndexColumn: number = 0; + + // startIndex, startFg, startBg, startStyle are used by _cacheReset + // to optimize moveToColumn on same row. It might be best to get rid of them; + // to mitigate the performance cost we could support backwards movement by moveToColumn. + // Changing Data>FG etc to use xor-encoding would help. TODO. + startFg: number = 0; + startBg: number = 0; + startStyle: number = -1; + + constructor(prevRow: BufferLine) { + super(); + const logicalLine = prevRow.logicalLine(); + prevRow.nextRowSameLine = this; + this._logicalLine = logicalLine; + this.length = logicalLine.length; + } + + public get isWrapped(): boolean { return true; } + + public setStartFromCache(line: BufferLine, column: LineColumn, content: number): void { + this.startColumn = content === 0 ? line._cachedColumn() : column; + this.startIndex = line._cachedDataIndex(); + this.startIndexColumn = line._cachedColumn(); + this.startBg = line._cachedBg(); + this.startFg = line._cachedFg(); + this.startStyle = line._cachedStyleFlagsIndex(); + } + + public override logicalLine(): LogicalBufferLine { return this._logicalLine; } + public override logicalStartColumn(): LineColumn { return this.startColumn; } + protected override data(): Uint32Array { return this._logicalLine.data(); } + public override dataLength(): number { return this._logicalLine.dataLength(); } + public override _cachedBg(): number { return this._logicalLine._cachedBg(); } + public override _cachedFg(): number { return this._logicalLine._cachedFg(); } + addEmptyDataElements(position: number, count: number, insertBeforeEnd?: boolean): void { + this._logicalLine.addEmptyDataElements(position, count, insertBeforeEnd); + } + protected _cachedColumnInRow(): RowColumn { return (this.logicalLine()._cache1 & 0xFFFF) - this.startIndexColumn; } + protected _cacheReset(): void { + this._cacheSetFgBg(this.startFg, this.startBg); + this._cacheSetStyleFlagsIndex(this.startStyle); + this._cacheSetColumnDataIndex(this.startIndexColumn, this.startIndex); + } + public resizeData(size: number): void { this._logicalLine.resizeData(size); } + public cleanupMemory(): number { return 0;} + public getPreviousRow(): BufferLine { + for (let row: BufferLine = this._logicalLine; ;) { + const next = row.nextRowSameLine as BufferLine; + if (next === this) { + return row; + } + row = next; } - return result; + } + + public asUnwrapped(prevRow: BufferLine = this.getPreviousRow()): LogicalBufferLine { + const oldStartColumn = this.logicalStartColumn(); + prevRow.nextRowSameLine = undefined; + const oldLine = prevRow.logicalLine(); + oldLine.moveToLineColumn(oldStartColumn, 1); + const startIndex = oldLine._cachedDataIndex(); + const cell = new CellData(); + this.loadCell(oldStartColumn, cell); + const newRow = new LogicalBufferLine(this.length, cell, this, startIndex); + newRow.nextRowSameLine = this.nextRowSameLine; + const oldStart = this.startIndex; + const oldIndexColumn = this.startIndexColumn; + for (let nextRow = newRow.nextRowSameLine; nextRow; nextRow = nextRow.nextRowSameLine) { + nextRow.startColumn -= oldStartColumn; + nextRow.startIndex -= oldStart; + nextRow.startIndexColumn -= oldIndexColumn; + nextRow._logicalLine = newRow; + } + oldLine._dataLength = startIndex; + return newRow; + } } diff --git a/src/common/buffer/BufferReflow.test.ts b/src/common/buffer/BufferReflow.test.ts index b351b89c42..5f0e3c7fdf 100644 --- a/src/common/buffer/BufferReflow.test.ts +++ b/src/common/buffer/BufferReflow.test.ts @@ -10,7 +10,7 @@ import { reflowSmallerGetNewLineLengths } from 'common/buffer/BufferReflow'; describe('BufferReflow', () => { describe('reflowSmallerGetNewLineLengths', () => { it('should return correct line lengths for a small line with wide characters', () => { - const line = new BufferLine(4); + const line = BufferLine.make(4); line.set(0, [0, '汉', 2, '汉'.charCodeAt(0)]); line.set(1, [0, '', 0, 0]); line.set(2, [0, '语', 2, '语'.charCodeAt(0)]); @@ -20,7 +20,7 @@ describe('BufferReflow', () => { assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 2), [2, 2], 'line: 汉, 语'); }); it('should return correct line lengths for a large line with wide characters', () => { - const line = new BufferLine(12); + const line = BufferLine.make(12); for (let i = 0; i < 12; i += 4) { line.set(i, [0, '汉', 2, '汉'.charCodeAt(0)]); line.set(i + 2, [0, '语', 2, '语'.charCodeAt(0)]); @@ -42,7 +42,7 @@ describe('BufferReflow', () => { assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 2), [2, 2, 2, 2, 2, 2], 'line: 汉, 语, 汉, 语, 汉, 语'); }); it('should return correct line lengths for a string with wide and single characters', () => { - const line = new BufferLine(6); + const line = BufferLine.make(6); line.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]); line.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]); line.set(2, [0, '', 0, 0]); @@ -56,14 +56,14 @@ describe('BufferReflow', () => { assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 2), [1, 2, 2, 1], 'line: a, 汉, 语, b'); }); it('should return correct line lengths for a wrapped line with wide and single characters', () => { - const line1 = new BufferLine(6); + const line1 = BufferLine.make(6); line1.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]); line1.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]); line1.set(2, [0, '', 0, 0]); line1.set(3, [0, '语', 2, '语'.charCodeAt(0)]); line1.set(4, [0, '', 0, 0]); line1.set(5, [0, 'b', 1, 'b'.charCodeAt(0)]); - const line2 = new BufferLine(6, undefined, true); + const line2 = BufferLine.make(6, undefined, true); line2.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]); line2.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]); line2.set(2, [0, '', 0, 0]); @@ -78,7 +78,7 @@ describe('BufferReflow', () => { assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 2), [1, 2, 2, 2, 2, 2, 1], 'lines: a, 汉, 语, ba, 汉, 语, b'); }); it('should work on lines ending in null space', () => { - const line = new BufferLine(5); + const line = BufferLine.make(5); line.set(0, [0, '汉', 2, '汉'.charCodeAt(0)]); line.set(1, [0, '', 0, 0]); line.set(2, [0, '语', 2, '语'.charCodeAt(0)]); diff --git a/src/common/buffer/BufferReflow.ts b/src/common/buffer/BufferReflow.ts index 44aa0976fe..8474761216 100644 --- a/src/common/buffer/BufferReflow.ts +++ b/src/common/buffer/BufferReflow.ts @@ -7,161 +7,6 @@ import { BufferLine } from 'common/buffer/BufferLine'; import { CircularList } from 'common/CircularList'; import { IBufferLine, ICellData } from 'common/Types'; -export interface INewLayoutResult { - layout: number[]; - countRemoved: number; -} - -/** - * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed - * when a wrapped line unwraps. - * @param lines The buffer lines. - * @param oldCols The columns before resize - * @param newCols The columns after resize. - * @param bufferAbsoluteY The absolute y position of the cursor (baseY + cursorY). - * @param nullCell The cell data to use when filling in empty cells. - * @param reflowCursorLine Whether to reflow the line containing the cursor. - */ -export function reflowLargerGetLinesToRemove(lines: CircularList, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData, reflowCursorLine: boolean): number[] { - // Gather all BufferLines that need to be removed from the Buffer here so that they can be - // batched up and only committed once - const toRemove: number[] = []; - - for (let y = 0; y < lines.length - 1; y++) { - // Check if this row is wrapped - let i = y; - let nextLine = lines.get(++i) as BufferLine; - if (!nextLine.isWrapped) { - continue; - } - - // Check how many lines it's wrapped for - const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine]; - while (i < lines.length && nextLine.isWrapped) { - wrappedLines.push(nextLine); - nextLine = lines.get(++i) as BufferLine; - } - - if (!reflowCursorLine) { - // If these lines contain the cursor don't touch them, the program will handle fixing up - // wrapped lines with the cursor - if (bufferAbsoluteY >= y && bufferAbsoluteY < i) { - y += wrappedLines.length - 1; - continue; - } - } - - // Copy buffer data to new locations - let destLineIndex = 0; - let destCol = getWrappedLineTrimmedLength(wrappedLines, destLineIndex, oldCols); - let srcLineIndex = 1; - let srcCol = 0; - while (srcLineIndex < wrappedLines.length) { - const srcTrimmedTineLength = getWrappedLineTrimmedLength(wrappedLines, srcLineIndex, oldCols); - const srcRemainingCells = srcTrimmedTineLength - srcCol; - const destRemainingCells = newCols - destCol; - const cellsToCopy = Math.min(srcRemainingCells, destRemainingCells); - - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol, destCol, cellsToCopy, false); - - destCol += cellsToCopy; - if (destCol === newCols) { - destLineIndex++; - destCol = 0; - } - srcCol += cellsToCopy; - if (srcCol === srcTrimmedTineLength) { - srcLineIndex++; - srcCol = 0; - } - - // Make sure the last cell isn't wide, if it is copy it to the current dest - if (destCol === 0 && destLineIndex !== 0) { - if (wrappedLines[destLineIndex - 1].getWidth(newCols - 1) === 2) { - wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[destLineIndex - 1], newCols - 1, destCol++, 1, false); - // Null out the end of the last row - wrappedLines[destLineIndex - 1].setCell(newCols - 1, nullCell); - } - } - } - - // Clear out remaining cells or fragments could remain; - wrappedLines[destLineIndex].replaceCells(destCol, newCols, nullCell); - - // Work backwards and remove any rows at the end that only contain null cells - let countToRemove = 0; - for (let i = wrappedLines.length - 1; i > 0; i--) { - if (i > destLineIndex || wrappedLines[i].getTrimmedLength() === 0) { - countToRemove++; - } else { - break; - } - } - - if (countToRemove > 0) { - toRemove.push(y + wrappedLines.length - countToRemove); // index - toRemove.push(countToRemove); - } - - y += wrappedLines.length - 1; - } - return toRemove; -} - -/** - * Creates and return the new layout for lines given an array of indexes to be removed. - * @param lines The buffer lines. - * @param toRemove The indexes to remove. - */ -export function reflowLargerCreateNewLayout(lines: CircularList, toRemove: number[]): INewLayoutResult { - const layout: number[] = []; - // First iterate through the list and get the actual indexes to use for rows - let nextToRemoveIndex = 0; - let nextToRemoveStart = toRemove[nextToRemoveIndex]; - let countRemovedSoFar = 0; - for (let i = 0; i < lines.length; i++) { - if (nextToRemoveStart === i) { - const countToRemove = toRemove[++nextToRemoveIndex]; - - // Tell markers that there was a deletion - lines.onDeleteEmitter.fire({ - index: i - countRemovedSoFar, - amount: countToRemove - }); - - i += countToRemove - 1; - countRemovedSoFar += countToRemove; - nextToRemoveStart = toRemove[++nextToRemoveIndex]; - } else { - layout.push(i); - } - } - return { - layout, - countRemoved: countRemovedSoFar - }; -} - -/** - * Applies a new layout to the buffer. This essentially does the same as many splice calls but it's - * done all at once in a single iteration through the list since splice is very expensive. - * @param lines The buffer lines. - * @param newLayout The new layout to apply. - */ -export function reflowLargerApplyNewLayout(lines: CircularList, newLayout: number[]): void { - // Record original lines so they don't get overridden when we rearrange the list - const newLayoutLines: BufferLine[] = []; - for (let i = 0; i < newLayout.length; i++) { - newLayoutLines.push(lines.get(newLayout[i]) as BufferLine); - } - - // Rearrange the list - for (let i = 0; i < newLayoutLines.length; i++) { - lines.set(i, newLayoutLines[i]); - } - lines.length = newLayout.length; -} - /** * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre- * compute the wrapping points since wide characters may need to be wrapped onto the following line. diff --git a/src/common/buffer/CellData.ts b/src/common/buffer/CellData.ts index 9454c553cf..6100ba7b9f 100644 --- a/src/common/buffer/CellData.ts +++ b/src/common/buffer/CellData.ts @@ -18,13 +18,30 @@ export class CellData extends AttributeData implements ICellData { obj.setFromCharData(value); return obj; } - /** Primitives from terminal buffer. */ + + public static fromChar(text: string, width: number = -1, fg: number = 0): CellData { + const obj = new CellData(); + obj.setFromChar(text, width, fg); + return obj; + } + + /** Primitives from terminal buffer. + * @deprecated + */ public content = 0; public fg = 0; public bg = 0; - public extended: IExtendedAttrs = new ExtendedAttrs(); + public combinedData = ''; - /** Whether cell contains a combined string. */ + + public copyFrom(src: CellData): void { + this.content = src.content; + this.fg = src.fg; + this.bg = src.bg; + this.extended = src.extended; + } + + /** Whether cell contains a combined string. DEPRECTED */ public isCombined(): number { return this.content & Content.IS_COMBINED_MASK; } @@ -49,27 +66,30 @@ export class CellData extends AttributeData implements ICellData { * of the last char in string to be in line with code in CharData. */ public getCode(): number { - return (this.isCombined()) - ? this.combinedData.charCodeAt(this.combinedData.length - 1) - : this.content & Content.CODEPOINT_MASK; + if (this.isCombined()) { + const chars = this.getChars(); + return chars.charCodeAt(chars.length - 1); + } + return this.content & Content.CODEPOINT_MASK; } - /** Set data from CharData */ - public setFromCharData(value: CharData): void { - this.fg = value[CHAR_DATA_ATTR_INDEX]; + public setFromChar(text: string, width: number = -1, fg: number = 0) { + width = width >= 0 ? width : stringFromCodePoint.length === 0 ? 0 : 1; + this.fg = fg; this.bg = 0; + let code = text.charCodeAt(0) || 0; let combined = false; + const length = text.length; // surrogates and combined strings need special treatment - if (value[CHAR_DATA_CHAR_INDEX].length > 2) { + if (length > 2) { combined = true; } - else if (value[CHAR_DATA_CHAR_INDEX].length === 2) { - const code = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0); + else if (length === 2) { // if the 2-char string is a surrogate create single codepoint // everything else is combined if (0xD800 <= code && code <= 0xDBFF) { - const second = value[CHAR_DATA_CHAR_INDEX].charCodeAt(1); + const second = text.charCodeAt(1); if (0xDC00 <= second && second <= 0xDFFF) { - this.content = ((code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); + code = ((code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000); } else { combined = true; @@ -79,14 +99,18 @@ export class CellData extends AttributeData implements ICellData { combined = true; } } - else { - this.content = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); - } if (combined) { - this.combinedData = value[CHAR_DATA_CHAR_INDEX]; - this.content = Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT); + this.combinedData = text; + code |= Content.IS_COMBINED_MASK; } + this.content = code | (width << Content.WIDTH_SHIFT); } + + /** Set data from CharData */ + public setFromCharData(value: CharData): void { + this.setFromChar(value[CHAR_DATA_CHAR_INDEX], value[CHAR_DATA_WIDTH_INDEX], value[CHAR_DATA_ATTR_INDEX]); + } + /** Get data as CharData. */ public getAsCharData(): CharData { return [this.fg, this.getChars(), this.getWidth(), this.getCode()]; diff --git a/src/common/buffer/Constants.ts b/src/common/buffer/Constants.ts index 5ce075cf78..e978cc725b 100644 --- a/src/common/buffer/Constants.ts +++ b/src/common/buffer/Constants.ts @@ -4,9 +4,10 @@ */ export const DEFAULT_COLOR = 0; -export const DEFAULT_ATTR = (0 << 18) | (DEFAULT_COLOR << 9) | (256 << 0); +export const DEFAULT_ATTR = 0; export const DEFAULT_EXT = 0; +// Deprecated export const CHAR_DATA_ATTR_INDEX = 0; export const CHAR_DATA_CHAR_INDEX = 1; export const CHAR_DATA_WIDTH_INDEX = 2; @@ -73,6 +74,8 @@ export const enum Content { WIDTH_SHIFT = 22 } +export const NULL_CELL_WORD = 1 << Content.WIDTH_MASK; + export const enum Attributes { /** * bit 1..8 blue in RGB, color in P256 and P16 @@ -98,6 +101,7 @@ export const enum Attributes { * bit 25..26 color mode: DEFAULT (0) | P16 (1) | P256 (2) | RGB (3) */ CM_MASK = 0x3000000, + CM_COLOR_MASK = 0x3ffffff, CM_DEFAULT = 0, CM_P16 = 0x1000000, CM_P256 = 0x2000000, @@ -106,30 +110,50 @@ export const enum Attributes { /** * bit 1..24 RGB room */ - RGB_MASK = 0xFFFFFF + RGB_MASK = 0xFFFFFF, + + /** + * bit 27..32 in bg/fg are used for FgFlags/BgFlags (style bits). + * This will probably change. + */ + STYLE_BITS_MASK = 0xFC000000 +} + +export const enum StyleFlags { + INVERSE = 0x4, + BOLD = 0x8, + UNDERLINE = 0x10, + BLINK = 0x20, + INVISIBLE = 0x40, + STRIKETHROUGH = 0x80, + ITALIC = 0x400, + DIM = 0x800, + HAS_EXTENDED = 0x1000, + PROTECTED = 0x2000, + OVERLINE = 0x4000 } -export const enum FgFlags { +export const enum FgFlags { // deprecated /** * bit 27..32 */ - INVERSE = 0x4000000, - BOLD = 0x8000000, - UNDERLINE = 0x10000000, - BLINK = 0x20000000, - INVISIBLE = 0x40000000, - STRIKETHROUGH = 0x80000000, + INVERSE = StyleFlags.INVERSE << 24, // 0x4000000, + BOLD = StyleFlags.BOLD << 24, // 0x8000000, + UNDERLINE = StyleFlags.UNDERLINE << 24, // 0x10000000, + BLINK = StyleFlags.BLINK << 24, // x20000000, + INVISIBLE = StyleFlags.INVISIBLE << 24, // 0x40000000, + STRIKETHROUGH = StyleFlags.STRIKETHROUGH << 24 // 0x80000000 } -export const enum BgFlags { +export const enum BgFlags { // deprecated /** * bit 27..32 (upper 2 unused) */ - ITALIC = 0x4000000, - DIM = 0x8000000, - HAS_EXTENDED = 0x10000000, - PROTECTED = 0x20000000, - OVERLINE = 0x40000000 + ITALIC = StyleFlags.ITALIC << 16, // 0x4000000, + DIM = StyleFlags.DIM << 16, // 0x8000000, + HAS_EXTENDED = StyleFlags.HAS_EXTENDED << 16, // 0x10000000, + PROTECTED = StyleFlags.PROTECTED << 16, // 0x20000000 + OVERLINE = StyleFlags.OVERLINE << 16 // 0x40000000 } export const enum ExtFlags { diff --git a/src/common/buffer/Types.ts b/src/common/buffer/Types.ts index a59c0e177d..5d1673ffad 100644 --- a/src/common/buffer/Types.ts +++ b/src/common/buffer/Types.ts @@ -11,10 +11,31 @@ export type BufferIndex = [number, number]; export interface IBuffer { readonly lines: ICircularList; + /** Number of rows above top visible row. + * Similar to scrollTop (i.e. affected by scrollbar), but in rows. + * FUTURE: We want to handle variable-height rows. Maybe just use scrollTop. + */ ydisp: number; + /** Number of rows in the scrollback buffer, above the home row. */ ybase: number; + + /** Row number relative to the "home" row, zero-origin. + * This is the row number changed/reported by cursor escape sequences, + * except that y is 0-origin: y=0 when we're at the home row. + * Currently assumed to be >= 0, but FUTURE should allow negative - i.e. + * in scroll-back area, as long as ybase+y >= 0. + */ y: number; + + /** Column number, zero-origin. + * Valid range is 0 through C (inclusive), if C is terminal width in columns. + * The first (left-most) column is 0. + * The right-most column is either C-1 (before the right-most column, and + * ready to write in it), or C (after the right-most column, having written + * to it, and ready to wrap). DSR 6 returns C (1-origin) in either case, + */ x: number; + tabs: any; scrollBottom: number; scrollTop: number; @@ -26,6 +47,7 @@ export interface IBuffer { isCursorInViewport: boolean; markers: IMarker[]; translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string; + splitLine(row: number, col: number): void; getWrappedRangeForLine(y: number): { first: number, last: number }; nextStop(x?: number): number; prevStop(x?: number): number; @@ -35,6 +57,8 @@ export interface IBuffer { addMarker(y: number): IMarker; clearMarkers(y: number): void; clearAllMarkers(): void; + setWrapped(row: number, value: boolean): void; + reflowRegion(startRow: number, endRow: number, maxRows: number): void; } export interface IBufferSet extends IDisposable { diff --git a/src/common/input/TextDecoder.ts b/src/common/input/TextDecoder.ts index 7ec9c7cd20..0fcf7e0d86 100644 --- a/src/common/input/TextDecoder.ts +++ b/src/common/input/TextDecoder.ts @@ -27,6 +27,7 @@ export function utf32ToString(data: Uint32Array, start: number = 0, end: number let result = ''; for (let i = start; i < end; ++i) { let codepoint = data[i]; + codepoint &= 0x1FFFFF; // Needed if data is _data field of BufferLine. if (codepoint > 0xFFFF) { // JS strings are encoded as UTF16, thus a non BMP codepoint gets converted into a surrogate // pair conversion rules: diff --git a/src/common/parser/Types.ts b/src/common/parser/Types.ts index 2ed4acdcaf..49702a9df9 100644 --- a/src/common/parser/Types.ts +++ b/src/common/parser/Types.ts @@ -226,7 +226,7 @@ export interface IDcsParser extends ISubParser> = { linkHandler: null, logLevel: 'info', logger: null, + newBufferLine: true, scrollback: 1000, scrollOnEraseInDisplay: false, scrollOnUserInput: true,