[Feature Request] 应用程序场景图的当前状态

[unknowIfGuestInDream]

Checklist

• I searched exising issues and no one else requests similar feature.
• I think that 25%+ users are positive towards this feature.

Describe the feature

https://github.com/JonathanGiles/scenic-view

参考PDE-tools 的camera功能

Additional context

No response

[unknowIfGuestInDream]

property view?
window builder?

[unknowIfGuestInDream]

启动扫描本地的 RCP 应用（或目标 RCP 应用）

获取并显示目标应用的 UI 组件树（SWT 控件树）

响应 UI 操作事件，并更新树节点高亮

支持从树中点击控件节点，目标应用中覆盖显示

+----------------------------------------------------------+
| 你的工具应用（Eclipse RCP） |
| +--------------------------------------+ |
| | UI 控件树视图（JFace TreeViewer） |<-- 控件监听事件 |
| +--------------------------------------+ |
| ↑ |
| | 通过共享内存/Socket/Agent方式 |
| ↓ |
| +------------------------------+ |
| | 目标 RCP 应用（SWT 应用） | |
| | - 提供控件树结构 | |
| | - 支持外部访问控件信息 | |
| +------------------------------+ |
+----------------------------------------------------------+

[unknowIfGuestInDream]

1. 目标 RCP 应用中注入一个控件服务（控件树扫描 + Socket 服务）

Details

public class UiIntrospectServer {
    private ServerSocket serverSocket;

