EditorScrollbar is a ViewPart

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

@@ -130,8 +130,6 @@ export class View extends ViewEventHandler implements editorBrowser.IView, IDisp
 		// - line heights updating & co.
 		this.layoutProvider = new LayoutProvider(configuration, model.getLineCount(), this.eventDispatcher);
 
-		this._scrollbar = new EditorScrollbar(this.layoutProvider.getScrollable(), configuration, this.linesContent, this.domNode, this.overflowGuardContainer);
-
 		// The view context is passed on to most classes (basically to reduce param. counts in ctors)
 		this._context = new ViewContext(configuration, model, this.eventDispatcher);
 
@@ -217,6 +215,9 @@ export class View extends ViewEventHandler implements editorBrowser.IView, IDisp
 	private createViewParts(): void {
 		this.viewParts = [];
 
+		this._scrollbar = new EditorScrollbar(this._context, this.layoutProvider.getScrollable(), this.linesContent, this.domNode, this.overflowGuardContainer);
+		this.viewParts.push(this._scrollbar);
+
 		// View Lines
 		this.viewLines = new ViewLines(this._context, this.layoutProvider);
 
@@ -547,13 +548,12 @@ export class View extends ViewEventHandler implements editorBrowser.IView, IDisp
 
 		this.viewLines.dispose();
 
-		// Destroy IViewPart second
+		// Destroy view parts
 		for (let i = 0, len = this.viewParts.length; i < len; i++) {
 			this.viewParts[i].dispose();
 		}
 		this.viewParts = [];
 
-		this._scrollbar.dispose();
 		this.layoutProvider.dispose();
 	}
 
@@ -921,9 +921,6 @@ export class View extends ViewEventHandler implements editorBrowser.IView, IDisp
 			viewPart.render(renderingContext);
 			viewPart.onDidRender();
 		}
-
-		// Render the scrollbar
-		this._scrollbar.renderScrollbar();
 	}
 
 	private _setHasFocus(newHasFocus: boolean): void {

src/vs/editor/browser/viewParts/editorScrollbar/editorScrollbar.ts

@@ -8,70 +8,56 @@ import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import * as dom from 'vs/base/browser/dom';
 import { ScrollableElementCreationOptions, ScrollableElementChangeOptions } from 'vs/base/browser/ui/scrollbar/scrollableElementOptions';
 import { IOverviewRulerLayoutInfo, ScrollableElement } from 'vs/base/browser/ui/scrollbar/scrollableElement';
-import { IConfiguration, IConfigurationChangedEvent, INewScrollPosition } from 'vs/editor/common/editorCommon';
+import { INewScrollPosition } from 'vs/editor/common/editorCommon';
 import { ClassNames } from 'vs/editor/browser/editorBrowser';
-import { PartFingerprint, PartFingerprints } from 'vs/editor/browser/view/viewPart';
+import { ViewPart, PartFingerprint, PartFingerprints } from 'vs/editor/browser/view/viewPart';
 import { Scrollable } from 'vs/base/common/scrollable';
+import { ViewContext } from 'vs/editor/common/view/viewContext';
+import * as viewEvents from 'vs/editor/common/view/viewEvents';
+import { IRenderingContext, IRestrictedRenderingContext } from 'vs/editor/common/view/renderingContext';
 
-function addPropertyIfPresent(src: any, dst: any, prop: string): void {
-	if (src.hasOwnProperty(prop)) {
-		dst[prop] = src[prop];
-	}
-}
-
-export class EditorScrollbar implements IDisposable {
+export class EditorScrollbar extends ViewPart {
 
 	private scrollable: Scrollable;
-	private configuration: IConfiguration;
-
 	private toDispose: IDisposable[];
 	private linesContent: HTMLElement;
 	private scrollbar: ScrollableElement;
 
-	constructor(scrollable: Scrollable, configuration: IConfiguration, linesContent: HTMLElement, viewDomNode: HTMLElement, overflowGuardDomNode: HTMLElement) {
+	constructor(context: ViewContext, scrollable: Scrollable, linesContent: HTMLElement, viewDomNode: HTMLElement, overflowGuardDomNode: HTMLElement) {
+		super(context);
+
 		this.toDispose = [];
 		this.scrollable = scrollable;
-		this.configuration = configuration;
 		this.linesContent = linesContent;
 
-		let configScrollbarOpts = this.configuration.editor.viewInfo.scrollbar;
+		const viewInfo = this._context.configuration.editor.viewInfo;
+		const configScrollbarOpts = viewInfo.scrollbar;
 
 		let scrollbarOptions: ScrollableElementCreationOptions = {
-			canUseTranslate3d: this.configuration.editor.viewInfo.canUseTranslate3d,
+			canUseTranslate3d: viewInfo.canUseTranslate3d,
 			listenOnDomNode: viewDomNode,
+			className: ClassNames.SCROLLABLE_ELEMENT + ' ' + viewInfo.theme,
+			useShadows: false,
+			lazyRender: true,
+
 			vertical: configScrollbarOpts.vertical,
 			horizontal: configScrollbarOpts.horizontal,
-			className: ClassNames.SCROLLABLE_ELEMENT + ' ' + this.configuration.editor.viewInfo.theme,
-			useShadows: false,
-			lazyRender: true
+			verticalHasArrows: configScrollbarOpts.verticalHasArrows,
+			horizontalHasArrows: configScrollbarOpts.horizontalHasArrows,
+			verticalScrollbarSize: configScrollbarOpts.verticalScrollbarSize,
+			verticalSliderSize: configScrollbarOpts.verticalSliderSize,
+			horizontalScrollbarSize: configScrollbarOpts.horizontalScrollbarSize,
+			horizontalSliderSize: configScrollbarOpts.horizontalSliderSize,
+			handleMouseWheel: configScrollbarOpts.handleMouseWheel,
+			arrowSize: configScrollbarOpts.arrowSize,
+			mouseWheelScrollSensitivity: configScrollbarOpts.mouseWheelScrollSensitivity,
 		};
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'verticalHasArrows');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'horizontalHasArrows');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'verticalScrollbarSize');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'verticalSliderSize');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'horizontalScrollbarSize');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'horizontalSliderSize');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'handleMouseWheel');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'arrowSize');
-		addPropertyIfPresent(configScrollbarOpts, scrollbarOptions, 'mouseWheelScrollSensitivity');
 
 		this.scrollbar = new ScrollableElement(linesContent, scrollbarOptions, this.scrollable);
 		PartFingerprints.write(this.scrollbar.getDomNode(), PartFingerprint.ScrollableElement);
 
 		this.toDispose.push(this.scrollbar);
 
