Refresh master with initial release/0.24 snapshot (#332)

* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json

src/sql/parts/connection/connectionDialog/connectionDialogWidget.ts

@@ -4,7 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 import 'vs/css!./media/connectionDialog';
 
-import { attachModalDialogStyler } from 'sql/common/theme/styler';
+import nls = require('vs/nls');
+import { Button } from 'sql/base/browser/ui/button/button';
+import { attachModalDialogStyler, attachButtonStyler } from 'sql/common/theme/styler';
+import { TPromise } from 'vs/base/common/winjs.base';
 import { SelectBox } from 'sql/base/browser/ui/selectBox/selectBox';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import { Modal } from 'sql/base/browser/ui/modal/modal';
@@ -14,51 +17,37 @@ import { TreeCreationUtils } from 'sql/parts/registeredServer/viewlet/treeCreati
 import { TreeUpdateUtils } from 'sql/parts/registeredServer/viewlet/treeUpdateUtils';
 import { ConnectionProfile } from 'sql/parts/connection/common/connectionProfile';
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
-
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IWorkbenchThemeService, IColorTheme } from 'vs/workbench/services/themes/common/workbenchThemeService';
 import { contrastBorder } from 'vs/platform/theme/common/colorRegistry';
 import * as styler from 'vs/platform/theme/common/styler';
 import { IPartService } from 'vs/workbench/services/part/common/partService';
-import { ITree } from 'vs/base/parts/tree/browser/tree';
 import Event, { Emitter } from 'vs/base/common/event';
 import { Builder, $ } from 'vs/base/browser/builder';
-import { Button } from 'vs/base/browser/ui/button/button';
-import { DefaultController, ICancelableEvent } from 'vs/base/parts/tree/browser/treeDefaults';
-import { IKeyboardEvent, StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
+import { ICancelableEvent } from 'vs/base/parts/tree/browser/treeDefaults';
+import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import * as TelemetryKeys from 'sql/common/telemetryKeys';
 import { localize } from 'vs/nls';
 import * as DOM from 'vs/base/browser/dom';
+import { ITree } from 'vs/base/parts/tree/browser/tree';
+import { RecentConnectionTreeController, RecentConnectionActionsProvider } from 'sql/parts/connection/connectionDialog/recentConnectionTreeController';
+import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IMessageService, IConfirmation } from 'vs/platform/message/common/message';
 
 export interface OnShowUIResponse {
 	selectedProviderType: string;
 	container: HTMLElement;
 }
 
