Merge pull request #1486 from Tyriar/1456_triple_click_wrapped

Select entire wrapped line on triple click

src/Buffer.test.ts

@@ -48,6 +48,63 @@ describe('Buffer', () => {
     });
   });
 
+  describe('getWrappedRangeForLine', () => {
+    describe('non-wrapped', () => {
+      it('should return a single row for the first row', () => {
+        buffer.fillViewportRows();
+        assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 0 });
+      });
+      it('should return a single row for a middle row', () => {
+        buffer.fillViewportRows();
+        assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 12 });
+      });
+      it('should return a single row for the last row', () => {
+        buffer.fillViewportRows();
+        assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 1), { first: 23, last: 23 });
+      });
+    });
+    describe('wrapped', () => {
+      it('should return a range for the first row', () => {
+        buffer.fillViewportRows();
+        (<any> buffer.lines.get(1)).isWrapped = true;
+        assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 1 });
+      });
+      it('should return a range for a middle row wrapping upwards', () => {
+        buffer.fillViewportRows();
+        (<any> buffer.lines.get(12)).isWrapped = true;
+        assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 11, last: 12 });
+      });
+      it('should return a range for a middle row wrapping downwards', () => {
+        buffer.fillViewportRows();
+        (<any> buffer.lines.get(13)).isWrapped = true;
+        assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 13 });
+      });
+      it('should return a range for a middle row wrapping both ways', () => {
+        buffer.fillViewportRows();
+        (<any> buffer.lines.get(11)).isWrapped = true;
+        (<any> buffer.lines.get(12)).isWrapped = true;
+        (<any> buffer.lines.get(13)).isWrapped = true;
+        (<any> buffer.lines.get(14)).isWrapped = true;
+        assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 10, last: 14 });
+      });
+      it('should return a range for the last row', () => {
+        buffer.fillViewportRows();
+        (<any> buffer.lines.get(23)).isWrapped = 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();
+        (<any> buffer.lines.get(1)).isWrapped = 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();
+        (<any> buffer.lines.get(buffer.lines.length - 1)).isWrapped = true;
+        assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 2), { first: 22, last: 23 });
+      });
+    });
+  });
+
   describe('resize', () => {
     describe('column size is reduced', () => {
       it('should not trim the data in the buffer', () => {

src/Buffer.ts

@@ -259,6 +259,20 @@ export class Buffer implements IBuffer {
     return lineString.substring(startIndex, endIndex);
   }
 
+  public getWrappedRangeForLine(y: number): { first: number, last: number } {
+    let first = y;
+    let last = y;
+    // Scan upwards for wrapped lines
+    while (first > 0 && (<any>this.lines.get(first)).isWrapped) {
+      first--;
+    }
+    // Scan downwards for wrapped lines
+    while (last + 1 < this.lines.length && (<any>this.lines.get(last + 1)).isWrapped) {
+      last++;
+    }
+    return { first, last };
+  }
+
   /**
    * Setup the tab stops.
    * @param i The index to start setting up tab stops from.

src/SelectionManager.test.ts

@@ -298,6 +298,16 @@ describe('SelectionManager', () => {
       assert.deepEqual(selectionManager.model.finalSelectionStart, [0, 0]);
       assert.deepEqual(selectionManager.model.finalSelectionEnd, [terminal.cols, 0], 'The actual selection spans the entire column');
     });
+    it('should select the entire wrapped line', () => {
+      buffer.lines.set(0, stringToRow('foo'));
+      const line2 = stringToRow('bar');
+      (<any>line2).isWrapped = true;
+      buffer.lines.set(1, line2);
+      selectionManager.selectLineAt(0);
+      assert.equal(selectionManager.selectionText, 'foobar', 'The selected text is correct');
+      assert.deepEqual(selectionManager.model.finalSelectionStart, [0, 0]);
+      assert.deepEqual(selectionManager.model.finalSelectionEnd, [terminal.cols, 1], 'The actual selection spans the entire column');
+    });
   });
 
   describe('selectAll', () => {

src/SelectionManager.ts

@@ -803,7 +803,9 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    * @param line The line index.
    */
   protected _selectLineAt(line: number): void {
-    this._model.selectionStart = [0, line];
-    this._model.selectionStartLength = this._terminal.cols;
+    const wrappedRange = this._buffer.getWrappedRangeForLine(line);
+    this._model.selectionStart = [0, wrappedRange.first];
+    this._model.selectionEnd = [this._terminal.cols, wrappedRange.last];
+    this._model.selectionStartLength = 0;
   }
 }

src/Types.ts

@@ -285,6 +285,7 @@ export interface IBuffer {
   savedX: number;
   isCursorInViewport: boolean;
   translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string;
+  getWrappedRangeForLine(y: number): { first: number, last: number };
   nextStop(x?: number): number;
   prevStop(x?: number): number;
 }

src/utils/TestUtils.test.ts

@@ -302,6 +302,9 @@ export class MockBuffer implements IBuffer {
   translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
     return Buffer.prototype.translateBufferLineToString.apply(this, arguments);
   }
+  getWrappedRangeForLine(y: number): { first: number; last: number; } {
+    throw new Error('Method not implemented.');
+  }
   nextStop(x?: number): number {
     throw new Error('Method not implemented.');
   }