message system for ui

Author: zsqw123

asm_egui/src/app.rs

@@ -13,7 +13,7 @@ use std::sync::Arc;
 pub struct EguiApp {
     pub server: ServerMut,
     pub log_holder: Arc<LogHolder>,
-    pub server_app: AppContainer,
+    pub ui_app: AppContainer,
 }
 
 impl EguiApp {
@@ -22,9 +22,9 @@ impl EguiApp {
         inject_log(Arc::clone(&log_holder));
         inject_sys_font(context);
         Self {
-            server: Default::default(),
             log_holder,
-            server_app: Default::default(),
+            server: Default::default(),
+            ui_app: Default::default(),
         }
     }
 }
@@ -69,13 +69,13 @@ impl EguiApp {
             let Some(server) = server_locked.as_ref() else {
                 return;
             };
-            let server_app = &self.server_app;
+            let server_app = &self.ui_app;
 
             render_tabs(ui, server_app);
 
             ui.separator();
 
-            smali_layout(ui, server, &self.server_app);
+            smali_layout(ui, server, &self.ui_app);
         });
     }
 }
@@ -87,7 +87,7 @@ impl EguiApp {
             if let Some(DroppedFile { path, .. }) = input.raw.dropped_files.get(0) {
                 if let Some(path) = path {
                     let path = path.display().to_string();
-                    AsmServer::smart_open(self.server.clone(), &path, self.server_app.clone());
+                    AsmServer::smart_open(self.server.clone(), &path, self.ui_app.clone());
                 }
             }
         })
