introduce explicit isReadonly in notebook options

Author: rebornix

src/vs/workbench/contrib/interactive/browser/interactiveEditor.ts

@@ -148,7 +148,7 @@ export class InteractiveEditor extends EditorPane {
 		this.#notebookExecutionStateService = notebookExecutionStateService;
 		this.#extensionService = extensionService;
 
-		this.#notebookOptions = new NotebookOptions(configurationService, notebookExecutionStateService, { cellToolbarInteraction: 'hover', globalToolbar: true, dragAndDropEnabled: false, insertToolbarBetweenCells: false });
+		this.#notebookOptions = new NotebookOptions(configurationService, notebookExecutionStateService, true, { cellToolbarInteraction: 'hover', globalToolbar: true, dragAndDropEnabled: false });
 		this.#editorMemento = this.getEditorMemento<InteractiveEditorViewState>(editorGroupService, textResourceConfigurationService, INTERACTIVE_EDITOR_VIEW_STATE_PREFERENCE_KEY);
 
 		codeEditorService.registerDecorationType('interactive-decoration', DECORATION_KEY, {});

src/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor.ts

@@ -151,7 +151,7 @@ export class NotebookTextDiffEditor extends EditorPane implements INotebookTextD
 		@INotebookExecutionStateService notebookExecutionStateService: INotebookExecutionStateService,
 	) {
 		super(NotebookTextDiffEditor.ID, telemetryService, themeService, storageService);
-		this._notebookOptions = new NotebookOptions(this.configurationService, notebookExecutionStateService);
+		this._notebookOptions = new NotebookOptions(this.configurationService, notebookExecutionStateService, false);
 		this._register(this._notebookOptions);
 		const editorOptions = this.configurationService.getValue<ICodeEditorOptions>('editor');
 		this._fontInfo = FontMeasurements.readFontInfo(BareFontInfo.createFromRawSettings(editorOptions, PixelRatio.value));

src/vs/workbench/contrib/notebook/browser/notebookBrowser.ts

@@ -30,7 +30,6 @@ import { IWebviewElement } from 'vs/workbench/contrib/webview/browser/webview';
 import { IEditorOptions } from 'vs/editor/common/config/editorOptions';
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
-import { ViewContext } from 'vs/workbench/contrib/notebook/browser/viewModel/viewContext';
 
 //#region Shared commands
 export const EXPAND_CELL_INPUT_COMMAND_ID = 'notebook.cell.expandCellInput';
@@ -709,8 +708,6 @@ export interface IBaseCellEditorOptions extends IDisposable {
 export interface INotebookEditorDelegate extends INotebookEditor {
 	hasModel(): this is IActiveNotebookEditorDelegate;
 
-	readonly viewContext: ViewContext;
-
 	readonly creationOptions: INotebookEditorCreationOptions;
 	readonly onDidChangeOptions: Event<void>;
 	readonly onDidChangeDecorations: Event<void>;

src/vs/workbench/contrib/notebook/browser/notebookEditorWidget.ts

@@ -266,10 +266,6 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		return this._notebookOptions;
 	}
 
-	get viewContext() {
-		return this._viewContext;
-	}
-
 	constructor(
 		readonly creationOptions: INotebookEditorCreationOptions,
 		dimension: DOM.Dimension | undefined,
@@ -296,13 +292,12 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		this.isEmbedded = creationOptions.isEmbedded ?? false;
 		this._readOnly = creationOptions.isReadOnly ?? false;
 
-		this._notebookOptions = creationOptions.options ?? new NotebookOptions(this.configurationService, notebookExecutionStateService);
+		this._notebookOptions = creationOptions.options ?? new NotebookOptions(this.configurationService, notebookExecutionStateService, this._readOnly);
 		this._register(this._notebookOptions);
 		this._viewContext = new ViewContext(
 			this._notebookOptions,
 			new NotebookEventDispatcher(),
-			language => this.getBaseCellEditorOptions(language),
-			() => this._readOnly);
+			language => this.getBaseCellEditorOptions(language));
 		this._register(this._viewContext.eventDispatcher.onDidChangeCellState(e => {
 			this._onDidChangeCellState.fire(e);
 		}));
@@ -603,15 +598,15 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 			collapsedIndicatorHeight,
 			compactView,
 			focusIndicator,
-			insertToolbarBetweenCells,
+			insertToolbarPosition,
 			insertToolbarAlignment,
 			fontSize,
 			outputFontSize,
 			focusIndicatorLeftMargin,
 			focusIndicatorGap
 		} = this._notebookOptions.getLayoutConfiguration();
 
-		const { bottomToolbarGap, bottomToolbarHeight } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+		const { bottomToolbarGap, bottomToolbarHeight } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
 
 		const styleSheets: string[] = [];
 		if (!this._fontInfo) {
@@ -721,7 +716,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		}
 
 		// between cell insert toolbar
-		if (insertToolbarBetweenCells) {
+		if (insertToolbarPosition === 'betweenCells' || insertToolbarPosition === 'both') {
 			styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .monaco-list-row .cell-bottom-toolbar-container { display: flex; }`);
 			styleSheets.push(`.monaco-workbench .notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element > .monaco-list-rows > .cell-list-top-cell-toolbar-container { display: flex; }`);
 		} else {
@@ -760,7 +755,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		}
 
 		// top insert toolbar
-		const topInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+		const topInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
 		styleSheets.push(`.notebookOverlay .cell-list-top-cell-toolbar-container { top: -${topInsertToolbarHeight - 3}px }`);
 		styleSheets.push(`.notebookOverlay > .cell-list-container > .monaco-list > .monaco-scrollable-element,
 		.notebookOverlay > .cell-list-container > .notebook-gutter > .monaco-list > .monaco-scrollable-element {
@@ -1053,12 +1048,12 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 
 	async setModel(textModel: NotebookTextModel, viewState: INotebookEditorViewState | undefined, perf?: NotebookPerfMarks): Promise<void> {
 		if (this.viewModel === undefined || !this.viewModel.equal(textModel)) {
-			const oldTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
-			const oldBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+			const oldTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
+			const oldBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
 			this._detachModel();
 			await this._attachModel(textModel, viewState, perf);
-			const newTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
-			const newBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+			const newTopInsertToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
+			const newBottomToolbarDimensions = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
 
 			if (oldTopInsertToolbarHeight !== newTopInsertToolbarHeight
 				|| oldBottomToolbarDimensions.bottomToolbarGap !== newBottomToolbarDimensions.bottomToolbarGap
@@ -1181,6 +1176,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		}
 
 		this.viewModel.updateOptions({ isReadOnly: this._readOnly });
+		this.notebookOptions.updateOptions(this._readOnly);
 
 		// reveal cell if editor options tell to do so
 		const cellOptions = options?.cellOptions ?? this._parseIndexedCellOptions(options);
@@ -1369,6 +1365,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 
 		this.viewModel = this.instantiationService.createInstance(NotebookViewModel, textModel.viewType, textModel, this._viewContext, this.getLayoutInfo(), { isReadOnly: this._readOnly });
 		this._viewContext.eventDispatcher.emit([new NotebookLayoutChangedEvent({ width: true, fontInfo: true }, this.getLayoutInfo())]);
+		this.notebookOptions.updateOptions(this._readOnly);
 
 		this._updateForOptions();
 		this._updateForNotebookConfiguration();
@@ -1472,7 +1469,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		}));
 
 		if (this._dimension) {
-			const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+			const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
 			this._list.layout(this._dimension.height - topInserToolbarHeight, this._dimension.width);
 		} else {
 			this._list.layout();
@@ -1766,7 +1763,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 		const newBodyHeight = Math.max(dimension.height - (this._notebookTopToolbar?.useGlobalToolbar ? /** Toolbar height */ 26 : 0), 0);
 		DOM.size(this._body, dimension.width, newBodyHeight);
 
-		const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+		const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);
 		const newCellListHeight = Math.max(newBodyHeight - topInserToolbarHeight, 0);
 		if (this._list.getRenderHeight() < newCellListHeight) {
 			// the new dimension is larger than the list viewport, update its additional height first, otherwise the list view will move down a bit (as the `scrollBottom` will move down)
@@ -2939,7 +2936,7 @@ export class NotebookEditorWidget extends Disposable implements INotebookEditorD
 	private _updateMarkupCellHeight(cellId: string, height: number, isInit: boolean) {
 		const cell = this._getCellById(cellId);
 		if (cell && cell instanceof MarkupCellViewModel) {
-			const { bottomToolbarGap } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType, this.viewModel?.options.isReadOnly);
+			const { bottomToolbarGap } = this._notebookOptions.computeBottomToolbarDimensions(this.viewModel?.viewType);
 			this._debug('updateMarkdownCellHeight', cell.handle, height + bottomToolbarGap, isInit);
 			cell.renderedMarkdownHeight = height;
 		}

src/vs/workbench/contrib/notebook/browser/notebookOptions.ts

@@ -58,7 +58,7 @@ export interface NotebookLayoutConfiguration {
 	cellToolbarInteraction: string;
 	compactView: boolean;
 	focusIndicator: 'border' | 'gutter';
-	insertToolbarBetweenCells: boolean;
+	insertToolbarPosition: 'betweenCells' | 'notebookToolbar' | 'both' | 'hidden';
 	insertToolbarAlignment: 'left' | 'center';
 	globalToolbar: boolean;
 	consolidatedOutputButton: boolean;
@@ -133,7 +133,8 @@ export class NotebookOptions extends Disposable {
 	constructor(
 		private readonly configurationService: IConfigurationService,
 		private readonly notebookExecutionStateService: INotebookExecutionStateService,
-		private readonly overrides?: { cellToolbarInteraction: string; globalToolbar: boolean; dragAndDropEnabled: boolean; insertToolbarBetweenCells?: boolean }
+		private isReadonly: boolean,
+		private readonly overrides?: { cellToolbarInteraction: string; globalToolbar: boolean; dragAndDropEnabled: boolean }
 	) {
 		super();
 		const showCellStatusBar = this.configurationService.getValue<ShowCellStatusBarType>(NotebookSetting.showCellStatusBar);
@@ -145,7 +146,7 @@ export class NotebookOptions extends Disposable {
 		const cellToolbarInteraction = overrides?.cellToolbarInteraction ?? this.configurationService.getValue<string>(NotebookSetting.cellToolbarVisibility);
 		const compactView = this.configurationService.getValue<boolean | undefined>(NotebookSetting.compactView) ?? true;
 		const focusIndicator = this._computeFocusIndicatorOption();
-		const insertToolbarBetweenCells = overrides?.insertToolbarBetweenCells ?? this._computeInsertToolbarBetweenCellsOption();
+		const insertToolbarPosition = this._computeInsertToolbarPositionOption(this.isReadonly);
 		const insertToolbarAlignment = this._computeInsertToolbarAlignmentOption();
 		const showFoldingControls = this._computeShowFoldingControlsOption();
 		// const { bottomToolbarGap, bottomToolbarHeight } = this._computeBottomToolbarDimensions(compactView, insertToolbarPosition, insertToolbarAlignment);
@@ -219,7 +220,7 @@ export class NotebookOptions extends Disposable {
 			cellToolbarInteraction,
 			compactView,
 			focusIndicator,
-			insertToolbarBetweenCells,
+			insertToolbarPosition,
 			insertToolbarAlignment,
 			showFoldingControls,
 			fontSize,
@@ -248,6 +249,22 @@ export class NotebookOptions extends Disposable {
 		}));
 	}
 
+	updateOptions(isReadonly: boolean) {
+		if (this.isReadonly !== isReadonly) {
+			this.isReadonly = isReadonly;
+
+			this._updateConfiguration({
+				affectsConfiguration(configuration: string): boolean {
+					return configuration === NotebookSetting.insertToolbarLocation;
+				},
+				source: ConfigurationTarget.DEFAULT,
+				affectedKeys: new Set([NotebookSetting.insertToolbarLocation]),
+				change: { keys: [NotebookSetting.insertToolbarLocation], overrides: [] },
+				sourceConfig: undefined
+			});
+		}
+	}
+
 	private _migrateDeprecatedSetting(deprecatedKey: string, key: string): void {
 		const deprecatedSetting = this.configurationService.inspect(deprecatedKey);
 
@@ -369,7 +386,7 @@ export class NotebookOptions extends Disposable {
 			configuration.cellToolbarLocation = this.configurationService.getValue<string | { [key: string]: string }>(NotebookSetting.cellToolbarLocation) ?? { 'default': 'right' };
 		}
 
-		if (cellToolbarInteraction && this.overrides?.cellToolbarInteraction === undefined) {
+		if (cellToolbarInteraction && !this.overrides?.cellToolbarInteraction) {
 			configuration.cellToolbarInteraction = this.configurationService.getValue<string>(NotebookSetting.cellToolbarVisibility);
 		}
 
@@ -389,8 +406,8 @@ export class NotebookOptions extends Disposable {
 			configuration.insertToolbarAlignment = this._computeInsertToolbarAlignmentOption();
 		}
 
-		if (insertToolbarPosition && this.overrides?.insertToolbarBetweenCells === undefined) {
-			configuration.insertToolbarBetweenCells = this._computeInsertToolbarBetweenCellsOption();
+		if (insertToolbarPosition) {
+			configuration.insertToolbarPosition = this._computeInsertToolbarPositionOption(this.isReadonly);
 		}
 
 		if (globalToolbar && this.overrides?.globalToolbar === undefined) {
@@ -479,9 +496,8 @@ export class NotebookOptions extends Disposable {
 		});
 	}
 
-	private _computeInsertToolbarBetweenCellsOption() {
-		const configValue = this.configurationService.getValue<'betweenCells' | 'notebookToolbar' | 'both' | 'hidden'>(NotebookSetting.insertToolbarLocation) ?? 'both';
-		return configValue === 'betweenCells' || configValue === 'both';
+	private _computeInsertToolbarPositionOption(isReadOnly: boolean) {
+		return isReadOnly ? 'hidden' : this.configurationService.getValue<'betweenCells' | 'notebookToolbar' | 'both' | 'hidden'>(NotebookSetting.insertToolbarLocation) ?? 'both';
 	}
 
 	private _computeInsertToolbarAlignmentOption() {
@@ -513,16 +529,16 @@ export class NotebookOptions extends Disposable {
 		return this._layoutConfiguration;
 	}
 
-	computeCollapsedMarkdownCellHeight(viewType: string, isReadOnly: boolean): number {
-		const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType, isReadOnly);
+	computeCollapsedMarkdownCellHeight(viewType: string): number {
+		const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType);
 		return this._layoutConfiguration.markdownCellTopMargin
 			+ this._layoutConfiguration.collapsedIndicatorHeight
 			+ bottomToolbarGap
 			+ this._layoutConfiguration.markdownCellBottomMargin;
 	}
 
-	computeBottomToolbarOffset(totalHeight: number, viewType: string, isReadOnly: boolean) {
-		const { bottomToolbarGap, bottomToolbarHeight } = this.computeBottomToolbarDimensions(viewType, isReadOnly);
+	computeBottomToolbarOffset(totalHeight: number, viewType: string) {
+		const { bottomToolbarGap, bottomToolbarHeight } = this.computeBottomToolbarDimensions(viewType);
 
 		return totalHeight
 			- bottomToolbarGap
@@ -548,37 +564,34 @@ export class NotebookOptions extends Disposable {
 		return this._layoutConfiguration.cellStatusBarHeight;
 	}
 
-	private _computeBottomToolbarDimensions(compactView: boolean, insertToolbarBetweenCells: boolean, insertToolbarAlignment: 'left' | 'center', cellToolbar: 'right' | 'left' | 'hidden'): { bottomToolbarGap: number; bottomToolbarHeight: number } {
-		if (!insertToolbarBetweenCells) {
-			return compactView ? {
-				bottomToolbarGap: 0,
-				bottomToolbarHeight: 0
-			} : {
-				bottomToolbarGap: 12,
-				bottomToolbarHeight: 12
-			};
-		}
-
+	private _computeBottomToolbarDimensions(compactView: boolean, insertToolbarPosition: 'betweenCells' | 'notebookToolbar' | 'both' | 'hidden', insertToolbarAlignment: 'left' | 'center', cellToolbar: 'right' | 'left' | 'hidden'): { bottomToolbarGap: number; bottomToolbarHeight: number } {
 		if (insertToolbarAlignment === 'left' || cellToolbar !== 'hidden') {
 			return {
 				bottomToolbarGap: 18,
 				bottomToolbarHeight: 18
 			};
 		}
 
-		return compactView ? {
-			bottomToolbarGap: 12,
-			bottomToolbarHeight: 20
-		} : {
-			bottomToolbarGap: 20,
-			bottomToolbarHeight: 20
-		};
+		if (insertToolbarPosition === 'betweenCells' || insertToolbarPosition === 'both') {
+			return compactView ? {
+				bottomToolbarGap: 12,
+				bottomToolbarHeight: 20
+			} : {
+				bottomToolbarGap: 20,
+				bottomToolbarHeight: 20
+			};
+		} else {
+			return {
+				bottomToolbarGap: 0,
+				bottomToolbarHeight: 0
+			};
+		}
 	}
 
-	computeBottomToolbarDimensions(viewType?: string, isReadOnly?: boolean): { bottomToolbarGap: number; bottomToolbarHeight: number } {
+	computeBottomToolbarDimensions(viewType?: string): { bottomToolbarGap: number; bottomToolbarHeight: number } {
 		const configuration = this._layoutConfiguration;
 		const cellToolbarPosition = this.computeCellToolbarLocation(viewType);
-		const { bottomToolbarGap, bottomToolbarHeight } = this._computeBottomToolbarDimensions(configuration.compactView, configuration.insertToolbarBetweenCells && !isReadOnly, configuration.insertToolbarAlignment, cellToolbarPosition);
+		const { bottomToolbarGap, bottomToolbarHeight } = this._computeBottomToolbarDimensions(configuration.compactView, configuration.insertToolbarPosition, configuration.insertToolbarAlignment, cellToolbarPosition);
 		return {
 			bottomToolbarGap,
 			bottomToolbarHeight
@@ -619,8 +632,8 @@ export class NotebookOptions extends Disposable {
 		return 'right';
 	}
 
-	computeTopInsertToolbarHeight(viewType?: string, isReadOnly?: boolean): number {
-		if (this._layoutConfiguration.insertToolbarBetweenCells && !isReadOnly) {
+	computeTopInsertToolbarHeight(viewType?: string): number {
+		if (this._layoutConfiguration.insertToolbarPosition === 'betweenCells' || this._layoutConfiguration.insertToolbarPosition === 'both') {
 			return SCROLLABLE_ELEMENT_PADDING_TOP;
 		}
 
@@ -700,8 +713,8 @@ export class NotebookOptions extends Disposable {
 		};
 	}
 
-	computeIndicatorPosition(totalHeight: number, foldHintHeight: number, viewType?: string, isReadOnly?: boolean) {
-		const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType, isReadOnly);
+	computeIndicatorPosition(totalHeight: number, foldHintHeight: number, viewType?: string) {
+		const { bottomToolbarGap } = this.computeBottomToolbarDimensions(viewType);
 
 		return {
 			bottomIndicatorTop: totalHeight - bottomToolbarGap - this._layoutConfiguration.cellBottomMargin - foldHintHeight,