@theia/notebook 1.47.1 → 1.48.2

package/src/browser/contributions/notebook-actions-contribution.ts

@@ -16,13 +16,15 @@
 
 import { Command, CommandContribution, CommandHandler, CommandRegistry, CompoundMenuNodeRole, MenuContribution, MenuModelRegistry, nls } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ApplicationShell, codicon, CommonCommands } from '@theia/core/lib/browser';
+import { ApplicationShell, codicon, CommonCommands, KeybindingContribution, KeybindingRegistry } from '@theia/core/lib/browser';
 import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookService } from '../service/notebook-service';
 import { CellEditType, CellKind, NotebookCommand } from '../../common';
 import { NotebookKernelQuickPickService } from '../service/notebook-kernel-quick-pick-service';
 import { NotebookExecutionService } from '../service/notebook-execution-service';
 import { NotebookEditorWidget } from '../notebook-editor-widget';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { NOTEBOOK_CELL_FOCUSED, NOTEBOOK_EDITOR_FOCUSED } from './notebook-context-keys';
 
 export namespace NotebookCommands {
     export const ADD_NEW_CELL_COMMAND = Command.toDefaultLocalizedCommand({
@@ -59,10 +61,20 @@ export namespace NotebookCommands {
         category: 'Notebook',
         iconClass: codicon('clear-all')
     });
+
+    export const CHANGE_SELECTED_CELL = Command.toDefaultLocalizedCommand({
+        id: 'notebook.change-selected-cell',
+        category: 'Notebook',
+    });
+}
+
+export enum CellChangeDirection {
+    Up = 'up',
+    Down = 'down'
 }
 
 @injectable()
-export class NotebookActionsContribution implements CommandContribution, MenuContribution {
+export class NotebookActionsContribution implements CommandContribution, MenuContribution, KeybindingContribution {
 
     @inject(NotebookService)
     protected notebookService: NotebookService;
@@ -76,10 +88,22 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
     @inject(ApplicationShell)
     protected shell: ApplicationShell;
 
+    @inject(NotebookEditorWidgetService)
+    protected notebookEditorWidgetService: NotebookEditorWidgetService;
+
     registerCommands(commands: CommandRegistry): void {
         commands.registerCommand(NotebookCommands.ADD_NEW_CELL_COMMAND, {
-            execute: (notebookModel: NotebookModel, cellKind: CellKind, index?: number) => {
-                const insertIndex = index ?? (notebookModel.selectedCell ? notebookModel.cells.indexOf(notebookModel.selectedCell) : 0);
+            execute: (notebookModel: NotebookModel, cellKind: CellKind = CellKind.Markup, index?: number | 'above' | 'below') => {
+                notebookModel = notebookModel ?? this.notebookEditorWidgetService.focusedEditor?.model;
+
+                let insertIndex: number = 0;
+                if (index && index >= 0) {
+                    insertIndex = index as number;
+                } else if (notebookModel.selectedCell && typeof index === 'string') {
+                    // if index is -1 insert below otherwise at the index of the selected cell which is above the selected.
+                    insertIndex = notebookModel.cells.indexOf(notebookModel.selectedCell) + (index === 'below' ? 1 : 0);
+                }
+
                 let firstCodeCell;
                 if (cellKind === CellKind.Code) {
                     firstCodeCell = notebookModel.cells.find(cell => cell.cellKind === CellKind.Code);
@@ -101,11 +125,11 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
         });
 
         commands.registerCommand(NotebookCommands.ADD_NEW_MARKDOWN_CELL_COMMAND, this.editableCommandHandler(
-            notebookModel => commands.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id, notebookModel, CellKind.Markup)
+            notebookModel => commands.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id, notebookModel, CellKind.Markup, 'below')
         ));
 
         commands.registerCommand(NotebookCommands.ADD_NEW_CODE_CELL_COMMAND, this.editableCommandHandler(
-            notebookModel => commands.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id, notebookModel, CellKind.Code)
+            notebookModel => commands.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id, notebookModel, CellKind.Code, 'below')
         ));
 
         commands.registerCommand(NotebookCommands.SELECT_KERNEL_COMMAND, this.editableCommandHandler(
@@ -120,6 +144,24 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
             notebookModel => notebookModel.cells.forEach(cell => cell.spliceNotebookCellOutputs({ start: 0, deleteCount: cell.outputs.length, newOutputs: [] }))
         ));
 
+        commands.registerCommand(NotebookCommands.CHANGE_SELECTED_CELL,
+            {
+                execute: (change: number | CellChangeDirection) => {
+                    const model = this.notebookEditorWidgetService.focusedEditor?.model;
+                    if (model && typeof change === 'number') {
+                        model.setSelectedCell(model.cells[change]);
+                    } else if (model && model.selectedCell) {
+                        const currentIndex = model.cells.indexOf(model.selectedCell);
+                        if (change === CellChangeDirection.Up && currentIndex > 0) {
+                            model.setSelectedCell(model.cells[currentIndex - 1]);
+                        } else if (change === CellChangeDirection.Down && currentIndex < model.cells.length - 1) {
+                            model.setSelectedCell(model.cells[currentIndex + 1]);
+                        }
+                    }
+                }
+            }
+        );
+
         commands.registerHandler(CommonCommands.UNDO.id, {
             isEnabled: () => {
                 const widget = this.shell.activeWidget;
@@ -134,6 +176,7 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
             },
             execute: () => (this.shell.activeWidget as NotebookEditorWidget).redo()
         });
+
     }
 
     protected editableCommandHandler(execute: (notebookModel: NotebookModel) => void): CommandHandler {
@@ -179,6 +222,23 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
         // other items
     }
 
+    registerKeybindings(keybindings: KeybindingRegistry): void {
+        keybindings.registerKeybindings(
+            {
+                command: NotebookCommands.CHANGE_SELECTED_CELL.id,
+                keybinding: 'up',
+                args: CellChangeDirection.Up,
+                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+            },
+            {
+                command: NotebookCommands.CHANGE_SELECTED_CELL.id,
+                keybinding: 'down',
+                args: CellChangeDirection.Down,
+                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+            },
+        );
+    }
+
 }
 
 export namespace NotebookMenus {

package/src/browser/contributions/notebook-cell-actions-contribution.ts

@@ -15,15 +15,22 @@
 // *****************************************************************************
 
 import { Command, CommandContribution, CommandHandler, CommandRegistry, CompoundMenuNodeRole, MenuContribution, MenuModelRegistry, nls } from '@theia/core';
-import { codicon } from '@theia/core/lib/browser';
+import { codicon, Key, KeybindingContribution, KeybindingRegistry, KeyCode, KeyModifier } from '@theia/core/lib/browser';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookCellModel } from '../view-model/notebook-cell-model';
-import { NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_TYPE, NotebookContextKeys, NOTEBOOK_CELL_EXECUTING } from './notebook-context-keys';
+import {
+    NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_TYPE,
+    NotebookContextKeys, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_EDITOR_FOCUSED,
+    NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_EDITABLE
+} from './notebook-context-keys';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { NotebookExecutionService } from '../service/notebook-execution-service';
 import { NotebookCellOutputModel } from '../view-model/notebook-cell-output-model';
-import { CellEditType } from '../../common';
+import { CellEditType, CellKind } from '../../common';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { NotebookCommands } from './notebook-actions-contribution';
+import { changeCellType } from './cell-operations';
 
 export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
@@ -52,6 +59,22 @@ export namespace NotebookCellCommands {
         iconClass: codicon('play'),
     });
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
+    export const EXECUTE_SINGLE_CELL_AND_FOCUS_NEXT_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.execute-cell-and-focus-next',
+    });
+
+    export const EXECUTE_ABOVE_CELLS_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebookActions.executeAbove',
+        label: 'Execute Above Cells',
+        iconClass: codicon('run-above')
+    });
+
+    export const EXECUTE_CELL_AND_BELOW_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebookActions.executeBelow',
+        label: 'Execute Cell and Below',
+        iconClass: codicon('run-below')
+    });
+    /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
     export const STOP_CELL_EXECUTION_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.stop-cell-execution',
         iconClass: codicon('stop'),
