ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-09 01:32:34 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.26.1 (#2394)

Browse Source 
* Squash merge commits for 1.26 (#1) (#2323)

* Polish tag search as per feedback (#55269)

* Polish tag search as per feedback

* Updated regex

* Allow users to opt-out of features that send online requests in the background (#55097)

* settings sweep #54690

* Minor css tweaks to enable eoverflow elipsis in more places (#55277)

* fix an issue with titlebarheight when not scaling with zoom

* Settings descriptions update #54690

* fixes #55209

* Settings editor - many padding fixes

* More space above level 2 label

* Fixing Cannot debug npm script using Yarn #55103

* Settings editor - show ellipsis when description overflows

* Settings editor - ... fix measuring around links, relayout

* Setting descriptions

* Settings editor - fix ... for some short lines, fix select container width

* Settings editor - overlay trees so scrollable shadow is full width

* Fix #54133 - missing extension settings after reload

* Settings color token description tweak

* Settings editor - disable overflow indicator temporarily, needs to be faster

* Added command to Run the selected npm script

* fixes #54452

* fixes #54929

* fixes #55248

* prefix command with extension name

* Contribute run selected to the context menu

* node-debug@1.26.6

* Allow terminal rendererType to be swapped out at runtime

Part of #53274
Fixes #55344

* Settings editor - fix not focusing search when restoring editor
setInput must be actually async. Will be fixed naturally when we aren't using winJS promises...

* Settings editor - TOC should only expand the section with a selected item

* Bump node-debug2

* Settings editor - Tree focus outlines

* Settings editor - don't blink the scrollbar when toc selection changes
And hide TOC correctly when the editor is narrow

* Settings editor - header rows should not be selectable

* fixes #54877

* change debug assignee to isi

* Settings sweep (#54690)

* workaround for #55051

* Settings sweep (#54690)

* settings sweep

#54690

* Don't try closing tags when you type > after another >

* Describe what implementation code lens does

Fixes #55370

* fix javadoc formatter setting description

* fixes #55325

* update to officical TS version

* Settings editor - Even more padding, use semibold instead of bold

* Fix #55357 - fix TOC twistie

* fixes #55288

* explorer: refresh on di change file system provider registration

fixes #53256

* Disable push to Linux repo to test standalone publisher

* New env var to notify log level to extensions #54001

* Disable snippets in extension search (when not in suggest dropdown) (#55281)

* Disable snippits in extension search (when not in suggest dropdown)

* Add monaco input contributions

* Fix bug preventing snippetSuggestions from taking effect in sub-editors

* Latest emmet helper to fix #52366

* Fix comment updates for threads within same file

* Allow extensions to log telemetry to log files #54001

* Pull latest css grammar

* files.exclude control - use same style for "add" vs "edit"

* files.exclude control - focus/keyboard behavior

* don't show menubar too early

* files.exclude - better styling

* Place cursor at end of extensions search box on autofill (#55254)

* Place cursor at end of extensions search box on autofill

* Use position instead of selection

* fix linux build issue (empty if block)

* Settings editor - fix extension category prefixes

* Settings editor - add simple ellipsis for first line that overflows, doesn't cover case when first line does not overflow but there is more text, TODO

* File/Text search provider docs

* Fixes #52655

* Include epoch (#55008)

* Fixes #53385

* Fixes #49480

*  VS Code Insiders (Users) not opening Fixes #55353

* Better handling of the case when the extension host fails to start

* Fixes #53966

*  Remove confusing Start from wordPartLeft commands ID

* vscode-xterm@3.6.0-beta12

Fixes #55488

* Initial size is set to infinity!! Fixes #55461

* Polish embeddedEditorBackground

* configuration service misses event

* Fix #55224 - fix duplicate results in multiroot workspace from splitting the diskseach query

* Select all not working in issue reporter on mac, fixes #55424

* Disable fuzzy matching for extensions autosuggest (#55498)

* Fix clipping of extensions search border in some third party themes (#55504)

* fixes #55538

* Fix bug causing an aria alert to not be shown the third time
 (and odd numbers thereafter)

* Settings editor - work around rendering glitch with webkit-line-clamp

* Settings editor - revert earlier '...' changes

* Settings editor - move enumDescription to its own div, because it disturbs -webkit-line-clamp for some reason

* Settings editor - better overflow indicator

* Don't show existing filters in autocomplete (#55495)

* Dont show existing filters in autocomplete

* Simplify

* Settings Editor: Add aria labels for input elements Fixes: #54836 (#55543)

* fixes #55223

* Update vscode-css-languageservice to 3.0.10-next.1

* Fix #55509 - settings navigation

* Fix #55519

* Fix #55520

* FIx #55524

* Fix #55556 - include wordSeparators in all search queries, so findTextInFiles can respect isWordMatch correctly

* oss updates for endgame

* Fix unit tests

* fixes #55522

* Avoid missing manifest error from bubbling up #54757

* Settings format crawl

* Search provider - Fix FileSearchProvider to return array, not progress

* Fix #55598

* Settings editor - fix NPE rendering settings with no description

* dont render inden guides in search box (#55600)

* fixes #55454

* More settings crawl

* Another change for #55598 - maxResults applies to FileSearch and TextSearch but not FileIndex

* Fix FileSearchProvider unit tests for progress change

* fixes #55561

* Settings description update for #54690

* Update setting descriptions for online services

* Minor edits

* fixes #55513

* fixes #55451

* Fix #55612 - fix findTextInFiles cancellation

* fixes #55539

* More setting description tweaks

* Setting to disable online experiments #54354

* fixes #55507

* fixes #55515

* Show online services action only in Insiders for now

* Settings editor - change toc behavior default to 'filter'

* Settings editor - nicer filter count style during search

* Fix #55617 - search viewlet icons

* Settings editor - better styling for element count indicator

* SearchProvider - fix NPE when searching extraFileResources

* Allow extends to work without json suffix

Fixes #16905

* Remove accessability options logic entirely

Follow up on #55451

* use latest version of DAP

* fixes #55490

* fixes #55122

* fixes #52332

* Avoid assumptions about git: URIs (fixes #36236)

* relative path for descriptions

* resourece: get rid of isFile context key

fixes #48275

* Register previous ids for compatibility (#53497)

* more tuning for #48275

* no need to always re-read "files explorer"

fixes #52003

* read out active composites properly

fixes #51967

* Update link colors for hc theme to meet color contrast ratio, fixes #55651

Also updated link color for `textLinkActiveForeground` to be the same as `textLinkForeground` as it wasn't properly updated

* detect 'winpty-agent.exe'; fixes #55672

* node-debug@1.26.7

* reset counter on new label

* Settings editor - fix multiple setting links in one description

* Settings editor - color code blocks in setting descriptions, fix #55532

* Settings editor - hover color in TOC

* Settings editor - fix navigation NPE

* Settings editor - fix text control width

* Settings editor - maybe fix #55684

* Fix bug causing cursor to not move on paste

* fixes #53582

* Use ctrlCmd instead of ctrl for go down from search box

* fixes #55264

* fixes #55456

* filter for spcaes before triggering search (#55611)

* Fix #55698 - don't lose filtered TOC counts when refreshing TOC

* fixes #55421

* fixes #28979

* fixes #55576

* only add check for updates to windows/linux help

* readonly files: append decoration to label

fixes #53022

* debug: do not show toolbar while initialising

fixes #55026

* Opening launch.json should not activate debug extensions

fixes #55029

* fixes #55435

* fixes #55434

* fixes #55439

* trigger menu only on altkey up

* Fix #50555 - fix settings editor memory leak

* Fix #55712 - no need to focus 'a' anymore when restoring control focus after tree render

* fixes #55335

* proper fix for readonly model

fixes #53022

* improve FoldingRangeKind spec (for #55686)

* Use class with static fields (fixes #55494)

* Fixes #53671

* fixes #54630

* [html] should disable ionic suggestions by default. Currently forces deprecated Ionic v1 suggestions in .html files while typing. Fixes #53324

* cleanup deps

* debug issues back to andre

* update electron for smoketest

* Fix #55757 - prevent settings tabs from overflowing

* Fix #53897 - revert setting menu defaults to old editor

* Add enum descriptions to `typescript.preferences.importModuleSpecifier`

* Fix #55767 - leaking style elements from settings editor

* Fix #55521 - prevent flashing when clicking in exclude control

* Update Git modified color for contrast ratio, fixes #53140

* Revert "Merge branch 'master' of github.com:Microsoft/vscode"

This reverts commit bf46b6bfbae0cab99c2863e1244a916181fa9fbc, reversing
changes made to e275a424483dfb4ed33b428c97d5e2c441d6b917.

* Revert "Revert "Merge branch 'master' of github.com:Microsoft/vscode""

This reverts commit 53949d963f39e40757557c6526332354a31d9154.

* don't ask to install an incomplete menu

* Fix NPE in terminal AccessibilityManager

Fixes #55744

* don't display fallback menu unless we've closed the last window

* fixes #55547

* Fix smoke tests for extension search box

* Update OSSREADME.json for Electron 2.0.5

* Update distro

Includes Chromium license changes

* fix #55455

* fix #55865

* fixes #55893

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation (#55805)

* Fix bug causing workspace recommendations to go away upon ignoring a recommendation

* ONly show on @recommended or @recommended:workspace

* Make more consistant

* Fix #55911

* Understand json activity (#55926)

* Understand json file activity

* Refactoring

* adding composer.json

* Distro update for experiments

* use terminal.processId for auto-attach; fixes #55918

* Reject invalid URI with vscode.openFolder (for #55891)

* improve win32 setup system vs user detection

fixes #55840

fixes #55840

delay winreg import

related to #55840

show notification earlier

related to #55840

fix #55840

update inno setup message

related to #55840

* Fix #55593 - this code only operates on local paths, so use fsPath and Uri.file instead

* Bring back the old menu due to electron 2.0 issues (#55913)

* add the old menu back for native menus

* make menu labels match

* `vscode.openFolder`: treat missing URI schema gracefully (for #55891)

* delay EH reattach; fixes #55955

* Mark all json files under appSettingsHome as settings

* Use localized strings for telemetry opt-out

* Exception when saving file editor opened from remote file provider (fixes #55051)

* Remove terminal menu from stable

Fixes 56003

* VSCode Insiders crashes on open with TypeError: Cannot read property 'lastIndexOf' of undefined. Fixes #54933

* improve fix for #55891

* fix #55916

* Improve #55891

* increase EH debugging restart delay; fixes #55955

* Revert "Don't include non-resource entries in history quick pick"

This reverts commit 37209a838e9f7e9abe6dc53ed73cdf1e03b72060.

* Diff editor: horizontal scrollbar height is smaller (fixes #56062)

* improve openFolder uri fix (correctly treat backslashes)

* fixes #56116
repair ipc for native menubar keybindings

* Fix #56240 - Open the JSON settings editor instead of the UI editor

* Fix #55536

* uriDisplay: if no formatter is registered fall back to getPathlabel

fixes #56104

* VSCode hangs when opening python file. Fixes #56377

* VS Code Hangs When Opening Specific PowerShell File. Fixes #56430

* Fix #56433 - search extraFileResources even when no folders open

* Workaround #55649

* Fix in master #56371

* Fix tests #56371

* Fix in master #56317

* increase version to 1.26.1

* Fixes #56387: Handle SIGPIPE in extension host

* fixes #56185

* Fix merge issues (part 1)

* Fix build breaks (part 1)

* Build breaks (part 2)

* Build breaks (part 3)

* More build breaks (part 4)

* Fix build breaks (part 5)

* WIP

* Fix menus

* Render query result and message panels (#2363)

* Put back query editor hot exit changes

* Fix grid changes that broke profiler (#2365)

* Update APIs for saving query editor state

* Fix restore view state for profiler and edit data

* Updating custom default themes to support 4.5:1 contrast ratio

* Test updates

* Fix Extension Manager and Windows Setup

* Update license headers

* Add appveyor and travis files back

* Fix hidden modal dropdown issue
This commit is contained in:
Karl Burtram
2018-09-04 14:55:00 -07:00
committed by GitHub
parent 3763278366
commit 81329fa7fa
2638 changed files with 118456 additions and 64012 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/vs/platform/windows/common/windows.ts
View File

@@ -11,12 +11,13 @@ import { Event, latch, anyEvent } from 'vs/base/common/event';
import { ITelemetryData } from 'vs/platform/telemetry/common/telemetry';
import { IProcessEnvironment } from 'vs/base/common/platform';
import { ParsedArgs } from 'vs/platform/environment/common/environment';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IRecentlyOpened } from 'vs/platform/history/common/history';
import { ICommandAction } from 'vs/platform/actions/common/actions';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import { PerformanceEntry } from 'vs/base/common/performance';
import { LogLevel } from 'vs/platform/log/common/log';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import URI, { UriComponents } from 'vs/base/common/uri';
export const IWindowsService = createDecorator<IWindowsService>('windowsService');
@@ -92,6 +93,10 @@ export interface OpenDialogOptions {
message?: string;
}
export interface IDevToolsOptions {
mode: 'right' | 'bottom' | 'undocked' | 'detach';
}
export interface IWindowsService {
_serviceBrand: any;
@@ -99,6 +104,9 @@ export interface IWindowsService {
onWindowOpen: Event<number>;
onWindowFocus: Event<number>;
onWindowBlur: Event<number>;
onWindowMaximize: Event<number>;
onWindowUnmaximize: Event<number>;
onRecentlyOpenedChange: Event<void>;
// Dialogs
pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
@@ -110,15 +118,16 @@ export interface IWindowsService {
showOpenDialog(windowId: number, options: OpenDialogOptions): TPromise<string[]>;
reloadWindow(windowId: number, args?: ParsedArgs): TPromise<void>;
openDevTools(windowId: number): TPromise<void>;
openDevTools(windowId: number, options?: IDevToolsOptions): TPromise<void>;
toggleDevTools(windowId: number): TPromise<void>;
closeWorkspace(windowId: number): TPromise<void>;
enterWorkspace(windowId: number, path: string): TPromise<IEnterWorkspaceResult>;
createAndEnterWorkspace(windowId: number, folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult>;
saveAndEnterWorkspace(windowId: number, path: string): TPromise<IEnterWorkspaceResult>;
toggleFullScreen(windowId: number): TPromise<void>;
setRepresentedFilename(windowId: number, fileName: string): TPromise<void>;
addRecentlyOpened(files: string[]): TPromise<void>;
removeFromRecentlyOpened(paths: string[]): TPromise<void>;
removeFromRecentlyOpened(paths: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string)[]): TPromise<void>;
clearRecentlyOpened(): TPromise<void>;
getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened>;
focusWindow(windowId: number): TPromise<void>;
@@ -127,6 +136,7 @@ export interface IWindowsService {
isMaximized(windowId: number): TPromise<boolean>;
maximizeWindow(windowId: number): TPromise<void>;
unmaximizeWindow(windowId: number): TPromise<void>;
minimizeWindow(windowId: number): TPromise<void>;
onWindowTitleDoubleClick(windowId: number): TPromise<void>;
setDocumentEdited(windowId: number, flag: boolean): TPromise<void>;
quit(): TPromise<void>;
@@ -140,20 +150,21 @@ export interface IWindowsService {
toggleWindowTabsBar(): TPromise<void>;
// macOS TouchBar
updateTouchBar(windowId: number, items: ICommandAction[][]): TPromise<void>;
updateTouchBar(windowId: number, items: ISerializableCommandAction[][]): TPromise<void>;
// Shared process
whenSharedProcessReady(): TPromise<void>;
toggleSharedProcess(): TPromise<void>;
// Global methods
openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean; }): TPromise<void>;
openWindow(windowId: number, paths: URI[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }): TPromise<void>;
openNewWindow(): TPromise<void>;
showWindow(windowId: number): TPromise<void>;
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]>;
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderUri?: ISingleFolderWorkspaceIdentifier; title: string; filename?: string; }[]>;
getWindowCount(): TPromise<number>;
log(severity: string, ...messages: string[]): TPromise<void>;
showItemInFolder(path: string): TPromise<void>;
getActiveWindowId(): TPromise<number | undefined>;
// This needs to be handled from browser process to prevent
// foreground ordering issues on Windows
@@ -177,6 +188,7 @@ export interface IWindowService {
_serviceBrand: any;
onDidChangeFocus: Event<boolean>;
onDidChangeMaximize: Event<boolean>;
getConfiguration(): IWindowConfiguration;
getCurrentWindowId(): number;
@@ -185,10 +197,11 @@ export interface IWindowService {
pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
pickWorkspaceAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
reloadWindow(args?: ParsedArgs): TPromise<void>;
openDevTools(): TPromise<void>;
openDevTools(options?: IDevToolsOptions): TPromise<void>;
toggleDevTools(): TPromise<void>;
closeWorkspace(): TPromise<void>;
updateTouchBar(items: ICommandAction[][]): TPromise<void>;
updateTouchBar(items: ISerializableCommandAction[][]): TPromise<void>;
enterWorkspace(path: string): TPromise<IEnterWorkspaceResult>;
createAndEnterWorkspace(folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult>;
saveAndEnterWorkspace(path: string): TPromise<IEnterWorkspaceResult>;
toggleFullScreen(): TPromise<void>;
@@ -196,8 +209,13 @@ export interface IWindowService {
getRecentlyOpened(): TPromise<IRecentlyOpened>;
focusWindow(): TPromise<void>;
closeWindow(): TPromise<void>;
openWindow(paths: URI[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }): TPromise<void>;
isFocused(): TPromise<boolean>;
setDocumentEdited(flag: boolean): TPromise<void>;
isMaximized(): TPromise<boolean>;
maximizeWindow(): TPromise<void>;
unmaximizeWindow(): TPromise<void>;
minimizeWindow(): TPromise<void>;
onWindowTitleDoubleClick(): TPromise<void>;
show(): TPromise<void>;
showMessageBox(options: MessageBoxOptions): TPromise<IMessageBoxResult>;
@@ -299,7 +317,7 @@ export interface IOpenFileRequest {
}
export interface IAddFoldersRequest {
foldersToAdd: IPath[];
foldersToAdd: UriComponents[];
}
export interface IWindowConfiguration extends ParsedArgs, IOpenFileRequest {
@@ -317,13 +335,15 @@ export interface IWindowConfiguration extends ParsedArgs, IOpenFileRequest {
backupPath?: string;
workspace?: IWorkspaceIdentifier;
folderPath?: string;
folderUri?: ISingleFolderWorkspaceIdentifier;
zoomLevel?: number;
fullscreen?: boolean;
maximized?: boolean;
highContrast?: boolean;
baseTheme?: string;
backgroundColor?: string;
frameless?: boolean;
accessibilitySupport?: boolean;
perfEntries: PerformanceEntry[];
@@ -340,19 +360,31 @@ export interface IRunActionInWindowRequest {
export class ActiveWindowManager implements IDisposable {
private disposables: IDisposable[] = [];
private _activeWindowId: number;
private firstActiveWindowIdPromise: TPromise<any> | null;
private _activeWindowId: number | undefined;
constructor(@IWindowsService windowsService: IWindowsService) {
const onActiveWindowChange = latch(anyEvent(windowsService.onWindowOpen, windowsService.onWindowFocus));
onActiveWindowChange(this.setActiveWindow, this, this.disposables);
this.firstActiveWindowIdPromise = windowsService.getActiveWindowId()
.then(id => (typeof this._activeWindowId === 'undefined') && this.setActiveWindow(id));
}
private setActiveWindow(windowId: number) {
if (this.firstActiveWindowIdPromise) {
this.firstActiveWindowIdPromise = null;
}
this._activeWindowId = windowId;
}
get activeClientId(): string {
return `window:${this._activeWindowId}`;
getActiveClientId(): TPromise<string> {
if (this.firstActiveWindowIdPromise) {
return this.firstActiveWindowIdPromise;
}
return TPromise.as(`window:${this._activeWindowId}`);
}
dispose() {

129
src/vs/platform/windows/common/windowsIpc.ts
View File

@@ -7,18 +7,23 @@
import { TPromise } from 'vs/base/common/winjs.base';
import { Event, buffer } from 'vs/base/common/event';
import { IChannel, eventToCall, eventFromCall } from 'vs/base/parts/ipc/common/ipc';
import { IWindowsService, INativeOpenDialogOptions, IEnterWorkspaceResult, CrashReporterStartOptions, IMessageBoxResult, MessageBoxOptions, SaveDialogOptions, OpenDialogOptions } from 'vs/platform/windows/common/windows';
import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
import { IWindowsService, INativeOpenDialogOptions, IEnterWorkspaceResult, CrashReporterStartOptions, IMessageBoxResult, MessageBoxOptions, SaveDialogOptions, OpenDialogOptions, IDevToolsOptions } from 'vs/platform/windows/common/windows';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData, ISingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IRecentlyOpened } from 'vs/platform/history/common/history';
import { ICommandAction } from 'vs/platform/actions/common/actions';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import URI from 'vs/base/common/uri';
import { ParsedArgs } from 'vs/platform/environment/common/environment';
export interface IWindowsChannel extends IChannel {
call(command: 'event:onWindowOpen'): TPromise<number>;
call(command: 'event:onWindowFocus'): TPromise<number>;
call(command: 'event:onWindowBlur'): TPromise<number>;
listen(event: 'onWindowOpen'): Event<number>;
listen(event: 'onWindowFocus'): Event<number>;
listen(event: 'onWindowBlur'): Event<number>;
listen(event: 'onWindowMaximize'): Event<number>;
listen(event: 'onWindowUnmaximize'): Event<number>;
listen(event: 'onRecentlyOpenedChange'): Event<void>;
listen<T>(event: string, arg?: any): Event<T>;
call(command: 'pickFileFolderAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
call(command: 'pickFileAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
call(command: 'pickFolderAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
@@ -27,45 +32,48 @@ export interface IWindowsChannel extends IChannel {
call(command: 'showSaveDialog', arg: [number, SaveDialogOptions]): TPromise<string>;
call(command: 'showOpenDialog', arg: [number, OpenDialogOptions]): TPromise<string[]>;
call(command: 'reloadWindow', arg: [number, ParsedArgs]): TPromise<void>;
call(command: 'openDevTools', arg: [number, IDevToolsOptions]): TPromise<void>;
call(command: 'toggleDevTools', arg: number): TPromise<void>;
call(command: 'closeWorkspace', arg: number): TPromise<void>;
call(command: 'enterWorkspace', arg: [number, string]): TPromise<IEnterWorkspaceResult>;
call(command: 'createAndEnterWorkspace', arg: [number, IWorkspaceFolderCreationData[], string]): TPromise<IEnterWorkspaceResult>;
call(command: 'saveAndEnterWorkspace', arg: [number, string]): TPromise<IEnterWorkspaceResult>;
call(command: 'toggleFullScreen', arg: number): TPromise<void>;
call(command: 'setRepresentedFilename', arg: [number, string]): TPromise<void>;
call(command: 'addRecentlyOpened', arg: string[]): TPromise<void>;
call(command: 'removeFromRecentlyOpened', arg: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier)[]): TPromise<void>;
call(command: 'removeFromRecentlyOpened', arg: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string)[]): TPromise<void>;
call(command: 'clearRecentlyOpened'): TPromise<void>;
call(command: 'getRecentlyOpened', arg: number): TPromise<IRecentlyOpened>;
call(command: 'showPreviousWindowTab', arg: number): TPromise<void>;
call(command: 'showNextWindowTab', arg: number): TPromise<void>;
call(command: 'moveWindowTabToNewWindow', arg: number): TPromise<void>;
call(command: 'mergeAllWindowTabs', arg: number): TPromise<void>;
call(command: 'toggleWindowTabsBar', arg: number): TPromise<void>;
call(command: 'updateTouchBar', arg: [number, ICommandAction[][]]): TPromise<void>;
call(command: 'showPreviousWindowTab'): TPromise<void>;
call(command: 'showNextWindowTab'): TPromise<void>;
call(command: 'moveWindowTabToNewWindow'): TPromise<void>;
call(command: 'mergeAllWindowTabs'): TPromise<void>;
call(command: 'toggleWindowTabsBar'): TPromise<void>;
call(command: 'updateTouchBar', arg: [number, ISerializableCommandAction[][]]): TPromise<void>;
call(command: 'focusWindow', arg: number): TPromise<void>;
call(command: 'closeWindow', arg: number): TPromise<void>;
call(command: 'isFocused', arg: number): TPromise<boolean>;
call(command: 'isMaximized', arg: number): TPromise<boolean>;
call(command: 'maximizeWindow', arg: number): TPromise<void>;
call(command: 'unmaximizeWindow', arg: number): TPromise<void>;
call(command: 'minimizeWindow', arg: number): TPromise<void>;
call(command: 'onWindowTitleDoubleClick', arg: number): TPromise<void>;
call(command: 'setDocumentEdited', arg: [number, boolean]): TPromise<void>;
call(command: 'quit'): TPromise<void>;
call(command: 'openWindow', arg: [string[], { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }]): TPromise<void>;
call(command: 'openWindow', arg: [number, URI[], { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }]): TPromise<void>;
call(command: 'openNewWindow'): TPromise<void>;
call(command: 'showWindow', arg: number): TPromise<void>;
call(command: 'getWindows'): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]>;
call(command: 'getWindows'): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderUri?: ISingleFolderWorkspaceIdentifier; title: string; filename?: string; }[]>;
call(command: 'getWindowCount'): TPromise<number>;
call(command: 'relaunch', arg: { addArgs?: string[], removeArgs?: string[] }): TPromise<number>;
call(command: 'relaunch', arg: [{ addArgs?: string[], removeArgs?: string[] }]): TPromise<void>;
call(command: 'whenSharedProcessReady'): TPromise<void>;
call(command: 'toggleSharedProcess'): TPromise<void>;
call(command: 'log', arg: [string, string[]]): TPromise<void>;
call(command: 'showItemInFolder', arg: string): TPromise<void>;
call(command: 'getActiveWindowId'): TPromise<number>;
call(command: 'openExternal', arg: string): TPromise<boolean>;
call(command: 'startCrashReporter', arg: CrashReporterStartOptions): TPromise<void>;
call(command: 'openAboutDialog'): TPromise<void>;
call(command: string, arg?: any): TPromise<any>;
}
export class WindowsChannel implements IWindowsChannel {
@@ -73,18 +81,34 @@ export class WindowsChannel implements IWindowsChannel {
private onWindowOpen: Event<number>;
private onWindowFocus: Event<number>;
private onWindowBlur: Event<number>;
private onWindowMaximize: Event<number>;
private onWindowUnmaximize: Event<number>;
private onRecentlyOpenedChange: Event<void>;
constructor(private service: IWindowsService) {
this.onWindowOpen = buffer(service.onWindowOpen, true);
this.onWindowFocus = buffer(service.onWindowFocus, true);
this.onWindowBlur = buffer(service.onWindowBlur, true);
this.onWindowMaximize = buffer(service.onWindowMaximize, true);
this.onWindowUnmaximize = buffer(service.onWindowUnmaximize, true);
this.onRecentlyOpenedChange = buffer(service.onRecentlyOpenedChange, true);
}
listen<T>(event: string, arg?: any): Event<any> {
switch (event) {
case 'onWindowOpen': return this.onWindowOpen;
case 'onWindowFocus': return this.onWindowFocus;
case 'onWindowBlur': return this.onWindowBlur;
case 'onWindowMaximize': return this.onWindowMaximize;
case 'onWindowUnmaximize': return this.onWindowUnmaximize;
case 'onRecentlyOpenedChange': return this.onRecentlyOpenedChange;
}
throw new Error('No event found');
}
call(command: string, arg?: any): TPromise<any> {
switch (command) {
case 'event:onWindowOpen': return eventToCall(this.onWindowOpen);
case 'event:onWindowFocus': return eventToCall(this.onWindowFocus);
case 'event:onWindowBlur': return eventToCall(this.onWindowBlur);
case 'pickFileFolderAndOpen': return this.service.pickFileFolderAndOpen(arg);
case 'pickFileAndOpen': return this.service.pickFileAndOpen(arg);
case 'pickFolderAndOpen': return this.service.pickFolderAndOpen(arg);
@@ -93,9 +117,10 @@ export class WindowsChannel implements IWindowsChannel {
case 'showSaveDialog': return this.service.showSaveDialog(arg[0], arg[1]);
case 'showOpenDialog': return this.service.showOpenDialog(arg[0], arg[1]);
case 'reloadWindow': return this.service.reloadWindow(arg[0], arg[1]);
case 'openDevTools': return this.service.openDevTools(arg);
case 'openDevTools': return this.service.openDevTools(arg[0], arg[1]);
case 'toggleDevTools': return this.service.toggleDevTools(arg);
case 'closeWorkspace': return this.service.closeWorkspace(arg);
case 'enterWorkspace': return this.service.enterWorkspace(arg[0], arg[1]);
case 'createAndEnterWorkspace': {
const rawFolders: IWorkspaceFolderCreationData[] = arg[1];
let folders: IWorkspaceFolderCreationData[];
@@ -114,7 +139,13 @@ export class WindowsChannel implements IWindowsChannel {
case 'toggleFullScreen': return this.service.toggleFullScreen(arg);
case 'setRepresentedFilename': return this.service.setRepresentedFilename(arg[0], arg[1]);
case 'addRecentlyOpened': return this.service.addRecentlyOpened(arg);
case 'removeFromRecentlyOpened': return this.service.removeFromRecentlyOpened(arg);
case 'removeFromRecentlyOpened': {
let paths: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string)[] = arg;
if (Array.isArray(paths)) {
paths = paths.map(path => isWorkspaceIdentifier(path) || typeof path === 'string' ? path : URI.revive(path));
}
return this.service.removeFromRecentlyOpened(paths);
}
case 'clearRecentlyOpened': return this.service.clearRecentlyOpened();
case 'showPreviousWindowTab': return this.service.showPreviousWindowTab();
case 'showNextWindowTab': return this.service.showNextWindowTab();
@@ -129,9 +160,10 @@ export class WindowsChannel implements IWindowsChannel {
case 'isMaximized': return this.service.isMaximized(arg);
case 'maximizeWindow': return this.service.maximizeWindow(arg);
case 'unmaximizeWindow': return this.service.unmaximizeWindow(arg);
case 'minimizeWindow': return this.service.minimizeWindow(arg);
case 'onWindowTitleDoubleClick': return this.service.onWindowTitleDoubleClick(arg);
case 'setDocumentEdited': return this.service.setDocumentEdited(arg[0], arg[1]);
case 'openWindow': return this.service.openWindow(arg[0], arg[1]);
case 'openWindow': return this.service.openWindow(arg[0], arg[1] ? (<URI[]>arg[1]).map(r => URI.revive(r)) : arg[1], arg[2]);
case 'openNewWindow': return this.service.openNewWindow();
case 'showWindow': return this.service.showWindow(arg);
case 'getWindows': return this.service.getWindows();
@@ -142,6 +174,7 @@ export class WindowsChannel implements IWindowsChannel {
case 'quit': return this.service.quit();
case 'log': return this.service.log(arg[0], arg[1]);
case 'showItemInFolder': return this.service.showItemInFolder(arg);
case 'getActiveWindowId': return this.service.getActiveWindowId();
case 'openExternal': return this.service.openExternal(arg);
case 'startCrashReporter': return this.service.startCrashReporter(arg);
case 'openAboutDialog': return this.service.openAboutDialog();
@@ -156,14 +189,12 @@ export class WindowsChannelClient implements IWindowsService {
constructor(private channel: IWindowsChannel) { }
private _onWindowOpen: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowOpen');
get onWindowOpen(): Event<number> { return this._onWindowOpen; }
private _onWindowFocus: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowFocus');
get onWindowFocus(): Event<number> { return this._onWindowFocus; }
private _onWindowBlur: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowBlur');
get onWindowBlur(): Event<number> { return this._onWindowBlur; }
get onWindowOpen(): Event<number> { return this.channel.listen('onWindowOpen'); }
get onWindowFocus(): Event<number> { return this.channel.listen('onWindowFocus'); }
get onWindowBlur(): Event<number> { return this.channel.listen('onWindowBlur'); }
get onWindowMaximize(): Event<number> { return this.channel.listen('onWindowMaximize'); }
get onWindowUnmaximize(): Event<number> { return this.channel.listen('onWindowUnmaximize'); }
get onRecentlyOpenedChange(): Event<void> { return this.channel.listen('onRecentlyOpenedChange'); }
pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
return this.channel.call('pickFileFolderAndOpen', options);
@@ -197,8 +228,8 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('reloadWindow', [windowId, args]);
}
openDevTools(windowId: number): TPromise<void> {
return this.channel.call('openDevTools', windowId);
openDevTools(windowId: number, options?: IDevToolsOptions): TPromise<void> {
return this.channel.call('openDevTools', [windowId, options]);
}
toggleDevTools(windowId: number): TPromise<void> {
@@ -209,6 +240,10 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('closeWorkspace', windowId);
}
enterWorkspace(windowId: number, path: string): TPromise<IEnterWorkspaceResult> {
return this.channel.call('enterWorkspace', [windowId, path]);
}
createAndEnterWorkspace(windowId: number, folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult> {
return this.channel.call('createAndEnterWorkspace', [windowId, folders, path]);
}
@@ -229,7 +264,7 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('addRecentlyOpened', files);
}
removeFromRecentlyOpened(paths: string[]): TPromise<void> {
removeFromRecentlyOpened(paths: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string)[]): TPromise<void> {
return this.channel.call('removeFromRecentlyOpened', paths);
}
@@ -238,7 +273,11 @@ export class WindowsChannelClient implements IWindowsService {
}
getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened> {
return this.channel.call('getRecentlyOpened', windowId);
return this.channel.call('getRecentlyOpened', windowId)
.then(recentlyOpened => {
recentlyOpened.workspaces = recentlyOpened.workspaces.map(workspace => isWorkspaceIdentifier(workspace) ? workspace : URI.revive(workspace));
return recentlyOpened;
});
}
showPreviousWindowTab(): TPromise<void> {
@@ -285,6 +324,10 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('unmaximizeWindow', windowId);
}
minimizeWindow(windowId: number): TPromise<void> {
return this.channel.call('minimizeWindow', windowId);
}
onWindowTitleDoubleClick(windowId: number): TPromise<void> {
return this.channel.call('onWindowTitleDoubleClick', windowId);
}
@@ -309,8 +352,8 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('toggleSharedProcess');
}
openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }): TPromise<void> {
return this.channel.call('openWindow', [paths, options]);
openWindow(windowId: number, paths: URI[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }): TPromise<void> {
return this.channel.call('openWindow', [windowId, paths, options]);
}
openNewWindow(): TPromise<void> {
@@ -321,8 +364,8 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('showWindow', windowId);
}
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]> {
return this.channel.call('getWindows');
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderUri?: ISingleFolderWorkspaceIdentifier; title: string; filename?: string; }[]> {
return this.channel.call('getWindows').then(result => { result.forEach(win => win.folderUri = win.folderUri ? URI.revive(win.folderUri) : win.folderUri); return result; });
}
getWindowCount(): TPromise<number> {
@@ -337,6 +380,10 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('showItemInFolder', path);
}
getActiveWindowId(): TPromise<number | undefined> {
return this.channel.call('getActiveWindowId');
}
openExternal(url: string): TPromise<boolean> {
return this.channel.call('openExternal', url);
}
@@ -345,7 +392,7 @@ export class WindowsChannelClient implements IWindowsService {
return this.channel.call('startCrashReporter', config);
}
updateTouchBar(windowId: number, items: ICommandAction[][]): TPromise<void> {
updateTouchBar(windowId: number, items: ISerializableCommandAction[][]): TPromise<void> {
return this.channel.call('updateTouchBar', [windowId, items]);
}

39
src/vs/platform/windows/electron-browser/windowService.ts
View File

@@ -7,15 +7,17 @@
import { Event, filterEvent, mapEvent, anyEvent } from 'vs/base/common/event';
import { TPromise } from 'vs/base/common/winjs.base';
import { IWindowService, IWindowsService, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult, IWindowConfiguration } from 'vs/platform/windows/common/windows';
import { IWindowService, IWindowsService, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult, IWindowConfiguration, IDevToolsOptions } from 'vs/platform/windows/common/windows';
import { IRecentlyOpened } from 'vs/platform/history/common/history';
import { ICommandAction } from 'vs/platform/actions/common/actions';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import { IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { ParsedArgs } from 'vs/platform/environment/common/environment';
import URI from 'vs/base/common/uri';
export class WindowService implements IWindowService {
readonly onDidChangeFocus: Event<boolean>;
readonly onDidChangeMaximize: Event<boolean>;
_serviceBrand: any;
@@ -26,7 +28,10 @@ export class WindowService implements IWindowService {
) {
const onThisWindowFocus = mapEvent(filterEvent(windowsService.onWindowFocus, id => id === windowId), _ => true);
const onThisWindowBlur = mapEvent(filterEvent(windowsService.onWindowBlur, id => id === windowId), _ => false);
const onThisWindowMaximize = mapEvent(filterEvent(windowsService.onWindowMaximize, id => id === windowId), _ => true);
const onThisWindowUnmaximize = mapEvent(filterEvent(windowsService.onWindowUnmaximize, id => id === windowId), _ => false);
this.onDidChangeFocus = anyEvent(onThisWindowFocus, onThisWindowBlur);
this.onDidChangeMaximize = anyEvent(onThisWindowMaximize, onThisWindowUnmaximize);
}
getCurrentWindowId(): number {
@@ -65,8 +70,8 @@ export class WindowService implements IWindowService {
return this.windowsService.reloadWindow(this.windowId, args);
}
openDevTools(): TPromise<void> {
return this.windowsService.openDevTools(this.windowId);
openDevTools(options?: IDevToolsOptions): TPromise<void> {
return this.windowsService.openDevTools(this.windowId, options);
}
toggleDevTools(): TPromise<void> {
@@ -77,6 +82,10 @@ export class WindowService implements IWindowService {
return this.windowsService.closeWorkspace(this.windowId);
}
enterWorkspace(path: string): TPromise<IEnterWorkspaceResult> {
return this.windowsService.enterWorkspace(this.windowId, path);
}
createAndEnterWorkspace(folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult> {
return this.windowsService.createAndEnterWorkspace(this.windowId, folders, path);
}
@@ -85,6 +94,10 @@ export class WindowService implements IWindowService {
return this.windowsService.saveAndEnterWorkspace(this.windowId, path);
}
openWindow(paths: URI[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }): TPromise<void> {
return this.windowsService.openWindow(this.windowId, paths, options);
}
closeWindow(): TPromise<void> {
return this.windowsService.closeWindow(this.windowId);
}
@@ -109,6 +122,22 @@ export class WindowService implements IWindowService {
return this.windowsService.isFocused(this.windowId);
}
isMaximized(): TPromise<boolean> {
return this.windowsService.isMaximized(this.windowId);
}
maximizeWindow(): TPromise<void> {
return this.windowsService.maximizeWindow(this.windowId);
}
unmaximizeWindow(): TPromise<void> {
return this.windowsService.unmaximizeWindow(this.windowId);
}
minimizeWindow(): TPromise<void> {
return this.windowsService.minimizeWindow(this.windowId);
}
onWindowTitleDoubleClick(): TPromise<void> {
return this.windowsService.onWindowTitleDoubleClick(this.windowId);
}
@@ -133,7 +162,7 @@ export class WindowService implements IWindowService {
return this.windowsService.showOpenDialog(this.windowId, options);
}
updateTouchBar(items: ICommandAction[][]): TPromise<void> {
updateTouchBar(items: ISerializableCommandAction[][]): TPromise<void> {
return this.windowsService.updateTouchBar(this.windowId, items);
}
}

13
src/vs/platform/windows/electron-main/windows.ts
View File

@@ -12,7 +12,8 @@ import { Event } from 'vs/base/common/event';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IProcessEnvironment } from 'vs/base/common/platform';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { ICommandAction } from 'vs/platform/actions/common/actions';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import URI from 'vs/base/common/uri';
export interface IWindowState {
width?: number;
@@ -35,7 +36,7 @@ export interface ICodeWindow {
win: Electron.BrowserWindow;
config: IWindowConfiguration;
openedFolderPath: string;
openedFolderUri: URI;
openedWorkspace: IWorkspaceIdentifier;
backupPath: string;
@@ -47,7 +48,7 @@ export interface ICodeWindow {
readyState: ReadyState;
ready(): TPromise<ICodeWindow>;
load(config: IWindowConfiguration, isReload?: boolean): void;
load(config: IWindowConfiguration, isReload?: boolean, disableExtensions?: boolean): void;
reload(configuration?: IWindowConfiguration, cli?: ParsedArgs): void;
focus(): void;
@@ -64,7 +65,7 @@ export interface ICodeWindow {
getRepresentedFilename(): string;
onWindowTitleDoubleClick(): void;
updateTouchBar(items: ICommandAction[][]): void;
updateTouchBar(items: ISerializableCommandAction[][]): void;
setReady(): void;
serializeWindowState(): IWindowState;
@@ -92,6 +93,7 @@ export interface IWindowsMainService {
// methods
ready(initialUserEnv: IProcessEnvironment): void;
reload(win: ICodeWindow, cli?: ParsedArgs): void;
enterWorkspace(win: ICodeWindow, path: string): TPromise<IEnterWorkspaceResult>;
createAndEnterWorkspace(win: ICodeWindow, folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult>;
saveAndEnterWorkspace(win: ICodeWindow, path: string): TPromise<IEnterWorkspaceResult>;
closeWorkspace(win: ICodeWindow): void;
@@ -119,9 +121,10 @@ export interface IWindowsMainService {
export interface IOpenConfiguration {
context: OpenContext;
contextWindowId?: number;
cli: ParsedArgs;
userEnv?: IProcessEnvironment;
pathsToOpen?: string[];
urisToOpen?: URI[];
preferNewWindow?: boolean;
forceNewWindow?: boolean;
forceReuseWindow?: boolean;

87
src/vs/platform/windows/electron-main/windowsService.ts
View File

@@ -11,19 +11,19 @@ import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { assign } from 'vs/base/common/objects';
import URI from 'vs/base/common/uri';
import product from 'vs/platform/node/product';
import { IWindowsService, OpenContext, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult } from 'vs/platform/windows/common/windows';
import { IWindowsService, OpenContext, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult, IDevToolsOptions } from 'vs/platform/windows/common/windows';
import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
import { shell, crashReporter, app, Menu, clipboard } from 'electron';
import { Event, fromNodeEventEmitter, mapEvent, filterEvent, anyEvent } from 'vs/base/common/event';
import { Event, fromNodeEventEmitter, mapEvent, filterEvent, anyEvent, latch } from 'vs/base/common/event';
import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
import { IWindowsMainService, ISharedProcess } from 'vs/platform/windows/electron-main/windows';
import { IHistoryMainService, IRecentlyOpened } from 'vs/platform/history/common/history';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { ICommandAction } from 'vs/platform/actions/common/actions';
import { IWorkspaceIdentifier, IWorkspaceFolderCreationData, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import { Schemas } from 'vs/base/common/network';
import { mnemonicButtonLabel } from 'vs/base/common/labels';
import { isWindows } from 'vs/base/common/platform';
import { isWindows, isMacintosh } from 'vs/base/common/platform';
import { ILogService } from 'vs/platform/log/common/log';
export class WindowsService implements IWindowsService, IURLHandler, IDisposable {
@@ -32,6 +32,8 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
private disposables: IDisposable[] = [];
private _activeWindowId: number | undefined;
readonly onWindowOpen: Event<number> = filterEvent(fromNodeEventEmitter(app, 'browser-window-created', (_, w: Electron.BrowserWindow) => w.id), id => !!this.windowsMainService.getWindowById(id));
readonly onWindowFocus: Event<number> = anyEvent(
mapEvent(filterEvent(mapEvent(this.windowsMainService.onWindowsCountChanged, () => this.windowsMainService.getLastActiveWindow()), w => !!w), w => w.id),
@@ -39,6 +41,10 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
);
readonly onWindowBlur: Event<number> = filterEvent(fromNodeEventEmitter(app, 'browser-window-blur', (_, w: Electron.BrowserWindow) => w.id), id => !!this.windowsMainService.getWindowById(id));
readonly onWindowMaximize: Event<number> = filterEvent(fromNodeEventEmitter(app, 'browser-window-maximize', (_, w: Electron.BrowserWindow) => w.id), id => !!this.windowsMainService.getWindowById(id));
readonly onWindowUnmaximize: Event<number> = filterEvent(fromNodeEventEmitter(app, 'browser-window-unmaximize', (_, w: Electron.BrowserWindow) => w.id), id => !!this.windowsMainService.getWindowById(id));
readonly onRecentlyOpenedChange: Event<void> = this.historyService.onRecentlyOpenedChange;
constructor(
private sharedProcess: ISharedProcess,
@@ -50,6 +56,10 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
@ILogService private logService: ILogService
) {
urlService.registerHandler(this);
// remember last active window id
latch(anyEvent(this.onWindowOpen, this.onWindowFocus))
(id => this._activeWindowId = id, null, this.disposables);
}
pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
@@ -112,12 +122,12 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
openDevTools(windowId: number): TPromise<void> {
openDevTools(windowId: number, options?: IDevToolsOptions): TPromise<void> {
this.logService.trace('windowsService#openDevTools', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
if (codeWindow) {
codeWindow.win.webContents.openDevTools();
codeWindow.win.webContents.openDevTools(options);
}
return TPromise.as(null);
@@ -129,7 +139,7 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
if (codeWindow) {
const contents = codeWindow.win.webContents;
if (codeWindow.hasHiddenTitleBarStyle() && !codeWindow.win.isFullScreen() && !contents.isDevToolsOpened()) {
if (isMacintosh && codeWindow.hasHiddenTitleBarStyle() && !codeWindow.win.isFullScreen() && !contents.isDevToolsOpened()) {
contents.openDevTools({ mode: 'undocked' }); // due to https://github.com/electron/electron/issues/3647
} else {
contents.toggleDevTools();
@@ -139,7 +149,7 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
updateTouchBar(windowId: number, items: ICommandAction[][]): TPromise<void> {
updateTouchBar(windowId: number, items: ISerializableCommandAction[][]): TPromise<void> {
this.logService.trace('windowsService#updateTouchBar', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
@@ -161,6 +171,17 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
enterWorkspace(windowId: number, path: string): TPromise<IEnterWorkspaceResult> {
this.logService.trace('windowsService#enterWorkspace', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
if (codeWindow) {
return this.windowsMainService.enterWorkspace(codeWindow, path);
}
return TPromise.as(null);
}
createAndEnterWorkspace(windowId: number, folders?: IWorkspaceFolderCreationData[], path?: string): TPromise<IEnterWorkspaceResult> {
this.logService.trace('windowsService#createAndEnterWorkspace', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
@@ -212,7 +233,7 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
removeFromRecentlyOpened(paths: string[]): TPromise<void> {
removeFromRecentlyOpened(paths: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | string)[]): TPromise<void> {
this.logService.trace('windowsService#removeFromRecentlyOpened');
this.historyService.removeFromRecentlyOpened(paths);
@@ -231,7 +252,7 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
const codeWindow = this.windowsMainService.getWindowById(windowId);
if (codeWindow) {
return TPromise.as(this.historyService.getRecentlyOpened(codeWindow.config.workspace || codeWindow.config.folderPath, codeWindow.config.filesToOpen));
return TPromise.as(this.historyService.getRecentlyOpened(codeWindow.config.workspace || codeWindow.config.folderUri, codeWindow.config.filesToOpen));
}
return TPromise.as(this.historyService.getRecentlyOpened());
@@ -338,6 +359,17 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
minimizeWindow(windowId: number): TPromise<void> {
this.logService.trace('windowsService#minimizeWindow', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
if (codeWindow) {
codeWindow.win.minimize();
}
return TPromise.as(null);
}
onWindowTitleDoubleClick(windowId: number): TPromise<void> {
this.logService.trace('windowsService#onWindowTitleDoubleClick', windowId);
const codeWindow = this.windowsMainService.getWindowById(windowId);
@@ -360,7 +392,7 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }): TPromise<void> {
openWindow(windowId: number, paths: URI[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean, args?: ParsedArgs }): TPromise<void> {
this.logService.trace('windowsService#openWindow');
if (!paths || !paths.length) {
return TPromise.as(null);
@@ -368,8 +400,9 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
this.windowsMainService.open({
context: OpenContext.API,
cli: this.environmentService.args,
pathsToOpen: paths,
contextWindowId: windowId,
urisToOpen: paths,
cli: options && options.args ? { ...this.environmentService.args, ...options.args } : this.environmentService.args,
forceNewWindow: options && options.forceNewWindow,
forceReuseWindow: options && options.forceReuseWindow,
forceOpenWorkspaceAsFile: options && options.forceOpenWorkspaceAsFile
@@ -395,10 +428,10 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]> {
getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderUri?: ISingleFolderWorkspaceIdentifier; title: string; filename?: string; }[]> {
this.logService.trace('windowsService#getWindows');
const windows = this.windowsMainService.getWindows();
const result = windows.map(w => ({ id: w.id, workspace: w.openedWorkspace, openedFolderPath: w.openedFolderPath, title: w.win.getTitle(), filename: w.getRepresentedFilename() }));
const result = windows.map(w => ({ id: w.id, workspace: w.openedWorkspace, folderUri: w.openedFolderUri, title: w.win.getTitle(), filename: w.getRepresentedFilename() }));
return TPromise.as(result);
}
@@ -419,6 +452,10 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
getActiveWindowId(): TPromise<number | undefined> {
return TPromise.as(this._activeWindowId);
}
openExternal(url: string): TPromise<boolean> {
this.logService.trace('windowsService#openExternal');
return TPromise.as(shell.openExternal(url));
@@ -460,13 +497,14 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
// {{SQL CARBON EDIT}}
const detail = nls.localize('aboutDetail',
"Version {0}\nCommit {1}\nDate {2}\nVS Code {7}\nShell {3}\nRenderer {4}\nNode {5}\nArchitecture {6}",
"Version {0}\nCommit {1}\nDate {2}\nVS Code {8}\nShell {3}\nRenderer {4}\nNode {5}\nV8: {6}\nArchitecture {7}",
app.getVersion(),
product.commit || 'Unknown',
product.date || 'Unknown',
process.versions['electron'],
process.versions['chrome'],
process.versions['node'],
process.versions['v8'],
process.arch,
product.vscodeVersion
);
@@ -492,21 +530,22 @@ export class WindowsService implements IWindowsService, IURLHandler, IDisposable
return TPromise.as(null);
}
async handleURL(uri: URI): TPromise<boolean> {
handleURL(uri: URI): TPromise<boolean> {
// Catch file URLs
if (uri.authority === Schemas.file && !!uri.path) {
return this.openFileForURI(URI.file(uri.fsPath));
this.openFileForURI(URI.file(uri.fsPath));
return TPromise.as(true);
}
return false;
return TPromise.wrap(false);
}
private async openFileForURI(uri: URI): TPromise<boolean> {
private openFileForURI(uri: URI): TPromise<boolean> {
const cli = assign(Object.create(null), this.environmentService.args, { goto: true });
const pathsToOpen = [uri.fsPath];
const urisToOpen = [uri];
this.windowsMainService.open({ context: OpenContext.API, cli, pathsToOpen });
return true;
this.windowsMainService.open({ context: OpenContext.API, cli, urisToOpen });
return TPromise.wrap(true);
}
dispose(): void {