#289 Adding a context option to Open in Solution Explorer

package.json

@@ -69,6 +69,11 @@
       }
     ],
     "commands": [
+      {
+        "command": "solutionExplorer.openSelectedSolution",
+        "title": "Open in Solution Explorer",
+        "icon": "$(folder-opened)"
+      },
       {
         "command": "solutionExplorer.openSolution",
         "title": "Open Solution",
@@ -328,6 +333,13 @@
       }
     ],
     "menus": {
+      "explorer/context": [
+        {
+          "command": "solutionExplorer.openSelectedSolution",
+          "when": "resourceExtname == .sln",
+          "group": "navigation"
+        }
+      ],
       "view/title": [
         {
           "command": "solutionExplorer.openSolution",

src/SolutionExplorerCommands.ts

@@ -159,6 +159,9 @@ export class SolutionExplorerCommands {
         this.commands['openSolution'] = [new cmds.OpenSolutionCommand(eventAggregator),
             undefined];
 
+        this.commands['openSelectedSolution'] = [new cmds.OpenSolutionFromDefaultExplorerCommand(eventAggregator),
+                undefined];
+
         this.commands['deleteMultiple'] = [new cmds.DeleteUnifiedCommand(),
             [ContextValues.multipleSelection]];
     }
@@ -177,7 +180,8 @@ export class SolutionExplorerCommands {
             vscode.commands.registerCommand(name, async (arg) => {
                 const clickedItem = arg instanceof TreeItem ? arg : undefined;
                 const selectedItems = this.provider.getSelectedItems();
-                const actions = await command.getActionsBase(clickedItem, selectedItems);
+                const ctx = new cmds.ActionCommandContext(clickedItem, selectedItems, arg);
+                const actions = await command.getActionsBase(ctx);
                 if (actions.length > 0) {
                     await this.actionsRunner.run(actions, { isCancellationRequested: false  });
                 }

src/commands/ActionsCommand.ts

@@ -1,11 +1,16 @@
 import { TreeItem } from "@tree";
 import { Action } from "@actions";
 
+export class ActionCommandContext {
+    constructor(public readonly clickedItem: TreeItem | undefined, public readonly selectedItems: readonly TreeItem[] | undefined, public readonly args: any) {
+    }
+}
+
 export abstract class ActionsCommand {
     constructor(protected title: string) {
     }
 
-    public abstract getActionsBase(clickedItem: TreeItem | undefined, selectedItems: readonly TreeItem[] | undefined):
+    public abstract getActionsBase(ctx: ActionCommandContext):
         Promise<Action[]>;
 }
 

src/commands/DeleteUnifiedCommand.ts

@@ -1,5 +1,5 @@
 import { TreeItem, ContextValues } from "@tree";
-import { ActionsCommand, prepareContextActionGetters } from "@commands";
+import { ActionCommandContext, ActionsCommand, prepareContextActionGetters } from "@commands";
 import {
     Action,
     DeleteProjectFile,
@@ -17,10 +17,9 @@ export class DeleteUnifiedCommand extends ActionsCommand {
         super('Delete');
     }
 
-    public async getActionsBase(clickedItem: TreeItem | undefined, selectedItems: readonly TreeItem[] | undefined):
-        Promise<Action[]> {
+    public async getActionsBase(ctx: ActionCommandContext): Promise<Action[]> {
 
-        const clickedItems = this.getClickedItems(clickedItem, selectedItems);
+        const clickedItems = this.getClickedItems(ctx.clickedItem, ctx.selectedItems);
 
         const topClickedItems = clickedItems.filter(item => !this.includedInFolder(clickedItems, item));
 

src/commands/OpenSolutionCommand.ts

@@ -21,3 +21,5 @@ export class OpenSolutionCommand extends SingleItemActionsCommand {
         return [new OpenSolution(solutionPath, this.eventAggregator)];
     }
 }
+
+

src/commands/OpenSolutionFromDefaultExplorerCommand.ts

@@ -0,0 +1,18 @@
+import { IEventAggregator } from "@events";
+import { Action, OpenSolution } from "@actions";
+import { SingleItemActionsFromDefaultExplorerCommand } from "./SingleItemActionsFromDefaultExplorerCommand";
+
+
+export class OpenSolutionFromDefaultExplorerCommand extends SingleItemActionsFromDefaultExplorerCommand {
+    constructor(private readonly eventAggregator: IEventAggregator) {
+        super('Open Solution');
+    }
+
+    public shouldRun(item: string): boolean {
+        return item.toLocaleLowerCase().endsWith('.sln');
+    }
+
+    public async getActions(item: string): Promise<Action[]> {
+        return [new OpenSolution(item, this.eventAggregator)];
+    }
+}

src/commands/SingleItemActionsCommand.ts

@@ -1,18 +1,20 @@
 import { TreeItem } from "@tree";
 import { Action } from "@actions";
-import { ActionsCommand } from "./ActionsCommand";
+import { ActionCommandContext, ActionsCommand } from "./ActionsCommand";
 
 export abstract class SingleItemActionsCommand extends ActionsCommand {
     constructor(title: string) {
         super(title);
     }
 
-    public async getActionsBase(clickedItem: TreeItem | undefined, selectedItems: readonly TreeItem[] | undefined): Promise<Action[]> {
-        const item = clickedItem ?? (selectedItems?.length === 1 ? selectedItems[0] : undefined);
+    public async getActionsBase(ctx: ActionCommandContext): Promise<Action[]> {
+        const item = ctx.clickedItem ?? (ctx.selectedItems?.length === 1 ? ctx.selectedItems[0] : undefined);
         return this.shouldRun(item) ? this.getActions(item) : [];
     }
 
     public abstract shouldRun(item: TreeItem | undefined): boolean;
 
     public abstract getActions(item: TreeItem | undefined): Promise<Action[]>;
 }
+
+

src/commands/SingleItemActionsFromDefaultExplorerCommand.ts

@@ -0,0 +1,22 @@
+import { Action } from "@actions";
+import { ActionCommandContext, ActionsCommand } from "./ActionsCommand";
+
+
+
+export abstract class SingleItemActionsFromDefaultExplorerCommand extends ActionsCommand {
+    constructor(title: string) {
+        super(title);
+    }
+
+    public async getActionsBase(ctx: ActionCommandContext): Promise<Action[]> {
+        if (!!ctx && !!ctx.args && !!ctx.args.path) {
+            return this.shouldRun(ctx.args.path) ? this.getActions(ctx.args.path) : [];
+        }
+
+        return [];
+    }
+
+    public abstract shouldRun(item: string): boolean;
+
+    public abstract getActions(item: string): Promise<Action[]>;
+}

src/commands/index.ts

@@ -24,6 +24,7 @@ export * from "./MoveFileDownCommand";
 export * from "./MoveToSolutionFolderCommand";
 export * from "./OpenFileCommand";
 export * from "./OpenSolutionCommand";
+export * from "./OpenSolutionFromDefaultExplorerCommand";
 export * from "./PackCommand";
 export * from "./PasteCommand";
 export * from "./PublishCommand";