@@ -66,10 +89,39 @@ export namespace NotebookCellCommands {
         id: 'notebook.cell.change-presentation',
         label: 'Change Presentation',
     });
+
+    export const INSERT_NEW_CELL_ABOVE_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.insertCodeCellAboveAndFocusContainer',
+        label: 'Insert Code Cell Above and Focus Container'
+    });
+
+    export const INSERT_NEW_CELL_BELOW_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.insertCodeCellBelowAndFocusContainer',
+        label: 'Insert Code Cell Below and Focus Container'
+    });
+
+    export const INSERT_MARKDOWN_CELL_ABOVE_COMMAND = Command.toLocalizedCommand({
+        id: 'notebook.cell.insertMarkdownCellAbove',
+        label: 'Insert Markdown Cell Above'
+    });
+    export const INSERT_MARKDOWN_CELL_BELOW_COMMAND = Command.toLocalizedCommand({
+        id: 'notebook.cell.insertMarkdownCellBelow',
+        label: 'Insert Markdown Cell Below'
+    });
+
+    export const TO_CODE_CELL_COMMAND = Command.toLocalizedCommand({
+        id: 'notebook.cell.to-code-cell',
+        label: 'Change Cell to Code'
+    });
+
+    export const TO_MARKDOWN_CELL_COMMAND = Command.toLocalizedCommand({
+        id: 'notebook.cell.to-markdown-cell',
+        label: 'Change Cell to Mardown'
+    });
 }
 
 @injectable()
