@theia/notebook 1.51.0 → 1.53.0-next.18

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

@@ -16,17 +16,17 @@
 
 import { Command, CommandContribution, CommandHandler, CommandRegistry, CompoundMenuNodeRole, MenuContribution, MenuModelRegistry, nls, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ApplicationShell, codicon, CommonCommands, KeybindingContribution, KeybindingRegistry } from '@theia/core/lib/browser';
+import { ApplicationShell, codicon, 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_CURSOR_FIRST_LINE, NOTEBOOK_CELL_CURSOR_LAST_LINE, NOTEBOOK_CELL_FOCUSED, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_HAS_OUTPUTS } from './notebook-context-keys';
 import { NotebookClipboardService } from '../service/notebook-clipboard-service';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
 
 export namespace NotebookCommands {
     export const ADD_NEW_CELL_COMMAND = Command.toDefaultLocalizedCommand({
@@ -83,6 +83,16 @@ export namespace NotebookCommands {
         id: 'notebook.cell.paste',
         category: 'Notebook',
     });
+
+    export const NOTEBOOK_FIND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.find',
+        category: 'Notebook',
+    });
+
+    export const CENTER_ACTIVE_CELL = Command.toDefaultLocalizedCommand({
+        id: 'notebook.centerActiveCell',
+        category: 'Notebook',
+    });
 }
 
 export enum CellChangeDirection {
@@ -129,8 +139,7 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
 
                 let cellLanguage: string = 'markdown';
                 if (cellKind === CellKind.Code) {
-                    const firstCodeCell = notebookModel.cells.find(cell => cell.cellKind === CellKind.Code);
-                    cellLanguage = firstCodeCell?.language ?? 'plaintext';
+                    cellLanguage = this.notebookService.getCodeCellLanguage(notebookModel);
                 }
 
                 notebookModel.applyEdits([{
@@ -184,12 +193,14 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
 
                         if (change === CellChangeDirection.Up && currentIndex > 0) {
                             model.setSelectedCell(model.cells[currentIndex - 1]);
-                            if (model.selectedCell?.cellKind === CellKind.Code && shouldFocusEditor) {
+                            if ((model.selectedCell?.cellKind === CellKind.Code
+                                || (model.selectedCell?.cellKind === CellKind.Markup && model.selectedCell?.editing)) && shouldFocusEditor) {
                                 model.selectedCell.requestFocusEditor('lastLine');
                             }
                         } else if (change === CellChangeDirection.Down && currentIndex < model.cells.length - 1) {
                             model.setSelectedCell(model.cells[currentIndex + 1]);
-                            if (model.selectedCell?.cellKind === CellKind.Code && shouldFocusEditor) {
+                            if ((model.selectedCell?.cellKind === CellKind.Code
+                                || (model.selectedCell?.cellKind === CellKind.Markup && model.selectedCell?.editing)) && shouldFocusEditor) {
                                 model.selectedCell.requestFocusEditor();
                             }
                         }
@@ -202,20 +213,11 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
                 }
             }
         );
-
-        commands.registerHandler(CommonCommands.UNDO.id, {
-            isEnabled: () => {
-                const widget = this.shell.activeWidget;
-                return widget instanceof NotebookEditorWidget && !Boolean(widget.model?.readOnly);
-            },
-            execute: () => (this.shell.activeWidget as NotebookEditorWidget).undo()
+        commands.registerCommand({ id: 'list.focusUp' }, {
+            execute: () => commands.executeCommand(NotebookCommands.CHANGE_SELECTED_CELL.id, CellChangeDirection.Up)
         });
-        commands.registerHandler(CommonCommands.REDO.id, {
-            isEnabled: () => {
-                const widget = this.shell.activeWidget;
-                return widget instanceof NotebookEditorWidget && !Boolean(widget.model?.readOnly);
-            },
-            execute: () => (this.shell.activeWidget as NotebookEditorWidget).redo()
+        commands.registerCommand({ id: 'list.focusDown' }, {
+            execute: () => commands.executeCommand(NotebookCommands.CHANGE_SELECTED_CELL.id, CellChangeDirection.Down)
         });
 
         commands.registerCommand(NotebookCommands.CUT_SELECTED_CELL, this.editableCommandHandler(
@@ -251,6 +253,19 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
             }
         });
 
+        commands.registerCommand(NotebookCommands.NOTEBOOK_FIND, {
+            execute: () => {
+                this.notebookEditorWidgetService.focusedEditor?.showFindWidget();
+            }
+        });
+
+        commands.registerCommand(NotebookCommands.CENTER_ACTIVE_CELL, {
+            execute: (editor?: NotebookEditorWidget) => {
+                const model = editor ? editor.model : this.notebookEditorWidgetService.focusedEditor?.model;
+                model?.selectedCell?.requestCenterEditor();
+            }
+        });
+
     }
 
     protected editableCommandHandler(execute: (notebookModel: NotebookModel) => void): CommandHandler {
@@ -326,18 +341,28 @@ export class NotebookActionsContribution implements CommandContribution, MenuCon
             {
                 command: NotebookCommands.CUT_SELECTED_CELL.id,
                 keybinding: 'ctrlcmd+x',
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && !inputFocus`
             },
             {
                 command: NotebookCommands.COPY_SELECTED_CELL.id,
                 keybinding: 'ctrlcmd+c',
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && !inputFocus`
             },
             {
                 command: NotebookCommands.PASTE_CELL.id,
                 keybinding: 'ctrlcmd+v',
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED}`
+                when: `${NOTEBOOK_EDITOR_FOCUSED} && !inputFocus`
+            },
+            {
+                command: NotebookCommands.NOTEBOOK_FIND.id,
+                keybinding: 'ctrlcmd+f',
+                when: `${NOTEBOOK_EDITOR_FOCUSED}`
             },
+            {
+                command: NotebookCommands.CENTER_ACTIVE_CELL.id,
+                keybinding: 'ctrlcmd+l',
+                when: `${NOTEBOOK_EDITOR_FOCUSED}`
+            }
         );
     }
 

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

@@ -22,7 +22,8 @@ import { NotebookCellModel } from '../view-model/notebook-cell-model';
 import {
     NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_TYPE,
     NotebookContextKeys, NOTEBOOK_CELL_EXECUTING, NOTEBOOK_EDITOR_FOCUSED,
-    NOTEBOOK_CELL_FOCUSED
+    NOTEBOOK_CELL_FOCUSED,
+    NOTEBOOK_CELL_LIST_FOCUSED
 } from './notebook-context-keys';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { NotebookExecutionService } from '../service/notebook-execution-service';
@@ -32,16 +33,19 @@ import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-s
 import { NotebookCommands } from './notebook-actions-contribution';
 import { changeCellType } from './cell-operations';
 import { EditorLanguageQuickPickService } from '@theia/editor/lib/browser/editor-language-quick-pick-service';
+import { NotebookService } from '../service/notebook-service';
 
 export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const EDIT_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.edit',
+        category: 'Notebook',
         iconClass: codicon('edit')
     });
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const STOP_EDIT_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.stop-edit',
+        category: 'Notebook',
         iconClass: codicon('check')
     });
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
@@ -57,11 +61,21 @@ export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
     export const EXECUTE_SINGLE_CELL_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.execute-cell',
+        category: 'Notebook',
+        label: nls.localizeByDefault('Execute Cell'),
         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',
+        label: nls.localizeByDefault('Execute Notebook Cell and Select Below'),
+        category: 'Notebook',
+    });
+    /** Parameters: notebookModel: NotebookModel, cell: NotebookCellModel */
+    export const EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND = Command.toDefaultLocalizedCommand({
+        id: 'notebook.cell.execute-cell-and-insert-below',
+        label: nls.localizeByDefault('Execute Notebook Cell and Insert Below'),
+        category: 'Notebook',
     });
 
     export const EXECUTE_ABOVE_CELLS_COMMAND = Command.toDefaultLocalizedCommand({
@@ -83,11 +97,13 @@ export namespace NotebookCellCommands {
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel */
     export const CLEAR_OUTPUTS_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.clear-outputs',
+        category: 'Notebook',
         label: 'Clear Cell Outputs',
     });
     /** Parameters: notebookModel: NotebookModel | undefined, cell: NotebookCellModel | undefined, output: NotebookCellOutputModel */
     export const CHANGE_OUTPUT_PRESENTATION_COMMAND = Command.toDefaultLocalizedCommand({
         id: 'notebook.cell.change-presentation',
+        category: 'Notebook',
         label: 'Change Presentation',
     });
 
@@ -112,12 +128,14 @@ export namespace NotebookCellCommands {
 
     export const TO_CODE_CELL_COMMAND = Command.toLocalizedCommand({
         id: 'notebook.cell.changeToCode',
+        category: 'Notebook',
         label: 'Change Cell to Code'
     });
 
     export const TO_MARKDOWN_CELL_COMMAND = Command.toLocalizedCommand({
         id: 'notebook.cell.changeToMarkdown',
-        label: 'Change Cell to Mardown'
+        category: 'Notebook',
+        label: 'Change Cell to Markdown'
     });
 
     export const TOGGLE_CELL_OUTPUT = Command.toDefaultLocalizedCommand({
@@ -146,6 +164,9 @@ export class NotebookCellActionContribution implements MenuContribution, Command
     @inject(ContextKeyService)
     protected contextKeyService: ContextKeyService;
 
+    @inject(NotebookService)
+    protected notebookService: NotebookService;
+
     @inject(NotebookExecutionService)
     protected notebookExecutionService: NotebookExecutionService;
 
@@ -297,6 +318,23 @@ export class NotebookCellActionContribution implements MenuContribution, Command
                 }
             })
         );
+        commands.registerCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND, this.editableCellCommandHandler(
+            async (notebookModel, cell) => {
+                if (cell.cellKind === CellKind.Code) {
+                    await commands.executeCommand(NotebookCellCommands.EXECUTE_SINGLE_CELL_COMMAND.id, notebookModel, cell);
+                }
+                await commands.executeCommand(NotebookCellCommands.STOP_EDIT_COMMAND.id, notebookModel, cell);
+
+                if (cell.cellKind === CellKind.Code) {
+                    await commands.executeCommand(NotebookCellCommands.INSERT_NEW_CELL_BELOW_COMMAND.id);
+                } else {
+                    await commands.executeCommand(NotebookCellCommands.INSERT_MARKDOWN_CELL_BELOW_COMMAND.id);
+                }
+
+                const index = notebookModel.cells.indexOf(cell);
+                notebookModel.setSelectedCell(notebookModel.cells[index + 1]);
+            })
+        );
 
         commands.registerCommand(NotebookCellCommands.EXECUTE_ABOVE_CELLS_COMMAND, this.editableCellCommandHandler(
             (notebookModel, cell) => {
@@ -345,7 +383,7 @@ export class NotebookCellActionContribution implements MenuContribution, Command
         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);
+            changeCellType(notebookModel, cell, CellKind.Code, this.notebookService.getCodeCellLanguage(notebookModel));
         }));
         commands.registerCommand(NotebookCellCommands.TO_MARKDOWN_CELL_COMMAND, this.editableCellCommandHandler((notebookModel, cell) => {
             changeCellType(notebookModel, cell, CellKind.Markup);
@@ -365,9 +403,21 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             execute: async (notebook?: NotebookModel, cell?: NotebookCellModel) => {
                 const selectedCell = cell ?? this.notebookEditorWidgetService.focusedEditor?.model?.selectedCell;
                 const activeNotebook = notebook ?? this.notebookEditorWidgetService.focusedEditor?.model;
-                if (selectedCell && activeNotebook) {
-                    const language = await this.languageQuickPickService.pickEditorLanguage(selectedCell.language);
-                    if (language?.value && language.value !== 'autoDetect') {
+                if (!selectedCell || !activeNotebook) {
+                    return;
+                }
+                const language = await this.languageQuickPickService.pickEditorLanguage(selectedCell.language);
+                if (!language?.value || language.value === 'autoDetect' || language.value.id === selectedCell.language) {
+                    return;
+                }
+                const isMarkdownCell = selectedCell.cellKind === CellKind.Markup;
+                const isMarkdownLanguage = language.value.id === 'markdown';
+                if (isMarkdownLanguage) {
+                    changeCellType(activeNotebook, selectedCell, CellKind.Markup, language.value.id);
+                } else {
+                    if (isMarkdownCell) {
+                        changeCellType(activeNotebook, selectedCell, CellKind.Code, language.value.id);
+                    } else {
                         this.notebookEditorWidgetService.focusedEditor?.model?.applyEdits([{
                             editType: CellEditType.CellLanguage,
                             index: activeNotebook.cells.indexOf(selectedCell),
@@ -411,12 +461,12 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             {
                 command: NotebookCellCommands.EDIT_COMMAND.id,
                 keybinding: 'Enter',
-                when: `!editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
+                when: `!editorTextFocus && !inputFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
             },
             {
                 command: NotebookCellCommands.STOP_EDIT_COMMAND.id,
-                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt] }).toString(),
-                when: `editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED}`,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt, KeyModifier.CtrlCmd] }).toString(),
+                when: `editorTextFocus && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_TYPE} == 'markdown'`,
             },
             {
                 command: NotebookCellCommands.STOP_EDIT_COMMAND.id,
@@ -426,12 +476,17 @@ export class NotebookCellActionContribution implements MenuContribution, Command
             {
                 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'`,
+                when: `${NOTEBOOK_CELL_LIST_FOCUSED} && ${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}`,
+                when: `${NOTEBOOK_CELL_LIST_FOCUSED} && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
+            },
+            {
+                command: NotebookCellCommands.EXECUTE_SINGLE_CELL_AND_INSERT_BELOW_COMMAND.id,
+                keybinding: KeyCode.createKeyCode({ first: Key.ENTER, modifiers: [KeyModifier.Alt] }).toString(),
+                when: `${NOTEBOOK_CELL_LIST_FOCUSED} && ${NOTEBOOK_EDITOR_FOCUSED} && ${NOTEBOOK_CELL_FOCUSED}`,
             },
             {
                 command: NotebookCellCommands.CLEAR_OUTPUTS_COMMAND.id,

package/src/browser/contributions/notebook-preferences.ts

@@ -19,7 +19,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { nls } from '@theia/core';
-import { PreferenceSchema } from '@theia/core/lib/browser';
+import { interfaces } from '@theia/core/shared/inversify';
+import { PreferenceContribution, PreferenceSchema } from '@theia/core/lib/browser';
 
 export namespace NotebookPreferences {
     export const NOTEBOOK_LINE_NUMBERS = 'notebook.lineNumbers';
@@ -81,3 +82,11 @@ export const notebookPreferenceSchema: PreferenceSchema = {
 
     }
 };
+
+export const NotebookPreferenceContribution = Symbol('NotebookPreferenceContribution');
+
+export function bindNotebookPreferences(bind: interfaces.Bind): void {
+    // We don't need a NotebookPreferenceConfiguration class, so there's no preference proxy to bind
+    bind(NotebookPreferenceContribution).toConstantValue({ schema: notebookPreferenceSchema });
+    bind(PreferenceContribution).toService(NotebookPreferenceContribution);
+}

package/src/browser/contributions/notebook-status-bar-contribution.ts

@@ -0,0 +1,77 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FrontendApplicationContribution, StatusBar, StatusBarAlignment } from '@theia/core/lib/browser';
+import { Disposable } from '@theia/core/lib/common';
+import { NotebookEditorWidgetService } from '../service/notebook-editor-widget-service';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
+import { nls } from '@theia/core';
+import { NotebookCommands } from './notebook-actions-contribution';
+
+export const NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID = 'notebook-cell-selection-position';
+
+@injectable()
+export class NotebookStatusBarContribution implements FrontendApplicationContribution {
+
+    @inject(StatusBar) protected readonly statusBar: StatusBar;
+    @inject(NotebookEditorWidgetService) protected readonly editorWidgetService: NotebookEditorWidgetService;
+
+    protected currentCellSelectionListener: Disposable | undefined;
+    protected lastFocusedEditor: NotebookEditorWidget | undefined;
+
+    onStart(): void {
+        this.editorWidgetService.onDidChangeFocusedEditor(editor => {
+            this.currentCellSelectionListener?.dispose();
+            this.currentCellSelectionListener = editor?.model?.onDidChangeSelectedCell(() =>
+                this.updateStatusbar(editor)
+            );
+            editor?.onDidDispose(() => {
+                this.lastFocusedEditor = undefined;
+                this.updateStatusbar();
+            });
+            this.updateStatusbar(editor);
+            this.lastFocusedEditor = editor;
+        });
+        if (this.editorWidgetService.focusedEditor) {
+            this.updateStatusbar();
+        }
+    }
+
+    protected async updateStatusbar(editor?: NotebookEditorWidget): Promise<void> {
+        if ((!editor && !this.lastFocusedEditor?.isVisible) || editor?.model?.cells.length === 0) {
+            this.statusBar.removeElement(NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID);
+            return;
+        }
+
+        await editor?.ready;
+        if (!editor?.model) {
+            return;
+        }
+
+        const selectedCellIndex = editor.model.selectedCell ? editor.model.cells.indexOf(editor.model.selectedCell) + 1 : '';
+
+        this.statusBar.setElement(NOTEBOOK_CELL_SELECTION_STATUS_BAR_ID, {
+            text: nls.localizeByDefault('Cell {0} of {1}', selectedCellIndex, editor.model.cells.length),
+            alignment: StatusBarAlignment.RIGHT,
+            priority: 100,
+            command: NotebookCommands.CENTER_ACTIVE_CELL.id,
+            arguments: [editor]
+        });
+
+    }
+
+}

package/src/browser/contributions/notebook-undo-redo-handler.ts

@@ -0,0 +1,41 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { ApplicationShell, UndoRedoHandler } from '@theia/core/lib/browser';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
+
+@injectable()
+export class NotebookUndoRedoHandler implements UndoRedoHandler<NotebookEditorWidget> {
+
+    @inject(ApplicationShell)
+    protected readonly applicationShell: ApplicationShell;
+
+    priority = 200;
+    select(): NotebookEditorWidget | undefined {
+        const current = this.applicationShell.currentWidget;
+        if (current instanceof NotebookEditorWidget) {
+            return current;
+        }
+        return undefined;
+    }
+    undo(item: NotebookEditorWidget): void {
+        item.undo();
+    }
+    redo(item: NotebookEditorWidget): void {
+        item.redo();
+    }
+}

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

@@ -33,6 +33,8 @@ import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import { NotebookContextManager } from './service/notebook-context-manager';
 import { NotebookViewportService } from './view/notebook-viewport-service';
 import { NotebookCellCommands } from './contributions/notebook-cell-actions-contribution';
+import { NotebookFindWidget } from './view/notebook-find-widget';
+import debounce = require('lodash/debounce');
 const PerfectScrollbar = require('react-perfect-scrollbar');
 
 export const NotebookEditorWidgetContainerFactory = Symbol('NotebookEditorWidgetContainerFactory');
@@ -126,7 +128,16 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     protected readonly renderers = new Map<CellKind, CellRenderer>();
     protected _model?: NotebookModel;
     protected _ready: Deferred<NotebookModel> = new Deferred();
+    protected _findWidgetVisible = false;
+    protected _findWidgetRef = React.createRef<NotebookFindWidget>();
     protected scrollBarRef = React.createRef<{ updateScroll(): void }>();
+    protected debounceFind = debounce(() => {
+        this._findWidgetRef.current?.search({});
+    }, 30, {
+        trailing: true,
+        maxWait: 100,
+        leading: false
+    });
 
     get notebookType(): string {
         return this.props.notebookType;
@@ -143,7 +154,6 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     @postConstruct()
     protected init(): void {
         this.id = NOTEBOOK_EDITOR_ID_PREFIX + this.props.uri.toString();
-        this.node.tabIndex = -1;
 
         this.scrollOptions = {
             suppressScrollY: true
@@ -163,8 +173,6 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
                 this.commandRegistry.executeCommand(NotebookCellCommands.EDIT_COMMAND.id, model, model.cells[0]);
                 model.setSelectedCell(model.cells[0]);
             }
-            model.cells.forEach(cell => cell.onWillBlurCellEditor(() => this.node.focus()));
-            model.onDidAddOrRemoveCell(e => e.newCellIds?.forEach(cellId => model.cells.find(cell => cell.handle === cellId)?.onWillBlurCellEditor(() => this.node.focus())));
         });
     }
 
@@ -177,6 +185,11 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
             // Wait one frame to ensure that the content has been rendered
             animationFrame().then(() => this.scrollBarRef.current?.updateScroll());
         }));
+        this.toDispose.push(this._model.onContentChanged(() => {
+            if (this._findWidgetVisible) {
+                this.debounceFind();
+            }
+        }));
         this.toDispose.push(this._model.onDidChangeReadOnly(readOnly => {
             if (readOnly) {
                 lock(this.title);
@@ -191,6 +204,7 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         }
         // Ensure that the model is loaded before adding the editor
         this.notebookEditorService.addNotebookEditor(this);
+        this._model.selectedCell = this._model.cells[0];
         this.update();
         this.notebookContextManager.init(this);
         return this._model;
@@ -220,18 +234,41 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
     protected render(): ReactNode {
         if (this._model) {
             return <div className='theia-notebook-main-container'>
+                <div className='theia-notebook-overlay'>
+                    <NotebookFindWidget
+                        ref={this._findWidgetRef}
+                        hidden={!this._findWidgetVisible}
+                        onClose={() => {
+                            this._findWidgetVisible = false;
+                            this._model?.findMatches({
+                                activeFilters: [],
+                                matchCase: false,
+                                regex: false,
+                                search: '',
+                                wholeWord: false
+                            });
+                            this.update();
+                        }}
+                        onSearch={options => this._model?.findMatches(options) ?? []}
+                        onReplace={(matches, replaceText) => this._model?.replaceAll(matches, replaceText)}
+                    />
+                </div>
                 {this.notebookMainToolbarRenderer.render(this._model, this.node)}
-                <div className='theia-notebook-viewport' ref={(ref: HTMLDivElement) => this.viewportService.viewportElement = ref}>
+                <div
+                    className='theia-notebook-viewport'
+                    ref={(ref: HTMLDivElement) => this.viewportService.viewportElement = ref}
+                >
                     <PerfectScrollbar className='theia-notebook-scroll-container'
                         ref={this.scrollBarRef}
                         onScrollY={(e: HTMLDivElement) => this.viewportService.onScroll(e)}>
                         <NotebookCellListView renderers={this.renderers}
                             notebookModel={this._model}
+                            notebookContext={this.notebookContextManager}
                             toolbarRenderer={this.cellToolbarFactory}
                             commandRegistry={this.commandRegistry} />
                     </PerfectScrollbar>
                 </div>
-            </div >;
+            </div>;
         } else {
             return <div className='theia-notebook-main-container'>
                 <div className='theia-notebook-main-loading-indicator'></div>
@@ -260,6 +297,14 @@ export class NotebookEditorWidget extends ReactWidget implements Navigatable, Sa
         this.onDidChangeOutputInputFocusEmitter.fire(focused);
     }
 
+    showFindWidget(): void {
+        if (!this._findWidgetVisible) {
+            this._findWidgetVisible = true;
+            this.update();
+        }
+        this._findWidgetRef.current?.focusSearch(this._model?.selectedText);
+    }
+
     override dispose(): void {
         this.notebookContextManager.dispose();
         this.onDidChangeModelEmitter.dispose();

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 { FrontendApplicationContribution, KeybindingContribution, LabelProviderContribution, OpenHandler, PreferenceContribution, WidgetFactory } from '@theia/core/lib/browser';
+import { FrontendApplicationContribution, KeybindingContribution, LabelProviderContribution, OpenHandler, UndoRedoHandler, 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';
@@ -44,8 +44,10 @@ import { NotebookOutlineContribution } from './contributions/notebook-outline-co
 import { NotebookLabelProviderContribution } from './contributions/notebook-label-provider-contribution';
 import { NotebookOutputActionContribution } from './contributions/notebook-output-action-contribution';
 import { NotebookClipboardService } from './service/notebook-clipboard-service';
-import { notebookPreferenceSchema } from './contributions/notebook-preferences';
+import { bindNotebookPreferences } from './contributions/notebook-preferences';
 import { NotebookOptionsService } from './service/notebook-options';
+import { NotebookUndoRedoHandler } from './contributions/notebook-undo-redo-handler';
+import { NotebookStatusBarContribution } from './contributions/notebook-status-bar-contribution';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookColorContribution).toSelf().inSingletonScope();
@@ -106,6 +108,12 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(NotebookLabelProviderContribution).toSelf().inSingletonScope();
     bind(LabelProviderContribution).toService(NotebookLabelProviderContribution);
 
-    bind(PreferenceContribution).toConstantValue({ schema: notebookPreferenceSchema });
+    bindNotebookPreferences(bind);
     bind(NotebookOptionsService).toSelf().inSingletonScope();
+
+    bind(NotebookUndoRedoHandler).toSelf().inSingletonScope();
+    bind(UndoRedoHandler).toService(NotebookUndoRedoHandler);
+
+    bind(NotebookStatusBarContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(NotebookStatusBarContribution);
 });

package/src/browser/service/notebook-context-manager.ts

@@ -21,7 +21,7 @@ import { NotebookKernelService } from './notebook-kernel-service';
 import {
     NOTEBOOK_CELL_EDITABLE,
     NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE,
-    NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE,
+    NOTEBOOK_CELL_FOCUSED, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE,
     NOTEBOOK_CELL_TYPE, NOTEBOOK_HAS_OUTPUTS, NOTEBOOK_KERNEL, NOTEBOOK_KERNEL_SELECTED,
     NOTEBOOK_OUTPUT_INPUT_FOCUSED,
     NOTEBOOK_VIEW_TYPE
@@ -85,7 +85,7 @@ export class NotebookContextManager {
 
         this.scopedStore.setContext(NOTEBOOK_HAS_OUTPUTS, !!widget.model?.cells.find(cell => cell.outputs.length > 0));
 
-        // Cell Selection realted keys
+        // Cell Selection related keys
         this.scopedStore.setContext(NOTEBOOK_CELL_FOCUSED, !!widget.model?.selectedCell);
         widget.model?.onDidChangeSelectedCell(e => {
             this.selectedCellChanged(e.cell);
@@ -144,8 +144,12 @@ export class NotebookContextManager {
         return this.contextKeyService.createOverlay(Object.entries(this.cellContexts.get(cellHandle) ?? {}));
     }
 
-    onDidEditorTextFocus(focus: boolean): void {
-        this.scopedStore.setContext('inputFocus', focus);
+    changeCellFocus(focus: boolean): void {
+        this.scopedStore.setContext(NOTEBOOK_CELL_FOCUSED, focus);
+    }
+
+    changeCellListFocus(focus: boolean): void {
+        this.scopedStore.setContext(NOTEBOOK_CELL_LIST_FOCUSED, focus);
     }
 
     createContextKeyChangedEvent(affectedKeys: string[]): ContextKeyChangeEvent {