+++ /dev/null
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IRenderDimensions } from 'browser/renderer/Types';
-import { BaseRenderLayer } from '../browser/renderer/BaseRenderLayer';
-import { ITerminal } from '../Types';
-import { ICellData } from 'common/Types';
-import { CellData } from 'common/buffer/CellData';
-import { IColorSet } from 'browser/Types';
-import { IBufferService, IOptionsService } from 'common/services/Services';
-
-interface ICursorState {
- x: number;
- y: number;
- isFocused: boolean;
- style: string;
- width: number;
-}
-
-/**
- * The time between cursor blinks.
- */
-const BLINK_INTERVAL = 600;
-
-export class CursorRenderLayer extends BaseRenderLayer {
- private _state: ICursorState;
- private _cursorRenderers: {[key: string]: (x: number, y: number, cell: ICellData) => void};
- private _cursorBlinkStateManager: CursorBlinkStateManager;
- private _cell: ICellData = new CellData();
-
- constructor(
- container: HTMLElement,
- zIndex: number,
- colors: IColorSet,
- private _terminal: ITerminal,
- rendererId: number,
- readonly bufferService: IBufferService,
- readonly optionsService: IOptionsService
- ) {
- super(container, 'cursor', zIndex, true, colors, rendererId, bufferService, optionsService);
- this._state = {
- x: null,
- y: null,
- isFocused: null,
- style: null,
- width: null
- };
- this._cursorRenderers = {
- 'bar': this._renderBarCursor.bind(this),
- 'block': this._renderBlockCursor.bind(this),
- 'underline': this._renderUnderlineCursor.bind(this)
- };
- // TODO: Consider initial options? Maybe onOptionsChanged should be called at the end of open?
- }
-
- public resize(dim: IRenderDimensions): void {
- super.resize(dim);
- // Resizing the canvas discards the contents of the canvas so clear state
- this._state = {
- x: null,
- y: null,
- isFocused: null,
- style: null,
- width: null
- };
- }
-
- public reset(): void {
- this._clearCursor();
- if (this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager.dispose();
- this._cursorBlinkStateManager = null;
- this.onOptionsChanged();
- }
- }
-
- public onBlur(): void {
- if (this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager.pause();
- }
- this._terminal.refresh(this._bufferService.buffer.y, this._bufferService.buffer.y);
- }
-
- public onFocus(): void {
- if (this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager.resume();
- } else {
- this._terminal.refresh(this._bufferService.buffer.y, this._bufferService.buffer.y);
- }
- }
-
- public onOptionsChanged(): void {
- if (this._optionsService.options.cursorBlink) {
- if (!this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager = new CursorBlinkStateManager(this._terminal.isFocused, () => {
- this._render(true);
- });
- }
- } else {
- if (this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager.dispose();
- this._cursorBlinkStateManager = null;
- }
- }
- // Request a refresh from the terminal as management of rendering is being
- // moved back to the terminal
- this._terminal.refresh(this._bufferService.buffer.y, this._bufferService.buffer.y);
- }
-
- public onCursorMove(): void {
- if (this._cursorBlinkStateManager) {
- this._cursorBlinkStateManager.restartBlinkAnimation();
- }
- }
-
- public onGridChanged(startRow: number, endRow: number): void {
- if (!this._cursorBlinkStateManager || this._cursorBlinkStateManager.isPaused) {
- this._render(false);
- } else {
- this._cursorBlinkStateManager.restartBlinkAnimation();
- }
- }
-
- private _render(triggeredByAnimationFrame: boolean): void {
- // Don't draw the cursor if it's hidden
- if (!this._terminal.cursorState || this._terminal.cursorHidden) {
- this._clearCursor();
- return;
- }
-
- const cursorY = this._bufferService.buffer.ybase + this._bufferService.buffer.y;
- const viewportRelativeCursorY = cursorY - this._bufferService.buffer.ydisp;
-
- // Don't draw the cursor if it's off-screen
- if (viewportRelativeCursorY < 0 || viewportRelativeCursorY >= this._bufferService.rows) {
- this._clearCursor();
- return;
- }
-
- this._bufferService.buffer.lines.get(cursorY).loadCell(this._bufferService.buffer.x, this._cell);
- if (this._cell.content === undefined) {
- return;
- }
-
- if (!this._terminal.isFocused) {
- this._clearCursor();
- this._ctx.save();
- this._ctx.fillStyle = this._colors.cursor.css;
- const cursorStyle = this._optionsService.options.cursorStyle;
- if (cursorStyle && cursorStyle !== 'block') {
- this._cursorRenderers[cursorStyle](this._bufferService.buffer.x, viewportRelativeCursorY, this._cell);
- } else {
- this._renderBlurCursor(this._bufferService.buffer.x, viewportRelativeCursorY, this._cell);
- }
- this._ctx.restore();
- this._state.x = this._bufferService.buffer.x;
- this._state.y = viewportRelativeCursorY;
- this._state.isFocused = false;
- this._state.style = cursorStyle;
- this._state.width = this._cell.getWidth();
- return;
- }
-
- // Don't draw the cursor if it's blinking
- if (this._cursorBlinkStateManager && !this._cursorBlinkStateManager.isCursorVisible) {
- this._clearCursor();
- return;
- }
-
- if (this._state) {
- // The cursor is already in the correct spot, don't redraw
- if (this._state.x === this._bufferService.buffer.x &&
- this._state.y === viewportRelativeCursorY &&
- this._state.isFocused === this._terminal.isFocused &&
- this._state.style === this._optionsService.options.cursorStyle &&
- this._state.width === this._cell.getWidth()) {
- return;
- }
- this._clearCursor();
- }
-
- this._ctx.save();
- this._cursorRenderers[this._optionsService.options.cursorStyle || 'block'](this._bufferService.buffer.x, viewportRelativeCursorY, this._cell);
- this._ctx.restore();
-
- this._state.x = this._bufferService.buffer.x;
- this._state.y = viewportRelativeCursorY;
- this._state.isFocused = false;
- this._state.style = this._optionsService.options.cursorStyle;
- this._state.width = this._cell.getWidth();
- }
-
- private _clearCursor(): void {
- if (this._state) {
- this._clearCells(this._state.x, this._state.y, this._state.width, 1);
- this._state = {
- x: null,
- y: null,
- isFocused: null,
- style: null,
- width: null
- };
- }
- }
-
- private _renderBarCursor(x: number, y: number, cell: ICellData): void {
- this._ctx.save();
- this._ctx.fillStyle = this._colors.cursor.css;
- this._fillLeftLineAtCell(x, y);
- this._ctx.restore();
- }
-
- private _renderBlockCursor(x: number, y: number, cell: ICellData): void {
- this._ctx.save();
- this._ctx.fillStyle = this._colors.cursor.css;
- this._fillCells(x, y, cell.getWidth(), 1);
- this._ctx.fillStyle = this._colors.cursorAccent.css;
- this._fillCharTrueColor(cell, x, y);
- this._ctx.restore();
- }
-
- private _renderUnderlineCursor(x: number, y: number, cell: ICellData): void {
- this._ctx.save();
- this._ctx.fillStyle = this._colors.cursor.css;
- this._fillBottomLineAtCells(x, y);
- this._ctx.restore();
- }
-
- private _renderBlurCursor(x: number, y: number, cell: ICellData): void {
- this._ctx.save();
- this._ctx.strokeStyle = this._colors.cursor.css;
- this._strokeRectAtCell(x, y, cell.getWidth(), 1);
- this._ctx.restore();
- }
-}
-
-class CursorBlinkStateManager {
- public isCursorVisible: boolean;
-
- private _animationFrame: number;
- private _blinkStartTimeout: number;
- private _blinkInterval: number;
-
- /**
- * The time at which the animation frame was restarted, this is used on the
- * next render to restart the timers so they don't need to restart the timers
- * multiple times over a short period.
- */
- private _animationTimeRestarted: number;
-
- constructor(
- isFocused: boolean,
- private _renderCallback: () => void
- ) {
- this.isCursorVisible = true;
- if (isFocused) {
- this._restartInterval();
- }
- }
-
- public get isPaused(): boolean { return !(this._blinkStartTimeout || this._blinkInterval); }
-
- public dispose(): void {
- if (this._blinkInterval) {
- window.clearInterval(this._blinkInterval);
- this._blinkInterval = null;
- }
- if (this._blinkStartTimeout) {
- window.clearTimeout(this._blinkStartTimeout);
- this._blinkStartTimeout = null;
- }
- if (this._animationFrame) {
- window.cancelAnimationFrame(this._animationFrame);
- this._animationFrame = null;
- }
- }
-
- public restartBlinkAnimation(): void {
- if (this.isPaused) {
- return;
- }
- // Save a timestamp so that the restart can be done on the next interval
- this._animationTimeRestarted = Date.now();
- // Force a cursor render to ensure it's visible and in the correct position
- this.isCursorVisible = true;
- if (!this._animationFrame) {
- this._animationFrame = window.requestAnimationFrame(() => {
- this._renderCallback();
- this._animationFrame = null;
- });
- }
- }
-
- private _restartInterval(timeToStart: number = BLINK_INTERVAL): void {
- // Clear any existing interval
- if (this._blinkInterval) {
- window.clearInterval(this._blinkInterval);
- }
-
- // Setup the initial timeout which will hide the cursor, this is done before
- // the regular interval is setup in order to support restarting the blink
- // animation in a lightweight way (without thrashing clearInterval and
- // setInterval).
- this._blinkStartTimeout = <number><any>setTimeout(() => {
- // Check if another animation restart was requested while this was being
- // started
- if (this._animationTimeRestarted) {
- const time = BLINK_INTERVAL - (Date.now() - this._animationTimeRestarted);
- this._animationTimeRestarted = null;
- if (time > 0) {
- this._restartInterval(time);
- return;
- }
- }
-
- // Hide the cursor
- this.isCursorVisible = false;
- this._animationFrame = window.requestAnimationFrame(() => {
- this._renderCallback();
- this._animationFrame = null;
- });
-
- // Setup the blink interval
- this._blinkInterval = <number><any>setInterval(() => {
- // Adjust the animation time if it was restarted
- if (this._animationTimeRestarted) {
- // calc time diff
- // Make restart interval do a setTimeout initially?
- const time = BLINK_INTERVAL - (Date.now() - this._animationTimeRestarted);
- this._animationTimeRestarted = null;
- this._restartInterval(time);
- return;
- }
-
- // Invert visibility and render
- this.isCursorVisible = !this.isCursorVisible;
- this._animationFrame = window.requestAnimationFrame(() => {
- this._renderCallback();
- this._animationFrame = null;
- });
- }, BLINK_INTERVAL);
- }, timeToStart);
- }
-
- public pause(): void {
- this.isCursorVisible = true;
- if (this._blinkInterval) {
- window.clearInterval(this._blinkInterval);
- this._blinkInterval = null;
- }
- if (this._blinkStartTimeout) {
- window.clearTimeout(this._blinkStartTimeout);
- this._blinkStartTimeout = null;
- }
- if (this._animationFrame) {
- window.cancelAnimationFrame(this._animationFrame);
- this._animationFrame = null;
- }
- }
-
- public resume(): void {
- this._animationTimeRestarted = null;
- this._restartInterval();
- this.restartBlinkAnimation();
- }
-}
projects / VSoRC / .git / blobdiff