Merge VS Code 1.21 source code (#1067)

* Initial VS Code 1.21 file copy with patches

* A few more merges

* Post npm install

* Fix batch of build breaks

* Fix more build breaks

* Fix more build errors

* Fix more build breaks

* Runtime fixes 1

* Get connection dialog working with some todos

* Fix a few packaging issues

* Copy several node_modules to package build to fix loader issues

* Fix breaks from master

* A few more fixes

* Make tests pass

* First pass of license header updates

* Second pass of license header updates

* Fix restore dialog issues

* Remove add additional themes menu items

* fix select box issues where the list doesn't show up

* formatting

* Fix editor dispose issue

* Copy over node modules to correct location on all platforms

src/vs/base/browser/ui/splitview/grid.ts

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import Event, { anyEvent } from 'vs/base/common/event';
+import { Orientation } from 'vs/base/browser/ui/sash/sash';
+import { append, $ } from 'vs/base/browser/dom';
+import { SplitView, IView } from 'vs/base/browser/ui/splitview/splitview';
+export { Orientation } from 'vs/base/browser/ui/sash/sash';
+
+export class GridNode implements IView {
+
+	get minimumSize(): number {
+		let result = 0;
+
+		for (const child of this.children) {
+			for (const grandchild of child.children) {
+				result += grandchild.minimumSize;
+			}
+		}
+
+		return result === 0 ? 50 : result;
+	}
+
+	readonly maximumSize = Number.MAX_VALUE;
+
+	private _onDidChange: Event<number | undefined> = Event.None;
+	get onDidChange(): Event<number | undefined> {
+		return this._onDidChange;
+	}
+
+	protected orientation: Orientation | undefined;
+	protected size: number | undefined;
+	protected orthogonalSize: number | undefined;
+	private splitview: SplitView | undefined;
+	private children: GridNode[] = [];
+	private color: string | undefined;
+
+	constructor(private parent?: GridNode, orthogonalSize?: number, color?: string) {
+		this.orthogonalSize = orthogonalSize;
+		this.color = color || `hsl(${Math.round(Math.random() * 360)}, 72%, 72%)`;
+	}
+
+	render(container: HTMLElement): void {
+		container = append(container, $('.node'));
+		container.style.backgroundColor = this.color;
+
+		append(container, $('.action', { onclick: () => this.split(container, Orientation.HORIZONTAL) }, '⬌'));
+		append(container, $('.action', { onclick: () => this.split(container, Orientation.VERTICAL) }, '⬍'));
+	}
+
+	protected split(container: HTMLElement, orientation: Orientation): void {
+		if (this.parent && this.parent.orientation === orientation) {
+			const index = this.parent.children.indexOf(this);
+			this.parent.addChild(this.size / 2, this.orthogonalSize, index + 1);
+		} else {
+			this.branch(container, orientation);
+		}
+	}
+
+	protected branch(container: HTMLElement, orientation: Orientation): void {
+		this.orientation = orientation;
+		container.innerHTML = '';
+
+		this.splitview = new SplitView(container, { orientation });
+		this.layout(this.size);
+		this.orthogonalLayout(this.orthogonalSize);
+
+		this.addChild(this.orthogonalSize / 2, this.size, 0, this.color);
+		this.addChild(this.orthogonalSize / 2, this.size);
+	}
+
+	layout(size: number): void {
+		this.size = size;
+
+		for (const child of this.children) {
+			child.orthogonalLayout(size);
+		}
+	}
+
+	orthogonalLayout(size: number): void {
+		this.orthogonalSize = size;
+
+		if (this.splitview) {
+			this.splitview.layout(size);
+		}
+	}
+
+	private addChild(size: number, orthogonalSize: number, index?: number, color?: string): void {
+		const child = new GridNode(this, orthogonalSize, color);
+		this.splitview.addView(child, size, index);
+
+		if (typeof index === 'number') {
+			this.children.splice(index, 0, child);
+		} else {
+			this.children.push(child);
+		}
+
+		this._onDidChange = anyEvent(...this.children.map(c => c.onDidChange));
+	}
+}
+
+export class RootGridNode extends GridNode {
+
+	private width: number;
+	private height: number;
+
+	protected branch(container: HTMLElement, orientation: Orientation): void {
+		if (orientation === Orientation.VERTICAL) {
+			this.size = this.width;
+			this.orthogonalSize = this.height;
+		} else {
+			this.size = this.height;
+			this.orthogonalSize = this.width;
+		}
+
+		super.branch(container, orientation);
+	}
+
+	layoutBox(width: number, height: number): void {
+		if (this.orientation === Orientation.VERTICAL) {
+			this.layout(width);
+			this.orthogonalLayout(height);
+		} else if (this.orientation === Orientation.HORIZONTAL) {
+			this.layout(height);
+			this.orthogonalLayout(width);
+		} else {
+			this.width = width;
+			this.height = height;
+		}
+	}
+}
+
+export class Grid {
+
+	private root: RootGridNode;
+
+	constructor(container: HTMLElement) {
+		this.root = new RootGridNode();
+		this.root.render(container);
+	}
+
+	layout(width: number, height: number): void {
+		this.root.layoutBox(width, height);
+	}
+}

src/vs/base/browser/ui/splitview/panelview.css

@@ -54,6 +54,7 @@
 
 /* TODO: actions should be part of the panel, but they aren't yet */
 .monaco-panel-view .panel:hover > .panel-header.expanded > .actions,
+.monaco-panel-view .panel > .panel-header.actions-always-visible.expanded > .actions,
 .monaco-panel-view .panel > .panel-header.focused.expanded > .actions {
 	display: initial;
 }

src/vs/base/browser/ui/splitview/panelview.ts

@@ -49,6 +49,10 @@ export abstract class Panel implements IView {
 	private _onDidChange = new Emitter<number | undefined>();
 	readonly onDidChange: Event<number | undefined> = this._onDidChange.event;
 
+	get element(): HTMLElement {
+		return this.el;
+	}
+
 	get draggableElement(): HTMLElement {
 		return this.header;
 	}

src/vs/base/browser/ui/splitview/splitview.css

@@ -20,4 +20,5 @@
 
 .monaco-split-view2.horizontal > .split-view-view {
 	height: 100%;
+	display: inline-block;
 }

src/vs/base/browser/ui/splitview/splitview.ts

@@ -91,10 +91,13 @@ export class SplitView implements IDisposable {
 
 	private _onDidSashChange = new Emitter<void>();
 	readonly onDidSashChange = this._onDidSashChange.event;
+	private _onDidSashReset = new Emitter<void>();
+	readonly onDidSashReset = this._onDidSashReset.event;
 
 	get length(): number {
 		return this.viewItems.length;
 	}
+
 	constructor(container: HTMLElement, options: ISplitViewOptions = {}) {
 		this.orientation = types.isUndefined(options.orientation) ? Orientation.VERTICAL : options.orientation;
 
@@ -152,15 +155,17 @@ export class SplitView implements IDisposable {
 			const onSashChangeDisposable = onChange(this.onSashChange, this);
 			const onEnd = mapEvent<void, void>(sash.onDidEnd, () => null);
 			const onEndDisposable = onEnd(() => this._onDidSashChange.fire());
+			const onDidReset = mapEvent<void, void>(sash.onDidReset, () => null);
+			const onDidResetDisposable = onDidReset(() => this._onDidSashReset.fire());
 
-			const disposable = combinedDisposable([onStartDisposable, onSashChangeDisposable, onEndDisposable, sash]);
+			const disposable = combinedDisposable([onStartDisposable, onSashChangeDisposable, onEndDisposable, onDidResetDisposable, sash]);
 			const sashItem: ISashItem = { sash, disposable };
 
 			this.sashItems.splice(index - 1, 0, sashItem);
 		}
 
 		view.render(container, this.orientation);
-		this.relayout();
+		this.relayout(index);
 		this.state = State.Idle;
 	}