Merge pull request #4195 from Tyriar/4190

Create onSpecificOptionChange and onMultipleOptionChange helpers

addons/xterm-addon-canvas/src/BaseRenderLayer.ts

@@ -79,7 +79,6 @@ export abstract class BaseRenderLayer extends Disposable implements IRenderLayer
     }
   }
 
-  public handleOptionsChanged(): void {}
   public handleBlur(): void {}
   public handleFocus(): void {}
   public handleCursorMove(): void {}

addons/xterm-addon-canvas/src/CanvasAddon.ts

@@ -4,7 +4,7 @@
  */
 
 import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
-import { IColorSet } from 'browser/Types';
+import { IColorSet, ITerminal } from 'browser/Types';
 import { CanvasRenderer } from './CanvasRenderer';
 import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
 import { ITerminalAddon, Terminal } from 'xterm';
@@ -23,25 +23,27 @@ export class CanvasAddon extends Disposable implements ITerminalAddon {
   }
 
   public activate(terminal: Terminal): void {
-    const core = (terminal as any)._core;
+    const core = (terminal as any)._core as ITerminal;
     if (!terminal.element) {
       this.register(core.onWillOpen(() => this.activate(terminal)));
       return;
     }
 
     this._terminal = terminal;
-    const bufferService: IBufferService = core._bufferService;
-    const renderService: IRenderService = core._renderService;
-    const characterJoinerService: ICharacterJoinerService = core._characterJoinerService;
-    const charSizeService: ICharSizeService = core._charSizeService;
-    const coreService: ICoreService = core.coreService;
-    const coreBrowserService: ICoreBrowserService = core._coreBrowserService;
-    const decorationService: IDecorationService = core._decorationService;
-    const optionsService: IOptionsService = core.optionsService;
-    const themeService: IThemeService = core._themeService;
-    const screenElement: HTMLElement = core.screenElement;
+    const coreService = core.coreService;
+    const optionsService = core.optionsService;
+    const screenElement = core.screenElement!;
     const linkifier = core.linkifier2;
 
+    const unsafeCore = core as any;
+    const bufferService: IBufferService = unsafeCore._bufferService;
+    const renderService: IRenderService = unsafeCore._renderService;
+    const characterJoinerService: ICharacterJoinerService = unsafeCore._characterJoinerService;
+    const charSizeService: ICharSizeService = unsafeCore._charSizeService;
+    const coreBrowserService: ICoreBrowserService = unsafeCore._coreBrowserService;
+    const decorationService: IDecorationService = unsafeCore._decorationService;
+    const themeService: IThemeService = unsafeCore._themeService;
+
     this._renderer = new CanvasRenderer(terminal, screenElement, linkifier, bufferService, charSizeService, optionsService, characterJoinerService, coreService, coreBrowserService, decorationService, themeService);
     this.register(forwardEvent(this._renderer.onChangeTextureAtlas, this._onChangeTextureAtlas));
     renderService.setRenderer(this._renderer);

addons/xterm-addon-canvas/src/CanvasRenderer.ts

@@ -68,9 +68,6 @@ export class CanvasRenderer extends Disposable implements IRenderer {
     this._updateDimensions();
 
     this.register(observeDevicePixelDimensions(this._renderLayers[0].canvas, this._coreBrowserService.window, (w, h) => this._setCanvasDevicePixelDimensions(w, h)));
-
-    this.handleOptionsChanged();
-
     this.register(toDisposable(() => {
       for (const l of this._renderLayers) {
         l.dispose();
@@ -130,10 +127,6 @@ export class CanvasRenderer extends Disposable implements IRenderer {
     this._runOperation(l => l.handleCursorMove());
   }
 
-  public handleOptionsChanged(): void {
-    this._runOperation(l => l.handleOptionsChanged());
-  }
-
   public clear(): void {
     this._runOperation(l => l.reset());
   }

addons/xterm-addon-canvas/src/CursorRenderLayer.ts

@@ -58,6 +58,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
       'block': this._renderBlockCursor.bind(this),
       'underline': this._renderUnderlineCursor.bind(this)
     };
+    this.register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
     this.register(toDisposable(() => {
       this._cursorBlinkStateManager?.dispose();
       this._cursorBlinkStateManager = undefined;
@@ -79,7 +80,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
   public reset(): void {
     this._clearCursor();
     this._cursorBlinkStateManager?.restartBlinkAnimation();
-    this.handleOptionsChanged();
+    this._handleOptionsChanged();
   }
 
   public handleBlur(): void {
@@ -92,7 +93,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
     this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
-  public handleOptionsChanged(): void {
+  private _handleOptionsChanged(): void {
     if (this._optionsService.rawOptions.cursorBlink) {
       if (!this._cursorBlinkStateManager) {
         this._cursorBlinkStateManager = new CursorBlinkStateManager(this._coreBrowserService.isFocused, () => {

addons/xterm-addon-canvas/src/TextRenderLayer.ts

@@ -45,6 +45,7 @@ export class TextRenderLayer extends BaseRenderLayer {
   ) {
     super(terminal, container, 'text', zIndex, alpha, themeService, bufferService, optionsService, decorationService, coreBrowserService);
     this._state = new GridCache<CharData>();
+    this.register(optionsService.onSpecificOptionChange('allowTransparency', value => this._setTransparency(value)));
   }
 
   public resize(dim: IRenderDimensions): void {
@@ -251,10 +252,6 @@ export class TextRenderLayer extends BaseRenderLayer {
     this._drawForeground(firstRow, lastRow);
   }
 
-  public handleOptionsChanged(): void {
-    this._setTransparency(this._optionsService.rawOptions.allowTransparency);
-  }
-
   /**
    * Whether a character is overlapping to the next cell.
    */

addons/xterm-addon-canvas/src/Types.d.ts

@@ -73,11 +73,6 @@ export interface IRenderLayer extends IDisposable {
    */
   handleCursorMove(): void;
 
-  /**
-   * Called when options change.
-   */
-  handleOptionsChanged(): void;
-
   /**
    * Called when the data in the grid has changed (or needs to be rendered
    * again).

addons/xterm-addon-webgl/src/WebglAddon.ts

@@ -3,14 +3,15 @@
  * @license MIT
  */
 
-import { Terminal, ITerminalAddon, IEvent } from 'xterm';
-import { WebglRenderer } from './WebglRenderer';
 import { ICharacterJoinerService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
-import { IColorSet } from 'browser/Types';
+import { ITerminal } from 'browser/Types';
 import { EventEmitter, forwardEvent } from 'common/EventEmitter';
-import { isSafari } from 'common/Platform';
-import { ICoreService, IDecorationService } from 'common/services/Services';
 import { Disposable, toDisposable } from 'common/Lifecycle';
+import { isSafari } from 'common/Platform';
+import { ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
+import { ICoreTerminal } from 'common/Types';
+import { ITerminalAddon, Terminal } from 'xterm';
+import { WebglRenderer } from './WebglRenderer';
 
 export class WebglAddon extends Disposable implements ITerminalAddon {
   private _terminal?: Terminal;
@@ -31,19 +32,25 @@ export class WebglAddon extends Disposable implements ITerminalAddon {
     if (isSafari) {
       throw new Error('Webgl is not currently supported on Safari');
     }
-    const core = (terminal as any)._core;
+
+    const core = (terminal as any)._core as ITerminal;
     if (!terminal.element) {
       this.register(core.onWillOpen(() => this.activate(terminal)));
       return;
     }
+
     this._terminal = terminal;
-    const renderService: IRenderService = core._renderService;
-    const characterJoinerService: ICharacterJoinerService = core._characterJoinerService;
-    const coreBrowserService: ICoreBrowserService = core._coreBrowserService;
     const coreService: ICoreService = core.coreService;
-    const decorationService: IDecorationService = core._decorationService;
-    const themeService: IThemeService = core._themeService;
-    this._renderer = this.register(new WebglRenderer(terminal, themeService, characterJoinerService, coreBrowserService, coreService, decorationService, this._preserveDrawingBuffer));
+    const optionsService: IOptionsService = core.optionsService;
+
+    const unsafeCore = core as any;
+    const renderService: IRenderService = unsafeCore._renderService;
+    const characterJoinerService: ICharacterJoinerService = unsafeCore._characterJoinerService;
+    const coreBrowserService: ICoreBrowserService = unsafeCore._coreBrowserService;
+    const decorationService: IDecorationService = unsafeCore._decorationService;
+    const themeService: IThemeService = unsafeCore._themeService;
+
+    this._renderer = this.register(new WebglRenderer(terminal, themeService, characterJoinerService, coreBrowserService, optionsService, coreService, decorationService, this._preserveDrawingBuffer));
     this.register(forwardEvent(this._renderer.onContextLoss, this._onContextLoss));
     this.register(forwardEvent(this._renderer.onChangeTextureAtlas, this._onChangeTextureAtlas));
     renderService.setRenderer(this._renderer);

addons/xterm-addon-webgl/src/WebglRenderer.ts

@@ -15,7 +15,7 @@ import { CellData } from 'common/buffer/CellData';
 import { Content, NULL_CELL_CHAR, NULL_CELL_CODE } from 'common/buffer/Constants';
 import { EventEmitter } from 'common/EventEmitter';
 import { Disposable, toDisposable } from 'common/Lifecycle';
-import { ICoreService, IDecorationService } from 'common/services/Services';
+import { ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
 import { CharData, IBufferLine, ICellData } from 'common/Types';
 import { Terminal } from 'xterm';
 import { GlyphRenderer } from './GlyphRenderer';
@@ -58,6 +58,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     private readonly _themeService: IThemeService,
     private readonly _characterJoinerService: ICharacterJoinerService,
     private readonly _coreBrowserService: ICoreBrowserService,
+    optionsService: IOptionsService,
     coreService: ICoreService,
     private readonly _decorationService: IDecorationService,
     preserveDrawingBuffer?: boolean
@@ -72,7 +73,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
 
     this._renderLayers = [
       new LinkRenderLayer(this._core.screenElement!, 2, this._terminal, this._core.linkifier2, this._coreBrowserService, this._themeService),
-      new CursorRenderLayer(_terminal, this._core.screenElement!, 3, this._onRequestRedraw, this._coreBrowserService, coreService, this._themeService)
+      new CursorRenderLayer(_terminal, this._core.screenElement!, 3, this._onRequestRedraw, this._coreBrowserService, coreService, this._themeService, optionsService)
     ];
     this.dimensions = {
       scaledCharWidth: 0,
@@ -90,6 +91,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     };
     this._devicePixelRatio = this._coreBrowserService.dpr;
     this._updateDimensions();
+    this.register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
 
     this._canvas = document.createElement('canvas');
 
@@ -230,10 +232,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     }
   }
 
-  public handleOptionsChanged(): void {
-    for (const l of this._renderLayers) {
-      l.handleOptionsChanged(this._terminal);
-    }
+  private _handleOptionsChanged(): void {
     this._updateDimensions();
     this._refreshCharAtlas();
   }

addons/xterm-addon-webgl/src/renderLayer/BaseRenderLayer.ts

@@ -59,7 +59,6 @@ export abstract class BaseRenderLayer extends Disposable implements IRenderLayer
     }
   }
 
-  public handleOptionsChanged(terminal: Terminal): void {}
   public handleBlur(terminal: Terminal): void {}
   public handleFocus(terminal: Terminal): void {}
   public handleCursorMove(terminal: Terminal): void {}

addons/xterm-addon-webgl/src/renderLayer/CursorRenderLayer.ts

@@ -11,7 +11,7 @@ import { IColorSet, ReadonlyColorSet } from 'browser/Types';
 import { IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/shared/Types';
 import { IEventEmitter } from 'common/EventEmitter';
 import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
-import { ICoreService } from 'common/services/Services';
+import { ICoreService, IOptionsService } from 'common/services/Services';
 import { toDisposable } from 'common/Lifecycle';
 
 interface ICursorState {
@@ -40,7 +40,8 @@ export class CursorRenderLayer extends BaseRenderLayer {
     private _onRequestRefreshRowsEvent: IEventEmitter<IRequestRedrawEvent>,
     coreBrowserService: ICoreBrowserService,
     private readonly _coreService: ICoreService,
-    themeService: IThemeService
+    themeService: IThemeService,
+    optionsService: IOptionsService
   ) {
     super(terminal, container, 'cursor', zIndex, true, coreBrowserService, themeService);
     this._state = {
@@ -55,7 +56,8 @@ export class CursorRenderLayer extends BaseRenderLayer {
       'block': this._renderBlockCursor.bind(this),
       'underline': this._renderUnderlineCursor.bind(this)
     };
-    this.handleOptionsChanged(terminal);
+    this._handleOptionsChanged(terminal);
+    this.register(optionsService.onOptionChange(() => this._handleOptionsChanged(terminal)));
     this.register(toDisposable(() => {
       this._cursorBlinkStateManager?.dispose();
       this._cursorBlinkStateManager = undefined;
@@ -77,7 +79,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
   public reset(terminal: Terminal): void {
     this._clearCursor();
     this._cursorBlinkStateManager?.restartBlinkAnimation(terminal);
-    this.handleOptionsChanged(terminal);
+    this._handleOptionsChanged(terminal);
   }
 
   public handleBlur(terminal: Terminal): void {
@@ -90,7 +92,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
     this._onRequestRefreshRowsEvent.fire({ start: terminal.buffer.active.cursorY, end: terminal.buffer.active.cursorY });
   }
 
-  public handleOptionsChanged(terminal: Terminal): void {
+  private _handleOptionsChanged(terminal: Terminal): void {
     if (terminal.options.cursorBlink) {
       if (!this._cursorBlinkStateManager) {
         this._cursorBlinkStateManager = new CursorBlinkStateManager(() => {

addons/xterm-addon-webgl/src/renderLayer/LinkRenderLayer.ts

@@ -7,7 +7,7 @@ import { is256Color } from 'browser/renderer/shared/CharAtlasUtils';
 import { INVERTED_DEFAULT_COLOR } from 'browser/renderer/shared/Constants';
 import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
-import { ILinkifier2, ILinkifierEvent, ITerminal } from 'browser/Types';
+import { ILinkifier2, ILinkifierEvent } from 'browser/Types';
 import { Terminal } from 'xterm';
 import { BaseRenderLayer } from './BaseRenderLayer';
 

addons/xterm-addon-webgl/src/renderLayer/Types.ts

@@ -4,7 +4,6 @@
  */
 
 import { IDisposable, Terminal } from 'xterm';
-import { IColorSet, ReadonlyColorSet } from 'browser/Types';
 import { IRenderDimensions } from 'browser/renderer/shared/Types';
 
 export interface IRenderLayer extends IDisposable {
@@ -23,11 +22,6 @@ export interface IRenderLayer extends IDisposable {
    */
   handleCursorMove(terminal: Terminal): void;
 
-  /**
-   * Called when options change.
-   */
-  handleOptionsChanged(terminal: Terminal): void;
-
   /**
    * Called when the data in the grid has changed (or needs to be rendered
    * again).

src/browser/Terminal.ts

@@ -264,50 +264,14 @@ export class Terminal extends CoreTerminal implements ITerminal {
     }
   }
 
-  protected _updateOptions(key: string): void {
-    super._updateOptions(key);
-
-    // TODO: These listeners should be owned by individual components
-    switch (key) {
-      case 'fontFamily':
-      case 'fontSize':
-        // When the font changes the size of the cells may change which requires a renderer clear
-        this._renderService?.clear();
-        this._charSizeService?.measure();
-        break;
-      case 'cursorBlink':
-      case 'cursorStyle':
-        // The DOM renderer needs a row refresh to update the cursor styles
-        this.refresh(this.buffer.y, this.buffer.y);
-        break;
-      case 'customGlyphs':
-      case 'drawBoldTextInBrightColors':
-      case 'letterSpacing':
-      case 'lineHeight':
-      case 'fontWeight':
-      case 'fontWeightBold':
-      case 'minimumContrastRatio':
-        // When the font changes the size of the cells may change which requires a renderer clear
-        if (this._renderService) {
-          this._renderService.clear();
-          this._renderService.handleResize(this.cols, this.rows);
-          this.refresh(0, this.rows - 1);
-        }
-        break;
-      case 'scrollback':
-        this.viewport?.syncScrollArea();
-        break;
-      case 'screenReaderMode':
-        if (this.optionsService.rawOptions.screenReaderMode) {
-          if (!this._accessibilityManager && this._renderService) {
-            this._accessibilityManager = new AccessibilityManager(this, this._renderService);
-          }
-        } else {
-          this._accessibilityManager?.dispose();
-          this._accessibilityManager = undefined;
-        }
-        break;
-      case 'tabStopWidth': this.buffers.setupTabStops(); break;
+  private _handleScreenReaderModeOptionChange(value: boolean): void {
+    if (value) {
+      if (!this._accessibilityManager && this._renderService) {
+        this._accessibilityManager = new AccessibilityManager(this, this._renderService);
+      }
+    } else {
+      this._accessibilityManager?.dispose();
+      this._accessibilityManager = undefined;
     }
   }
 
@@ -583,12 +547,13 @@ export class Terminal extends CoreTerminal implements ITerminal {
       // ensure the correct order of the dprchange event
       this._accessibilityManager = new AccessibilityManager(this, this._renderService);
     }
+    this.register(this.optionsService.onSpecificOptionChange('screenReaderMode', e => this._handleScreenReaderModeOptionChange(e)));
 
     if (this.options.overviewRulerWidth) {
       this._overviewRulerRenderer = this.register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
     }
-    this.optionsService.onOptionChange(() => {
-      if (!this._overviewRulerRenderer && this.options.overviewRulerWidth && this._viewportElement && this.screenElement) {
+    this.optionsService.onSpecificOptionChange('overviewRulerWidth', value => {
+      if (!this._overviewRulerRenderer && value && this._viewportElement && this.screenElement) {
         this._overviewRulerRenderer = this.register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
       }
     });

src/browser/Viewport.ts

@@ -75,6 +75,7 @@ export class Viewport extends Disposable implements IViewport {
 
     this._handleThemeChange(themeService.colors);
     this.register(themeService.onChangeColors(e => this._handleThemeChange(e)));
+    this.register(this._optionsService.onSpecificOptionChange('scrollback', () => this.syncScrollArea()));
 
     // Perform this async to ensure the ICharSizeService is ready.
     setTimeout(() => this.syncScrollArea(), 0);

src/browser/decorations/OverviewRulerRenderer.ts

@@ -110,15 +110,9 @@ export class OverviewRulerRenderer extends Disposable {
       }
     }));
     // overview ruler width changed
-    this.register(this._optionsService.onOptionChange(o => {
-      if (o === 'overviewRulerWidth') {
-        this._queueRefresh(true);
-      }
-    }));
+    this.register(this._optionsService.onSpecificOptionChange('overviewRulerWidth', () => this._queueRefresh(true)));
     // device pixel ratio changed
-    this.register(addDisposableDomListener(this._coreBrowseService.window, 'resize', () => {
-      this._queueRefresh(true);
-    }));
+    this.register(addDisposableDomListener(this._coreBrowseService.window, 'resize', () => this._queueRefresh(true)));
     // set the canvas dimensions
     this._queueRefresh(true);
   }

src/browser/renderer/dom/DomRenderer.ts

@@ -79,6 +79,7 @@ export class DomRenderer extends Disposable implements IRenderer {
       actualCellHeight: 0
     };
     this._updateDimensions();
+    this.register(this._optionsService.onOptionChange(() => this._handleOptionsChanged()));
 
     this.register(themeService.onChangeColors(e => this._injectCss(e)));
     this._injectCss(themeService.colors);
@@ -342,7 +343,7 @@ export class DomRenderer extends Disposable implements IRenderer {
     // No-op, the cursor is drawn when rows are drawn
   }
 
-  public handleOptionsChanged(): void {
+  private _handleOptionsChanged(): void {
     // Force a refresh
     this._updateDimensions();
   }

src/browser/renderer/shared/Types.d.ts

@@ -68,7 +68,6 @@ export interface IRenderer extends IDisposable {
   handleFocus(): void;
   handleSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
   handleCursorMove(): void;
-  handleOptionsChanged(): void;
   clear(): void;
   renderRows(start: number, end: number): void;
   clearTextureAtlas?(): void;

src/browser/services/CharSizeService.ts

@@ -7,6 +7,7 @@ import { IOptionsService } from 'common/services/Services';
 import { EventEmitter } from 'common/EventEmitter';
 import { ICharSizeService } from 'browser/services/Services';
 import { Disposable } from 'common/Lifecycle';
+import { ITerminalOptions } from 'common/Types';
 
 export class CharSizeService extends Disposable implements ICharSizeService {
   public serviceBrand: undefined;
@@ -27,6 +28,7 @@ export class CharSizeService extends Disposable implements ICharSizeService {
   ) {
     super();
     this._measureStrategy = new DomMeasureStrategy(document, parentElement, this._optionsService);
+    this.register(this._optionsService.onMultipleOptionChange(['fontFamily', 'fontSize'], () => this.measure()));
   }
 
   public measure(): void {

src/browser/services/RenderService.ts

@@ -84,8 +84,28 @@ export class RenderService extends Disposable implements IRenderService {
     this.register(decorationService.onDecorationRegistered(() => this._fullRefresh()));
     this.register(decorationService.onDecorationRemoved(() => this._fullRefresh()));
 
-    // No need to register this as renderer is explicitly disposed in RenderService.dispose
-    // this._renderer.onRequestRedraw(e => this.refreshRows(e.start, e.end, true));
+    // Clear the renderer when the a change that could affect glyphs occurs
+    this.register(optionsService.onMultipleOptionChange([
+      'customGlyphs',
+      'drawBoldTextInBrightColors',
+      'letterSpacing',
+      'lineHeight',
+      'fontFamily',
+      'fontSize',
+      'fontWeight',
+      'fontWeightBold',
+      'minimumContrastRatio'
+    ], () => {
+      this.clear();
+      this.handleResize(bufferService.cols, bufferService.rows);
+      this._fullRefresh();
+    }));
+
+    // Refresh the cursor line when the cursor changes
+    this.register(optionsService.onMultipleOptionChange([
+      'cursorBlink',
+      'cursorStyle'
+    ], () => this.refreshRows(bufferService.buffer.y, bufferService.buffer.y, true)));
 
     // dprchange should handle this case, we need this as well for browsers that don't support the
     // matchMedia query.
@@ -157,7 +177,6 @@ export class RenderService extends Disposable implements IRenderService {
     if (!this._renderer) {
       return;
     }
-    this._renderer.handleOptionsChanged();
     this.refreshRows(0, this._rowCount - 1);
     this._fireOnCanvasResize();
   }

src/browser/services/ThemeService.ts

@@ -111,16 +111,8 @@ export class ThemeService extends Disposable implements IThemeService {
     this._updateRestoreColors();
     this._setTheme(this._optionsService.rawOptions.theme);
 
-    this.register(this._optionsService.onOptionChange(key => {
-      switch (key) {
-        case 'minimumContrastRatio':
-          this._contrastCache.clear();
-          break;
-        case 'theme':
-          this._setTheme(this._optionsService.rawOptions.theme);
-          break;
-      }
-    }));
+    this.register(this._optionsService.onSpecificOptionChange('minimumContrastRatio', () => this._contrastCache.clear()));
+    this.register(this._optionsService.onSpecificOptionChange('theme', () => this._setTheme(this._optionsService.rawOptions.theme)));
   }
 
   /**