@theia/core 1.27.0-next.9 → 1.27.0

package/src/browser/preferences/preference-proxy.spec.ts

@@ -31,7 +31,6 @@ import { PreferenceScope } from './preference-scope';
 import { PreferenceProvider } from './preference-provider';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { PreferenceProxyOptions, PreferenceProxy, PreferenceChangeEvent, createPreferenceProxy } from './preference-proxy';
-import { ApplicationProps } from '@theia/application-package/lib/application-props';
 import { PreferenceProxyFactory } from './injectable-preference-proxy';
 import { waitForEvent } from '../../common/promise-util';
 
@@ -43,8 +42,6 @@ process.on('unhandledRejection', (reason, promise) => {
 });
 
 import { expect } from 'chai';
-import { PreferenceValidationService } from './preference-validation-service';
-import { JSONValue } from '@phosphor/coreutils';
 let testContainer: Container;
 
 function createTestContainer(): Container {
@@ -57,14 +54,10 @@ function createTestContainer(): Container {
 describe('Preference Proxy', () => {
     let prefService: PreferenceServiceImpl;
     let prefSchema: PreferenceSchemaProvider;
-    let validator: PreferenceValidationService;
 
     before(() => {
         disableJSDOM = enableJSDOM();
-        FrontendApplicationConfigProvider.set({
-            ...ApplicationProps.DEFAULT.frontend.config,
-            'applicationName': 'test'
-        });
+        FrontendApplicationConfigProvider.set({});
     });
 
     after(() => {
@@ -75,7 +68,6 @@ describe('Preference Proxy', () => {
         testContainer = createTestContainer();
         prefSchema = testContainer.get(PreferenceSchemaProvider);
         prefService = testContainer.get<PreferenceService>(PreferenceService) as PreferenceServiceImpl;
-        validator = testContainer.get(PreferenceValidationService);
         getProvider(PreferenceScope.User).markReady();
         getProvider(PreferenceScope.Workspace).markReady();
         getProvider(PreferenceScope.Folder).markReady();
@@ -121,13 +113,13 @@ describe('Preference Proxy', () => {
                         prefSchema.setSchema(s);
                         resolve(s);
                     }, 1000));
-                    const proxy = (testOptions.useFactory || options?.validated)
+                    const proxy = testOptions.useFactory
                         ? testContainer.get<PreferenceProxyFactory>(PreferenceProxyFactory)(promisedSchema, options)
                         : createPreferenceProxy(prefService, promisedSchema, options);
                     return { proxy, promisedSchema };
                 } else {
                     prefSchema.setSchema(s);
-                    const proxy = (testOptions.useFactory || options?.validated)
+                    const proxy = testOptions.useFactory
                         ? testContainer.get<PreferenceProxyFactory>(PreferenceProxyFactory)(s, options)
                         : createPreferenceProxy(prefService, s, options);
                     return { proxy };
@@ -275,108 +267,6 @@ describe('Preference Proxy', () => {
                 expect(changesAffectingTypescript, 'One event should have been fired that does affect typescript.').to.equal(1);
             });
 
-            if (testOptions.useFactory) {
-                async function prepareValidationTest(): Promise<{ proxy: PreferenceProxy<{ [key: string]: unknown }>, validationCallCounter: { calls: number } }> {
-                    const validationCallCounter = { calls: 0 };
-                    const originalValidateByName = validator.validateByName.bind(validator);
-                    function newValidateByName(...args: unknown[]): JSONValue {
-                        validationCallCounter.calls++;
-                        return originalValidateByName(...args);
-                    };
-                    validator.validateByName = newValidateByName;
-                    const { proxy, promisedSchema } = getProxy({
-                        properties: {
-                            'my.pref': {
-                                type: 'string',
-                                defaultValue: 'foo',
-                                overridable: true,
-                            }
-                        }
-                    }, { style: 'both', validated: true });
-                    await promisedSchema;
-                    return { proxy, validationCallCounter };
-                }
-
-                it('Validated proxies always return good values.', async () => {
-                    const { proxy, validationCallCounter } = await prepareValidationTest();
-                    let event: PreferenceChangeEvent<{ [key: string]: unknown }> | undefined = undefined;
-                    proxy.onPreferenceChanged(change => event = change);
-                    expect(proxy['my.pref']).to.equal('foo', 'Should start with default value.');
-                    expect(validationCallCounter.calls).to.equal(1, 'Should have validated preference retrieval.');
-                    expect(proxy.get('my.pref')).to.equal('foo', 'Should have default value for `get`.');
-                    expect(validationCallCounter.calls).to.equal(1, 'Should have cached first validation.');
-                    const newValue = 'Also a string';
-                    await prefService.set('my.pref', newValue, PreferenceScope.User);
-                    expect(event !== undefined);
-                    expect(event!.newValue).to.equal(newValue, 'Should accept good value');
-                    expect(validationCallCounter.calls).to.equal(2, 'Should have validated event value');
-                    expect(proxy['my.pref']).to.equal(newValue, 'Should return default value on access.');
-                    expect(proxy.get('my.pref')).to.equal(newValue);
-                    expect(validationCallCounter.calls).to.equal(2, 'Should have used cached value for retrievals');
-                    await prefService.set('my.pref', { complete: 'garbage' }, PreferenceScope.User);
-                    expect(event !== undefined);
-                    expect(event!.newValue).to.equal('foo', 'Should have fallen back to default.');
-                    expect(validationCallCounter.calls).to.equal(3, 'Should have validated event');
-                    expect(proxy['my.pref']).to.equal('foo', 'Should return default value on access.');
-                    expect(proxy.get('my.pref')).to.equal('foo');
-                    expect(validationCallCounter.calls).to.equal(3, 'Should have used cached value for retrievals');
-                });
-
-                it('Validated proxies only validate one value if multiple language-override events are emitted for the same change', async () => {
-                    const { proxy, validationCallCounter } = await prepareValidationTest();
-                    prefSchema.registerOverrideIdentifier('swift');
-                    prefSchema.registerOverrideIdentifier('typescript');
-                    const events: Array<PreferenceChangeEvent<{ [key: string]: unknown }>> = [];
-                    proxy.onPreferenceChanged(event => events.push(event));
-                    await prefService.set('my.pref', { complete: 'garbage' }, PreferenceScope.User);
-                    expect(validationCallCounter.calls, 'Validation should have been performed once.').to.equal(1);
-                    expect(events).to.have.length(3, 'One event for base, one for each override');
-                    expect(events.every(event => event.newValue === 'foo'), 'Should have returned the default in case of garbage.');
-                });
-
-                it("Validated proxies don't retain old values for overrides after a change (no emitter).", async () => {
-                    const { proxy, validationCallCounter } = await prepareValidationTest();
-                    prefSchema.registerOverrideIdentifier('swift');
-                    const initialValue = proxy.get({ preferenceName: 'my.pref', overrideIdentifier: 'swift' });
-                    expect(initialValue).to.equal('foo', 'Proxy should start with default value.');
-                    expect(validationCallCounter.calls).to.equal(1, 'Retrieval should validate (1).');
-                    await prefService.set('my.pref', 'bar', PreferenceScope.User);
-                    expect(proxy.get('my.pref')).to.equal('bar', 'The base should have been updated.');
-                    expect(validationCallCounter.calls).to.equal(2, 'Retrieval should validate (2).');
-                    expect(proxy.get({ preferenceName: 'my.pref', overrideIdentifier: 'swift' })).to.equal('bar', 'Proxy should update empty overrides on change.');
-                    expect(validationCallCounter.calls).to.equal(3, 'Retrieval should validate (3).');
-                });
-
-                // The scenario with a listener differs because the proxy will start caching known valid values when a listener is attached.
-                it("Validated proxies don't retain old values for overrides after a change (with emitter)", async () => {
-                    const { proxy, validationCallCounter } = await prepareValidationTest();
-                    prefSchema.registerOverrideIdentifier('swift');
-                    const override = { preferenceName: 'my.pref', overrideIdentifier: 'swift' };
-                    proxy.onPreferenceChanged; // Initialize the listeners.
-                    const initialValue = proxy.get(override);
-                    expect(initialValue).to.equal('foo', 'Proxy should start with default value.');
-                    expect(validationCallCounter.calls).to.equal(1, 'Retrieval should validate.');
-
-                    await prefService.set('my.pref', 'bar', PreferenceScope.User);
-                    expect(validationCallCounter.calls).to.equal(2, 'Event should trigger validation (1).');
-                    expect(proxy.get('my.pref')).to.equal('bar', 'The base should have been updated.');
-                    expect(proxy.get(override)).to.equal('bar', 'Proxy should update empty overrides on change.');
-                    expect(validationCallCounter.calls).to.equal(2, 'Subsequent retrievals should not trigger validation. (1)');
-
-                    await prefService.set(prefService.overridePreferenceName(override), 'baz', PreferenceScope.User);
-                    expect(validationCallCounter.calls).to.equal(3, 'Event should trigger validation (2).');
-                    expect(proxy.get('my.pref')).to.equal('bar', 'Base should not have been updated.');
-                    expect(proxy.get(override)).to.equal('baz', 'Override should have been updated');
-                    expect(validationCallCounter.calls).to.equal(3, 'Subsequent retrievals should not trigger validation. (2)');
-
-                    await prefService.set('my.pref', 'boom', PreferenceScope.User);
-                    expect(validationCallCounter.calls).to.equal(4, 'Event should trigger validation (3).');
-                    expect(proxy.get('my.pref')).to.equal('boom', 'Base should have been updated.');
-                    expect(proxy.get(override)).to.equal('baz', 'Override should not have been updated');
-                    expect(validationCallCounter.calls).to.equal(4, 'Subsequent retrievals should not trigger validation. (3)');
-                });
-            }
-
             it('toJSON with deep', async () => {
                 const { proxy, promisedSchema } = getProxy({
                     properties: {

package/src/browser/preferences/preference-proxy.ts

@@ -151,10 +151,6 @@ export interface PreferenceProxyOptions {
      * Indicates whether the proxy should be disposable. Proxies that are shared between multiple callers should not be disposable.
      */
     isDisposable?: boolean;
-    /**
-     * Indicates whether the proxy will validate values before returning them to clients.
-     */
-    validated?: boolean;
 }
 
 /**

package/src/browser/preferences/preference-schema-provider.spec.ts

@@ -23,7 +23,6 @@ import { Container } from 'inversify';
 import { bindPreferenceService } from '../frontend-application-bindings';
 import { PreferenceSchemaProperties, PreferenceSchemaProvider } from './preference-contribution';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
-import { ApplicationProps } from '@theia/application-package/lib/application-props';
 
 disableJSDOM();
 
@@ -62,9 +61,7 @@ describe('Preference Schema Provider', () => {
     before(() => {
         disableJSDOM = enableJSDOM();
         FrontendApplicationConfigProvider.set({
-            ...ApplicationProps.DEFAULT.frontend.config,
-            'applicationName': 'test',
-            'preferences': {
+            preferences: {
                 'editor.fontSize': 20,
                 '[typescript]': { 'editor.fontSize': 24 }
             }

package/src/browser/preferences/preference-service.spec.ts

@@ -31,7 +31,6 @@ import { PreferenceScope } from './preference-scope';
 import { PreferenceProvider } from './preference-provider';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { createPreferenceProxy, PreferenceChangeEvent } from './preference-proxy';
-import { ApplicationProps } from '@theia/application-package/lib/application-props';
 
 disableJSDOM();
 
@@ -56,10 +55,7 @@ describe('Preference Service', () => {
 
     before(() => {
         disableJSDOM = enableJSDOM();
-        FrontendApplicationConfigProvider.set({
-            ...ApplicationProps.DEFAULT.frontend.config,
-            'applicationName': 'test',
-        });
+        FrontendApplicationConfigProvider.set({});
     });
 
     after(() => {

package/src/browser/preferences/preference-validation-service.spec.ts

@@ -16,11 +16,11 @@
 
 import { Container } from 'inversify';
 import { PreferenceValidationService } from './preference-validation-service';
-import { JsonType, PreferenceItem, PreferenceSchemaProvider } from './preference-contribution';
+import { PreferenceItem, PreferenceSchemaProvider } from './preference-contribution';
 import { PreferenceLanguageOverrideService } from './preference-language-override-service';
 import * as assert from 'assert';
 import { JSONValue } from '@phosphor/coreutils';
-import { IJSONSchema } from 'src/common/json-schema';
+import { IJSONSchema, JsonType } from '../../common/json-schema';
 
 /* eslint-disable no-unused-expressions,no-null/no-null */
 

package/src/browser/preferences/preference-validation-service.ts

@@ -14,12 +14,12 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { JsonType, PreferenceItem } from '../../common/preferences/preference-schema';
+import { PreferenceItem } from '../../common/preferences/preference-schema';
 import { JSONObject, JSONValue } from '../../../shared/@phosphor/coreutils';
 import { PreferenceSchemaProvider } from './preference-contribution';
 import { PreferenceLanguageOverrideService } from './preference-language-override-service';
 import { inject, injectable } from '../../../shared/inversify';
-import { IJSONSchema } from '../../common/json-schema';
+import { IJSONSchema, JsonType } from '../../common/json-schema';
 import { deepClone, unreachable } from '../../common';
 import { PreferenceProvider } from './preference-provider';
 

package/src/browser/preloader.ts

@@ -17,7 +17,7 @@
 import { nls } from '../common/nls';
 import { Endpoint } from './endpoint';
 import { OS } from '../common/os';
-import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
+import { DEFAULT_BACKGROUND_COLOR_STORAGE_KEY, FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 
 function fetchFrom(path: string): Promise<Response> {
     const endpoint = new Endpoint({ path }).getRestUrl().toString();
@@ -47,9 +47,16 @@ async function loadBackendOS(): Promise<void> {
     OS.backend.type = () => osType;
 }
 
+function initBackground(): void {
+    const value = window.localStorage.getItem(DEFAULT_BACKGROUND_COLOR_STORAGE_KEY) || '#1d1d1d';
+    const documentElement = document.documentElement;
+    documentElement.style.setProperty('--theia-editor-background', value);
+}
+
 export async function preload(): Promise<void> {
     await Promise.allSettled([
         loadTranslations(),
-        loadBackendOS()
+        loadBackendOS(),
+        initBackground(),
     ]);
 }

package/src/browser/progress-status-bar-item.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable, inject } from 'inversify';
-import { CancellationToken } from 'vscode-ws-jsonrpc';
+import { CancellationToken } from '../../shared/vscode-languageserver-protocol';
 import { ProgressClient, ProgressMessage, ProgressUpdate } from '../common';
 import { StatusBar, StatusBarAlignment } from './status-bar';
 import { Deferred } from '../common/promise-util';

package/src/browser/quick-input/quick-command-service.ts

@@ -16,7 +16,7 @@
 
 import { inject, injectable } from 'inversify';
 import { KeybindingRegistry } from '../keybinding';
-import { Disposable, Command, CommandRegistry, CancellationToken } from '../../common';
+import { Disposable, Command, CommandRegistry, CancellationToken, nls } from '../../common';
 import { ContextKeyService } from '../context-key-service';
 import { CorePreferences } from '../core-preferences';
 import { QuickAccessContribution, QuickAccessProvider, QuickAccessRegistry } from './quick-access';
@@ -86,12 +86,12 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
         const otherItems = filterItems(this.otherItems.slice(), filter);
 
         if (recentItems.length > 0) {
-            items.push({ type: 'separator', label: 'recently used' }, ...recentItems);
+            items.push({ type: 'separator', label: nls.localizeByDefault('recently used') }, ...recentItems);
         }
 
         if (otherItems.length > 0) {
             if (recentItems.length > 0) {
-                items.push({ type: 'separator', label: 'other commands' });
+                items.push({ type: 'separator', label: nls.localizeByDefault('other commands') });
             }
             items.push(...otherItems);
         }

package/src/browser/saveable.ts

@@ -21,6 +21,7 @@ import { MaybePromise } from '../common/types';
 import { Key } from './keyboard/keys';
 import { AbstractDialog } from './dialogs';
 import { waitForClosed } from './widgets';
+import { nls } from '../common/nls';
 
 export interface Saveable {
     readonly dirty: boolean;
@@ -290,20 +291,20 @@ export class ShouldSaveDialog extends AbstractDialog<boolean> {
 
     constructor(widget: Widget) {
         super({
-            title: `Do you want to save the changes you made to ${widget.title.label || widget.title.caption}?`
+            title: nls.localizeByDefault('Do you want to save the changes you made to {0}?', widget.title.label || widget.title.caption)
         });
 
         const messageNode = document.createElement('div');
-        messageNode.textContent = "Your changes will be lost if you don't save them.";
+        messageNode.textContent = nls.localizeByDefault("Your changes will be lost if you don't save them.");
         messageNode.setAttribute('style', 'flex: 1 100%; padding-bottom: calc(var(--theia-ui-padding)*3);');
         this.contentNode.appendChild(messageNode);
         this.dontSaveButton = this.appendDontSaveButton();
         this.appendCloseButton();
-        this.appendAcceptButton('Save');
+        this.appendAcceptButton(nls.localizeByDefault('Save'));
     }
 
     protected appendDontSaveButton(): HTMLButtonElement {
-        const button = this.createButton("Don't save");
+        const button = this.createButton(nls.localizeByDefault("Don't Save"));
         this.controlPanel.appendChild(button);
         button.classList.add('secondary');
         return button;

package/src/browser/shell/application-shell.ts

@@ -34,11 +34,12 @@ import { FrontendApplicationStateService } from '../frontend-application-state';
 import { TabBarToolbarRegistry, TabBarToolbarFactory } from './tab-bar-toolbar';
 import { ContextKeyService } from '../context-key-service';
 import { Emitter } from '../../common/event';
-import { waitForRevealed, waitForClosed } from '../widgets';
+import { waitForRevealed, waitForClosed, PINNED_CLASS } from '../widgets';
 import { CorePreferences } from '../core-preferences';
 import { BreadcrumbsRendererFactory } from '../breadcrumbs/breadcrumbs-renderer';
 import { Deferred } from '../../common/promise-util';
 import { SaveResourceService } from '../save-resource-service';
+import { nls } from '../../common/nls';
 
 /** The class name added to ApplicationShell instances. */
 const APPLICATION_SHELL_CLASS = 'theia-ApplicationShell';
@@ -622,7 +623,7 @@ export class ApplicationShell extends Widget {
         const pinned: boolean[] = [];
 
         toArray(this.mainPanel.widgets()).forEach((a, i) => {
-            pinned[i] = a.title.className.indexOf('theia-mod-pinned') >= 0;
+            pinned[i] = a.title.className.includes(PINNED_CLASS);
         });
 
         return pinned;
@@ -633,7 +634,7 @@ export class ApplicationShell extends Widget {
         const pinned: boolean[] = [];
 
         toArray(this.bottomPanel.widgets()).forEach((a, i) => {
-            pinned[i] = a.title.className.indexOf('theia-mod-pinned') >= 0;
+            pinned[i] = a.title.className.includes(PINNED_CLASS);
         });
 
         return pinned;
@@ -700,7 +701,7 @@ export class ApplicationShell extends Widget {
             if (bottomPanel.pinned && bottomPanel.pinned.length === widgets.length) {
                 widgets.forEach((a, i) => {
                     if (bottomPanel.pinned![i]) {
-                        a.title.className += ' theia-mod-pinned';
+                        a.title.className += ` ${PINNED_CLASS}`;
                         a.title.closable = false;
                     }
                 });
@@ -719,7 +720,7 @@ export class ApplicationShell extends Widget {
             if (mainPanelPinned && mainPanelPinned.length === widgets.length) {
                 widgets.forEach((a, i) => {
                     if (mainPanelPinned[i]) {
-                        a.title.className += ' theia-mod-pinned';
+                        a.title.className += ` ${PINNED_CLASS}`;
                         a.title.closable = false;
                     }
                 });
@@ -795,36 +796,13 @@ export class ApplicationShell extends Widget {
      *
      * Widgets added to the top area are not tracked regarding the _current_ and _active_ states.
      */
-    async addWidget(widget: Widget, options: Readonly<ApplicationShell.WidgetOptions> = {}): Promise<void> {
+    async addWidget(widget: Widget, options?: Readonly<ApplicationShell.WidgetOptions>): Promise<void> {
         if (!widget.id) {
             console.error('Widgets added to the application shell must have a unique id property.');
             return;
         }
-        let ref: Widget | undefined = options.ref;
-        let area: ApplicationShell.Area = options.area || 'main';
-        if (!ref && (area === 'main' || area === 'bottom')) {
-            const tabBar = this.getTabBarFor(area);
-            ref = tabBar && tabBar.currentTitle && tabBar.currentTitle.owner || undefined;
-        }
-        // make sure that ref belongs to area
-        area = ref && this.getAreaFor(ref) || area;
-        const addOptions: DockPanel.IAddOptions = {};
-        if (ApplicationShell.isOpenToSideMode(options.mode)) {
-            const areaPanel = area === 'main' ? this.mainPanel : area === 'bottom' ? this.bottomPanel : undefined;
-            const sideRef = areaPanel && ref && (options.mode === 'open-to-left' ?
-                areaPanel.previousTabBarWidget(ref) :
-                areaPanel.nextTabBarWidget(ref));
-            if (sideRef) {
-                addOptions.ref = sideRef;
-            } else {
-                addOptions.ref = ref;
-                addOptions.mode = options.mode === 'open-to-left' ? 'split-left' : 'split-right';
-            }
-        } else {
-            addOptions.ref = ref;
-            addOptions.mode = options.mode;
-        }
-        const sidePanelOptions: SidePanel.WidgetOptions = { rank: options.rank };
+        const { area, addOptions } = this.getInsertionOptions(options);
+        const sidePanelOptions: SidePanel.WidgetOptions = { rank: options?.rank };
         switch (area) {
             case 'main':
                 this.mainPanel.addWidget(widget, addOptions);
@@ -842,13 +820,41 @@ export class ApplicationShell extends Widget {
                 this.rightPanelHandler.addWidget(widget, sidePanelOptions);
                 break;
             default:
-                throw new Error('Unexpected area: ' + options.area);
+                throw new Error('Unexpected area: ' + options?.area);
         }
         if (area !== 'top') {
             this.track(widget);
         }
     }
 
+    getInsertionOptions(options?: Readonly<ApplicationShell.WidgetOptions>): { area: string; addOptions: DockLayout.IAddOptions; } {
+        let ref: Widget | undefined = options?.ref;
+        let area: ApplicationShell.Area = options?.area || 'main';
+        if (!ref && (area === 'main' || area === 'bottom')) {
+            const tabBar = this.getTabBarFor(area);
+            ref = tabBar && tabBar.currentTitle && tabBar.currentTitle.owner || undefined;
+        }
+        // make sure that ref belongs to area
+        area = ref && this.getAreaFor(ref) || area;
+        const addOptions: DockPanel.IAddOptions = {};
+        if (ApplicationShell.isOpenToSideMode(options?.mode)) {
+            const areaPanel = area === 'main' ? this.mainPanel : area === 'bottom' ? this.bottomPanel : undefined;
+            const sideRef = areaPanel && ref && (options?.mode === 'open-to-left' ?
+                areaPanel.previousTabBarWidget(ref) :
+                areaPanel.nextTabBarWidget(ref));
+            if (sideRef) {
+                addOptions.ref = sideRef;
+            } else {
+                addOptions.ref = ref;
+                addOptions.mode = options?.mode === 'open-to-left' ? 'split-left' : 'split-right';
+            }
+        } else {
+            addOptions.ref = ref;
+            addOptions.mode = options?.mode;
+        }
+        return { area, addOptions };
+    }
+
     /**
      * The widgets contained in the given shell area.
      */
@@ -1423,14 +1429,15 @@ export class ApplicationShell extends Widget {
         if (this.bottomPanel.isEmpty) {
             this.statusBar.removeElement(BOTTOM_PANEL_TOGGLE_ID);
         } else {
+            const label = nls.localize('theia/core/common/collapseBottomPanel', 'Toggle Bottom Panel');
             const element: StatusBarEntry = {
-                name: 'Toggle Bottom Panel',
+                name: label,
                 text: '$(codicon-window)',
                 alignment: StatusBarAlignment.RIGHT,
-                tooltip: 'Toggle Bottom Panel',
+                tooltip: label,
                 command: 'core.toggle.bottom.panel',
                 accessibilityInformation: {
-                    label: 'Toggle Bottom Panel',
+                    label: label,
                     role: 'button'
                 },
                 priority: -1000

package/src/browser/shell/shell-layout-restorer.ts

@@ -123,11 +123,9 @@ export class ShellLayoutRestorer implements CommandContribution {
     protected storageKey = 'layout';
     protected shouldStoreLayout: boolean = true;
 
-    @inject(ContributionProvider) @named(ApplicationShellLayoutMigration)
-    protected readonly migrations: ContributionProvider<ApplicationShellLayoutMigration>;
-
-    @inject(WindowService)
-    protected readonly windowService: WindowService;
+    @inject(ContributionProvider) @named(ApplicationShellLayoutMigration) protected readonly migrations: ContributionProvider<ApplicationShellLayoutMigration>;
+    @inject(WindowService) protected readonly windowService: WindowService;
+    @inject(ThemeService) protected readonly themeService: ThemeService;
 
     constructor(
         @inject(WidgetManager) protected widgetManager: WidgetManager,
@@ -145,7 +143,7 @@ export class ShellLayoutRestorer implements CommandContribution {
             this.logger.info('>>> Resetting layout...');
             this.shouldStoreLayout = false;
             this.storageService.setData(this.storageKey, undefined);
-            ThemeService.get().reset(); // Theme service cannot use DI, so the current theme ID is stored elsewhere. Hence the explicit reset.
+            this.themeService.reset();
             this.logger.info('<<< The layout has been successfully reset.');
             this.windowService.reload();
         }

package/src/browser/shell/side-panel-handler.ts

@@ -33,6 +33,7 @@ import { ContextMenuRenderer } from '../context-menu-renderer';
 import { MenuPath } from '../../common/menu';
 import { SidebarBottomMenuWidget } from './sidebar-bottom-menu-widget';
 import { SidebarTopMenuWidget } from './sidebar-top-menu-widget';
+import { PINNED_CLASS } from '../widgets';
 
 /** The class name added to the left and right area panels. */
 export const LEFT_RIGHT_AREA_CLASS = 'theia-app-sides';
@@ -274,7 +275,7 @@ export class SidePanelHandler {
             widget: title.owner,
             rank: SidePanelHandler.rankProperty.get(title.owner),
             expanded: title === currentTitle,
-            pinned: title.className.indexOf('theia-mod-pinned') >= 0
+            pinned: title.className.includes(PINNED_CLASS)
         }));
         // eslint-disable-next-line no-null/no-null
         const size = currentTitle !== null ? this.getPanelSize() : this.state.lastPanelSize;
@@ -299,7 +300,7 @@ export class SidePanelHandler {
                         currentTitle = widget.title;
                     }
                     if (pinned) {
-                        widget.title.className += ' theia-mod-pinned';
+                        widget.title.className += ` ${PINNED_CLASS}`;
                         widget.title.closable = false;
                     }
                     // Add the widgets directly to the tab bar in the same order as they are stored

package/src/browser/shell/tab-bars.ts

@@ -17,7 +17,7 @@
 import PerfectScrollbar from 'perfect-scrollbar';
 import { TabBar, Title, Widget } from '@phosphor/widgets';
 import { VirtualElement, h, VirtualDOM, ElementInlineStyle } from '@phosphor/virtualdom';
-import { Disposable, DisposableCollection, MenuPath, notEmpty, SelectionService, CommandService } from '../../common';
+import { Disposable, DisposableCollection, MenuPath, notEmpty, SelectionService, CommandService, nls } from '../../common';
 import { ContextMenuRenderer } from '../context-menu-renderer';
 import { Signal, Slot } from '@phosphor/signaling';
 import { Message, MessageLoop } from '@phosphor/messaging';
@@ -32,6 +32,7 @@ import { BreadcrumbsRenderer, BreadcrumbsRendererFactory } from '../breadcrumbs/
 import { NavigatableWidget } from '../navigatable-types';
 import { IDragEvent } from '@phosphor/dragdrop';
 import { PINNED_CLASS } from '../widgets/widget';
+import { CorePreferences } from '../core-preferences';
 
 /** The class name added to hidden content nodes, which are required to render vertical side bars. */
 const HIDDEN_CONTENT_CLASS = 'theia-TabBar-hidden-content';
@@ -88,7 +89,8 @@ export class TabBarRenderer extends TabBar.Renderer {
         protected readonly decoratorService?: TabBarDecoratorService,
         protected readonly iconThemeService?: IconThemeService,
         protected readonly selectionService?: SelectionService,
-        protected readonly commandService?: CommandService
+        protected readonly commandService?: CommandService,
+        protected readonly corePreferences?: CorePreferences
     ) {
         super();
         if (this.decoratorService) {
@@ -148,6 +150,9 @@ export class TabBarRenderer extends TabBar.Renderer {
         const style = this.createTabStyle(data);
         const className = this.createTabClass(data);
         const dataset = this.createTabDataset(data);
+        const closeIconTitle = data.title.className.includes(PINNED_CLASS)
+            ? nls.localizeByDefault('Unpin')
+            : nls.localizeByDefault('Close');
         return h.li(
             {
                 key, className, id, title: title.caption, style, dataset,
@@ -166,6 +171,7 @@ export class TabBarRenderer extends TabBar.Renderer {
             ),
             h.div({
                 className: 'p-TabBar-tabCloseIcon action-label',
+                title: closeIconTitle,
                 onclick: this.handleCloseClickEvent
             })
         );
@@ -483,6 +489,9 @@ export class TabBarRenderer extends TabBar.Renderer {
     };
 
     protected handleDblClickEvent = (event: MouseEvent) => {
+        if (!this.corePreferences?.get('workbench.tab.maximize')) {
+            return;
+        }
         if (this.tabBar && event.currentTarget instanceof HTMLElement) {
             const id = event.currentTarget.id;
             // eslint-disable-next-line no-null/no-null
@@ -493,6 +502,7 @@ export class TabBarRenderer extends TabBar.Renderer {
             }
         }
     };
+
 }
 
 /**
@@ -686,7 +696,7 @@ export class ToolbarAwareTabBar extends ScrollableTabBar {
             if (this.breadcrumbsContainer) {
                 this.node.appendChild(this.breadcrumbsContainer);
             }
-            this.breadcrumbsRenderer?.refresh();
+            this.updateBreadcrumbs();
         }
         super.onAfterAttach(msg);
     }
@@ -1014,7 +1024,7 @@ export class SideTabBar extends ScrollableTabBar {
 
     /**
      * Handle `viewContainerPart` drag over,
-     * Defines the appropriate `drpAction` and opens the tab on which the mouse stands on for more than 800 ms.
+     * Defines the appropriate `dropAction` and opens the tab on which the mouse stands on for more than 800 ms.
      */
     protected onDragOver = (event: IDragEvent) => {
         const factory = event.mimeData.getData('application/vnd.phosphor.view-container-factory');

package/src/browser/source-tree/source-tree-widget.tsx

@@ -81,7 +81,7 @@ export class SourceTreeWidget extends TreeWidget {
     protected override renderCaption(node: TreeNode): React.ReactNode {
         if (TreeElementNode.is(node)) {
             const classNames = this.createTreeElementNodeClassNames(node);
-            return <div className={classNames.join(' ')}>{node.element.render()}</div>;
+            return <div className={classNames.join(' ')}>{node.element.render(this)}</div>;
         }
         return undefined;
     }