-export class NotebookCellActionContribution implements MenuContribution, CommandContribution {
+export class NotebookCellActionContribution implements MenuContribution, CommandContribution, KeybindingContribution {
 
     @inject(ContextKeyService)
     protected contextKeyService: ContextKeyService;
@@ -77,6 +129,9 @@ export class NotebookCellActionContribution implements MenuContribution, Command
     @inject(NotebookExecutionService)
     protected notebookExecutionService: NotebookExecutionService;
 
+    @inject(NotebookEditorWidgetService)
+    protected notebookEditorWidgetService: NotebookEditorWidgetService;
+
     @postConstruct()
     protected init(): void {
         NotebookContextKeys.initNotebookContextKeys(this.contextKeyService);
@@ -97,20 +152,30 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             label: nls.localizeByDefault('Stop Editing Cell'),
             order: '10'
         });
+
         menus.registerMenuAction(NotebookCellActionContribution.ACTION_MENU, {
-            commandId: NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.id,
-            icon: NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.iconClass,
+            commandId: NotebookCellCommands.EXECUTE_ABOVE_CELLS_COMMAND.id,
+            icon: NotebookCellCommands.EXECUTE_ABOVE_CELLS_COMMAND.iconClass,
             when: `${NOTEBOOK_CELL_TYPE} == 'code'`,
-            label: nls.localizeByDefault('Execute Cell'),
+            label: nls.localizeByDefault('Execute Above Cells'),
             order: '10'
         });
 
         menus.registerMenuAction(NotebookCellActionContribution.ACTION_MENU, {
-            commandId: NotebookCellCommands.SPLIT_CELL_COMMAND.id,
-            icon: NotebookCellCommands.SPLIT_CELL_COMMAND.iconClass,
-            label: nls.localizeByDefault('Split Cell'),
+            commandId: NotebookCellCommands.EXECUTE_CELL_AND_BELOW_COMMAND.id,
+            icon: NotebookCellCommands.EXECUTE_CELL_AND_BELOW_COMMAND.iconClass,
+            when: `${NOTEBOOK_CELL_TYPE} == 'code'`,
+            label: nls.localizeByDefault('Execute Cell and Below'),
             order: '20'
         });
+
+        // menus.registerMenuAction(NotebookCellActionContribution.ACTION_MENU, {
+        //     commandId: NotebookCellCommands.SPLIT_CELL_COMMAND.id,
+        //     icon: NotebookCellCommands.SPLIT_CELL_COMMAND.iconClass,
+        //     label: nls.localizeByDefault('Split Cell'),
+        //     order: '20'
+        // });
+
         menus.registerMenuAction(NotebookCellActionContribution.ACTION_MENU, {
             commandId: NotebookCellCommands.DELETE_COMMAND.id,
             icon: NotebookCellCommands.DELETE_COMMAND.iconClass,
@@ -150,7 +215,7 @@ export class NotebookCellActionContribution implements MenuContribution, Command
         menus.registerIndependentSubmenu(NotebookCellActionContribution.CONTRIBUTED_CELL_EXECUTION_MENU,
             nls.localizeByDefault('More...'),
             { role: CompoundMenuNodeRole.Flat, icon: codicon('chevron-down') });
-        menus.getMenu(NotebookCellActionContribution.CODE_CELL_SIDEBAR_MENU).addNode(menus.getMenuNode(NotebookCellActionContribution.CONTRIBUTED_CELL_EXECUTION_MENU));
+        // menus.getMenu(NotebookCellActionContribution.CODE_CELL_SIDEBAR_MENU).addNode(menus.getMenuNode(NotebookCellActionContribution.CONTRIBUTED_CELL_EXECUTION_MENU));
 
         // code cell output sidebar menu
         menus.registerSubmenu(
@@ -173,28 +238,83 @@ export class NotebookCellActionContribution implements MenuContribution, Command
 
     registerCommands(commands: CommandRegistry): void {
         commands.registerCommand(NotebookCellCommands.EDIT_COMMAND, this.editableCellCommandHandler((_, cell) => cell.requestEdit()));
-        commands.registerCommand(NotebookCellCommands.STOP_EDIT_COMMAND, { execute: (_, cell: NotebookCellModel) => cell.requestStopEdit() });
+        commands.registerCommand(NotebookCellCommands.STOP_EDIT_COMMAND, { execute: (_, cell: NotebookCellModel) => (cell ?? this.getSelectedCell()).requestStopEdit() });
         commands.registerCommand(NotebookCellCommands.DELETE_COMMAND,
-            this.editableCellCommandHandler((notebookModel, cell) => notebookModel.applyEdits([{
-                editType: CellEditType.Replace,
-                index: notebookModel.cells.indexOf(cell),
-                count: 1,
-                cells: []
-            }], true)));
+            this.editableCellCommandHandler((notebookModel, cell) => {
+                notebookModel.applyEdits([{
+                    editType: CellEditType.Replace,
+                    index: notebookModel.cells.indexOf(cell),
+                    count: 1,
+                    cells: []
+                }]
+                    , true);
+            }));
         commands.registerCommand(NotebookCellCommands.SPLIT_CELL_COMMAND);
 
         commands.registerCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND, this.editableCellCommandHandler(
-            (notebookModel, cell) => this.notebookExecutionService.executeNotebookCells(notebookModel, [cell])
-        ));
+            (notebookModel, cell) => {
+                this.notebookExecutionService.executeNotebookCells(notebookModel, [cell]);
+            })
+        );
+
+        commands.registerCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_FOCUS_NEXT_COMMAND, this.editableCellCommandHandler(
+            (notebookModel, cell) => {
+                commands.executeCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.id, notebookModel, cell);
+                const index = notebookModel.cells.indexOf(cell);
+                if (index < notebookModel.cells.length - 1) {
+                    notebookModel.setSelectedCell(notebookModel.cells[index + 1]);
+                } else {
+                    commands.executeCommand(NotebookCellCommands.INSERT_NEW_CELL_BELOW_COMMAND.id, notebookModel, CellKind.Code, 'below');
+                }
+            })
+        );
+
+        commands.registerCommand(NotebookCellCommands.EXECUTE_ABOVE_CELLS_COMMAND, this.editableCellCommandHandler(
+            (notebookModel, cell) => {
+                const index = notebookModel.cells.indexOf(cell);
+                if (index > 0) {
+                    this.notebookExecutionService.executeNotebookCells(notebookModel, notebookModel.cells.slice(0, index).filter(c => c.cellKind === CellKind.Code));
+                }
+            })
+        );
+
+        commands.registerCommand(NotebookCellCommands.EXECUTE_CELL_AND_BELOW_COMMAND, this.editableCellCommandHandler(
+            (notebookModel, cell) => {
+                const index = notebookModel.cells.indexOf(cell);
+                if (index < notebookModel.cells.length - 1) {
+                    this.notebookExecutionService.executeNotebookCells(notebookModel, notebookModel.cells.slice(index).filter(c => c.cellKind === CellKind.Code));
+                }
+            })
+        );
+
         commands.registerCommand(NotebookCellCommands.STOP_CELL_EXECUTION_COMMAND, {
-            execute: (notebookModel: NotebookModel, cell: NotebookCellModel) => this.notebookExecutionService.cancelNotebookCells(notebookModel, [cell])
+            execute: (notebookModel: NotebookModel, cell: NotebookCellModel) => {
+                notebookModel = notebookModel ?? this.notebookEditorWidgetService.focusedEditor?.model;
+                cell = cell ?? this.getSelectedCell();
+                this.notebookExecutionService.cancelNotebookCells(notebookModel, [cell]);
+            }
         });
         commands.registerCommand(NotebookCellCommands.CLEAR_OUTPUTS_COMMAND, this.editableCellCommandHandler(
-            (_, cell) => cell.spliceNotebookCellOutputs({ start: 0, deleteCount: cell.outputs.length, newOutputs: [] })
+            (_, cell) => cell.spliceNotebookCellOutputs({ start: 0, deleteCount: (cell ?? this.getSelectedCell()).outputs.length, newOutputs: [] })
         ));
         commands.registerCommand(NotebookCellCommands.CHANGE_OUTPUT_PRESENTATION_COMMAND, this.editableCellCommandHandler(
             (_, __, output) => output?.requestOutputPresentationUpdate()
         ));
