Emit the content size changed event through the view model

src/vs/editor/browser/view/viewImpl.ts

@@ -299,10 +299,6 @@ export class View extends ViewEventHandler {
 		this._applyLayout();
 		return false;
 	}
-	public onContentSizeChanged(e: viewEvents.ViewContentSizeChangedEvent): boolean {
-		this.outgoingEvents.emitContentSizeChange(e);
-		return false;
-	}
 	public onCursorStateChanged(e: viewEvents.ViewCursorStateChangedEvent): boolean {
 		this._selections = e.selections;
 		return false;

src/vs/editor/browser/view/viewOutgoingEvents.ts

@@ -9,7 +9,7 @@ import { MouseTarget } from 'vs/editor/browser/controller/mouseTarget';
 import { IEditorMouseEvent, IMouseTarget, IPartialEditorMouseEvent, MouseTargetType } from 'vs/editor/browser/editorBrowser';
 import { Position } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
-import { IScrollEvent, IContentSizeChangedEvent } from 'vs/editor/common/editorCommon';
+import { IScrollEvent } from 'vs/editor/common/editorCommon';
 import * as viewEvents from 'vs/editor/common/view/viewEvents';
 import { IViewModel, ICoordinatesConverter } from 'vs/editor/common/viewModel/viewModel';
 import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
@@ -20,7 +20,6 @@ export interface EventCallback<T> {
 
 export class ViewOutgoingEvents extends Disposable {
 
-	public onDidContentSizeChange: EventCallback<IContentSizeChangedEvent> | null = null;
 	public onDidScroll: EventCallback<IScrollEvent> | null = null;
 	public onDidGainFocus: EventCallback<void> | null = null;
 	public onDidLoseFocus: EventCallback<void> | null = null;
@@ -42,12 +41,6 @@ export class ViewOutgoingEvents extends Disposable {
 		this._viewModel = viewModel;
 	}
 
-	public emitContentSizeChange(e: viewEvents.ViewContentSizeChangedEvent): void {
-		if (this.onDidContentSizeChange) {
-			this.onDidContentSizeChange(e);
-		}
-	}
-
 	public emitScrollChanged(e: viewEvents.ViewScrollChangedEvent): void {
 		if (this.onDidScroll) {
 			this.onDidScroll(e);

src/vs/editor/browser/widget/codeEditorWidget.ts

@@ -54,6 +54,7 @@ import { MonospaceLineBreaksComputerFactory } from 'vs/editor/common/viewModel/m
 import { DOMLineBreaksComputerFactory } from 'vs/editor/browser/view/domLineBreaksComputer';
 import { WordOperations } from 'vs/editor/common/controller/cursorWordOperations';
 import { IViewModel } from 'vs/editor/common/viewModel/viewModel';
+import { OutgoingViewModelEventKind } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
 
 let EDITOR_ID = 0;
 
@@ -1509,6 +1510,14 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
 			this._onDidChangeCursorSelection.fire(e2);
 		}));
 
+		listenersToRemove.push(viewModel.onEvent((e) => {
+			switch (e.kind) {
+				case OutgoingViewModelEventKind.ContentSizeChanged:
+					this._onDidContentSizeChange.fire(e);
+					break;
+			}
+		}));
+
 		const [view, hasRealView] = this._createView(viewModel);
 		if (hasRealView) {
 			this._domElement.appendChild(view.domNode.domNode);
@@ -1592,7 +1601,6 @@ export class CodeEditorWidget extends Disposable implements editorBrowser.ICodeE
 		};
 
 		const viewOutgoingEvents = new ViewOutgoingEvents(viewModel);
-		viewOutgoingEvents.onDidContentSizeChange = (e) => this._onDidContentSizeChange.fire(e);
 		viewOutgoingEvents.onDidScroll = (e) => this._onDidScrollChange.fire(e);
 		viewOutgoingEvents.onDidGainFocus = () => onDidChangeTextFocus(true);
 		viewOutgoingEvents.onDidLoseFocus = () => onDidChangeTextFocus(false);

src/vs/editor/common/view/viewEvents.ts

@@ -3,33 +3,30 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ViewModelEventDispatcher } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
-import { Disposable } from 'vs/base/common/lifecycle';
 import { ScrollEvent } from 'vs/base/common/scrollable';
 import { ConfigurationChangedEvent, EditorOption } from 'vs/editor/common/config/editorOptions';
 import { Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
-import { ScrollType, IContentSizeChangedEvent } from 'vs/editor/common/editorCommon';
+import { ScrollType } from 'vs/editor/common/editorCommon';
 import { IModelDecorationsChangedEvent } from 'vs/editor/common/model/textModelEvents';
 
 export const enum ViewEventType {
-	ViewConfigurationChanged = 1,
-	ViewContentSizeChanged = 2,
-	ViewCursorStateChanged = 3,
-	ViewDecorationsChanged = 4,
-	ViewFlushed = 5,
-	ViewFocusChanged = 6,
-	ViewLanguageConfigurationChanged = 7,
-	ViewLineMappingChanged = 8,
-	ViewLinesChanged = 9,
-	ViewLinesDeleted = 10,
-	ViewLinesInserted = 11,
-	ViewRevealRangeRequest = 12,
-	ViewScrollChanged = 13,
-	ViewThemeChanged = 14,
-	ViewTokensChanged = 15,
-	ViewTokensColorsChanged = 16,
-	ViewZonesChanged = 17,
+	ViewConfigurationChanged,
+	ViewCursorStateChanged,
+	ViewDecorationsChanged,
+	ViewFlushed,
+	ViewFocusChanged,
+	ViewLanguageConfigurationChanged,
+	ViewLineMappingChanged,
+	ViewLinesChanged,
+	ViewLinesDeleted,
+	ViewLinesInserted,
+	ViewRevealRangeRequest,
+	ViewScrollChanged,
+	ViewThemeChanged,
+	ViewTokensChanged,
+	ViewTokensColorsChanged,
+	ViewZonesChanged,
 }
 
 export class ViewConfigurationChangedEvent {
@@ -47,25 +44,6 @@ export class ViewConfigurationChangedEvent {
 	}
 }
 
-export class ViewContentSizeChangedEvent implements IContentSizeChangedEvent {
-
-	public readonly type = ViewEventType.ViewContentSizeChanged;
-
-	public readonly contentWidth: number;
-	public readonly contentHeight: number;
-
-	public readonly contentWidthChanged: boolean;
-	public readonly contentHeightChanged: boolean;
-
-	constructor(source: IContentSizeChangedEvent) {
-		this.contentWidth = source.contentWidth;
-		this.contentHeight = source.contentHeight;
-
-		this.contentWidthChanged = source.contentWidthChanged;
-		this.contentHeightChanged = source.contentHeightChanged;
-	}
-}
-
 export class ViewCursorStateChangedEvent {
 
 	public readonly type = ViewEventType.ViewCursorStateChanged;
@@ -308,7 +286,6 @@ export class ViewZonesChangedEvent {
 
 export type ViewEvent = (
 	ViewConfigurationChangedEvent
-	| ViewContentSizeChangedEvent
 	| ViewCursorStateChangedEvent
 	| ViewDecorationsChangedEvent
 	| ViewFlushedEvent
@@ -326,49 +303,6 @@ export type ViewEvent = (
 	| ViewZonesChangedEvent
 );
 
-export interface IViewEventListener {
-	(events: ViewEvent[]): void;
-}
-
-export class ViewEventEmitter extends Disposable {
-	private _collector: ViewEventsCollector | null;
-	private _collectorCnt: number;
-
-	constructor() {
-		super();
-		this._collector = null;
-		this._collectorCnt = 0;
-	}
-
-	protected _beginEmitViewEvents(): ViewEventsCollector {
-		this._collectorCnt++;
-		if (this._collectorCnt === 1) {
-			this._collector = new ViewEventsCollector();
-		}
-		return this._collector!;
-	}
-
-	protected _endEmitViewEvents(eventDispatcher: ViewModelEventDispatcher): void {
-		this._collectorCnt--;
-		if (this._collectorCnt === 0) {
-			const events = this._collector!.finalize();
-			this._collector = null;
-			if (events.length > 0) {
-				eventDispatcher.emitMany(events);
-			}
-		}
-	}
-
-	protected _emitSingleViewEvent(eventDispatcher: ViewModelEventDispatcher, event: ViewEvent): void {
-		try {
-			const eventsCollector = this._beginEmitViewEvents();
-			eventsCollector.emit(event);
-		} finally {
-			this._endEmitViewEvents(eventDispatcher);
-		}
-	}
-}
-
 export class ViewEventsCollector {
 
 	private _events: ViewEvent[];
@@ -388,5 +322,4 @@ export class ViewEventsCollector {
 		this._events = [];
 		return result;
 	}
-
 }

src/vs/editor/common/viewLayout/viewLayout.ts

@@ -7,10 +7,11 @@ import { Event, Emitter } from 'vs/base/common/event';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
 import { IScrollPosition, ScrollEvent, Scrollable, ScrollbarVisibility, INewScrollPosition } from 'vs/base/common/scrollable';
 import { ConfigurationChangedEvent, EditorOption } from 'vs/editor/common/config/editorOptions';
-import { IConfiguration, IContentSizeChangedEvent, ScrollType } from 'vs/editor/common/editorCommon';
+import { IConfiguration, ScrollType } from 'vs/editor/common/editorCommon';
 import { LinesLayout, IEditorWhitespace, IWhitespaceChangeAccessor } from 'vs/editor/common/viewLayout/linesLayout';
 import { IPartialViewLinesViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
 import { IViewLayout, IViewWhitespaceViewportData, Viewport } from 'vs/editor/common/viewModel/viewModel';
+import { ContentSizeChangedEvent } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
 
 const SMOOTH_SCROLLING_TIME = 125;
 
@@ -75,8 +76,8 @@ class EditorScrollable extends Disposable {
 
 	public readonly onDidScroll: Event<ScrollEvent>;
 
-	private readonly _onDidContentSizeChange = this._register(new Emitter<IContentSizeChangedEvent>());
-	public readonly onDidContentSizeChange: Event<IContentSizeChangedEvent> = this._onDidContentSizeChange.event;
+	private readonly _onDidContentSizeChange = this._register(new Emitter<ContentSizeChangedEvent>());
+	public readonly onDidContentSizeChange: Event<ContentSizeChangedEvent> = this._onDidContentSizeChange.event;
 
 	constructor(smoothScrollDuration: number, scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable) {
 		super();
@@ -119,13 +120,10 @@ class EditorScrollable extends Disposable {
 		const contentWidthChanged = (oldDimensions.contentWidth !== dimensions.contentWidth);
 		const contentHeightChanged = (oldDimensions.contentHeight !== dimensions.contentHeight);
 		if (contentWidthChanged || contentHeightChanged) {
-			this._onDidContentSizeChange.fire({
-				contentWidth: dimensions.contentWidth,
-				contentHeight: dimensions.contentHeight,
-
-				contentWidthChanged: contentWidthChanged,
-				contentHeightChanged: contentHeightChanged
-			});
+			this._onDidContentSizeChange.fire(new ContentSizeChangedEvent(
+				oldDimensions.contentWidth, oldDimensions.contentHeight,
+				dimensions.contentWidth, dimensions.contentHeight
+			));
 		}
 	}
 
@@ -153,7 +151,7 @@ export class ViewLayout extends Disposable implements IViewLayout {
 
 	private readonly _scrollable: EditorScrollable;
 	public readonly onDidScroll: Event<ScrollEvent>;
-	public readonly onDidContentSizeChange: Event<IContentSizeChangedEvent>;
+	public readonly onDidContentSizeChange: Event<ContentSizeChangedEvent>;
 
 	constructor(configuration: IConfiguration, lineCount: number, scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable) {
 		super();

src/vs/editor/common/viewModel/viewEventHandler.ts

@@ -36,9 +36,7 @@ export class ViewEventHandler extends Disposable {
 	public onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean {
 		return false;
 	}
-	public onContentSizeChanged(e: viewEvents.ViewContentSizeChangedEvent): boolean {
-		return false;
-	}
+
 	public onCursorStateChanged(e: viewEvents.ViewCursorStateChangedEvent): boolean {
 		return false;
 	}
@@ -102,12 +100,6 @@ export class ViewEventHandler extends Disposable {
 					}
 					break;
 
-				case viewEvents.ViewEventType.ViewContentSizeChanged:
-					if (this.onContentSizeChanged(e)) {
-						shouldRender = true;
-					}
-					break;
-
 				case viewEvents.ViewEventType.ViewCursorStateChanged:
 					if (this.onCursorStateChanged(e)) {
 						shouldRender = true;

src/vs/editor/common/viewModel/viewModelEventDispatcher.ts

@@ -4,21 +4,58 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
-import { ViewEvent } from 'vs/editor/common/view/viewEvents';
+import { ViewEvent, ViewEventsCollector } from 'vs/editor/common/view/viewEvents';
 import { IContentSizeChangedEvent } from 'vs/editor/common/editorCommon';
+import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'vs/base/common/lifecycle';
 
-export class ViewModelEventDispatcher {
+export class ViewModelEventDispatcher extends Disposable {
+
+	private readonly _onEvent = this._register(new Emitter<OutgoingViewModelEvent>());
+	public readonly onEvent = this._onEvent.event;
 
 	private readonly _eventHandlers: ViewEventHandler[];
 	private _viewEventQueue: ViewEvent[] | null;
 	private _isConsumingViewEventQueue: boolean;
-	// private _outgoingContentSizeChangedEvent: OutgoingContentSizeChangedEvent | null;
+	private _collector: ViewEventsCollector | null;
+	private _collectorCnt: number;
+	private _outgoingEvents: OutgoingViewModelEvent[];
 
 	constructor() {
+		super();
 		this._eventHandlers = [];
 		this._viewEventQueue = null;
 		this._isConsumingViewEventQueue = false;
-		// this._outgoingContentSizeChangedEvent = null;
+		this._collector = null;
+		this._collectorCnt = 0;
+		this._outgoingEvents = [];
+	}
+
+	public emitOutgoingEvent(e: OutgoingViewModelEvent): void {
+		this._addOutgoingEvent(e);
+		this._emitOugoingEvents();
+	}
+
+	private _addOutgoingEvent(e: OutgoingViewModelEvent): void {
+		for (let i = 0, len = this._outgoingEvents.length; i < len; i++) {
+			if (this._outgoingEvents[i].kind === e.kind) {
+				this._outgoingEvents[i] = this._outgoingEvents[i].merge(e);
+				return;
+			}
+		}
+		// not merged
+		this._outgoingEvents.push(e);
+	}
+
+	private _emitOugoingEvents(): void {
+		while (this._outgoingEvents.length > 0) {
+			if (this._collector || this._isConsumingViewEventQueue) {
+				// right now collecting or emitting view events, so let's postpone emitting
+				return;
+			}
+			const event = this._outgoingEvents.shift()!;
+			this._onEvent.fire(event);
+		}
 	}
 
 	public addViewEventHandler(eventHandler: ViewEventHandler): void {
@@ -39,7 +76,36 @@ export class ViewModelEventDispatcher {
 		}
 	}
 
-	public emitMany(events: ViewEvent[]): void {
+	public beginEmitViewEvents(): ViewEventsCollector {
+		this._collectorCnt++;
+		if (this._collectorCnt === 1) {
+			this._collector = new ViewEventsCollector();
+		}
+		return this._collector!;
+	}
+
+	public endEmitViewEvents(): void {
+		this._collectorCnt--;
+		if (this._collectorCnt === 0) {
+			const events = this._collector!.finalize();
+			this._collector = null;
+			if (events.length > 0) {
+				this._emitMany(events);
+			}
+		}
+		this._emitOugoingEvents();
+	}
+
+	public emitSingleViewEvent(event: ViewEvent): void {
+		try {
+			const eventsCollector = this.beginEmitViewEvents();
+			eventsCollector.emit(event);
+		} finally {
+			this.endEmitViewEvents();
+		}
+	}
+
+	private _emitMany(events: ViewEvent[]): void {
 		if (this._viewEventQueue) {
 			this._viewEventQueue = this._viewEventQueue.concat(events);
 		} else {
@@ -75,7 +141,13 @@ export class ViewModelEventDispatcher {
 	}
 }
 
-export class OutgoingContentSizeChangedEvent implements IContentSizeChangedEvent {
+export const enum OutgoingViewModelEventKind {
+	ContentSizeChanged,
+}
+
+export class ContentSizeChangedEvent implements IContentSizeChangedEvent {
+
+	public readonly kind = OutgoingViewModelEventKind.ContentSizeChanged;
 
 	private readonly _oldContentWidth: number;
 	private readonly _oldContentHeight: number;
@@ -93,4 +165,10 @@ export class OutgoingContentSizeChangedEvent implements IContentSizeChangedEvent
 		this.contentWidthChanged = (this._oldContentWidth !== this.contentWidth);
 		this.contentHeightChanged = (this._oldContentHeight !== this.contentHeight);
 	}
+
+	public merge(other: ContentSizeChangedEvent): ContentSizeChangedEvent {
+		return new ContentSizeChangedEvent(this._oldContentWidth, this._oldContentHeight, other.contentWidth, other.contentHeight);
+	}
 }
+
+export type OutgoingViewModelEvent = ContentSizeChangedEvent;

src/vs/editor/common/viewModel/viewModelImpl.ts

@@ -4,7 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Color } from 'vs/base/common/color';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { Event } from 'vs/base/common/event';
+import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
 import * as strings from 'vs/base/common/strings';
 import { ConfigurationChangedEvent, EDITOR_FONT_DEFAULTS, EditorOption, filterValidationDecorations } from 'vs/editor/common/config/editorOptions';
 import { IPosition, Position } from 'vs/editor/common/core/position';
@@ -29,17 +30,18 @@ import { Cursor } from 'vs/editor/common/controller/cursor';
 import { PartialCursorState, CursorState, IColumnSelectData, EditOperationType, CursorConfiguration } from 'vs/editor/common/controller/cursorCommon';
 import { CursorChangeReason } from 'vs/editor/common/controller/cursorEvents';
 import { IWhitespaceChangeAccessor } from 'vs/editor/common/viewLayout/linesLayout';
-import { ViewModelEventDispatcher } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
+import { ViewModelEventDispatcher, OutgoingViewModelEvent } from 'vs/editor/common/viewModel/viewModelEventDispatcher';
 import { ViewEventHandler } from 'vs/editor/common/viewModel/viewEventHandler';
 
 const USE_IDENTITY_LINES_COLLECTION = true;
 
-export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel {
+export class ViewModel extends Disposable implements IViewModel {
 
 	private readonly editorId: number;
 	private readonly configuration: IConfiguration;
 	public readonly model: ITextModel;
 	private readonly _eventDispatcher: ViewModelEventDispatcher;
+	public readonly onEvent: Event<OutgoingViewModelEvent>;
 	public cursorConfig: CursorConfiguration;
 	private readonly _tokenizeViewportSoon: RunOnceScheduler;
 	private readonly _updateConfigurationViewLineCount: RunOnceScheduler;
@@ -67,6 +69,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 		this.configuration = configuration;
 		this.model = model;
 		this._eventDispatcher = new ViewModelEventDispatcher();
+		this.onEvent = this._eventDispatcher.onEvent;
 		this.cursorConfig = new CursorConfiguration(this.model.getLanguageIdentifier(), this.model.getOptions(), this.configuration);
 		this._tokenizeViewportSoon = this._register(new RunOnceScheduler(() => this.tokenizeViewport(), 50));
 		this._updateConfigurationViewLineCount = this._register(new RunOnceScheduler(() => this._updateConfigurationViewLineCountNow(), 0));
@@ -108,11 +111,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 			if (e.scrollTopChanged) {
 				this._tokenizeViewportSoon.schedule();
 			}
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewScrollChangedEvent(e));
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewScrollChangedEvent(e));
 		}));
 
 		this._register(this.viewLayout.onDidContentSizeChange((e) => {
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewContentSizeChangedEvent(e));
+			this._eventDispatcher.emitOutgoingEvent(e);
 		}));
 
 		this.decorations = new ViewModelDecorations(this.editorId, this.model, this.configuration, this.lines, this.coordinatesConverter);
@@ -121,15 +124,15 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 
 		this._register(this.configuration.onDidChange((e) => {
 			try {
-				const eventsCollector = this._beginEmitViewEvents();
+				const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 				this._onConfigurationChanged(eventsCollector, e);
 			} finally {
-				this._endEmitViewEvents(this._eventDispatcher);
+				this._eventDispatcher.endEmitViewEvents();
 			}
 		}));
 
 		this._register(MinimapTokensColorTracker.getInstance().onDidChange(() => {
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewTokensColorsChangedEvent());
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewTokensColorsChangedEvent());
 		}));
 
 		this._updateConfigurationViewLineCountNow();
@@ -143,6 +146,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 		this.lines.dispose();
 		this.invalidateMinimapColorCache();
 		this.viewportStartLineTrackedRange = this.model._setTrackedRange(this.viewportStartLineTrackedRange, null, TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges);
+		this._eventDispatcher.dispose();
 	}
 
 	public addViewEventHandler(eventHandler: ViewEventHandler): void {
@@ -167,11 +171,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 	public setHasFocus(hasFocus: boolean): void {
 		this.hasFocus = hasFocus;
 		this.cursor.setHasFocus(hasFocus);
-		this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewFocusChangedEvent(hasFocus));
+		this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewFocusChangedEvent(hasFocus));
 	}
 
 	public onDidColorThemeChange(): void {
-		this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewThemeChangedEvent());
+		this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewThemeChangedEvent());
 	}
 
 	private _onConfigurationChanged(eventsCollector: viewEvents.ViewEventsCollector, e: ConfigurationChangedEvent): void {
@@ -231,7 +235,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 
 		this._register(this.model.onDidChangeRawContentFast((e) => {
 			try {
-				const eventsCollector = this._beginEmitViewEvents();
+				const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 
 				let hadOtherModelChange = false;
 				let hadModelLineChangeThatChangedLineMapping = false;
@@ -325,7 +329,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 					this.decorations.onLineMappingChanged();
 				}
 			} finally {
-				this._endEmitViewEvents(this._eventDispatcher);
+				this._eventDispatcher.endEmitViewEvents();
 			}
 
 			// Update the configuration and reset the centered view line
@@ -344,10 +348,10 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 			}
 
 			try {
-				const eventsCollector = this._beginEmitViewEvents();
+				const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 				this.cursor.onModelContentChanged(eventsCollector, e);
 			} finally {
-				this._endEmitViewEvents(this._eventDispatcher);
+				this._eventDispatcher.endEmitViewEvents();
 			}
 		}));
 
@@ -362,7 +366,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 					toLineNumber: viewEndLineNumber
 				};
 			}
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewTokensChangedEvent(viewRanges));
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewTokensChangedEvent(viewRanges));
 
 			if (e.tokenizationSupportChanged) {
 				this._tokenizeViewportSoon.schedule();
@@ -370,7 +374,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 		}));
 
 		this._register(this.model.onDidChangeLanguageConfiguration((e) => {
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewLanguageConfigurationEvent());
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewLanguageConfigurationEvent());
 			this.cursorConfig = new CursorConfiguration(this.model.getLanguageIdentifier(), this.model.getOptions(), this.configuration);
 			this.cursor.updateConfiguration(this.cursorConfig);
 		}));