@@ -96,6 +96,11 @@ impl EguiApp {
 
 impl eframe::App for EguiApp {
     fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        let mut mutex = self.server.lock();
+        if let Some(server) = mutex.as_mut() {
+            self.ui_app.process_messages(server);
+        }
+        drop(mutex);
         self.top_bar(ctx);
         self.bottom_log_panel(ctx);
         self.left_bar(ctx);

asm_egui/src/file_tree.rs

@@ -1,45 +1,46 @@
 use crate::app::EguiApp;
 use egui::text::LayoutJob;
 use egui::{ScrollArea, TextStyle};
-use java_asm_server::ui::{AppContainer, FileEntry, FileInfo, RawDirInfo};
-use java_asm_server::AsmServer;
-use std::ops::Deref;
+use java_asm_server::ui::{AppContainer, FileEntry, FileInfo, OpenFileMessage, RawDirInfo, UIMessage};
 
 pub fn render_dir(ui: &mut egui::Ui, app: &mut EguiApp) {
-    let server_app = &app.server_app;
-    let mut server_app_left = server_app.left().lock();
-    let entries = &mut server_app_left.root_node.visible_items();
+    let server_app = &app.ui_app;
+    let mut left = server_app.left().lock();
+    let entries = &mut left.root_node.visible_items();
     let server = app.server.lock();
-    if let Some(server) = server.deref() {
-        let row_height = ui.spacing().interact_size.y;
-        ScrollArea::vertical().auto_shrink(false)
-            .show_rows(ui, row_height, entries.len(), |ui, range| {
-                for i in range {
-                    let entry = &mut entries[i];
-                    match entry {
-                        FileEntry::Dir(raw_dir) => {
-                            render_dir_raw(ui, raw_dir);
-                        }
-                        FileEntry::File(file_info) => {
-                            render_file(ui, file_info, server, server_app);
-                        }
+    if server.is_none() { return; }
+    let row_height = ui.spacing().interact_size.y;
+    ScrollArea::vertical().auto_shrink(false)
+        .show_rows(ui, row_height, entries.len(), |ui, range| {
+            for i in range {
+                let entry = &mut entries[i];
+                match entry {
+                    FileEntry::Dir(raw_dir) => {
+                        render_dir_raw(ui, raw_dir);
+                    }
+                    FileEntry::File(file_info) => {
+                        render_file(ui, file_info, server_app);
                     }
                 }
-            });
-    }
+            }
+        });
 }
 
 fn render_file(
-    ui: &mut egui::Ui, file_info: &mut FileInfo,
-    server: &AsmServer, app: &AppContainer,
+    ui: &mut egui::Ui, file_info: &mut FileInfo, app: &AppContainer,
 ) {
     let FileInfo { title, file_key, level } = file_info;
     ui.horizontal(|ui| {
         ui.add_space((*level as f32) * 12.0);
         let layout_job = layout_string(ui, title.to_string());
         let label = ui.selectable_label(false, layout_job);
         if label.clicked() {
-            server.switch_or_open(file_key, app);
+            let message = UIMessage::OpenFile(
+                OpenFileMessage {
+                    path: file_key.clone(),
+                }
+            );
+            app.send_message(message);
         }
     });
 }

asm_egui/src/smali.rs

@@ -3,12 +3,13 @@ use egui::text::LayoutJob;
 use egui::{CursorIcon, FontId, Response, ScrollArea, TextStyle, Ui, Vec2};
 use java_asm::smali::SmaliToken;
 use java_asm::StrRef;
-use java_asm_server::ui::{AppContainer, Content, Top};
+use java_asm_server::ui::{AppContainer, Content, Left, Top};
 use java_asm_server::AsmServer;
 use std::ops::{Deref, DerefMut};
 
 pub fn smali_layout(ui: &mut Ui, server: &AsmServer, app: &AppContainer) {
     let mut content_locked = app.content().lock();
+    let mut left_locked = app.left().lock();
     let selected_tab_index = content_locked.selected;
     let Some(selected_tab_index) = selected_tab_index else { return; };
 
@@ -36,6 +37,7 @@ pub fn smali_layout(ui: &mut Ui, server: &AsmServer, app: &AppContainer) {
         font: &font,
         content: content_mut,
         top: &mut top_locked,
+        left: &mut left_locked,
         lines: &lines,
         smali_style: &smali_style,
         dft_color,
@@ -51,6 +53,7 @@ pub fn smali_layout(ui: &mut Ui, server: &AsmServer, app: &AppContainer) {
 
 struct RenderContext<'a> {
     pub server: &'a AsmServer,
+    pub left: &'a mut Left,
     pub top: &'a mut Top,
     pub content: &'a mut Content,
     pub lines: &'a Vec<Vec<SmaliToken>>,
@@ -256,7 +259,7 @@ impl<'a> RenderContext<'a> {
         &mut self, ui: &mut Ui, descriptor: &str,
     ) {
         let RenderContext {
-            server, content, top, ..
+            server, content, top, left, ..
         } = self;
         let existed = server.find_class(descriptor);
         if !existed {
@@ -266,7 +269,7 @@ impl<'a> RenderContext<'a> {
             let Some(accessor) = accessor_locked.deref() else { return };
             let link = ui.link(descriptor);
             if link.clicked() {
-                server.switch_or_open_lock_free(descriptor, accessor, content, top)
+                server.switch_or_open_lock_free(descriptor, accessor, left, content, top)
             }
         }
     }

asm_egui/src/top_bar.rs

@@ -3,14 +3,15 @@ use bit_set::BitSet;
 use egui::containers::PopupCloseBehavior;
 use egui::text::LayoutJob;
 use egui::{popup_below_widget, Context, Id, Response, TextEdit, TextFormat, TextStyle, Ui};
+use java_asm_server::ui::{OpenFileMessage, UIMessage};
 use java_asm_server::AsmServer;
 use std::ops::Deref;
 
 impl EguiApp {
     pub(crate) fn top_bar(&mut self, ctx: &Context) {
         egui::TopBottomPanel::top("top_bar").show(ctx, |ui| {
             ui.vertical(|ui| {
-                let server_app = &mut self.server_app;
+                let server_app = &mut self.ui_app;
                 // loading state
                 let locked_top = server_app.top().lock();
                 let loading_state = &locked_top.loading_state;
@@ -30,15 +31,15 @@ impl EguiApp {
         ui.horizontal(|ui| {
             if ui.button("📂 Open...").clicked() {
                 AsmServer::dialog_to_open_file(
-                    self.server.clone(), self.server_app.clone(),
+                    self.server.clone(), self.ui_app.clone(),
                 );
             }
             self.file_path_input(ui);
         });
     }
 
     fn file_path_input(&mut self, ui: &mut Ui) {
-        let mut locked_top = self.server_app.top().lock();
+        let mut locked_top = self.ui_app.top().lock();
         let Some(file_path) = &mut locked_top.file_path else { return; };
 
         let edit_path_ui = Self::file_path_input_area(ui, file_path);
@@ -89,7 +90,7 @@ impl EguiApp {
     }
 
     fn popup_file_path_ui(&mut self, ui: &mut Ui) {
-        let search_results = self.server_app.top().lock().search_result.clone();
+        let search_results = self.ui_app.top().lock().search_result.clone();
         let style = ui.style();
         let font = TextStyle::Monospace.resolve(&style);
 
@@ -115,9 +116,10 @@ impl EguiApp {
             }
             let selectable_label = ui.selectable_label(false, text_layout_job);
             if selectable_label.clicked() {
-                let server_locked = self.server.lock();
-                let Some(server) = server_locked.deref() else { return; };
-                server.switch_or_open(&result.item, &self.server_app);
+                let message = UIMessage::OpenFile(
+                    OpenFileMessage { path: result.item }
+                );
+                self.ui_app.send_message(message);
                 ui.memory_mut(|m| m.close_popup());
             }
         }

asm_server/src/server.rs

@@ -1,7 +1,7 @@
 use crate::impls::fuzzy::FuzzyMatchModel;
 use crate::impls::server::FileOpenContext;
 use crate::impls::util::new_tokio_thread;
-use crate::ui::{AppContainer, Content, Tab, Top};
+use crate::ui::{AppContainer, Content, DirInfo, Left, Tab, Top};
 use crate::{Accessor, AccessorEnum, ArcVarOpt, AsmServer, ExportableSource, LoadingState, ServerMut};
 use java_asm::smali::SmaliNode;
 use java_asm::{AsmErr, StrRef};
@@ -89,14 +89,17 @@ impl AsmServer {
     pub fn switch_or_open(&self, file_key: &str, render_target: &AppContainer) {
         let accessor_locked = self.accessor.lock();
         let Some(accessor) = accessor_locked.deref() else { return; };
+        let mut left = render_target.left().lock();
         let mut content = render_target.content().lock();
         let mut top = render_target.top().lock();
-        self.switch_or_open_lock_free(file_key, accessor, &mut content, &mut top);
+        self.switch_or_open_lock_free(file_key, accessor, &mut left, &mut content, &mut top);
     }
 
     pub fn switch_or_open_lock_free(
-        &self, file_key: &str, accessor: &AccessorEnum, content: &mut Content, top: &mut Top,
+        &self, file_key: &str, accessor: &AccessorEnum,
+        left: &mut Left, content: &mut Content, top: &mut Top,
     ) {
+        self.switch_file_tree(left, file_key);
         let existed_tab = content.opened_tabs.iter().position(|tab| *tab.file_key == *file_key);
         if let Some(existed_tab) = existed_tab {
             content.selected = Some(existed_tab);
@@ -121,6 +124,22 @@ impl AsmServer {
         top.file_path = Some(file_key.to_string());
     }
 
+    fn switch_file_tree(&self, left: &mut Left, file_key: &str) {
+        let root_node = &mut left.root_node;
+        let parts: Vec<&str> = file_key.split('/').collect();
+        if parts.is_empty() { return; }
+
+        let mut current_node = root_node;
+        for part in parts {
+            current_node.raw.opened = true;
+            if let Some(child) = current_node.dirs.get_mut(part) {
+                current_node = child;
+            } else {
+                break;
+            }
+        }
+    }
+
     pub fn search(&self, top: &mut Top) {
         let Some(query) = &top.file_path else { return; };
         let query: StrRef = query.as_str().into();

asm_server/src/ui/mod.rs

@@ -2,9 +2,10 @@ pub mod log;
 pub mod msg;
 pub mod font;
 
+use crate::impls::fuzzy::SearchResult;
 use crate::ui::log::LogHolder;
 use crate::ui::AbsFile::{Dir, File};
-use crate::LoadingState;
+use crate::{AsmServer, LoadingState};
 use java_asm::smali::SmaliNode;
 use java_asm::StrRef;
 use ::log::Level;
@@ -13,7 +14,6 @@ use std::collections::BTreeMap;
 use std::iter::{Enumerate, Peekable};
 use std::str::Split;
 use std::sync::Arc;
-use crate::impls::fuzzy::SearchResult;
 
 /// contains all states of the app.
 /// It's not like the [crate::AsmServer] which only contains the information of a file.
@@ -23,8 +23,20 @@ pub struct App {
     pub top: Arc<Mutex<Top>>,
     pub left: Arc<Mutex<Left>>,
     pub content: Arc<Mutex<Content>>,
+    pub messages: Arc<Mutex<Vec<UIMessage>>>,
+}
+
+#[derive(Clone, Debug)]
+pub enum UIMessage {
+    OpenFile(OpenFileMessage),
 }
 
+#[derive(Clone, Debug)]
+pub struct OpenFileMessage {
+    pub path: StrRef,
+}
+
+
 #[derive(Default, Clone, Debug)]
 pub struct AppContainer(Arc<App>);
 
@@ -36,6 +48,22 @@ impl AppContainer {
     pub fn set_left(&self, left: Left) { *self.0.left.lock() = left; }
 
     pub fn content(&self) -> &Arc<Mutex<Content>> { &self.0.content }
+
+    pub fn send_message(&self, message: UIMessage) {
+        self.0.messages.lock().push(message);
+    }
+}
+
+impl AppContainer {
+    pub fn process_messages(&mut self, server: &mut AsmServer) {
+        for message in self.0.messages.lock().drain(..) {
+            match message {
+                UIMessage::OpenFile(message) => {
+                    server.switch_or_open(&message.path, self);
+                }
+            }
+        }
+    }
 }
 
 #[derive(Default, Clone, Debug)]