Move Renderer ownership to RenderCoordinator

src/renderer/RenderCoordinator.ts

@@ -3,12 +3,14 @@
  * @license MIT
  */
 
-import { IRenderer } from './Types';
+import { IRenderer, IRenderDimensions } from './Types';
 import { RenderDebouncer } from '../ui/RenderDebouncer';
 import { EventEmitter2, IEvent } from '../common/EventEmitter2';
 import { Disposable } from '../common/Lifecycle';
-import { ScreenDprMonitor } from '../../lib/ui/ScreenDprMonitor';
+import { ScreenDprMonitor } from '../ui/ScreenDprMonitor';
 import { addDisposableDomListener } from '../ui/Lifecycle';
+import { IColorSet } from '..//ui/Types';
+import { CharacterJoinerHandler } from '../Types';
 
 export class RenderCoordinator extends Disposable {
   private _renderDebouncer: RenderDebouncer;
@@ -19,10 +21,14 @@ export class RenderCoordinator extends Disposable {
   private _canvasWidth: number = 0;
   private _canvasHeight: number = 0;
 
-  private _onCanvasResize = new EventEmitter2<{ width: number, height: number }>();
-  public get onCanvasResize(): IEvent<{ width: number, height: number }> { return this._onCanvasResize.event; }
+  private _onDimensionsChange = new EventEmitter2<IRenderDimensions>();
+  public get onDimensionsChange(): IEvent<IRenderDimensions> { return this._onDimensionsChange.event; }
   private _onRender = new EventEmitter2<{ start: number, end: number }>();
   public get onRender(): IEvent<{ start: number, end: number }> { return this._onRender.event; }
+  private _onRefreshRequest = new EventEmitter2<{ start: number, end: number }>();
+  public get onRefreshRequest(): IEvent<{ start: number, end: number }> { return this._onRefreshRequest.event; }
+
+  public get dimensions(): IRenderDimensions { return this._renderer.dimensions; }
 
   constructor(
     private _renderer: IRenderer,
@@ -86,15 +92,71 @@ export class RenderCoordinator extends Disposable {
     if (this._renderer.dimensions.canvasWidth === this._canvasWidth && this._renderer.dimensions.canvasHeight === this._canvasHeight) {
       return;
     }
-    this._canvasWidth = this._renderer.dimensions.canvasWidth;
-    this._canvasHeight = this._renderer.dimensions.canvasHeight;
-    this._onCanvasResize.fire({
-      width: this._canvasWidth,
-      height: this._canvasHeight
-    });
+    this._onDimensionsChange.fire(this._renderer.dimensions);
   }
 
   public setRenderer(renderer: IRenderer): void {
+    // TODO: RenderCoordinator should be the only one to dispose the renderer
+    this._renderer.dispose();
     this._renderer = renderer;
   }
+
+  private _fullRefresh(): void {
+    if (this._isPaused) {
+      this._needsFullRefresh = true;
+    } else {
+      this.refreshRows(0, this._rowCount);
+    }
+  }
+
+  public setColors(colors: IColorSet): void {
+    this._renderer.setColors(colors);
+    this._fullRefresh();
+  }
+
+  public onDevicePixelRatioChange(): void {
+    this._renderer.onDevicePixelRatioChange();
+  }
+
+  public onResize(cols: number, rows: number): void {
+    this._renderer.onResize(cols, rows);
+    this._fullRefresh();
+  }
+
+  // TODO: Is this useful when we have onResize?
+  public onCharSizeChanged(): void {
+    this._renderer.onCharSizeChanged();
+  }
+
+  public onBlur(): void {
+    this._renderer.onBlur();
+  }
+
+  public onFocus(): void {
+    this._renderer.onFocus();
+  }
+
+  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+    this._renderer.onSelectionChanged(start, end, columnSelectMode);
+  }
+
+  public onCursorMove(): void {
+    this._renderer.onCursorMove();
+  }
+
+  public onOptionsChanged(): void {
+    this._renderer.onOptionsChanged();
+  }
+
+  public clear(): void {
+    this._renderer.clear();
+  }
+
+  public registerCharacterJoiner(handler: CharacterJoinerHandler): number {
+    return this._renderer.registerCharacterJoiner(handler);
+  }
+
+  public deregisterCharacterJoiner(joinerId: number): boolean {
+    return this._renderer.deregisterCharacterJoiner(joinerId);
+  }
 }

src/renderer/Renderer.ts

@@ -75,8 +75,6 @@ export class Renderer extends Disposable implements IRenderer {
       l.setColors(this._terminal, this._colors);
       l.reset(this._terminal);
     });
-
-    this._terminal.refresh(0, this._terminal.rows - 1);
   }
 
   public onResize(cols: number, rows: number): void {
@@ -86,9 +84,6 @@ export class Renderer extends Disposable implements IRenderer {
     // Resize all render layers
     this._renderLayers.forEach(l => l.resize(this._terminal, this.dimensions));
 
-    // Force a refresh
-    this._terminal.refresh(0, this._terminal.rows - 1);
-
     // Resize the screen
     this._terminal.screenElement.style.width = `${this.dimensions.canvasWidth}px`;
     this._terminal.screenElement.style.height = `${this.dimensions.canvasHeight}px`;

src/renderer/Types.ts

@@ -25,7 +25,20 @@ export const enum FLAGS {
  * rendering rows to the screen.
  */
 export interface IRenderer extends IDisposable {
-  dimensions: IRenderDimensions;
+  readonly dimensions: IRenderDimensions;
+
+  /**
+   * A property that is set by consumers of this interface, this will be set to true when the
+   * terminal is completely offscreen and to false when it comes back on. When true the consumer of
+   * the renderer will not trigger `renderRows`, the renderer should disable code in functions other
+   * than `renderRows` that renders to the screen but it should continue to gather state changes.
+   * When the renderer is unpaused, a full `renderRows` will be triggered if it was called while
+   * paused.
+   *
+   * For example, when `isPaused` is `true`, `IRenderer.onBlur` should record the state change, but
+   * not actually draw the blurred cursor.
+   */
+  // isPaused: boolean;
 
   dispose(): void;
   setColors(colors: IColorSet): void;