8196531018

Committed 08 Mar 2024 12:06AM UTC coverage: 41.901% (+6.5%) from 35.353%

Build # 8196531018

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #50 from ergrelet/40-make-it-possible-to-explore-types-by-browsing-modules

Make it possible to explore types by browsing modules

Run Details

287 of 784 new or added lines in 11 files covered. (36.61%)

6 existing lines in 3 files now uncovered.

1221 of 2914 relevant lines covered (41.9%)

1.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/resym/src/ui_components/module_tree.rs

use std::cell::RefCell;

use eframe::egui::{self, ScrollArea};

use resym_core::frontend::ModuleList;

use crate::{
    module_tree::{ModuleInfo, ModulePath, ModuleTreeNode},
    module_tree_view::{ModuleTreeView, ModuleTreeViewNode},
};

/// UI component in charge of rendering a tree of PDB modules
pub struct ModuleTreeComponent {
    /// Tree data
    module_tree_view: ModuleTreeView,
    /// Index of the currently selected module
    selected_module: RefCell<usize>,
}

impl ModuleTreeComponent {
    pub fn new() -> Self {
        Self {
            module_tree_view: ModuleTreeView::new(),
            selected_module: usize::MAX.into(),
        }
    }

    /// Update the list of modules that the tree contains
    pub fn set_module_list(&mut self, module_list: ModuleList) {
        // Generate the module tree
        let mut root_tree_node = ModuleTreeNode::default();
        for (module_path, module_index) in module_list.iter() {
            let module_path = ModulePath::from(module_path.as_str());
            // Add module to the tree
            if let Err(err) = root_tree_node.add_module_by_path(
                module_path,
                ModuleInfo {
                    pdb_index: *module_index,
                },
            ) {
                // Log error and continue
                log::warn!("Failed to add module to tree: {}", err);
            }
        }
        // Get a view of the module tree and store it
        self.module_tree_view = ModuleTreeView::from_tree_node(root_tree_node);
    }

    /// Update/render the UI component
    pub fn update<CB: Fn(&ModulePath, &ModuleInfo)>(
        &self,
        ctx: &egui::Context,
        ui: &mut egui::Ui,
        on_module_selected: &CB,
    ) {
        ScrollArea::vertical()
            .auto_shrink([false, false])
            .show(ui, |ui| {
                self.module_tree_view.children.iter().for_each(|view_node| {
                    self.update_module_tree(ctx, ui, view_node, on_module_selected);
                });
            });
    }

    fn update_module_tree<CB: Fn(&ModulePath, &ModuleInfo)>(
        &self,
        ctx: &egui::Context,
        ui: &mut egui::Ui,
        view_node: &ModuleTreeViewNode,
        on_module_selected: &CB,
    ) {
        if view_node.is_leaf() {
            self.update_module_leaf(ui, view_node, on_module_selected);
        } else {
            egui::collapsing_header::CollapsingState::load_with_default_open(
                ctx,
                ui.id().with(view_node.path().hash()),
                false,
            )
            .show_header(ui, |ui| {
                ui.label(&view_node.name);
            })
            .body(|ui| {
                view_node.children.iter().for_each(|view_node| {
                    self.update_module_tree(ctx, ui, view_node, on_module_selected);
                });
            });
        }
    }

    fn update_module_leaf<CB: Fn(&ModulePath, &ModuleInfo)>(
        &self,
        ui: &mut egui::Ui,
        view_node: &ModuleTreeViewNode,
        on_module_selected: &CB,
    ) {
        if let Some(ref module_info) = view_node.module_info() {
            if ui
                .selectable_label(
                    *self.selected_module.borrow() == module_info.pdb_index,
                    &view_node.name,
                )
                .clicked()
            {
                *self.selected_module.borrow_mut() = module_info.pdb_index;
                // Invoke event callback
                on_module_selected(view_node.path(), module_info);
            }
        }
    }
}