    public void start(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        new Thread(() -> {
            try {
                while (!serverSocket.isClosed()) {
                    Socket socket = serverSocket.accept();
                    handleClient(socket);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    private void handleClient(Socket socket) {
        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
            Display.getDefault().asyncExec(() -> {
                String json = UiTreeSerializer.serialize(Display.getDefault());
                try {
                    writer.write(json);
                    writer.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 控件树序列化工具（简化版本）

Details

public class UiTreeSerializer {
    public static String serialize(Display display) {
        List<Map<String, Object>> windows = new ArrayList<>();
        for (Shell shell : display.getShells()) {
            Map<String, Object> shellData = serializeControl(shell);
            windows.add(shellData);
        }
        return new Gson().toJson(windows);
    }

    private static Map<String, Object> serializeControl(Control control) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("class", control.getClass().getSimpleName());
        map.put("bounds", control.getBounds().toString());
        if (control instanceof Composite) {
            List<Object> children = new ArrayList<>();
            for (Control child : ((Composite) control).getChildren()) {
                children.add(serializeControl(child));
            }
            map.put("children", children);
        }
        return map;
    }
}

3. 你的工具应用（树视图）读取并展示控件树

使用 TreeViewer 展示节点，并点击后触发事件（通过 Socket 或共享库调用目标进程高亮控件）。

Details

public class RemoteUiTreeLoader {
    public static String loadUiTree(String host, int port) throws IOException {
        try (Socket socket = new Socket(host, port);
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            return reader.lines().collect(Collectors.joining());
        }
    }

    public static List<UiNode> parseJsonTree(String json) {
        Type listType = new TypeToken<List<UiNode>>(){}.getType();
        return new Gson().fromJson(json, listType);
    }
}

public class UiNode {
    public String className;
    public String bounds;
    public List<UiNode> children;

    public String toString() {
        return className + " " + bounds;
    }
}

高亮控件（在目标应用上加半透明图层）

你可以通过发送控件 ID 或 bounds 坐标从工具端请求目标应用端执行这个方法。

Details

Details

public class Highlighter {
    public static void highlightControl(Control control) {
        Shell shell = control.getShell();
        Rectangle bounds = control.getBounds();

        Canvas overlay = new Canvas(shell, SWT.NO_BACKGROUND);
        overlay.setBounds(bounds);
        overlay.setBackground(shell.getDisplay().getSystemColor(SWT.COLOR_RED));
        overlay.setAlpha(80);
        overlay.moveAbove(null);
        overlay.setVisible(true);

        shell.layout(true);
        shell.redraw();
    }
}

[unknowIfGuestInDream]

架构升级
+------------------+ Socket / Attach API +----------------------+
| RCP 工具应用 |<-------------------------------->| 目标 RCP 应用进程 |
| (TreeViewer+UI) | | (通过 Agent 注入探针) |
+------------------+ +----------------------+
|
| 用户点击树节点
V
+-------------------------+
| 高亮控件 / 属性展示等操作 |
+-------------------------+

Attach Agent 示例

Details

public class ScenicAgent {
    public static void agentmain(String agentArgs, Instrumentation inst) {
        Display.getDefault().asyncExec(() -> {
            try {
                SocketServer.startServer(3456); // 提供控件树查询服务
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }
}

打包为 scenic-agent.jar，包含 Premain-Class 和 Agent-Class：

Manifest-Version: 1.0
Agent-Class: your.package.ScenicAgent
Can-Redefine-Classes: true

Attach 工具

public class AttachUtil {
    public static void attachTo(String pid, String agentJar) throws Exception {
        VirtualMachine vm = VirtualMachine.attach(pid);
        vm.loadAgent(agentJar);
        vm.detach();
    }
}

控件树序列化（部分示例）

public class UiTreeSerializer {
    public static String collect(Display display) {
        List<Object> list = new ArrayList<>();
        for (Shell shell : display.getShells()) {
            list.add(serialize(shell));
        }
        return new Gson().toJson(list);
    }

    private static Map<String, Object> serialize(Control c) {
        Map<String, Object> map = new HashMap<>();
        map.put("class", c.getClass().getSimpleName());
        map.put("bounds", c.getBounds().toString());
        map.put("visible", c.isVisible());
        map.put("enabled", c.isEnabled());
        if (c instanceof Composite composite) {
            List<Object> children = new ArrayList<>();
            for (Control child : composite.getChildren()) {
                children.add(serialize(child));
            }
            map.put("children", children);
        }
        return map;
    }
}

实现
Socket Server + 控件树导出 + 高亮控件
✅ Socket 服务监听（端口 3456）

✅ 控件树采集与 JSON 序列化

✅ 根据 bounds 字符串进行控件高亮（红色半透明覆盖层）
可以在目标 RCP 应用中执行 RcpUiSocketServer.start() 来启动服务。

Details

package com.example.scenic;

import com.google.gson.Gson;
import org.eclipse.swt.widgets.*;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;

public class RcpUiSocketServer {

    private static final int PORT = 3456;
    private static final Gson gson = new Gson();
    private static ServerSocket serverSocket;

    public static void start() throws IOException {
        if (serverSocket != null && !serverSocket.isClosed()) return;

        serverSocket = new ServerSocket(PORT);
        System.out.println("[RCP-UI-Server] Listening on port " + PORT);

        new Thread(() -> {
            while (true) {
                try {
                    Socket socket = serverSocket.accept();
                    handle(socket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }, "RCP-UI-Socket-Thread").start();
    }

    private static void handle(Socket socket) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {

            String line = reader.readLine();
            if (line == null) return;

            if (line.startsWith("GET_TREE")) {
                Display.getDefault().asyncExec(() -> {
                    String json = gson.toJson(collectAllShells(Display.getDefault()));
                    try {
                        writer.write(json);
                        writer.flush();
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });
            } else if (line.startsWith("HIGHLIGHT:")) {
                String boundsStr = line.substring("HIGHLIGHT:".length());
                Display.getDefault().asyncExec(() -> {
                    highlightByBounds(boundsStr);
                });
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static List<Map<String, Object>> collectAllShells(Display display) {
        List<Map<String, Object>> list = new ArrayList<>();
        for (Shell shell : display.getShells()) {
            list.add(serializeControl(shell));
        }
        return list;
    }

    private static Map<String, Object> serializeControl(Control control) {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("class", control.getClass().getSimpleName());
        map.put("bounds", control.getBounds().toString());
        map.put("visible", control.isVisible());
        map.put("enabled", control.isEnabled());
        map.put("hashCode", control.hashCode());
        if (control instanceof Composite composite) {
            List<Object> children = new ArrayList<>();
            for (Control child : composite.getChildren()) {
                children.add(serializeControl(child));
            }
            map.put("children", children);
        }
        return map;
    }

    private static void highlightByBounds(String boundsStr) {
        for (Shell shell : Display.getDefault().getShells()) {
            highlightMatch(shell, boundsStr);
        }
    }

    private static void highlightMatch(Control control, String boundsStr) {
        if (control.getBounds().toString().equals(boundsStr)) {
            Canvas overlay = new Canvas(control.getParent(), SWT.NO_BACKGROUND);
            overlay.setBounds(control.getBounds());
            overlay.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_RED));
            overlay.setAlpha(100);
            overlay.moveAbove(null);
            overlay.setVisible(true);
            control.getParent().layout(true);
        } else if (control instanceof Composite composite) {
            for (Control child : composite.getChildren()) {
                highlightMatch(child, boundsStr);
            }
        }
    }
} 

Attach Agent 模块
它支持两种加载方式：
动态 attach（推荐）
JVM 启动时使用 -javaagent

Details

使用 Attach API 注入示例 ```java import com.sun.tools.attach.VirtualMachine;

public class AgentAttacher {
public static void main(String[] args) throws Exception {
String pid = args[0]; // 目标 JVM PID
String agentJar = args[1]; // scenic-agent.jar 路径
VirtualMachine vm = VirtualMachine.attach(pid);
vm.loadAgent(agentJar);
vm.detach();
}
}

可通过 jps 获取 PID，然后运行：
java -cp attach-client.jar AgentAttacher 12345 /path/to/scenic-agent.jar

实现
```java
package com.example.scenic;

import java.lang.instrument.Instrumentation;

/**
 * Attach Agent，用于在运行中的 JVM 中启动控件树 Socket 服务。
 */
public class ScenicAgent {

    public static void agentmain(String agentArgs, Instrumentation inst) {
        System.out.println("[ScenicAgent] Agent loaded into target JVM.");
        try {
            RcpUiSocketServer.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void premain(String agentArgs, Instrumentation inst) {
        // 可选支持 java -javaagent 启动方式
        agentmain(agentArgs, inst);
    }
} 

构建 Eclipse RCP 工具 UI，包括：
TreeViewer 展示控件树结构
StyledText 展示选中控件属性
Socket 客户端发送 GET_TREE 与 HIGHLIGHT

Details

1.在 Eclipse RCP 工具 WorkbenchWindowAdvisor 中调用： ```java public void postWindowOpen() { Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); ScenicViewClient.createUI(shell); }

2.启动目标 RCP 应用，使用 Attach 工具注入 scenic-agent.jar。
3.启动你的 RCP 工具，即可获取并操作控件树。

```java
package com.example.toolui;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.rules.*;
import org.eclipse.jface.viewers.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

import java.io.*;
import java.lang.reflect.Type;
import java.net.Socket;
import java.util.*;
import java.util.concurrent.Executors;

public class ScenicViewClient {

    private static final String HOST = "127.0.0.1";
    private static final int PORT = 3456;
    private static final Gson gson = new Gson();

    private static TreeViewer viewer;
    private static StyledText styledText;
    private static UiNode currentSelection = null;

    public static void createUI(Shell shell) {
        shell.setText("RCP Scenic View");
        shell.setLayout(new FillLayout(SWT.HORIZONTAL));

        SashForm sashForm = new SashForm(shell, SWT.HORIZONTAL);

        viewer = new TreeViewer(sashForm, SWT.BORDER | SWT.SINGLE);
        viewer.setContentProvider(new TreeContentProvider());
        viewer.setLabelProvider(new LabelProvider() {
            public String getText(Object element) {
                if (element instanceof UiNode node)
                    return node.className + " " + node.bounds;
                return super.getText(element);
            }
        });

        styledText = new StyledText(sashForm, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
        styledText.setEditable(false);

        viewer.addSelectionChangedListener(event -> {
            IStructuredSelection selection = viewer.getStructuredSelection();
            UiNode node = (UiNode) selection.getFirstElement();
            if (node != null) {
                currentSelection = node;
                updateDetails(node);
                highlightRemote(node);
            }
        });

        sashForm.setWeights(new int[]{2, 3});

        List<UiNode> nodes = fetchUiTree();
        viewer.setInput(nodes);

        startEventListener();
    }

    private static List<UiNode> fetchUiTree() {
        try (Socket socket = new Socket(HOST, PORT);
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

            writer.write("GET_TREE\n");
            writer.flush();

            String json = reader.lines().reduce("", (a, b) -> a + b);
            Type type = new TypeToken<List<UiNode>>(){}.getType();
            return gson.fromJson(json, type);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return Collections.emptyList();
    }

    private static void highlightRemote(UiNode node) {
        try (Socket socket = new Socket(HOST, PORT);
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {

            writer.write("HIGHLIGHT:" + node.bounds + "\n");
            writer.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void highlightJson(StyledText text, String json) {
        text.setStyleRange(null);
        List<StyleRange> ranges = new ArrayList<>();
        int index = 0;
        while ((index = json.indexOf("\"", index)) != -1) {
            int end = json.indexOf("\"", index + 1);
            if (end == -1) break;
            ranges.add(new StyleRange(index, end - index + 1, text.getDisplay().getSystemColor(SWT.COLOR_DARK_BLUE), null));
            index = end + 1;
        }
        for (StyleRange range : ranges) {
            text.setStyleRange(range);
        }
    }

    private static void updateDetails(UiNode node) {
        String json = node.toJson();
        styledText.setText(json);
        highlightJson(styledText, json);
    }

    private static void startEventListener() {
        Executors.newSingleThreadExecutor().submit(() -> {
            while (true) {
                try (Socket socket = new Socket(HOST, PORT);
                     BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                     BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

                    writer.write("WAIT_EVENT\n");
                    writer.flush();

                    String line = reader.readLine();
                    if (line != null) {
                        if (line.startsWith("FOCUS:")) {
                            String hashStr = line.substring("FOCUS:".length());
                            int hash = Integer.parseInt(hashStr);
                            Display.getDefault().asyncExec(() -> {
                                if (currentSelection == null || currentSelection.hashCode != hash) {
                                    selectNodeByHash(hash);
                                }
                            });
                        } else if (line.startsWith("SELECT:")) {
                            String hashStr = line.substring("SELECT:".length());
                            int hash = Integer.parseInt(hashStr);
                            Display.getDefault().asyncExec(() -> {
                                if (currentSelection == null || currentSelection.hashCode != hash) {
                                    selectNodeByHash(hash);
                                }
                            });
                        }
                    }

                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                    try { Thread.sleep(5000); } catch (InterruptedException ignored) {}
                }
            }
        });
    }

    private static void selectNodeByHash(int hash) {
        List<UiNode> nodes = (List<UiNode>) viewer.getInput();
        UiNode found = findByHash(nodes, hash);
        if (found != null) {
            viewer.setSelection(new StructuredSelection(found), true);
            updateDetails(found);
        }
    }

    private static UiNode findByHash(List<UiNode> nodes, int hash) {
        for (UiNode node : nodes) {
            if (node.hashCode == hash) return node;
            UiNode sub = findByHash(node.children, hash);
            if (sub != null) return sub;
        }
        return null;
    }

    static class TreeContentProvider implements ITreeContentProvider {
        public Object[] getElements(Object inputElement) {
            return ((List<?>) inputElement).toArray();
        }

        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof UiNode node) {
                return node.children.toArray();
            }
            return new Object[0];
        }

        public Object getParent(Object element) {
            return null;
        }

        public boolean hasChildren(Object element) {
            return element instanceof UiNode node && !node.children.isEmpty();
        }
    }

    public static class UiNode {
        public String className;
        public String bounds;
        public boolean visible;
        public boolean enabled;
        public int hashCode;
        public List<UiNode> children = new ArrayList<>();

        public String toJson() {
            return gson.toJson(this);
        }
    }
}