Merge from vscode 61d5f2b82f17bf9f99f56405204caab88a7e8747

src/vs/base/browser/ui/codiconLabel/codicon/codicon.css

@@ -5,7 +5,7 @@
 
 @font-face {
 	font-family: "codicon";
-	src: url("./codicon.ttf?5490083fcec741c6a0a08a366d2f9c98") format("truetype");
+	src: url("./codicon.ttf?fb4c14f317e1decb0289895ecc9356f0") format("truetype");
 }
 
 .codicon[class*='codicon-'] {
@@ -416,7 +416,8 @@
 .codicon-feedback:before { content: "\eb96" }
 .codicon-group-by-ref-type:before { content: "\eb97" }
 .codicon-ungroup-by-ref-type:before { content: "\eb98" }
-.codicon-bell-dot:before { content: "\f101" }
-.codicon-debug-alt-2:before { content: "\f102" }
-.codicon-debug-alt:before { content: "\f103" }
-.codicon-run-all:before { content: "\f104" }
+.codicon-account:before { content: "\f101" }
+.codicon-bell-dot:before { content: "\f102" }
+.codicon-debug-alt-2:before { content: "\f103" }
+.codicon-debug-alt:before { content: "\f104" }
+.codicon-run-all:before { content: "\f105" }

src/vs/base/browser/ui/list/listView.ts

@@ -279,18 +279,32 @@ export class ListView<T> implements ISpliceable<T>, IDisposable {
 		this.scrollableElement.triggerScrollFromMouseWheelEvent(browserEvent);
 	}
 
-	updateElementHeight(index: number, size: number): void {
+	updateElementHeight(index: number, size: number, anchorIndex: number | null): void {
 		if (this.items[index].size === size) {
 			return;
 		}
 
 		const lastRenderRange = this.getRenderRange(this.lastRenderTop, this.lastRenderHeight);
 
-		const heightDiff = index < lastRenderRange.start ? size - this.items[index].size : 0;
+		let heightDiff = 0;
+
+		if (index < lastRenderRange.start) {
+			// do not scroll the viewport if resized element is out of viewport
+			heightDiff = size - this.items[index].size;
+		} else {
+			if (anchorIndex !== null && anchorIndex > index && anchorIndex <= lastRenderRange.end) {
+				// anchor in viewport
+				// resized elemnet in viewport and above the anchor
+				heightDiff = size - this.items[index].size;
+			} else {
+				heightDiff = 0;
+			}
+		}
+
 		this.rangeMap.splice(index, 1, [{ size: size }]);
 		this.items[index].size = size;
 
-		this.render(lastRenderRange, this.lastRenderTop + heightDiff, this.lastRenderHeight, undefined, undefined, true);
+		this.render(lastRenderRange, Math.max(0, this.lastRenderTop + heightDiff), this.lastRenderHeight, undefined, undefined, true);
 
 		this.eventuallyUpdateScrollDimensions();
 
@@ -1134,6 +1148,10 @@ export class ListView<T> implements ISpliceable<T>, IDisposable {
 			return 0;
 		}
 
+		if (!!this.virtualDelegate.hasDynamicHeight && !this.virtualDelegate.hasDynamicHeight(item.element)) {
+			return 0;
+		}
+
 		const size = item.size;
 
 		if (!this.setRowHeight && item.row && item.row.domNode) {

src/vs/base/browser/ui/list/listWidget.ts

@@ -1314,7 +1314,7 @@ export class List<T> implements ISpliceable<T>, IDisposable {
 	}
 
 	updateElementHeight(index: number, size: number): void {
-		this.view.updateElementHeight(index, size);
+		this.view.updateElementHeight(index, size, null);
 	}
 
 	rerender(): void {

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

@@ -99,3 +99,26 @@
 .monaco-pane-view.animated.horizontal .split-view-view {
 	transition-property: width;
 }
+
+#monaco-workbench-pane-drop-overlay {
+	position: absolute;
+	z-index: 10000;
+	width: 100%;
+	height: 100%;
+	left: 0;
+	box-sizing: border-box;
+}
+
+#monaco-workbench-pane-drop-overlay > .pane-overlay-indicator {
+	position: absolute;
+	width: 100%;
+	height: 100%;
+	min-height: 22px;
+
+	pointer-events: none; /* very important to not take events away from the parent */
+	transition: opacity 150ms ease-out;
+}
+
+#monaco-workbench-pane-drop-overlay > .pane-overlay-indicator.overlay-move-transition {
+	transition: top 70ms ease-out, left 70ms ease-out, width 70ms ease-out, height 70ms ease-out, opacity 150ms ease-out;
+}

src/vs/base/common/collections.ts

@@ -20,7 +20,7 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 /**
  * Returns an array which contains all values that reside
- * in the given set.
+ * in the given dictionary.
  */
 export function values<T>(from: IStringDictionary<T> | INumberDictionary<T>): T[] {
 	const result: T[] = [];
@@ -52,7 +52,7 @@ export function first<T>(from: IStringDictionary<T> | INumberDictionary<T>): T |
 }
 
 /**
- * Iterates over each entry in the provided set. The iterator allows
+ * Iterates over each entry in the provided dictionary. The iterator allows
  * to remove elements and will stop when the callback returns {{false}}.
  */
 export function forEach<T>(from: IStringDictionary<T>, callback: (entry: { key: string; value: T; }, remove: () => void) => any): void; // {{SQL CARBON EDIT}} @anthonydresser add hard typings

src/vs/base/common/iterator.ts

@@ -49,7 +49,15 @@ export namespace Iterable {
 		return false;
 	}
 
-	export function* map<T, R>(iterable: Iterable<T>, fn: (t: T) => R): IterableIterator<R> {
+	export function* filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T> {
+		for (const element of iterable) {
+			if (predicate(element)) {
+				return yield element;
+			}
+		}
+	}
+
+	export function* map<T, R>(iterable: Iterable<T>, fn: (t: T) => R): Iterable<R> {
 		for (const element of iterable) {
 			return yield fn(element);
 		}

src/vs/base/parts/composite/browser/compositeDnd.ts

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IDragAndDropData } from 'vs/base/browser/dnd';
-
-export class CompositeDragAndDropData implements IDragAndDropData {
-	constructor(private type: 'view' | 'composite', private id: string) { }
-	update(dataTransfer: DataTransfer): void {
-		// no-op
-	}
-	getData(): {
-		type: 'view' | 'composite';
-		id: string;
-	} {
-		return { type: this.type, id: this.id };
-	}
-}
-
-export interface ICompositeDragAndDrop {
-	drop(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): void;
-	onDragOver(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
-	onDragEnter(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
-}

src/vs/base/parts/quickinput/browser/media/quickInput.css

@@ -220,11 +220,20 @@
 
 .quick-input-list .quick-input-list-entry-action-bar {
 	display: flex;
-	visibility: hidden; /* not using display: none here to not flicker too much */
 	flex: 0;
 	overflow: visible;
 }
 
+.quick-input-list .quick-input-list-entry-action-bar .action-label {
+	/*
+	 * By default, actions in the quick input action bar are hidden
+	 * until hovered over them or selected. We do not use display:none
+	 * so that the amount of visual flickering is little by reserving the
+	 * space the button needs still.
+	 */
+	visibility: hidden;
+}
+
 .quick-input-list .quick-input-list-entry-action-bar .action-label.codicon {
 	margin: 0;
 	width: 19px;
@@ -244,8 +253,8 @@
 	margin-right: 4px; /* separate actions */
 }
 
-.quick-input-list .quick-input-list-entry.always-visible-actions .quick-input-list-entry-action-bar,
-.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar,
-.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar {
+.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible,
+.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label,
+.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label {
 	visibility: visible;
 }

src/vs/base/parts/quickinput/browser/quickInputList.ts

@@ -181,7 +181,11 @@ class ListElementRenderer implements IListRenderer<ListElement, IListElementTemp
 		const buttons = element.item.buttons;
 		if (buttons && buttons.length) {
 			data.actionBar.push(buttons.map((button, index) => {
-				const action = new Action(`id-${index}`, '', button.iconClass || (button.iconPath ? getIconClass(button.iconPath) : undefined), true, () => {
+				let cssClasses = button.iconClass || (button.iconPath ? getIconClass(button.iconPath) : undefined);
+				if (button.alwaysVisible) {
+					cssClasses = cssClasses ? `${cssClasses} always-visible` : 'always-visible';
+				}
+				const action = new Action(`id-${index}`, '', cssClasses, true, () => {
 					element.fireButtonTriggered({
 						button,
 						item: element.item
@@ -195,12 +199,6 @@ class ListElementRenderer implements IListRenderer<ListElement, IListElementTemp
 		} else {
 			dom.removeClass(data.entry, 'has-actions');
 		}
-
-		if (element.item.buttonsAlwaysVisible) {
-			dom.addClass(data.entry, 'always-visible-actions');
-		} else {
-			dom.removeClass(data.entry, 'always-visible-actions');
-		}
 	}
 
 	disposeElement(element: ListElement, index: number, data: IListElementTemplateData): void {

src/vs/base/parts/quickinput/common/quickInput.ts

@@ -35,11 +35,6 @@ export interface IQuickPickItem {
 	strikethrough?: boolean;
 	highlights?: IQuickPickItemHighlights;
 	buttons?: IQuickInputButton[];
-	/**
-	 * Wether to always show the buttons. By default buttons
-	 * are only visible when hovering over them with the mouse
-	 */
-	buttonsAlwaysVisible?: boolean;
 	picked?: boolean;
 	alwaysShow?: boolean;
 }
@@ -290,6 +285,11 @@ export interface IQuickInputButton {
 	/** iconPath or iconClass required */
 	iconClass?: string;
 	tooltip?: string;
+	/**
+	 * Wether to always show the button. By default buttons
+	 * are only visible when hovering over them with the mouse
+	 */
+	alwaysVisible?: boolean;
 }
 
 export interface IQuickPickItemButtonEvent<T extends IQuickPickItem> {
@@ -308,22 +308,35 @@ export type QuickPickInput<T = IQuickPickItem> = T | IQuickPickSeparator;
 
 export type IQuickPickItemWithResource = IQuickPickItem & { resource: URI | undefined };
 
-export const quickPickItemScorerAccessor = new class implements IItemAccessor<IQuickPickItemWithResource> {
+export class QuickPickItemScorerAccessor implements IItemAccessor<IQuickPickItemWithResource> {
+
+	constructor(private options?: { skipDescription?: boolean, skipPath?: boolean }) { }
+
 	getItemLabel(entry: IQuickPickItemWithResource): string {
 		return entry.label;
 	}
 
 	getItemDescription(entry: IQuickPickItemWithResource): string | undefined {
+		if (this.options?.skipDescription) {
+			return undefined;
+		}
+
 		return entry.description;
 	}
 
 	getItemPath(entry: IQuickPickItemWithResource): string | undefined {
+		if (this.options?.skipPath) {
+			return undefined;
+		}
+
 		if (entry.resource?.scheme === Schemas.file) {
 			return entry.resource.fsPath;
 		}
 
 		return entry.resource?.path;
 	}
-};
+}
+
+export const quickPickItemScorerAccessor = new QuickPickItemScorerAccessor();
 
 //#endregion