1	use std::cell::RefCell;
2
3	use eframe::egui::{self, ScrollArea};
4
5	use resym_core::frontend::ModuleList;
6
7	use crate::{
8	module_tree::{ModuleInfo, ModulePath, ModuleTreeNode},
9	module_tree_view::{ModuleTreeView, ModuleTreeViewNode},
10	};
11
12	/// UI component in charge of rendering a tree of PDB modules
13	pub struct ModuleTreeComponent {
14	/// Tree data
15	module_tree_view: ModuleTreeView,
16	/// Index of the currently selected module
17	selected_module: RefCell<usize>,
18	}
19
20	impl ModuleTreeComponent {
NEW 21	pub fn new() -> Self {	×
22	Self {
NEW 23	module_tree_view: ModuleTreeView::new(),	×
NEW 24	selected_module: usize::MAX.into(),	×
25	}
26	}
27
28	/// Update the list of modules that the tree contains
NEW 29	pub fn set_module_list(&mut self, module_list: ModuleList) {	×
30	// Generate the module tree
NEW 31	let mut root_tree_node = ModuleTreeNode::default();	×
NEW 32	for (module_path, module_index) in module_list.iter() {	×
NEW 33	let module_path = ModulePath::from(module_path.as_str());	×
34	// Add module to the tree
NEW 35	if let Err(err) = root_tree_node.add_module_by_path(	×
NEW 36	module_path,	×
NEW 37	ModuleInfo {	×
NEW 38	pdb_index: *module_index,	×
39	},
40	) {
41	// Log error and continue
NEW 42	log::warn!("Failed to add module to tree: {}", err);	×
43	}
44	}
45	// Get a view of the module tree and store it
NEW 46	self.module_tree_view = ModuleTreeView::from_tree_node(root_tree_node);	×
47	}
48
49	/// Update/render the UI component
NEW 50	pub fn update<CB: Fn(&ModulePath, &ModuleInfo)>(	×
51	&self,
52	ctx: &egui::Context,
53	ui: &mut egui::Ui,
54	on_module_selected: &CB,
55	) {
NEW 56	ScrollArea::vertical()	×
NEW 57	.auto_shrink([false, false])	×
NEW 58	.show(ui, \|ui\| {	×
NEW 59	self.module_tree_view.children.iter().for_each(\|view_node\| {	×
NEW 60	self.update_module_tree(ctx, ui, view_node, on_module_selected);	×
61	});
62	});
63	}
64
NEW 65	fn update_module_tree<CB: Fn(&ModulePath, &ModuleInfo)>(	×
66	&self,
67	ctx: &egui::Context,
68	ui: &mut egui::Ui,
69	view_node: &ModuleTreeViewNode,
70	on_module_selected: &CB,
71	) {
NEW 72	if view_node.is_leaf() {	×
NEW 73	self.update_module_leaf(ui, view_node, on_module_selected);	×
74	} else {
75	egui::collapsing_header::CollapsingState::load_with_default_open(
NEW 76	ctx,	×
NEW 77	ui.id().with(view_node.path().hash()),	×
78	false,
79	)
NEW 80	.show_header(ui, \|ui\| {	×
NEW 81	ui.label(&view_node.name);	×
82	})
NEW 83	.body(\|ui\| {	×
NEW 84	view_node.children.iter().for_each(\|view_node\| {	×
NEW 85	self.update_module_tree(ctx, ui, view_node, on_module_selected);	×
86	});
87	});
88	}
89	}
90
NEW 91	fn update_module_leaf<CB: Fn(&ModulePath, &ModuleInfo)>(	×
92	&self,
93	ui: &mut egui::Ui,
94	view_node: &ModuleTreeViewNode,
95	on_module_selected: &CB,
96	) {
NEW 97	if let Some(ref module_info) = view_node.module_info() {	×
NEW 98	if ui	×
99	.selectable_label(
NEW 100	*self.selected_module.borrow() == module_info.pdb_index,	×
NEW 101	&view_node.name,	×
102	)
103	.clicked()
104	{
NEW 105	*self.selected_module.borrow_mut() = module_info.pdb_index;	×
106	// Invoke event callback
NEW 107	on_module_selected(view_node.path(), module_info);	×
108	}
109	}
110	}
111	}

ergrelet / resym / 8196531018

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous