RT-Thread · BernardXiong · May 5, 2025 · May 5, 2025
diff --git a/package.json b/package.json
@@ -73,10 +73,40 @@
                 "command": "extension.refreshRTThread",
                 "title": "Refresh",
                 "icon": "$(sync)"
+            },
+            {
+                "command": "extension.showWorkspaceSettings",
+                "title": "Show Workspace Settings",
+                "icon": "$(settings-gear)"
+            },
+            {
+                "command": "extension.switchProject",
+                "title": "Switch project to this bsp",
+                "icon": "$(pass-filled)"
+            },
+            {
+                "command": "extension.fastBuildProject",
+                "title": "Build (-j CPU)...",
+                "icon": "$(github-action)"
+            },
+            {
+                "command": "extension.configProject",
+                "title": "Menuconfig",
+                "icon": "$(gear)"
+            },
+            {
+                "command": "extension.openTerminalProject",
+                "title": "Open RT-Thread Terminal",
+                "icon": "$(console)"
             }
         ],
         "menus": {
             "view/title": [
+                {
+                    "command": "extension.showWorkspaceSettings",
+                    "when": "(view == projectFilesId || view == groupsId) && isRTThreadWorksapce",
+                    "group": "navigation"
+                },
                 {
                     "command": "extension.refreshRTThread",
                     "when": "view == projectFilesId || view == groupsId",
@@ -87,6 +117,28 @@
                     "when": "(view == projectFilesId || view == groupsId) && isRTThread",
                     "group": "navigation"
                 }
+            ],
+            "view/item/context": [
+                {
+                    "command": "extension.switchProject",
+                    "when": "view == projectFilesId && viewItem == project_bsp",
+                    "group": "inline"
+                },
+                {
+                    "command": "extension.fastBuildProject",
+                    "when": "view == projectFilesId && viewItem == project_bsp",
+                    "group": "inline"
+                },
+                {
+                    "command": "extension.configProject",
+                    "when": "view == projectFilesId && viewItem == project_bsp",
+                    "group": "inline"
+                },
+                {
+                    "command": "extension.openTerminalProject",
+                    "when": "view == projectFilesId && viewItem == project_bsp",
+                    "group": "inline"
+                }
             ]
         },
         "configuration": {

diff --git a/src/api.ts b/src/api.ts
@@ -6,16 +6,20 @@ import * as path from 'path';
 import { executeCommand } from './terminal';
 
 let _context: vscode.ExtensionContext;
-let _isRTThread = false;
 let _bi: any[] = [];
 
 export function isRTThreadProject() {
-    return _isRTThread;
+    let status = _context.workspaceState.get<boolean>('isRTThread') || false;
+    return status;
 }
 
-export function initAPI(context:vscode.ExtensionContext, isRTThreadEnv: boolean) {
+export function isRTThreadWorksapce() {
+    let status = _context.workspaceState.get<boolean>('isRTThreadWorksapce') || false;
+    return status;
+}
+
+export function initAPI(context:vscode.ExtensionContext) {
     _context = context;
-    _isRTThread = isRTThreadEnv;
 
     // read resources/bi.json for boards information
     _bi = readJsonObject(path.join(getExtensionPath(), "resources", "bi.json"));
@@ -149,7 +153,7 @@ export async function openFolder(uri?: string) {
             canSelectFolders: true,
             canSelectFiles: false,
             canSelectMany: false,
-          });      
+          });
     }
     else {
         selectedFolder = await vscode.window.showOpenDialog({

diff --git a/src/cmds/index.ts b/src/cmds/index.ts
@@ -50,6 +50,16 @@ export let cmds: Object = {
                     ]
                 }
             },
+            {
+                name : "fix config",
+                iconId : "layers-active",
+                cmd : {
+                    title : "fix-config",
+                    arguments : [
+                        "scons --pyconfig-silent"
+                    ]
+                }
+            },
             {
                 name : "vscode settings",
                 iconId : "compare-changes",

diff --git a/src/dock.ts b/src/dock.ts
@@ -2,8 +2,8 @@ import path from 'path';
 import * as vscode from 'vscode';
 import os from 'os';
 import fs from 'fs';
-import { getWorkspaceFolder, isRTThreadProject } from './api';
-import { buildGroupsTree, buildProjectTree, buildEmptyProjectTree, ProjectTreeItem, listFolderTreeItem } from './project/tree';
+import { getWorkspaceFolder, isRTThreadProject, isRTThreadWorksapce } from './api';
+import { buildGroupsTree, buildProjectTree, buildEmptyProjectTree, ProjectTreeItem, listFolderTreeItem, buildBSPTree } from './project/tree';
 import { cmds } from './cmds/index';
 
 class CmdTreeDataProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
@@ -12,7 +12,13 @@ class CmdTreeDataProvider implements vscode.TreeDataProvider<vscode.TreeItem> {
     }
 
     getChildren(element?: vscode.TreeItem): vscode.ProviderResult<vscode.TreeItem[]> {
-        if (isRTThreadProject() != true) {
+        const isRTT = isRTThreadProject();
+        const isRTTWorksapce = isRTThreadWorksapce();
+        if (isRTT != true && isRTTWorksapce != true) {
+            console.log("not RT-Thread project or workspace, return empty tree item.");
+        }
+
+        if (isRTThreadProject() != true && isRTThreadWorksapce() != true) {
             // only show Home command
             let home = new vscode.TreeItem("Home", vscode.TreeItemCollapsibleState.None);
             home.iconPath = new vscode.ThemeIcon("home");
@@ -114,6 +120,22 @@ class GroupsDataProvider implements vscode.TreeDataProvider<ProjectTreeItem> {
                 return buildEmptyProjectTree();
             }
         }
+        else {
+            jsonPath = getWorkspaceFolder() + "/.vscode/workspace.json";
+            if (fs.existsSync(jsonPath)) {
+                try {
+                    const json = fs.readFileSync(jsonPath, 'utf8');
+                    const jsonNode = JSON.parse(json);
+
+                    if (jsonNode.hasOwnProperty("bsps")) {
+                        return buildBSPTree(jsonNode);
+                    }
+                }
+                catch (err) {
+                    return buildEmptyProjectTree();
+                }
+            }
+        }
 
         /* build empty project tree */
         return buildEmptyProjectTree();
@@ -212,6 +234,21 @@ class ProjectFilesDataProvider implements vscode.TreeDataProvider<ProjectTreeIte
             }
         }
 
+        let workspacePath = getWorkspaceFolder() + "/.vscode/workspace.json";
+        if (fs.existsSync(workspacePath)) {
+            try {
+                const json = fs.readFileSync(workspacePath, 'utf8');
+                const jsonNode = JSON.parse(json);
+
+                if (jsonNode.hasOwnProperty("bsps")) {
+                    return buildBSPTree(jsonNode);
+                }
+            }
+            catch (err) {
+                return buildEmptyProjectTree();
+            }
+        }
+
         /* build empty project tree */
         return buildEmptyProjectTree();
     }
@@ -253,6 +290,7 @@ export function initDockView(context: vscode.ExtensionContext) {
     const view = vscode.window.createTreeView('projectFilesId', {
         treeDataProvider: _projectFilesDataProvider, showCollapseAll: true
     });
+
     context.subscriptions.push(view);
     vscode.commands.registerCommand('extension.refreshRTThread', () => refreshProjectFilesAndGroups());
 

diff --git a/src/extension.ts b/src/extension.ts
@@ -12,24 +12,55 @@ import { getMenuItems, getParallelBuildNumber } from './smart';
 import { initDockView } from './dock';
 import { setupVEnv } from './venv';
 import { initAPI } from './api';
+import { openWorkspaceProjectsWebview } from './webviews/project';
+import { initProjectTree } from './project/tree';
 
 let _context: vscode.ExtensionContext;
 
+// 有两种模式
+// isRTThreadWorksapce - workspace模式，会定位.vscode/workspace.json文件是否存在，是否启用
+// isRTThread - 项目模式，rtconfig.h文件是否存在
+
 export async function activate(context: vscode.ExtensionContext) {
     let isRTThread: boolean = false;
-    const workspaceFolders = vscode.workspace.workspaceFolders;
+    let isRTThreadWorksapce: boolean = false;
 
     _context = context;
+
+    // init context for isRTThread, isRTThreadWorksapce
+    vscode.commands.executeCommand('setContext', 'isRTThread', isRTThread);
+    context.workspaceState.update('isRTThread', isRTThread);
+    vscode.commands.executeCommand('setContext', 'isRTThreadWorksapce', isRTThreadWorksapce);
+    context.workspaceState.update('isRTThreadWorksapce', isRTThreadWorksapce);
+    initAPI(context);
+
+    const workspaceFolders = vscode.workspace.workspaceFolders;
     if (workspaceFolders) {
         const workspacePath = workspaceFolders[0].uri.fsPath;
-        // check rtconfig.h exists
-        const rtconfigPath = path.join(workspacePath, 'rtconfig.h');
-        if (fs.existsSync(rtconfigPath)) {
-            /* The workspace is a RT-Thread Project*/
-            isRTThread = true;
-            initAPI(context, isRTThread);
-            vscode.commands.executeCommand('setContext', 'isRTThread', true);
 
+        const rtthreadWorkspace = path.join(workspacePath, '.vscode', 'workspace.json');
+        if (fs.existsSync(rtthreadWorkspace)) {
+            const json = fs.readFileSync(rtthreadWorkspace, 'utf8');
+            const jsonNode = JSON.parse(json);
+
+            if (jsonNode.hasOwnProperty("bsps")) {
+                isRTThreadWorksapce = true;
+                vscode.commands.executeCommand('setContext', 'isRTThreadWorksapce', true);
+                context.workspaceState.update('isRTThreadWorksapce', isRTThreadWorksapce);
+            }
+        }
+        else {
+            // check rtconfig.h exists
+            const rtconfigPath = path.join(workspacePath, 'rtconfig.h');
+            if (fs.existsSync(rtconfigPath)) {
+                /* The workspace is a RT-Thread Project*/
+                isRTThread = true;
+                vscode.commands.executeCommand('setContext', 'isRTThread', true);
+                context.workspaceState.update('isRTThread', isRTThread);
+            }
+        }
+
+        if (isRTThread || isRTThreadWorksapce) {
             // if it's Windows system
             if (os.platform() === 'win32') {
                 await setupVEnv();
@@ -42,7 +73,7 @@ export async function activate(context: vscode.ExtensionContext) {
             // register commands
             vscode.commands.registerCommand('extension.showAbout', () => {
                 openAboutWebview(context);
-            });            
+            });
             vscode.commands.registerCommand('extension.executeCommand', (arg1, arg2) => {
                 if (arg1)
                 {
@@ -60,21 +91,35 @@ export async function activate(context: vscode.ExtensionContext) {
                 }
             })
         }
-        else {
-            isRTThread = false;
-            vscode.commands.executeCommand('setContext', 'isRTThread', false);
-            initAPI(context, isRTThread);
-        }
-    }
-    else {
-        initAPI(context, isRTThread);
     }
 
     vscode.commands.registerCommand('extension.showHome', () => {
         openHomeWebview(context);
     });
+    if (isRTThreadWorksapce) {
+        vscode.commands.registerCommand('extension.showWorkspaceSettings', () => {
+            openWorkspaceProjectsWebview(context);
+        });
+        initProjectTree(context);
+    }
+
     /* initialize dock view always */
     initDockView(context);
+    initExperimentStatusBarItem(context)
+}
+
+function initExperimentStatusBarItem(context: vscode.ExtensionContext) {
+    if (false){
+        const statusItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 5);
+        statusItem.text = '$(beaker) 实验性功能';
+        statusItem.tooltip = 'Experimental features';
+        statusItem.command = 'extension.Experimental';
+        statusItem.show();
+
+        vscode.commands.registerCommand('extension.Experimental', () => {
+            console.log('Experimental features are not available yet.');
+        });
+    }
 }
 
 function setupStatusBarItems(context: vscode.ExtensionContext) {

diff --git a/src/project/cmd.ts b/src/project/cmd.ts
@@ -0,0 +1,56 @@
+import * as os from 'os';
+import * as fs from 'fs';
+
+import { getWorkspaceFolder } from '../api';
+import { executeCommand } from '../terminal';
+
+let _currentProject: string = '';
+
+export function fastBuildProject(arg: any) {
+    if (arg) {
+        const cpus = os.cpus().length;
+        let cmd = 'scons -C ' + arg.fn + ' -j ' + cpus.toString();
+
+        executeCommand(cmd);
+    }
+
+    return;
+}
+
+export function configProject(arg: any) {
+    if (arg) {
+        let cmd = 'scons -C ' + arg.fn + ' --menuconfig';
+
+        executeCommand(cmd);
+    }
+
+    return;
+}
+
+export function openTerminalProject(arg: any) {
+    if (arg) {
+        let cmd = 'cd ' + arg.fn;
+
+        executeCommand(cmd);
+    }
+
+    return;
+}
+
+export function setCurrentProject(arg: any) {
+    if (arg) {
+        _currentProject = arg.fn;
+    }
+
+    return;
+}
+
+export function getCurrentProject() {
+    let rtconfig = getWorkspaceFolder() + '/' + 'rtconfig.h';
+
+    if (fs.existsSync(rtconfig)) {
+        return getWorkspaceFolder();
+    }
+
+    return _currentProject;
+}