@@ -384,7 +388,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 			// A tab size change causes a line mapping changed event => all view parts will repaint OK, no further event needed here
 			if (this.lines.setTabSize(this.model.getOptions().tabSize)) {
 				try {
-					const eventsCollector = this._beginEmitViewEvents();
+					const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 					eventsCollector.emit(new viewEvents.ViewFlushedEvent());
 					eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
 					eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent(null));
@@ -392,7 +396,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 					this.decorations.onLineMappingChanged();
 					this.viewLayout.onFlushed(this.getLineCount());
 				} finally {
-					this._endEmitViewEvents(this._eventDispatcher);
+					this._eventDispatcher.endEmitViewEvents();
 				}
 				this._updateConfigurationViewLineCount.schedule();
 			}
@@ -403,13 +407,13 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 
 		this._register(this.model.onDidChangeDecorations((e) => {
 			this.decorations.onModelDecorationsChanged();
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewDecorationsChangedEvent(e));
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewDecorationsChangedEvent(e));
 		}));
 	}
 
 	public setHiddenAreas(ranges: Range[]): void {
 		try {
-			const eventsCollector = this._beginEmitViewEvents();
+			const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 			let lineMappingChanged = this.lines.setHiddenAreas(ranges);
 			if (lineMappingChanged) {
 				eventsCollector.emit(new viewEvents.ViewFlushedEvent());
@@ -421,7 +425,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 				this.viewLayout.onHeightMaybeChanged();
 			}
 		} finally {
-			this._endEmitViewEvents(this._eventDispatcher);
+			this._eventDispatcher.endEmitViewEvents();
 		}
 		this._updateConfigurationViewLineCount.schedule();
 	}
@@ -970,7 +974,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 	public changeWhitespace(callback: (accessor: IWhitespaceChangeAccessor) => void): void {
 		const hadAChange = this.viewLayout.changeWhitespace(callback);
 		if (hadAChange) {
-			this._emitSingleViewEvent(this._eventDispatcher, new viewEvents.ViewZonesChangedEvent());
+			this._eventDispatcher.emitSingleViewEvent(new viewEvents.ViewZonesChangedEvent());
 		}
 	}
 	public setMaxLineWidth(maxLineWidth: number): void {
@@ -980,10 +984,10 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 
 	private _withViewEventsCollector(callback: (eventsCollector: viewEvents.ViewEventsCollector) => void): void {
 		try {
-			const eventsCollector = this._beginEmitViewEvents();
+			const eventsCollector = this._eventDispatcher.beginEmitViewEvents();
 			callback(eventsCollector);
 		} finally {
-			this._endEmitViewEvents(this._eventDispatcher);
+			this._eventDispatcher.endEmitViewEvents();
 		}
 	}
 }