+
+        const insertCommand = (type: CellKind, index: number | 'above' | 'below'): CommandHandler => this.editableCellCommandHandler(() =>
+            commands.executeCommand(NotebookCommands.ADD_NEW_CELL_COMMAND.id, undefined, type, index)
+        );
+        commands.registerCommand(NotebookCellCommands.INSERT_NEW_CELL_ABOVE_COMMAND, insertCommand(CellKind.Code, 'above'));
+        commands.registerCommand(NotebookCellCommands.INSERT_NEW_CELL_BELOW_COMMAND, insertCommand(CellKind.Code, 'below'));
+        commands.registerCommand(NotebookCellCommands.INSERT_MARKDOWN_CELL_ABOVE_COMMAND, insertCommand(CellKind.Markup, 'above'));
+        commands.registerCommand(NotebookCellCommands.INSERT_MARKDOWN_CELL_BELOW_COMMAND, insertCommand(CellKind.Markup, 'below'));
+
+        commands.registerCommand(NotebookCellCommands.TO_CODE_CELL_COMMAND, this.editableCellCommandHandler((notebookModel, cell) => {
+            changeCellType(notebookModel, cell, CellKind.Code);
+        }));
+        commands.registerCommand(NotebookCellCommands.TO_MARKDOWN_CELL_COMMAND, this.editableCellCommandHandler((notebookModel, cell) => {
+            changeCellType(notebookModel, cell, CellKind.Markup);
+        }));
     }
 
     protected editableCellCommandHandler(execute: (notebookModel: NotebookModel, cell: NotebookCellModel, output?: NotebookCellOutputModel) => void): CommandHandler {
@@ -202,10 +322,61 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             isEnabled: (notebookModel: NotebookModel) => !Boolean(notebookModel?.readOnly),
             isVisible: (notebookModel: NotebookModel) => !Boolean(notebookModel?.readOnly),
             execute: (notebookModel: NotebookModel, cell: NotebookCellModel, output?: NotebookCellOutputModel) => {
+                notebookModel = notebookModel ?? this.notebookEditorWidgetService.focusedEditor?.model;
+                cell = cell ?? this.getSelectedCell();
                 execute(notebookModel, cell, output);
             }
         };
     }
