Enable taskbar buttons and basic query execution (#275)

- Enable basic query execution by adding live connection handling to taskbar buttons
- Remove database dropdown list 
- Add IConnectableEditor, IConnectableEditorParams, and  INewConnectionParams
- Add back IShowQueryResultsEditor

src/sql/parts/connection/common/connectionManagement.ts

@@ -13,7 +13,6 @@ import { ConnectionProfile } from 'sql/parts/connection/node/connectionProfile';
 import { IConnectionProfile } from 'sql/parts/connection/node/interfaces';
 import Severity from 'vs/base/common/severity';
 
-
 export const VIEWLET_ID = 'workbench.view.connections';
 
 export interface IConnectionsViewlet extends IViewlet {
@@ -31,7 +30,7 @@ export interface IConnectionManagementService {
 	onAddConnectionProfile: Event<void>;
 	onDeleteConnectionProfile: Event<void>;
 
-	newConnection(): void;
+	newConnection(params?: INewConnectionParams): void;
 
 	addConnectionProfile(connection: IConnectionProfile): Promise<boolean>;
 
@@ -51,9 +50,11 @@ export interface IConnectionManagementService {
 
 	getAdvancedProperties(): data.ConnectionOption[];
 
-	connectEditor(uri: string, connection: ConnectionProfile): Promise<boolean>;
+	connectEditor(editor: IConnectableEditor, uri: string, runQueryOnCompletion: boolean, connection: ConnectionProfile | IConnectionProfile): Promise<boolean>;
+
+	isConnected(fileUri: string): boolean;
 
-	disconnectEditor(fileUri: string, force?: boolean): Promise<boolean>;
+	disconnectEditor(editor: IConnectableEditor, uri: string, force?: boolean): Promise<boolean>;
 
 	/**
 	 * Register a connection provider
@@ -64,7 +65,7 @@ export interface IConnectionManagementService {
 export const IConnectionDialogService = createDecorator<IConnectionDialogService>('connectionDialogService');
 export interface IConnectionDialogService {
 	_serviceBrand: any;
-	showDialog(connectionManagementService: IConnectionManagementService): TPromise<void>;
+	showDialog(connectionManagementService: IConnectionManagementService, params: INewConnectionParams): TPromise<void>;
 }
 
 export const IErrorMessageService = createDecorator<IErrorMessageService>('errorMessageService');
@@ -90,6 +91,31 @@ export enum ConnectionOptionSpecialType {
 	password = 4
 }
 
+export interface INewConnectionParams {
+	connectionType: ConnectionType;
+	editor?: IConnectableEditor;
+	uri?: string;
+	runQueryOnCompletion?: boolean;
+}
+
+export interface IConnectableEditorParams {
+	uri: string;
+	editor: IConnectableEditor;
+}
+
+export interface IConnectableEditor {
+	uri: string;
+	onConnectStart(): void;
+	onConnectReject(): void;
+	onConnectSuccess(runQueryOnCompletion: boolean): void;
+	onDisconnect(): void;
+}
+
+export enum ConnectionType {
+	default = 0,
+	queryEditor = 1
+}
+
 export enum MetadataType
 {
 	Table = 0,

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

@@ -5,7 +5,8 @@
 
 'use strict';
 
-import { IConnectionDialogService, IConnectionManagementService, IErrorMessageService } from 'sql/parts/connection/common/connectionManagement';
+import { IConnectionDialogService, IConnectionManagementService, IErrorMessageService,
+	ConnectionType, INewConnectionParams } from 'sql/parts/connection/common/connectionManagement';
 import { IPartService } from 'vs/workbench/services/part/common/partService';
 import { ConnectionDialogWidget } from 'sql/parts/connection/connectionDialog/connectionDialogWidget';
 import { AdvancedPropertiesController } from 'sql/parts/connection/connectionDialog/advancedPropertiesController';
@@ -33,7 +34,21 @@ export class ConnectionDialogService implements IConnectionDialogService {
 	private _connectionDialog: ConnectionDialogWidget;
 	private _advancedcontroller: AdvancedPropertiesController;
 
-	private handleOnConnect(): void {
+	private handleOnConnect(params: INewConnectionParams): void {
+		if (params && params.connectionType === ConnectionType.default) {
+			this.handleDefaultOnConnect();
+		} else if (params && params.editor && params.uri && params.connectionType === ConnectionType.queryEditor) {
+			this.handleQueryEditorOnConnect(params);
+		}
+	}
+
+	private handleOnCancel(params: INewConnectionParams): void {
+		if (params && params.editor && params.uri && params.connectionType === ConnectionType.queryEditor) {
+			params.editor.onConnectReject();
+		}
+	}
+
+	private handleDefaultOnConnect(): void {
 		this._connectionManagementService.addConnectionProfile(this._connectionDialog.getConnection()).then(connected => {
 			if (connected) {
 				this._connectionDialog.close();
@@ -44,6 +59,18 @@ export class ConnectionDialogService implements IConnectionDialogService {
 		});
 	}
 
+	private handleQueryEditorOnConnect(params: INewConnectionParams): void {
+		this._connectionManagementService.connectEditor(params.editor, params.uri, params.runQueryOnCompletion, this._connectionDialog.getConnection()).then(connected => {
+			if (connected) {
+				this._connectionDialog.close();
+			}
+
+		}).catch(err => {
+			this._connectionDialog.showError(err);
+		});
+	}
+
+
 	private handleOnAdvancedProperties(): void {
 		if (!this._advancedcontroller) {
 			this._advancedcontroller = new AdvancedPropertiesController(() => this._connectionDialog.focusOnAdvancedButton());
@@ -56,24 +83,25 @@ export class ConnectionDialogService implements IConnectionDialogService {
 		}
 	}
 
-	public showDialog(connectionManagementService: IConnectionManagementService, model?: IConnectionProfile): TPromise<void> {
+	public showDialog(connectionManagementService: IConnectionManagementService, params: INewConnectionParams, model?: IConnectionProfile): TPromise<void> {
 		this._connectionManagementService = connectionManagementService;
 		return new TPromise<void>(() => {
-			this.doShowDialog(model);
+			this.doShowDialog(params, model);
 		});
 	}
 
-	private doShowDialog(model?: IConnectionProfile): TPromise<void> {
+	private doShowDialog(params: INewConnectionParams, model?: IConnectionProfile): TPromise<void> {
 		if (!this._connectionDialog) {
 			let container = withElementById(this._partService.getWorkbenchElementId()).getHTMLElement().parentElement;
 			this._container = container;
 			this._connectionDialog = this._instantiationService.createInstance(ConnectionDialogWidget, container, {
-				onCancel: () => { },
-				onConnect: () => this.handleOnConnect(),
-				onAdvancedProperties: () => this.handleOnAdvancedProperties()
+				onCancel: () => this.handleOnCancel(this._connectionDialog.newConnectionParams),
+				onConnect: () => this.handleOnConnect(this._connectionDialog.newConnectionParams),
+				onAdvancedProperties: () => this.handleOnAdvancedProperties(),
 			});
 			this._connectionDialog.create();
 		}
+		this._connectionDialog.newConnectionParams = params;
 
 		return new TPromise<void>(() => {
 			model = model !== undefined ? model : {

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

@@ -24,13 +24,14 @@ import DOM = require('vs/base/browser/dom');
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { KeyCode } from 'vs/base/common/keyCodes';
 import { TreeUtils } from 'sql/parts/connection/electron-browser/recentConnectionsController';
-import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
+import { IConnectionManagementService, INewConnectionParams } from 'sql/parts/connection/common/connectionManagement';
 import { ConnectionProfile } from 'sql/parts/connection/node/connectionProfile';
 
 export interface IConnectionDialogCallbacks {
 	onConnect: () => void;
 	onCancel: () => void;
 	onAdvancedProperties: () => void;
+	params: INewConnectionParams;
 }
 
 export class ConnectionDialogWidget {
@@ -55,6 +56,7 @@ export class ConnectionDialogWidget {
 	private _dialog: ModalDialogBuilder;
 	private _authenticationOptions: string[];
 	private _recentConnectionButtons: Button[];
+	public _newConnectionParams: INewConnectionParams;
 
 	constructor(container: HTMLElement,
 		callbacks: IConnectionDialogCallbacks,
@@ -273,6 +275,14 @@ export class ConnectionDialogWidget {
 		}
 	}
 
+	public get newConnectionParams(): INewConnectionParams {
+		return this._newConnectionParams;
+	}
+
+	public set newConnectionParams(params: INewConnectionParams) {
+		this._newConnectionParams = params;
+	}
+
 	public set authenticationType(authenticationType: string) {
 		let index = this._authenticationOptions.indexOf(authenticationType);
 		if (index >= 0) {

src/sql/parts/connection/electron-browser/recentConnectionsController.ts

@@ -94,7 +94,7 @@ export class ConnectionTreeController extends treedefaults.DefaultController {
 					tree.DOMFocus();
 				}
 			},
-			getActionsContext: () => (parent)
+			getActionsContext: () => (element)
 		});
 
 		return true;

src/sql/parts/connection/electron-browser/serverTreeRenderer.ts

@@ -17,6 +17,7 @@ import errors = require('vs/base/common/errors');
 import { DragMouseEvent } from 'vs/base/browser/mouseEvent';
 import { IConnectionProfileGroupTemplateData, IConnectionTemplateData } from 'sql/parts/connection/electron-browser/templateData';
 import { IQueryEditorService } from 'sql/parts/editor/queryEditorService';
+import { IConnectableEditorParams } from 'sql/parts/connection/common/connectionManagement';
 const $ = dom.$;
 
 /**
@@ -303,9 +304,9 @@ export class NewQueryAction extends Action {
 	}
 
 	public run(connectionProfileGroup: ConnectionProfile): TPromise<boolean> {
-		this.queryEditorService.newSqlEditor().then((newDocUri) => {
+		this.queryEditorService.newSqlEditor().then((params: IConnectableEditorParams) => {
 			// Connect our editor to the input connection
-			this.connectionManagementService.connectEditor(newDocUri.toString(), connectionProfileGroup);
+			this.connectionManagementService.connectEditor(params.editor, params.uri, false, connectionProfileGroup);
 		});
 		return TPromise.as(true);
 	}