-		this.toDispose.push(this.configuration.onDidChange((e: IConfigurationChangedEvent) => {
-			this.scrollbar.updateClassName(ClassNames.SCROLLABLE_ELEMENT + ' ' + this.configuration.editor.viewInfo.theme);
-			if (e.viewInfo.scrollbar || e.viewInfo.canUseTranslate3d) {
-				let newOpts: ScrollableElementChangeOptions = {
-					canUseTranslate3d: this.configuration.editor.viewInfo.canUseTranslate3d,
-					handleMouseWheel: this.configuration.editor.viewInfo.scrollbar.handleMouseWheel,
-					mouseWheelScrollSensitivity: this.configuration.editor.viewInfo.scrollbar.mouseWheelScrollSensitivity
-				};
-				this.scrollbar.updateOptions(newOpts);
-			}
-		}));
-
 		// When having a zone widget that calls .focus() on one of its dom elements,
 		// the browser will try desperately to reveal that dom node, unexpectedly
 		// changing the .scrollTop of this.linesContent
@@ -109,10 +95,6 @@ export class EditorScrollbar implements IDisposable {
 		this.toDispose = dispose(this.toDispose);
 	}
 
-	public renderScrollbar(): void {
-		this.scrollbar.renderNow();
-	}
-
 	public getOverviewRulerLayoutInfo(): IOverviewRulerLayoutInfo {
 		return this.scrollbar.getOverviewRulerLayoutInfo();
 	}
@@ -128,4 +110,73 @@ export class EditorScrollbar implements IDisposable {
 	public getVerticalSliderVerticalCenter(): number {
 		return this.scrollbar.getVerticalSliderVerticalCenter();
 	}
+
+	// --- begin event handlers
+
+	public onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean {
+		const viewInfo = this._context.configuration.editor.viewInfo;
+
+		this.scrollbar.updateClassName(ClassNames.SCROLLABLE_ELEMENT + ' ' + viewInfo.theme);
+		if (e.viewInfo.scrollbar || e.viewInfo.canUseTranslate3d) {
+			let newOpts: ScrollableElementChangeOptions = {
+				canUseTranslate3d: viewInfo.canUseTranslate3d,
+				handleMouseWheel: viewInfo.scrollbar.handleMouseWheel,
+				mouseWheelScrollSensitivity: viewInfo.scrollbar.mouseWheelScrollSensitivity
+			};
+			this.scrollbar.updateOptions(newOpts);
+		}
+		return true;
+	}
+	public onCursorPositionChanged(e: viewEvents.ViewCursorPositionChangedEvent): boolean {
+		return false;
+	}
+	public onCursorSelectionChanged(e: viewEvents.ViewCursorSelectionChangedEvent): boolean {
+		return false;
+	}
+	public onDecorationsChanged(e: viewEvents.ViewDecorationsChangedEvent): boolean {
+		return false;
+	}
+	public onFlushed(e: viewEvents.ViewFlushedEvent): boolean {
+		return false;
+	}
+	public onFocusChanged(e: viewEvents.ViewFocusChangedEvent): boolean {
+		return false;
+	}
+	public onLineChanged(e: viewEvents.ViewLineChangedEvent): boolean {
+		return false;
+	}
+	public onLineMappingChanged(e: viewEvents.ViewLineMappingChangedEvent): boolean {
+		return false;
+	}
+	public onLinesDeleted(e: viewEvents.ViewLinesDeletedEvent): boolean {
+		return false;
+	}
+	public onLinesInserted(e: viewEvents.ViewLinesInsertedEvent): boolean {
+		return false;
+	}
+	public onRevealRangeRequest(e: viewEvents.ViewRevealRangeRequestEvent): boolean {
+		return false;
+	}
+	public onScrollChanged(e: viewEvents.ViewScrollChangedEvent): boolean {
+		return true;
+	}
+	public onScrollRequest(e: viewEvents.ViewScrollRequestEvent): boolean {
+		return false;
+	}
+	public onTokensChanged(e: viewEvents.ViewTokensChangedEvent): boolean {
+		return false;
+	}
+	public onZonesChanged(e: viewEvents.ViewZonesChangedEvent): boolean {
+		return false;
+	}
+
+	// --- end event handlers
+
+	public prepareRender(ctx: IRenderingContext): void {
+		// Nothing to do
+	}
+
+	public render(ctx: IRestrictedRenderingContext): void {
+		this.scrollbar.renderNow();
+	}
 }