@theia/core 1.44.0 → 1.45.0

package/src/browser/user-working-directory-provider.ts

@@ -16,14 +16,34 @@
 
 import { inject, injectable } from 'inversify';
 import URI from '../common/uri';
-import { MaybePromise, SelectionService, UriSelection } from '../common';
+import { MaybePromise, SelectionService, UNTITLED_SCHEME, UriSelection } from '../common';
 import { EnvVariablesServer } from '../common/env-variables';
+import { FrontendApplication } from './frontend-application';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
+import { Widget } from './widgets';
+import { Navigatable } from './navigatable-types';
 
 @injectable()
-export class UserWorkingDirectoryProvider {
+export class UserWorkingDirectoryProvider implements FrontendApplicationContribution {
     @inject(SelectionService) protected readonly selectionService: SelectionService;
     @inject(EnvVariablesServer) protected readonly envVariables: EnvVariablesServer;
 
+    protected lastOpenResource: URI | undefined;
+
+    configure(app: FrontendApplication): void {
+        app.shell.onDidChangeCurrentWidget(e => this.setLastOpenResource(e.newValue ?? undefined));
+        this.setLastOpenResource(app.shell.currentWidget);
+    }
+
+    protected setLastOpenResource(widget?: Widget): void {
+        if (Navigatable.is(widget)) {
+            const uri = widget.getResourceUri();
+            if (uri && uri.scheme !== UNTITLED_SCHEME) {
+                this.lastOpenResource = uri;
+            }
+        }
+    }
+
     /**
      * @returns A {@link URI} that represents a good guess about the directory in which the user is currently operating.
      *
@@ -35,7 +55,16 @@ export class UserWorkingDirectoryProvider {
     }
 
     protected getFromSelection(): MaybePromise<URI | undefined> {
-        return this.ensureIsDirectory(UriSelection.getUri(this.selectionService.selection));
+        const uri = UriSelection.getUri(this.selectionService.selection);
+        if (uri?.scheme === UNTITLED_SCHEME) {
+            // An untitled file is not a valid working directory context.
+            return undefined;
+        }
+        return this.ensureIsDirectory(uri);
+    }
+
+    protected getFromLastOpenResource(): MaybePromise<URI | undefined> {
+        return this.ensureIsDirectory(this.lastOpenResource);
     }
 
     protected getFromUserHome(): MaybePromise<URI> {

package/src/browser/window/default-secondary-window-service.ts

@@ -19,6 +19,8 @@ import { WindowService } from './window-service';
 import { ExtractableWidget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
+import { PreferenceService } from '../preferences';
+import { environment } from '../../common';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -38,6 +40,9 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     @inject(WindowService)
     protected readonly windowService: WindowService;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     @postConstruct()
     init(): void {
         // Set up messaging with secondary windows
@@ -100,7 +105,13 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     }
 
     protected doCreateSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
-        const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), 'popup') ?? undefined;
+        let options;
+        const [height, width, left, top] = this.findSecondaryWindowCoordinates(widget);
+        options = `popup=1,width=${width},height=${height},left=${left},top=${top}`;
+        if (this.preferenceService.get('window.secondaryWindowAlwaysOnTop')) {
+            options += ',alwaysOnTop=true';
+        }
+        const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), options) ?? undefined;
         if (newWindow) {
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
@@ -124,6 +135,48 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         return newWindow;
     }
 
+    protected findSecondaryWindowCoordinates(widget: ExtractableWidget): (number | undefined)[] {
+        const clientBounds = widget.node.getBoundingClientRect();
+        const preference = this.preferenceService.get('window.secondaryWindowPlacement');
+
+        let height; let width; let left; let top;
+        const offsetY = 20; // Offset to avoid the window title bar
+
+        switch (preference) {
+            case 'originalSize': {
+                height = widget.node.clientHeight;
+                width = widget.node.clientWidth;
+                left = window.screenLeft + clientBounds.x;
+                top = window.screenTop + (window.outerHeight - window.innerHeight) + offsetY;
+                if (environment.electron.is()) {
+                    top = window.screenTop + clientBounds.y;
+                }
+                break;
+            }
+            case 'halfWidth': {
+                height = window.innerHeight - (window.outerHeight - window.innerHeight);
+                width = window.innerWidth / 2;
+                left = window.screenLeft;
+                top = window.screenTop;
+                if (!environment.electron.is()) {
+                    height = window.innerHeight + clientBounds.y - offsetY;
+                }
+                break;
+            }
+            case 'fullSize': {
+                height = window.innerHeight - (window.outerHeight - window.innerHeight);
+                width = window.innerWidth;
+                left = window.screenLeft;
+                top = window.screenTop;
+                if (!environment.electron.is()) {
+                    height = window.innerHeight + clientBounds.y - offsetY;
+                }
+                break;
+            }
+        }
+        return [height, width, left, top];
+    }
+
     focus(win: Window): void {
         win.focus();
     }