-class TreeController extends DefaultController {
-	constructor(private clickcb: (element: any, eventish: ICancelableEvent, origin: string) => void) {
-		super();
-	}
-
-	protected onLeftClick(tree: ITree, element: any, eventish: ICancelableEvent, origin: string = 'mouse'): boolean {
-		this.clickcb(element, eventish, origin);
-		return super.onLeftClick(tree, element, eventish, origin);
-	}
-
-	protected onEnter(tree: ITree, event: IKeyboardEvent): boolean {
-		super.onEnter(tree, event);
-		this.clickcb(tree.getSelection()[0], event, 'keyboard');
-		return true;
-	}
-}
-
 export class ConnectionDialogWidget extends Modal {
 	private _bodyBuilder: Builder;
 	private _recentConnectionBuilder: Builder;
+	private _noRecentConnectionBuilder: Builder;
 	private _dividerBuilder: Builder;
 	private _connectButton: Button;
 	private _closeButton: Button;
+	private _providerTypeSelectBox: SelectBox;
 	private _newConnectionParams: INewConnectionParams;
 	private _recentConnectionTree: ITree;
 	private $connectionUIContainer: Builder;
@@ -89,16 +78,20 @@ export class ConnectionDialogWidget extends Modal {
 		@IWorkbenchThemeService private _themeService: IWorkbenchThemeService,
 		@IPartService _partService: IPartService,
 		@ITelemetryService telemetryService: ITelemetryService,
-		@IContextKeyService contextKeyService: IContextKeyService
+		@IContextKeyService contextKeyService: IContextKeyService,
+		@IContextMenuService private _contextMenuService: IContextMenuService,
+		@IMessageService private _messageService: IMessageService
 	) {
 		super(localize('connection', 'Connection'), TelemetryKeys.Connection, _partService, telemetryService, contextKeyService, { hasSpinner: true, hasErrors: true });
 	}
 
 	protected renderBody(container: HTMLElement): void {
 		this._bodyBuilder = new Builder(container);
+		this._providerTypeSelectBox = new SelectBox(this.providerTypeOptions, this.selectedProviderType);
 
 		this._bodyBuilder.div({ class: 'connection-recent', id: 'recentConnection' }, (builder) => {
 			this._recentConnectionBuilder = new Builder(builder.getHTMLElement());
+			this._noRecentConnectionBuilder = new Builder(builder.getHTMLElement());
 			this.createRecentConnections();
 			this._recentConnectionBuilder.hide();
 		});
@@ -108,16 +101,10 @@ export class ConnectionDialogWidget extends Modal {
 		});
 
 		this._bodyBuilder.div({ class: 'connection-type' }, (modelTableContent) => {
-			// add SQL Server label to Connection Dialog until we support multiple connection providers
-			let sqlServerName = localize('microsoftSqlServer', "Microsoft SQL Server");
-			modelTableContent.div({ class: 'server-name-label' }, (nameLabel) => {
-				nameLabel.innerHtml(sqlServerName);
-			});
-
-			//let connectTypeLabel = localize('connectType', 'Connection type');
+			let connectTypeLabel = localize('connectType', 'Connection type');
 			modelTableContent.element('table', { class: 'connection-table-content' }, (tableContainer) => {
-				// DialogHelper.appendInputSelectBox(
-				// 	DialogHelper.appendRow(tableContainer, connectTypeLabel, 'connection-label', 'connection-input'), this._providerTypeSelectBox);
+				DialogHelper.appendInputSelectBox(
+					DialogHelper.appendRow(tableContainer, connectTypeLabel, 'connection-label', 'connection-input'), this._providerTypeSelectBox);
 			});
 		});
 
@@ -141,7 +128,7 @@ export class ConnectionDialogWidget extends Modal {
 		this._connectButton.enabled = false;
 		this._closeButton = this.addFooterButton(cancelLabel, () => this.cancel());
 		this.registerListeners();
-		this.onProviderTypeSelected('MSSQL');
+		this.onProviderTypeSelected(this._providerTypeSelectBox.value);
 	}
 
 	// Update theming that is specific to connection flyout body
@@ -156,9 +143,14 @@ export class ConnectionDialogWidget extends Modal {
 	}
 
 	private registerListeners(): void {
-		this._register(styler.attachButtonStyler(this._connectButton, this._themeService));
-		this._register(styler.attachButtonStyler(this._closeButton, this._themeService));
+		// Theme styler
+		this._register(styler.attachSelectBoxStyler(this._providerTypeSelectBox, this._themeService));
+		this._register(attachButtonStyler(this._connectButton, this._themeService));
+		this._register(attachButtonStyler(this._closeButton, this._themeService));
 
+		this._register(this._providerTypeSelectBox.onDidSelect(selectedProviderType => {
+			this.onProviderTypeSelected(selectedProviderType.selected);
+		}));
 	}
 
 	private onProviderTypeSelected(selectedProviderType: string) {
@@ -171,6 +163,7 @@ export class ConnectionDialogWidget extends Modal {
 	private connect(element?: IConnectionProfile): void {
 		if (this._connectButton.enabled) {
 			this._connectButton.enabled = false;
+			this._providerTypeSelectBox.disable();
 			this.showSpinner();
 			this._onConnect.fire(element);
 		}
@@ -198,13 +191,37 @@ export class ConnectionDialogWidget extends Modal {
 		this.hide();
 	}
 
-	private createRecentConnections() {
+	private clearRecentConnectionList(): TPromise<boolean> {
+
+		let confirm: IConfirmation = {
+			message: nls.localize('clearRecentConnectionMessage', 'Are you sure you want to delete all the connections from the list?'),
+			primaryButton: localize('yes', 'Yes'),
+			secondaryButton: localize('no', 'No'),
+			type: 'question'
+		};
+
+		return this._messageService.confirm(confirm).then(confirmation => {
+			if (!confirmation.confirmed) {
+				return TPromise.as(false);
+			} else {
+				this._connectionManagementService.clearRecentConnectionsList();
+				this.open(false);
+				return TPromise.as(true);
+			}
+		});
+	}
+
+	private createRecentConnectionList(): void {
 		this._recentConnectionBuilder.div({ class: 'connection-recent-content' }, (recentConnectionContainer) => {
 			let recentHistoryLabel = localize('recentHistory', 'Recent history');
-			recentConnectionContainer.div({ class: 'connection-history-label' }, (recentTitle) => {
-				recentTitle.innerHtml(recentHistoryLabel);
+			recentConnectionContainer.div({ class: 'recent-titles-container'}, (container) => {
+				container.div({ class: 'connection-history-label' }, (recentTitle) => {
+					recentTitle.innerHtml(recentHistoryLabel);
+				});
+				container.div({ class: 'search-action clear-search-results'}, (clearSearchIcon) => {
+					clearSearchIcon.on('click', () => this.clearRecentConnectionList());
+				});
 			});
-
 			recentConnectionContainer.div({ class: 'server-explorer-viewlet' }, (divContainer: Builder) => {
 				divContainer.div({ class: 'explorer-servers' }, (treeContainer: Builder) => {
 					let leftClick = (element: any, eventish: ICancelableEvent, origin: string) => {
@@ -212,9 +229,16 @@ export class ConnectionDialogWidget extends Modal {
 						if (element instanceof ConnectionProfile) {
 							this.onRecentConnectionClick({ payload: { origin: origin, originalEvent: eventish } }, element);
 						}
-
 					};
-					let controller = new TreeController(leftClick);
+					let actionProvider = this._instantiationService.createInstance(RecentConnectionActionsProvider, this._instantiationService, this._connectionManagementService,
+						this._messageService);
+					let controller = new RecentConnectionTreeController(leftClick, actionProvider, this._connectionManagementService, this._contextMenuService);
+					actionProvider.onRecentConnectionRemoved(() => {
+						this.open(this._connectionManagementService.getRecentConnections().length > 0);
+					});
+					controller.onRecentConnectionRemoved(() => {
+						this.open(this._connectionManagementService.getRecentConnections().length > 0);
+					})
 					this._recentConnectionTree = TreeCreationUtils.createConnectionTree(treeContainer.getHTMLElement(), this._instantiationService, controller);
 
 					// Theme styler
@@ -225,6 +249,20 @@ export class ConnectionDialogWidget extends Modal {
 		});
 	}
 
+	private createRecentConnections() {
+		this.createRecentConnectionList();
+		this._noRecentConnectionBuilder.div({ class: 'connection-recent-content' }, (noRecentConnectionContainer) => {
+			let recentHistoryLabel = localize('recentHistory', 'Recent history');
+			noRecentConnectionContainer.div({ class: 'connection-history-label' }, (recentTitle) => {
+				recentTitle.innerHtml(recentHistoryLabel);
+			});
+			let noRecentHistoryLabel = localize('noRecentConnections', 'No Recent Connections');
+			noRecentConnectionContainer.div({ class: 'no-recent-connections' }, (noRecentTitle) => {
+				noRecentTitle.innerHtml(noRecentHistoryLabel);
+			});
+		});
+	}
+
 	private onRecentConnectionClick(event: any, element: IConnectionProfile) {
 		let isMouseOrigin = event.payload && (event.payload.origin === 'mouse');
 		let isDoubleClick = isMouseOrigin && event.payload.originalEvent && event.payload.originalEvent.detail === 2;
@@ -244,14 +282,15 @@ export class ConnectionDialogWidget extends Modal {
 	public open(recentConnections: boolean) {
 		this.show();
 		if (recentConnections) {
+			this._noRecentConnectionBuilder.hide();
 			this._recentConnectionBuilder.show();
-			TreeUpdateUtils.structuralTreeUpdate(this._recentConnectionTree, 'recent', this._connectionManagementService);
-			// call layout with view height
-			this.layout();
 		} else {
 			this._recentConnectionBuilder.hide();
+			this._noRecentConnectionBuilder.show();
 		}
-
+		TreeUpdateUtils.structuralTreeUpdate(this._recentConnectionTree, 'recent', this._connectionManagementService);
+		// call layout with view height
+		this.layout();
 		this.initDialog();
 	}
 
@@ -284,6 +323,7 @@ export class ConnectionDialogWidget extends Modal {
 	public resetConnection(): void {
 		this.hideSpinner();
 		this._connectButton.enabled = true;
+		this._providerTypeSelectBox.enable();
 		this._onResetConnection.fire();
 	}
 
@@ -296,6 +336,7 @@ export class ConnectionDialogWidget extends Modal {
 	}
 
 	public updateProvider(displayName: string) {
-		this.onProviderTypeSelected('MSSQL');
+		this._providerTypeSelectBox.selectWithOptionName(displayName);
+		this.onProviderTypeSelected(displayName);
 	}
 }