Merge branch 'listcontextmenu'

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

@@ -353,14 +353,24 @@ function isSelectionChangeEvent(event: IListMouseEvent<any> | IListTouchEvent<an
 class MouseController<T> implements IDisposable {
 
 	private multipleSelectionSupport: boolean;
+	private didJustPressContextMenuKey: boolean = false;
 	private disposables: IDisposable[] = [];
 
 	@memoize get onContextMenu(): Event<IListContextMenuEvent<T>> {
-		const fromKeyboard = chain(domEvent(this.view.domNode, 'keydown'))
+		const fromKeydown = chain(domEvent(this.view.domNode, 'keydown'))
 			.map(e => new StandardKeyboardEvent(e))
-			.filter(e => this.list.getFocus().length > 0)
-			.filter(e => e.keyCode === KeyCode.ContextMenu || (e.shiftKey && e.keyCode === KeyCode.F10))
-			.map(e => {
+			.filter(e => this.didJustPressContextMenuKey = e.keyCode === KeyCode.ContextMenu || (e.shiftKey && e.keyCode === KeyCode.F10))
+			.filter(e => { e.preventDefault(); e.stopPropagation(); return false; })
+			.event as Event<any>;
+
+		const fromKeyup = chain(domEvent(this.view.domNode, 'keyup'))
+			.filter(() => {
+				const didJustPressContextMenuKey = this.didJustPressContextMenuKey;
+				this.didJustPressContextMenuKey = false;
+				return didJustPressContextMenuKey;
+			})
+			.filter(() => this.list.getFocus().length > 0)
+			.map(() => {
 				const index = this.list.getFocus()[0];
 				const element = this.view.element(index);
 				const anchor = this.view.domElement(index);
@@ -370,10 +380,11 @@ class MouseController<T> implements IDisposable {
 			.event;
 
 		const fromMouse = chain(this.view.onContextMenu)
+			.filter(() => !this.didJustPressContextMenuKey)
 			.map(({ element, index, browserEvent }) => ({ element, index, anchor: { x: browserEvent.clientX + 1, y: browserEvent.clientY } }))
 			.event;
 
-		return anyEvent<IListContextMenuEvent<T>>(fromKeyboard, fromMouse);
+		return anyEvent<IListContextMenuEvent<T>>(fromKeydown, fromKeyup, fromMouse);
 	}
 
 	constructor(
@@ -655,10 +666,7 @@ export class List<T> implements ISpliceable<T>, IDisposable {
 		return mapEvent(this.eventBufferer.wrapEvent(this.selection.onChange), e => this.toListEvent(e));
 	}
 
-	private _onContextMenu: Event<IListContextMenuEvent<T>> = Event.None;
-	get onContextMenu(): Event<IListContextMenuEvent<T>> {
-		return this._onContextMenu;
-	}
+	readonly onContextMenu: Event<IListContextMenuEvent<T>> = Event.None;
 
 	private _onOpen = new Emitter<number[]>();
 	@memoize get onOpen(): Event<IListEvent<T>> {
@@ -731,7 +739,7 @@ export class List<T> implements ISpliceable<T>, IDisposable {
 		if (typeof options.mouseSupport !== 'boolean' || options.mouseSupport) {
 			const controller = new MouseController(this, this.view, options);
 			this.disposables.push(controller);
-			this._onContextMenu = controller.onContextMenu;
+			this.onContextMenu = controller.onContextMenu;
 		}
 
 		this.onFocusChange(this._onFocusChange, this, this.disposables);

src/vs/base/common/event.ts

@@ -365,6 +365,7 @@ export class EventBufferer {
 export interface IChainableEvent<T> {
 	event: Event<T>;
 	map<O>(fn: (i: T) => O): IChainableEvent<O>;
+	forEach(fn: (i: T) => void): IChainableEvent<T>;
 	filter(fn: (e: T) => boolean): IChainableEvent<T>;
 	on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
 }
@@ -373,6 +374,10 @@ export function mapEvent<I, O>(event: Event<I>, map: (i: I) => O): Event<O> {
 	return (listener, thisArgs = null, disposables?) => event(i => listener.call(thisArgs, map(i)), null, disposables);
 }
 
+export function forEach<I>(event: Event<I>, each: (i: I) => void): Event<I> {
+	return (listener, thisArgs = null, disposables?) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables);
+}
+
 export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {
 	return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
 }
@@ -387,6 +392,10 @@ class ChainableEvent<T> implements IChainableEvent<T> {
 		return new ChainableEvent(mapEvent(this._event, fn));
 	}
 
+	forEach(fn: (i: T) => void): IChainableEvent<T> {
+		return new ChainableEvent(forEach(this._event, fn));
+	}
+
 	filter(fn: (e: T) => boolean): IChainableEvent<T> {
 		return new ChainableEvent(filterEvent(this._event, fn));
 	}