Remove utils/ folder

Part of #1507

src/ui/MouseHelper.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2017 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import jsdom = require('jsdom');
+import { assert } from 'chai';
+import { MouseHelper } from './MouseHelper';
+import { MockCharMeasure, MockRenderer } from './TestUtils.test';
+
+const CHAR_WIDTH = 10;
+const CHAR_HEIGHT = 20;
+
+describe('MouseHelper.getCoords', () => {
+  let dom: jsdom.JSDOM;
+  let window: Window;
+  let document: Document;
+  let mouseHelper: MouseHelper;
+
+  let charMeasure: MockCharMeasure;
+
+  beforeEach(() => {
+    dom = new jsdom.JSDOM('');
+    window = dom.window;
+    document = window.document;
+    charMeasure = new MockCharMeasure();
+    charMeasure.width = CHAR_WIDTH;
+    charMeasure.height = CHAR_HEIGHT;
+    const renderer = new MockRenderer();
+    renderer.dimensions = <any>{
+      actualCellWidth: CHAR_WIDTH,
+      actualCellHeight: CHAR_HEIGHT
+    };
+    mouseHelper = new MouseHelper(renderer);
+  });
+
+  describe('when charMeasure is not initialized', () => {
+    it('should return null', () => {
+      charMeasure = new MockCharMeasure();
+      assert.equal(mouseHelper.getCoords({ clientX: 0, clientY: 0 }, document.createElement('div'), charMeasure, 10, 10), null);
+    });
+  });
+
+  it('should return the cell that was clicked', () => {
+    let coords: [number, number];
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH / 2, clientY: CHAR_HEIGHT / 2 }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [1, 1]);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH, clientY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [1, 1]);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH, clientY: CHAR_HEIGHT + 1 }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [1, 2]);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH + 1, clientY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [2, 1]);
+  });
+
+  it('should ensure the coordinates are returned within the terminal bounds', () => {
+    let coords: [number, number];
+    coords = mouseHelper.getCoords({ clientX: -1, clientY: -1 }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [1, 1]);
+    // Event are double the cols/rows
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH * 20, clientY: CHAR_HEIGHT * 20 }, document.createElement('div'), charMeasure, 10, 10);
+    assert.deepEqual(coords, [10, 10], 'coordinates should never come back as larger than the terminal');
+  });
+});

src/ui/MouseHelper.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2017 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { ICharMeasure, IMouseHelper } from '../Types';
+import { IRenderer } from '../renderer/Types';
+
+export class MouseHelper implements IMouseHelper {
+  constructor(private _renderer: IRenderer) {}
+
+  public setRenderer(renderer: IRenderer): void {
+    this._renderer = renderer;
+  }
+
+  public static getCoordsRelativeToElement(event: {clientX: number, clientY: number}, element: HTMLElement): [number, number] {
+    const rect = element.getBoundingClientRect();
+    return [event.clientX - rect.left, event.clientY - rect.top];
+  }
+
+  /**
+   * Gets coordinates within the terminal for a particular mouse event. The result
+   * is returned as an array in the form [x, y] instead of an object as it's a
+   * little faster and this function is used in some low level code.
+   * @param event The mouse event.
+   * @param element The terminal's container element.
+   * @param charMeasure The char measure object used to determine character sizes.
+   * @param colCount The number of columns in the terminal.
+   * @param rowCount The number of rows n the terminal.
+   * @param isSelection Whether the request is for the selection or not. This will
+   * apply an offset to the x value such that the left half of the cell will
+   * select that cell and the right half will select the next cell.
+   */
+  public getCoords(event: {clientX: number, clientY: number}, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number, isSelection?: boolean): [number, number] {
+    // Coordinates cannot be measured if charMeasure has not been initialized
+    if (!charMeasure.width || !charMeasure.height) {
+      return null;
+    }
+
+    const coords = MouseHelper.getCoordsRelativeToElement(event, element);
+    if (!coords) {
+      return null;
+    }
+
+    coords[0] = Math.ceil((coords[0] + (isSelection ? this._renderer.dimensions.actualCellWidth / 2 : 0)) / this._renderer.dimensions.actualCellWidth);
+    coords[1] = Math.ceil(coords[1] / this._renderer.dimensions.actualCellHeight);
+
+    // Ensure coordinates are within the terminal viewport. Note that selections
+    // need an addition point of precision to cover the end point (as characters
+    // cover half of one char and half of the next).
+    coords[0] = Math.min(Math.max(coords[0], 1), colCount + (isSelection ? 1 : 0));
+    coords[1] = Math.min(Math.max(coords[1], 1), rowCount);
+
+    return coords;
+  }
+
+  /**
+   * Gets coordinates within the terminal for a particular mouse event, wrapping
+   * them to the bounds of the terminal and adding 32 to both the x and y values
+   * as expected by xterm.
+   * @param event The mouse event.
+   * @param element The terminal's container element.
+   * @param charMeasure The char measure object used to determine character sizes.
+   * @param colCount The number of columns in the terminal.
+   * @param rowCount The number of rows in the terminal.
+   */
+  public getRawByteCoords(event: MouseEvent, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number): { x: number, y: number } {
+    const coords = this.getCoords(event, element, charMeasure, colCount, rowCount);
+    let x = coords[0];
+    let y = coords[1];
+
+    // xterm sends raw bytes and starts at 32 (SP) for each.
+    x += 32;
+    y += 32;
+
+    return { x, y };
+  }
+}