+
+    protected getSelectedCell(): NotebookCellModel | undefined {
+        return this.notebookEditorWidgetService.focusedEditor?.model?.selectedCell;
+    }
+
+    registerKeybindings(keybindings: KeybindingRegistry): void {
+        keybindings.registerKeybindings(
+            {
+                command: NotebookCellCommands.EDIT_COMMAND.id,
+                keybinding: 'Enter',
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_EDITABLE}`,
+            },
+            {
+                command: NotebookCellCommands.STOP_EDIT_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt] }).toString(),
+                when: `editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED}`,
+            },
+            {
+                command: NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.CtrlCmd] }).toString(),
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'code'`,
+            },
+            {
+                command: NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_FOCUS_NEXT_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Shift] }).toString(),
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'code'`,
+            },
+            {
+                command: NotebookCellCommands.CLEAR_OUTPUTS_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.KEY_O, modifiers: [KeyModifier.Alt] }).toString(),
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'code'`,
+            },
+            {
+                command: NotebookCellCommands.CHANGE_OUTPUT_PRESENTATION_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.KEY_P, modifiers: [KeyModifier.Alt] }).toString(),
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'code'`,
+            },
+            {
+                command: NotebookCellCommands.TO_CODE_CELL_COMMAND.id,
+                keybinding: 'Y',
+                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'markdown'`,
+            },
+            {
+                command: NotebookCellCommands.TO_MARKDOWN_CELL_COMMAND.id,
+                keybinding: 'M',
+                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'code'`,
+            }
+        );
+    }
 }
 
 export namespace NotebookCellActionContribution {
@@ -218,3 +389,4 @@ export namespace NotebookCellActionContribution {
     export const ADDITIONAL_OUTPUT_SIDEBAR_MENU = [...OUTPUT_SIDEBAR_MENU, 'more'];
 
 }
+

package/src/browser/notebook-editor-widget.tsx

@@ -30,7 +30,8 @@ import { NotebookEditorWidgetService } from './service/notebook-editor-widget-se
 import { NotebookMainToolbarRenderer } from './view/notebook-main-toolbar';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
-
+import { NotebookContextManager } from './service/notebook-context-manager';
+import { NotebookViewportService } from './view/notebook-viewport-service';
 const PerfectScrollbar = require('react-perfect-scrollbar');
 
 export const NotebookEditorWidgetContainerFactory = Symbol('NotebookEditorWidgetContainerFactory');
@@ -39,12 +40,19 @@ export function createNotebookEditorWidgetContainer(parent: interfaces.Container
     const child = parent.createChild();
 
     child.bind(NotebookEditorProps).toConstantValue(props);
+
+    child.bind(NotebookContextManager).toSelf().inSingletonScope();
+    child.bind(NotebookMainToolbarRenderer).toSelf().inSingletonScope();
+    child.bind(NotebookCodeCellRenderer).toSelf().inSingletonScope();
+    child.bind(NotebookMarkdownCellRenderer).toSelf().inSingletonScope();
+    child.bind(NotebookViewportService).toSelf().inSingletonScope();
+
     child.bind(NotebookEditorWidget).toSelf();
 
     return child;
 }
 
-const NotebookEditorProps = Symbol('NotebookEditorProps');
+export const NotebookEditorProps = Symbol('NotebookEditorProps');
 
 interface RenderMessage {
     rendererId: string;
@@ -79,6 +87,9 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     @inject(NotebookMainToolbarRenderer)
     protected notebookMainToolbarRenderer: NotebookMainToolbarRenderer;
 
+    @inject(NotebookContextManager)
+    protected notebookContextManager: NotebookContextManager;
+
     @inject(NotebookCodeCellRenderer)
     protected codeCellRenderer: NotebookCodeCellRenderer;
     @inject(NotebookMarkdownCellRenderer)
@@ -86,6 +97,9 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     @inject(NotebookEditorProps)
     protected readonly props: NotebookEditorProps;
 
+    @inject(NotebookViewportService)
+    protected readonly viewportService: NotebookViewportService;
+
     protected readonly onDidChangeModelEmitter = new Emitter<void>();
     readonly onDidChangeModel = this.onDidChangeModelEmitter.event;
 
@@ -159,6 +173,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         // Ensure that the model is loaded before adding the editor
         this.notebookEditorService.addNotebookEditor(this);
         this.update();
+        this.notebookContextManager.init(this);
         return this._model;
     }
 
@@ -172,7 +187,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     }
 
     createMoveToUri(resourceUri: URI): URI | undefined {
-        return this.props.uri;
+        return this.model?.uri.withPath(resourceUri.path);
     }
 
     undo(): void {
@@ -186,25 +201,24 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     protected render(): ReactNode {
         if (this._model) {
             return <div className='theia-notebook-main-container'>
-                {this.notebookMainToolbarRenderer.render(this._model)}
-                <PerfectScrollbar className='theia-notebook-scroll-container'>
-                    <NotebookCellListView renderers={this.renderers}
-                        notebookModel={this._model}
-                        toolbarRenderer={this.cellToolbarFactory}
-                        commandRegistry={this.commandRegistry} />
-                </PerfectScrollbar>
-            </div>;
+                {this.notebookMainToolbarRenderer.render(this._model, this.node)}
+                <div className='theia-notebook-viewport' ref={(ref: HTMLDivElement) => this.viewportService.viewportElement = ref}>
+                    <PerfectScrollbar className='theia-notebook-scroll-container'
+                        onScrollY={(e: HTMLDivElement) => this.viewportService.onScroll(e)}>
+                        <NotebookCellListView renderers={this.renderers}
+                            notebookModel={this._model}
+                            toolbarRenderer={this.cellToolbarFactory}
+                            commandRegistry={this.commandRegistry} />
+                    </PerfectScrollbar>
+                </div>
+            </div >;
         } else {
             return <div></div>;
         }
     }
 
-    protected override onAfterAttach(msg: Message): void {
-        super.onAfterAttach(msg);
-    }
-
-    protected override onAfterDetach(msg: Message): void {
-        super.onAfterDetach(msg);
+    protected override onCloseRequest(msg: Message): void {
+        super.onCloseRequest(msg);
         this.notebookEditorService.removeNotebookEditor(this);
     }
 
@@ -221,10 +235,22 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     }
 
     override dispose(): void {
+        this.notebookContextManager.dispose();
         this.onDidChangeModelEmitter.dispose();
         this.onDidPostKernelMessageEmitter.dispose();
         this.onDidReceiveKernelMessageEmitter.dispose();
         this.onPostRendererMessageEmitter.dispose();
+        this.viewportService.dispose();
         super.dispose();
     }
+
+    protected override onAfterShow(msg: Message): void {
+        super.onAfterShow(msg);
+        this.notebookEditorService.notebookEditorFocusChanged(this, true);
+    }
+
+    protected override onAfterHide(msg: Message): void {
+        super.onAfterHide(msg);
+        this.notebookEditorService.notebookEditorFocusChanged(this, false);
+    }
 }

package/src/browser/notebook-frontend-module.ts

@@ -16,7 +16,7 @@
 import '../../src/browser/style/index.css';
 
 import { ContainerModule } from '@theia/core/shared/inversify';
-import { OpenHandler, WidgetFactory } from '@theia/core/lib/browser';
+import { KeybindingContribution, OpenHandler, WidgetFactory } from '@theia/core/lib/browser';
 import { ColorContribution } from '@theia/core/lib/browser/color-application-contribution';
 import { NotebookOpenHandler } from './notebook-open-handler';
 import { CommandContribution, MenuContribution, ResourceResolver, } from '@theia/core';
@@ -31,8 +31,6 @@ import { NotebookCellToolbarFactory } from './view/notebook-cell-toolbar-factory
 import { createNotebookModelContainer, NotebookModel, NotebookModelFactory, NotebookModelProps } from './view-model/notebook-model';
 import { createNotebookCellModelContainer, NotebookCellModel, NotebookCellModelFactory, NotebookCellModelProps } from './view-model/notebook-cell-model';
 import { createNotebookEditorWidgetContainer, NotebookEditorWidgetContainerFactory, NotebookEditorProps, NotebookEditorWidget } from './notebook-editor-widget';
-import { NotebookCodeCellRenderer } from './view/notebook-code-cell-view';
-import { NotebookMarkdownCellRenderer } from './view/notebook-markdown-cell-view';
 import { NotebookActionsContribution } from './contributions/notebook-actions-contribution';
 import { NotebookExecutionService } from './service/notebook-execution-service';
 import { NotebookExecutionStateService } from './service/notebook-execution-state-service';
@@ -42,10 +40,9 @@ import { NotebookKernelHistoryService } from './service/notebook-kernel-history-
 import { NotebookEditorWidgetService } from './service/notebook-editor-widget-service';
 import { NotebookRendererMessagingService } from './service/notebook-renderer-messaging-service';
 import { NotebookColorContribution } from './contributions/notebook-color-contribution';
-import { NotebookCellContextManager } from './service/notebook-cell-context-manager';
-import { NotebookMainToolbarRenderer } from './view/notebook-main-toolbar';
+import { NotebookMonacoTextModelService } from './service/notebook-monaco-text-model-service';
 
-export default new ContainerModule(bind => {
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookColorContribution).toSelf().inSingletonScope();
     bind(ColorContribution).toService(NotebookColorContribution);
 
@@ -74,14 +71,12 @@ export default new ContainerModule(bind => {
     bind(NotebookCellActionContribution).toSelf().inSingletonScope();
     bind(MenuContribution).toService(NotebookCellActionContribution);
     bind(CommandContribution).toService(NotebookCellActionContribution);
+    bind(KeybindingContribution).toService(NotebookCellActionContribution);
 
     bind(NotebookActionsContribution).toSelf().inSingletonScope();
     bind(CommandContribution).toService(NotebookActionsContribution);
     bind(MenuContribution).toService(NotebookActionsContribution);
-
-    bind(NotebookCodeCellRenderer).toSelf().inSingletonScope();
-    bind(NotebookMarkdownCellRenderer).toSelf().inSingletonScope();
-    bind(NotebookMainToolbarRenderer).toSelf().inSingletonScope();
+    bind(KeybindingContribution).toService(NotebookActionsContribution);
 
     bind(NotebookEditorWidgetContainerFactory).toFactory(ctx => (props: NotebookEditorProps) =>
         createNotebookEditorWidgetContainer(ctx.container, props).get(NotebookEditorWidget)
@@ -90,6 +85,8 @@ export default new ContainerModule(bind => {
         createNotebookModelContainer(ctx.container, props).get(NotebookModel)
     );
     bind(NotebookCellModelFactory).toFactory(ctx => (props: NotebookCellModelProps) =>
-        createNotebookCellModelContainer(ctx.container, props, NotebookCellContextManager).get(NotebookCellModel)
+        createNotebookCellModelContainer(ctx.container, props).get(NotebookCellModel)
     );
+
+    bind(NotebookMonacoTextModelService).toSelf().inSingletonScope();
 });

package/src/browser/notebook-types.ts

@@ -17,6 +17,7 @@
 import {
     CellData, CellEditType, CellMetadataEdit, CellOutput, CellOutputItem, CellRange, NotebookCellContentChangeEvent,
     NotebookCellInternalMetadata,
+    NotebookCellMetadata,
     NotebookCellsChangeInternalMetadataEvent,
     NotebookCellsChangeLanguageEvent,
     NotebookCellsChangeMetadataEvent,
@@ -152,13 +153,24 @@ export interface CellReplaceEdit {
     cells: CellData[];
 }
 
+export interface CellPartialMetadataEdit {
+    editType: CellEditType.PartialMetadata;
+    index: number;
+    metadata: NullablePartialNotebookCellMetadata;
+}
+
 export type ImmediateCellEditOperation = CellOutputEditByHandle | CellOutputItemEdit | CellPartialInternalMetadataEditByHandle; // add more later on
 export type CellEditOperation = ImmediateCellEditOperation | CellReplaceEdit | CellOutputEdit |
-    CellMetadataEdit | CellLanguageEdit | DocumentMetadataEdit | CellMoveEdit; // add more later on
+    CellMetadataEdit | CellLanguageEdit | DocumentMetadataEdit | CellMoveEdit | CellPartialMetadataEdit; // add more later on
 
 export type NullablePartialNotebookCellInternalMetadata = {
     [Key in keyof Partial<NotebookCellInternalMetadata>]: NotebookCellInternalMetadata[Key] | null
 };
+
+export type NullablePartialNotebookCellMetadata = {
+    [Key in keyof Partial<NotebookCellMetadata>]: NotebookCellMetadata[Key] | null
+};
+
 export interface CellPartialInternalMetadataEditByHandle {
     editType: CellEditType.PartialInternalMetadata;
     handle: number;