src/ui/TestUtils.test.ts

@@ -0,0 +1,405 @@
+/**
+ * Copyright (c) 2017 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IColorSet, IRenderer, IRenderDimensions, IColorManager } from '../renderer/Types';
+import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, ILinkifier, IMouseHelper, ILinkMatcherOptions, CharacterJoinerHandler, IBufferLine, IBufferStringIterator } from '../Types';
+import { ICircularList, XtermListener } from '../common/Types';
+import { Buffer } from '../Buffer';
+import * as Browser from '../core/Platform';
+import { ITheme, IDisposable, IMarker } from 'xterm';
+import { Terminal } from '../Terminal';
+
+export class TestTerminal extends Terminal {
+  writeSync(data: string): void {
+    this.writeBuffer.push(data);
+    this._innerWrite();
+  }
+}
+
+export class MockTerminal implements ITerminal {
+  markers: IMarker[];
+  addMarker(cursorYOffset: number): IMarker {
+    throw new Error('Method not implemented.');
+  }
+  selectLines(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollToLine(line: number): void {
+    throw new Error('Method not implemented.');
+  }
+  static string: any;
+  getOption(key: any): any {
+    throw new Error('Method not implemented.');
+  }
+  setOption(key: any, value: any): void {
+    throw new Error('Method not implemented.');
+  }
+  blur(): void {
+    throw new Error('Method not implemented.');
+  }
+  focus(): void {
+    throw new Error('Method not implemented.');
+  }
+  resize(columns: number, rows: number): void {
+    throw new Error('Method not implemented.');
+  }
+  writeln(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  open(parent: HTMLElement): void {
+    throw new Error('Method not implemented.');
+  }
+  attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
+    throw new Error('Method not implemented.');
+  }
+  deregisterLinkMatcher(matcherId: number): void {
+    throw new Error('Method not implemented.');
+  }
+  hasSelection(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  getSelection(): string {
+    throw new Error('Method not implemented.');
+  }
+  clearSelection(): void {
+    throw new Error('Method not implemented.');
+  }
+  selectAll(): void {
+    throw new Error('Method not implemented.');
+  }
+  dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  destroy(): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollPages(pageCount: number): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollToTop(): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollToBottom(): void {
+    throw new Error('Method not implemented.');
+  }
+  clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  write(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  bracketedPasteMode: boolean;
+  mouseHelper: IMouseHelper;
+  renderer: IRenderer;
+  linkifier: ILinkifier;
+  isFocused: boolean;
+  options: ITerminalOptions = {};
+  element: HTMLElement;
+  screenElement: HTMLElement;
+  rowContainer: HTMLElement;
+  selectionContainer: HTMLElement;
+  selectionManager: ISelectionManager;
+  charMeasure: ICharMeasure;
+  textarea: HTMLTextAreaElement;
+  rows: number;
+  cols: number;
+  browser: IBrowser = <any>Browser;
+  writeBuffer: string[];
+  children: HTMLElement[];
+  cursorHidden: boolean;
+  cursorState: number;
+  scrollback: number;
+  buffers: IBufferSet;
+  buffer: IBuffer;
+  viewport: IViewport;
+  applicationCursor: boolean;
+  handler(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  on(event: string, callback: (...args: any[]) => void): void {
+    throw new Error('Method not implemented.');
+  }
+  off(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  addDisposableListener(type: string, handler: XtermListener): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  scrollLines(disp: number, suppressScrollEvent: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollToRow(absoluteRow: number): number {
+    throw new Error('Method not implemented.');
+  }
+  cancel(ev: Event, force?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  log(text: string): void {
+    throw new Error('Method not implemented.');
+  }
+  emit(event: string, data: any): void {
+    throw new Error('Method not implemented.');
+  }
+  reset(): void {
+    throw new Error('Method not implemented.');
+  }
+  showCursor(): void {
+    throw new Error('Method not implemented.');
+  }
+  refresh(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
+  deregisterCharacterJoiner(joinerId: number): void { }
+}
+
+export class MockCharMeasure implements ICharMeasure {
+  width: number;
+  height: number;
+  measure(options: ITerminalOptions): void {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockInputHandlingTerminal implements IInputHandlingTerminal {
+  element: HTMLElement;
+  options: ITerminalOptions = {};
+  cols: number;
+  rows: number;
+  charset: { [key: string]: string; };
+  gcharset: number;
+  glevel: number;
+  charsets: { [key: string]: string; }[];
+  applicationKeypad: boolean;
+  applicationCursor: boolean;
+  originMode: boolean;
+  insertMode: boolean;
+  wraparoundMode: boolean;
+  bracketedPasteMode: boolean;
+  curAttr: number;
+  savedCols: number;
+  x10Mouse: boolean;
+  vt200Mouse: boolean;
+  normalMouse: boolean;
+  mouseEvents: boolean;
+  sendFocus: boolean;
+  utfMouse: boolean;
+  sgrMouse: boolean;
+  urxvtMouse: boolean;
+  cursorHidden: boolean;
+  buffers: IBufferSet;
+  buffer: IBuffer = new MockBuffer();
+  viewport: IViewport;
+  selectionManager: ISelectionManager;
+  focus(): void {
+    throw new Error('Method not implemented.');
+  }
+  convertEol: boolean;
+  bell(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  updateRange(y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  scroll(isWrapped?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  nextStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  setgLevel(g: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseAttr(): number {
+    throw new Error('Method not implemented.');
+  }
+  eraseRight(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseLine(y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseLeft(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  prevStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  is(term: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+  setgCharset(g: number, charset: { [key: string]: string; }): void {
+    throw new Error('Method not implemented.');
+  }
+  resize(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  log(text: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  reset(): void {
+    throw new Error('Method not implemented.');
+  }
+  showCursor(): void {
+    throw new Error('Method not implemented.');
+  }
+  refresh(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  matchColor(r1: number, g1: number, b1: number): number {
+    throw new Error('Method not implemented.');
+  }
+  error(text: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  setOption(key: string, value: any): void {
+    (<any>this.options)[key] = value;
+  }
+  on(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  off(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  emit(type: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  addDisposableListener(type: string, handler: XtermListener): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  tabSet(): void {
+    throw new Error('Method not implemented.');
+  }
+  handler(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  handleTitle(title: string): void {
+    throw new Error('Method not implemented.');
+  }
+  index(): void {
+    throw new Error('Method not implemented.');
+  }
+  reverseIndex(): void {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockBuffer implements IBuffer {
+  isCursorInViewport: boolean;
+  lines: ICircularList<IBufferLine>;
+  ydisp: number;
+  ybase: number;
+  hasScrollback: boolean;
+  y: number;
+  x: number;
+  tabs: any;
+  scrollBottom: number;
+  scrollTop: number;
+  savedY: number;
+  savedX: number;
+  savedCurAttr: number;
+  translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
+    return Buffer.prototype.translateBufferLineToString.apply(this, arguments);
+  }
+  getWrappedRangeForLine(y: number): { first: number; last: number; } {
+    return Buffer.prototype.getWrappedRangeForLine.apply(this, arguments);
+  }
+  nextStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  prevStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  setLines(lines: ICircularList<IBufferLine>): void {
+    this.lines = lines;
+  }
+  getBlankLine(attr: number, isWrapped?: boolean): IBufferLine {
+    return Buffer.prototype.getBlankLine.apply(this, arguments);
+  }
+  stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[] {
+    return Buffer.prototype.stringIndexToBufferIndex.apply(this, arguments);
+  }
+  iterator(trimRight: boolean, startIndex?: number, endIndex?: number): IBufferStringIterator {
+    return Buffer.prototype.iterator.apply(this, arguments);
+  }
+}
+
+export class MockRenderer implements IRenderer {
+  dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  colorManager: IColorManager;
+  on(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  off(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  emit(type: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  addDisposableListener(type: string, handler: XtermListener): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  dimensions: IRenderDimensions;
+  setTheme(theme: ITheme): IColorSet { return <IColorSet>{}; }
+  onResize(cols: number, rows: number): void {}
+  onCharSizeChanged(): void {}
+  onBlur(): void {}
+  onFocus(): void {}
+  onSelectionChanged(start: [number, number], end: [number, number]): void {}
+  onCursorMove(): void {}
+  onOptionsChanged(): void {}
+  onWindowResize(devicePixelRatio: number): void {}
+  clear(): void {}
+  refreshRows(start: number, end: number): void {}
+  registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
+  deregisterCharacterJoiner(): boolean { return true; }
+}
+
+export class MockViewport implements IViewport {
+  dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  scrollBarWidth: number = 0;
+  onThemeChanged(colors: IColorSet): void {
+    throw new Error('Method not implemented.');
+  }
+  onWheel(ev: WheelEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  onTouchStart(ev: TouchEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  onTouchMove(ev: TouchEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  syncScrollArea(): void { }
+  getLinesScrolled(ev: WheelEvent): number {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockCompositionHelper implements ICompositionHelper {
+  compositionstart(): void {
+    throw new Error('Method not implemented.');
+  }
+  compositionupdate(ev: CompositionEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  compositionend(): void {
+    throw new Error('Method not implemented.');
+  }
+  updateCompositionElements(dontRecurse?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  keydown(ev: KeyboardEvent): boolean {
+    return true;
+  }
+}