Document configuration file & more cleanup

Cargo.lock

@@ -508,6 +508,16 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "bstr"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.12.0"
@@ -885,7 +895,16 @@ version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.3.7",
+]
+
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys 0.4.1",
 ]
 
 [[package]]
@@ -899,6 +918,18 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "dirs-sys-next"
 version = "0.1.2"
@@ -1455,6 +1486,20 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
+[[package]]
+name = "globset"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "fnv",
+ "log",
+ "regex",
+ "serde",
+]
+
 [[package]]
 name = "glow"
 version = "0.12.1"
@@ -2412,7 +2457,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff"
-version = "0.3.4"
+version = "0.4.0"
 dependencies = [
  "anyhow",
  "byteorder",
@@ -2421,11 +2466,13 @@ dependencies = [
  "console_error_panic_hook",
  "const_format",
  "cwdemangle",
+ "dirs 5.0.1",
  "eframe",
  "egui",
  "egui_extras",
  "exec",
  "flagset",
+ "globset",
  "log",
  "memmap2 0.7.1",
  "notify",
@@ -2438,6 +2485,8 @@ dependencies = [
  "rfd",
  "self_update",
  "serde",
+ "serde_json",
+ "serde_yaml",
  "tempfile",
  "thiserror",
  "time",
@@ -2519,6 +2568,12 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
 [[package]]
 name = "orbclient"
 version = "0.3.45"
@@ -3131,9 +3186,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.100"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f1e14e89be7aa4c4b78bdbdc9eb5bf8517829a600ae8eaa39a6e1d960b5185c"
+checksum = "076066c5f1078eac5b722a31827a8832fe108bed65dfa75e233c89f8206e976c"
 dependencies = [
  "itoa",
  "ryu",
@@ -3172,6 +3227,19 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_yaml"
+version = "0.9.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a49e178e4452f45cb61d0cd8cebc1b0fafd3e41929e996cef79aa3aca91f574"
+dependencies = [
+ "indexmap 2.0.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "sha1"
 version = "0.10.5"
@@ -3701,6 +3769,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa"
+
 [[package]]
 name = "untrusted"
 version = "0.7.1"
@@ -3965,7 +4039,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "579cc485bd5ce5bfa0d738e4921dd0b956eca9800be1fd2e5257ebe95bc4617e"
 dependencies = [
  "core-foundation",
- "dirs",
+ "dirs 4.0.0",
  "jni",
  "log",
  "ndk-context",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff"
-version = "0.3.4"
+version = "0.4.0"
 edition = "2021"
 rust-version = "1.65"
 authors = ["Luke Street <luke@street.dev>"]
@@ -23,14 +23,17 @@ wgpu = ["eframe/wgpu"]
 
 [dependencies]
 anyhow = "1.0.71"
+byteorder = "1.4.3"
 bytes = "1.4.0"
 cfg-if = "1.0.0"
 const_format = "0.2.31"
 cwdemangle = "0.1.5"
+dirs = "5.0.1"
 eframe = { version = "0.22.0", features = ["persistence"] }
 egui = "0.22.0"
 egui_extras = "0.22.0"
 flagset = "0.4.3"
+globset = { version = "0.4.13", features = ["serde1"] }
 log = "0.4.19"
 memmap2 = "0.7.1"
 notify = "6.0.1"
@@ -40,12 +43,13 @@ ppc750cl = { git = "https://github.com/terorie/ppc750cl", rev = "9ae36eef34aa6d7
 rabbitizer = "1.7.4"
 rfd = { version = "0.11.4" } #, default-features = false, features = ['xdg-portal']
 serde = { version = "1", features = ["derive"] }
+serde_json = "1.0.104"
+serde_yaml = "0.9.25"
 tempfile = "3.6.0"
 thiserror = "1.0.41"
 time = { version = "0.3.22", features = ["formatting", "local-offset"] }
 toml = "0.7.6"
 twox-hash = "1.6.3"
-byteorder = "1.4.3"
 
 # For Linux static binaries, use rustls
 [target.'cfg(target_os = "linux")'.dependencies]

README.md

@@ -5,14 +5,87 @@
 
 A local diffing tool for decompilation projects.
 
-Currently supports:
+Supports:
 - PowerPC 750CL (GameCube & Wii)
 - MIPS (Nintendo 64)
 
+See [Usage](#usage) for more information.
+
 ![Symbol Screenshot](assets/screen-symbols.png)
 ![Diff Screenshot](assets/screen-diff.png)
 
-### License
+## Usage
+
+objdiff works by comparing two relocatable object files (`.o`). The objects are expected to have the same relative path from the "target" and "base" directories.
+
+For example, if the target ("expected") object is located at `build/asm/MetroTRK/mslsupp.o` and the base ("actual") object 
+is located at `build/src/MetroTRK/mslsupp.o`, the following configuration would be used:
+
+- Target build directory: `build/asm`
+- Base build directory: `build/src`
+- Object: `MetroTRK/mslsupp.o`
+
+objdiff will then execute the build system from the project directory to build both objects:
+
+```sh
+$ make build/asm/MetroTRK/mslsupp.o # Only if "Build target object" is enabled
+$ make build/src/MetroTRK/mslsupp.o
+```
+
+The objects will then be compared and the results will be displayed in the UI.
+
+See [Configuration](#configuration) for more information.
+
+## Configuration
+
+While **not required** (most settings can be specified in the UI), projects can add an `objdiff.json` (or `objdiff.yaml`, `objdiff.yml`) file to configure the tool automatically. The configuration file must be located in the root project directory.
+
+```json5
+// objdiff.json
+{
+  "custom_make": "ninja",
+  "target_dir": "build/mp1.0/asm",
+  "base_dir": "build/mp1.0/src",
+  "build_target": true,
+  "watch_patterns": [
+    "*.c",
+    "*.cp",
+    "*.cpp",
+    "*.h",
+    "*.hpp",
+    "*.py"
+  ],
+  "objects": [
+    {
+      "path": "MetroTRK/mslsupp.o",
+      "name": "MetroTRK/mslsupp",
+      "reverse_fn_order": false
+    },
+    // ...
+  ]
+}
+```
+
+- `custom_make` _(optional)_: By default, objdiff will use `make` to build the project.  
+  If the project uses a different build system (e.g. `ninja`), specify it here.
+- `target_dir`: Relative from the root of the project, this where the "target" or "expected" objects are located.  
+  These are the **intended result** of the match.
+- `base_dir`: Relative from the root of the project, this is where the "base" or "actual" objects are located.  
+  These are objects built from the **current source code**.
+- `build_target`: If true, objdiff will tell the build system to build the target objects before diffing (e.g. `make path/to/target.o`).  
+  This is useful if the target objects are not built by default or can change based on project configuration or edits to assembly files.  
+  Requires the build system to be configured properly.
+- `watch_patterns` _(optional)_: A list of glob patterns to watch for changes. ([Supported syntax](https://docs.rs/globset/latest/globset/#syntax))  
+  If any of these files change, objdiff will automatically rebuild the objects and re-compare them.
+- `objects` _(optional)_: If specified, objdiff will display a list of objects in the sidebar for easy navigation.
+  - `path`: Relative path to the object from the `target_dir` and `base_dir`.
+  - `name` _(optional)_: The name of the object in the UI. If not specified, the object's `path` will be used.  
+  - `reverse_fn_order` _(optional)_: Displays function symbols in reversed order.  
+    Used to support MWCC's `-inline deferred` option, which reverses the order of functions in the object file.
+
+
+
+## License
 
 Licensed under either of
 

src/config.rs

@@ -0,0 +1,126 @@
+use std::{
+    fs::File,
+    path::{Component, Path, PathBuf},
+};
+
+use anyhow::{Context, Result};
+use globset::{Glob, GlobSet, GlobSetBuilder};
+
+use crate::app::AppConfig;
+
+#[derive(Default, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct ProjectConfig {
+    pub custom_make: Option<String>,
+    pub target_dir: Option<PathBuf>,
+    pub base_dir: Option<PathBuf>,
+    pub build_target: bool,
+    pub watch_patterns: Vec<Glob>,
+    #[serde(alias = "units")]
+    pub objects: Vec<ProjectObject>,
+}
+
+#[derive(Default, Clone, serde::Deserialize)]
+pub struct ProjectObject {
+    pub name: Option<String>,
+    pub path: PathBuf,
+    pub reverse_fn_order: Option<bool>,
+}
+
+#[derive(Clone)]
+pub enum ProjectObjectNode {
+    File(String, ProjectObject),
+    Dir(String, Vec<ProjectObjectNode>),
+}
+
+fn find_dir<'a>(
+    name: &str,
+    nodes: &'a mut Vec<ProjectObjectNode>,
+) -> &'a mut Vec<ProjectObjectNode> {
+    if let Some(index) = nodes
+        .iter()
+        .position(|node| matches!(node, ProjectObjectNode::Dir(dir_name, _) if dir_name == name))
+    {
+        if let ProjectObjectNode::Dir(_, children) = &mut nodes[index] {
+            return children;
+        }
+    } else {
+        nodes.push(ProjectObjectNode::Dir(name.to_string(), vec![]));
+        if let Some(ProjectObjectNode::Dir(_, children)) = nodes.last_mut() {
+            return children;
+        }
+    }
+    unreachable!();
+}
+
+fn build_nodes(objects: &[ProjectObject]) -> Vec<ProjectObjectNode> {
+    let mut nodes = vec![];
+    for object in objects {
+        let mut out_nodes = &mut nodes;
+        let path = object.name.as_ref().map(Path::new).unwrap_or(&object.path);
+        if let Some(parent) = path.parent() {
+            for component in parent.components() {
+                if let Component::Normal(name) = component {
+                    let name = name.to_str().unwrap();
+                    out_nodes = find_dir(name, out_nodes);
+                }
+            }
+        }
+        let filename = path.file_name().unwrap().to_str().unwrap().to_string();
+        out_nodes.push(ProjectObjectNode::File(filename, object.clone()));
+    }
+    nodes
+}
+
+pub const CONFIG_FILENAMES: [&str; 3] = ["objdiff.yml", "objdiff.yaml", "objdiff.json"];
+
+pub fn load_project_config(config: &mut AppConfig) -> Result<()> {
+    let Some(project_dir) = &config.project_dir else {
+        return Ok(());
+    };
+    if let Some(result) = try_project_config(project_dir) {
+        let project_config = result?;
+        config.custom_make = project_config.custom_make;
+        config.target_obj_dir = project_config.target_dir.map(|p| project_dir.join(p));
+        config.base_obj_dir = project_config.base_dir.map(|p| project_dir.join(p));
+        config.build_target = project_config.build_target;
+        config.watch_patterns = project_config.watch_patterns;
+        config.watcher_change = true;
+        config.objects = project_config.objects;
+        config.object_nodes = build_nodes(&config.objects);
+    }
+    Ok(())
+}
+
+fn try_project_config(dir: &Path) -> Option<Result<ProjectConfig>> {
+    for filename in CONFIG_FILENAMES.iter() {
+        let config_path = dir.join(filename);
+        if config_path.is_file() {
+            return match filename.contains("json") {
+                true => Some(read_json_config(&config_path)),
+                false => Some(read_yml_config(&config_path)),
+            };
+        }
+    }
+    None
+}
+
+fn read_yml_config(config_path: &Path) -> Result<ProjectConfig> {
+    let mut reader = File::open(config_path)
+        .with_context(|| format!("Failed to open config file '{}'", config_path.display()))?;
+    Ok(serde_yaml::from_reader(&mut reader)?)
+}
+
+fn read_json_config(config_path: &Path) -> Result<ProjectConfig> {
+    let mut reader = File::open(config_path)
+        .with_context(|| format!("Failed to open config file '{}'", config_path.display()))?;
+    Ok(serde_json::from_reader(&mut reader)?)
+}
+
+pub fn build_globset(vec: &[Glob]) -> std::result::Result<GlobSet, globset::Error> {
+    let mut builder = GlobSetBuilder::new();
+    for glob in vec {
+        builder.add(glob.clone());
+    }
+    builder.build()
+}

src/diff.rs

@@ -3,7 +3,6 @@ use std::{collections::BTreeMap, mem::take};
 use anyhow::Result;
 
 use crate::{
-    app::DiffConfig,
     editops::{editops_find, LevEditType},
     obj::{
         mips, ppc, ObjArchitecture, ObjDataDiff, ObjDataDiffKind, ObjInfo, ObjInsArg,
@@ -373,7 +372,7 @@ fn find_section_and_symbol(obj: &ObjInfo, name: &str) -> Option<(usize, usize)>
     None
 }
 
-pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo, _diff_config: &DiffConfig) -> Result<()> {
+pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo) -> Result<()> {
     for left_section in &mut left.sections {
         if left_section.kind == ObjSectionKind::Code {
             for left_symbol in &mut left_section.symbols {

src/jobs/bindiff.rs

@@ -1,44 +0,0 @@
-use std::sync::{mpsc::Receiver, Arc, RwLock};
-
-use anyhow::{Error, Result};
-
-use crate::{
-    app::{AppConfig, DiffConfig},
-    diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
-    obj::{elf, ObjInfo},
-};
-
-pub struct BinDiffResult {
-    pub first_obj: ObjInfo,
-    pub second_obj: ObjInfo,
-}
-
-fn run_build(
-    status: &Status,
-    cancel: Receiver<()>,
-    config: Arc<RwLock<AppConfig>>,
-) -> Result<Box<BinDiffResult>> {
-    let config = config.read().map_err(|_| Error::msg("Failed to lock app config"))?.clone();
-    let target_path =
-        config.left_obj.as_ref().ok_or_else(|| Error::msg("Missing target obj path"))?;
-    let base_path = config.right_obj.as_ref().ok_or_else(|| Error::msg("Missing base obj path"))?;
-
-    update_status(status, "Loading target obj".to_string(), 0, 3, &cancel)?;
-    let mut left_obj = elf::read(target_path)?;
-
-    update_status(status, "Loading base obj".to_string(), 1, 3, &cancel)?;
-    let mut right_obj = elf::read(base_path)?;
-
-    update_status(status, "Performing diff".to_string(), 2, 3, &cancel)?;
-    diff_objs(&mut left_obj, &mut right_obj, &DiffConfig::default() /* TODO */)?;
-
-    update_status(status, "Complete".to_string(), 3, 3, &cancel)?;
-    Ok(Box::new(BinDiffResult { first_obj: left_obj, second_obj: right_obj }))
-}
-
-pub fn queue_bindiff(config: Arc<RwLock<AppConfig>>) -> JobState {
-    queue_job("Binary diff", Job::BinDiff, move |status, cancel| {
-        run_build(status, cancel, config).map(JobResult::BinDiff)
-    })
-}

src/jobs/check_update.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use self_update::{cargo_crate_version, update::Release};
 
 use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
     update::{build_updater, BIN_NAME},
 };
 
@@ -14,7 +14,7 @@ pub struct CheckUpdateResult {
     pub found_binary: bool,
 }
 
-fn run_check_update(status: &Status, cancel: Receiver<()>) -> Result<Box<CheckUpdateResult>> {
+fn run_check_update(status: &JobStatusRef, cancel: Receiver<()>) -> Result<Box<CheckUpdateResult>> {
     update_status(status, "Fetching latest release".to_string(), 0, 1, &cancel)?;
     let updater = build_updater().context("Failed to create release updater")?;
     let latest_release = updater.get_latest_release()?;
@@ -26,8 +26,8 @@ fn run_check_update(status: &Status, cancel: Receiver<()>) -> Result<Box<CheckUp
     Ok(Box::new(CheckUpdateResult { update_available, latest_release, found_binary }))
 }
 
-pub fn queue_check_update() -> JobState {
-    queue_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
-        run_check_update(status, cancel).map(JobResult::CheckUpdate)
+pub fn start_check_update() -> JobState {
+    start_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
+        run_check_update(status, cancel).map(|result| JobResult::CheckUpdate(Some(result)))
     })
 }

src/jobs/mod.rs

@@ -9,12 +9,8 @@ use std::{
 
 use anyhow::Result;
 
-use crate::jobs::{
-    bindiff::BinDiffResult, check_update::CheckUpdateResult, objdiff::ObjDiffResult,
-    update::UpdateResult,
-};
+use crate::jobs::{check_update::CheckUpdateResult, objdiff::ObjDiffResult, update::UpdateResult};
 
-pub mod bindiff;
 pub mod check_update;
 pub mod objdiff;
 pub mod update;
@@ -22,19 +18,88 @@ pub mod update;
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub enum Job {
     ObjDiff,
-    BinDiff,
     CheckUpdate,
     Update,
 }
 pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Default)]
+pub struct JobQueue {
+    pub jobs: Vec<JobState>,
+    pub results: Vec<JobResult>,
+}
+
+impl JobQueue {
+    /// Adds a job to the queue.
+    #[inline]
+    pub fn push(&mut self, state: JobState) { self.jobs.push(state); }
+
+    /// Adds a job to the queue if a job of the given kind is not already running.
+    #[inline]
+    pub fn push_once(&mut self, job: Job, func: impl FnOnce() -> JobState) {
+        if !self.is_running(job) {
+            self.push(func());
+        }
+    }
+
+    /// Returns whether a job of the given kind is running.
+    pub fn is_running(&self, kind: Job) -> bool {
+        self.jobs.iter().any(|j| j.kind == kind && j.handle.is_some())
+    }
+
+    /// Returns whether any job is running.
+    pub fn any_running(&self) -> bool {
+        self.jobs.iter().any(|job| {
+            if let Some(handle) = &job.handle {
+                return !handle.is_finished();
+            }
+            false
+        })
+    }
+
+    /// Iterates over all jobs mutably.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut JobState> + '_ { self.jobs.iter_mut() }
+
+    /// Iterates over all finished jobs, returning the job state and the result.
+    pub fn iter_finished(
+        &mut self,
+    ) -> impl Iterator<Item = (&mut JobState, std::thread::Result<JobResult>)> + '_ {
+        self.jobs.iter_mut().filter_map(|job| {
+            if let Some(handle) = &job.handle {
+                if !handle.is_finished() {
+                    return None;
+                }
+                let result = job.handle.take().unwrap().join();
+                return Some((job, result));
+            }
+            None
+        })
+    }
+
+    /// Clears all finished jobs.
+    pub fn clear_finished(&mut self) {
+        self.jobs.retain(|job| {
+            !(job.should_remove
+                && job.handle.is_none()
+                && job.status.read().unwrap().error.is_none())
+        });
+    }
+
+    /// Removes a job from the queue given its ID.
+    pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
+}
+
+pub type JobStatusRef = Arc<RwLock<JobStatus>>;
+
 pub struct JobState {
     pub id: usize,
-    pub job_type: Job,
+    pub kind: Job,
     pub handle: Option<JoinHandle<JobResult>>,
-    pub status: Arc<RwLock<JobStatus>>,
+    pub status: JobStatusRef,
     pub cancel: Sender<()>,
     pub should_remove: bool,
 }
+
 #[derive(Default)]
 pub struct JobStatus {
     pub title: String,
@@ -43,11 +108,11 @@ pub struct JobStatus {
     pub status: String,
     pub error: Option<anyhow::Error>,
 }
+
 pub enum JobResult {
     None,
-    ObjDiff(Box<ObjDiffResult>),
-    BinDiff(Box<BinDiffResult>),
-    CheckUpdate(Box<CheckUpdateResult>),
+    ObjDiff(Option<Box<ObjDiffResult>>),
+    CheckUpdate(Option<Box<CheckUpdateResult>>),
     Update(Box<UpdateResult>),
 }
 
@@ -58,12 +123,10 @@ fn should_cancel(rx: &Receiver<()>) -> bool {
     }
 }
 
-type Status = Arc<RwLock<JobStatus>>;
-
-fn queue_job(
+fn start_job(
     title: &str,
-    job_type: Job,
-    run: impl FnOnce(&Status, Receiver<()>) -> Result<JobResult> + Send + 'static,
+    kind: Job,
+    run: impl FnOnce(&JobStatusRef, Receiver<()>) -> Result<JobResult> + Send + 'static,
 ) -> JobState {
     let status = Arc::new(RwLock::new(JobStatus {
         title: title.to_string(),
@@ -89,7 +152,7 @@ fn queue_job(
     log::info!("Started job {}", id);
     JobState {
         id,
-        job_type,
+        kind,
         handle: Some(handle),
         status: status_clone,
         cancel: tx,
@@ -98,7 +161,7 @@ fn queue_job(
 }
 
 fn update_status(
-    status: &Status,
+    status: &JobStatusRef,
     str: String,
     count: u32,
     total: u32,

src/jobs/objdiff.rs

@@ -1,17 +1,12 @@
-use std::{
-    path::Path,
-    process::Command,
-    str::from_utf8,
-    sync::{mpsc::Receiver, Arc, RwLock},
-};
+use std::{path::Path, process::Command, str::from_utf8, sync::mpsc::Receiver};
 
 use anyhow::{Context, Error, Result};
 use time::OffsetDateTime;
 
 use crate::{
-    app::{AppConfig, DiffConfig},
+    app::{AppConfig, AppConfigRef},
     diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
     obj::{elf, ObjInfo},
 };
 
@@ -76,10 +71,9 @@ fn run_make(cwd: &Path, arg: &Path, config: &AppConfig) -> BuildStatus {
 }
 
 fn run_build(
-    status: &Status,
+    status: &JobStatusRef,
     cancel: Receiver<()>,
-    config: Arc<RwLock<AppConfig>>,
-    diff_config: DiffConfig,
+    config: AppConfigRef,
 ) -> Result<Box<ObjDiffResult>> {
     let config = config.read().map_err(|_| Error::msg("Failed to lock app config"))?.clone();
     let obj_path = config.obj_path.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
@@ -129,15 +123,15 @@ fn run_build(
 
     if let (Some(first_obj), Some(second_obj)) = (&mut first_obj, &mut second_obj) {
         update_status(status, "Performing diff".to_string(), 4, total, &cancel)?;
-        diff_objs(first_obj, second_obj, &diff_config)?;
+        diff_objs(first_obj, second_obj)?;
     }
 
     update_status(status, "Complete".to_string(), total, total, &cancel)?;
     Ok(Box::new(ObjDiffResult { first_status, second_status, first_obj, second_obj, time }))
 }
 
-pub fn queue_build(config: Arc<RwLock<AppConfig>>, diff_config: DiffConfig) -> JobState {
-    queue_job("Object diff", Job::ObjDiff, move |status, cancel| {
-        run_build(status, cancel, config, diff_config).map(JobResult::ObjDiff)
+pub fn start_build(config: AppConfigRef) -> JobState {
+    start_job("Object diff", Job::ObjDiff, move |status, cancel| {
+        run_build(status, cancel, config).map(|result| JobResult::ObjDiff(Some(result)))
     })
 }

src/jobs/update.rs

@@ -9,7 +9,7 @@ use anyhow::{Context, Result};
 use const_format::formatcp;
 
 use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
     update::{build_updater, BIN_NAME},
 };
 
@@ -17,7 +17,7 @@ pub struct UpdateResult {
     pub exe_path: PathBuf,
 }
 
-fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>> {
+fn run_update(status: &JobStatusRef, cancel: Receiver<()>) -> Result<Box<UpdateResult>> {
     update_status(status, "Fetching latest release".to_string(), 0, 3, &cancel)?;
     let updater = build_updater().context("Failed to create release updater")?;
     let latest_release = updater.get_latest_release()?;
@@ -53,8 +53,8 @@ fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn queue_update() -> JobState {
-    queue_job("Update app", Job::Update, move |status, cancel| {
+pub fn start_update() -> JobState {
+    start_job("Update app", Job::Update, move |status, cancel| {
         run_update(status, cancel).map(JobResult::Update)
     })
 }

src/lib.rs

@@ -3,6 +3,7 @@
 pub use app::App;
 
 mod app;
+mod config;
 mod diff;
 mod editops;
 mod jobs;

src/obj/elf.rs

@@ -181,7 +181,7 @@ fn find_section_symbol(
 fn relocations_by_section(
     arch: ObjArchitecture,
     obj_file: &File<'_>,
-    section: &mut ObjSection,
+    section: &ObjSection,
 ) -> Result<Vec<ObjReloc>> {
     let obj_section = obj_file.section_by_index(SectionIndex(section.index))?;
     let mut relocations = Vec::<ObjReloc>::new();

src/views/appearance.rs

@@ -0,0 +1,139 @@
+use egui::{Color32, FontFamily, FontId, TextStyle};
+use time::UtcOffset;
+
+#[derive(serde::Deserialize, serde::Serialize)]
+#[serde(default)]
+pub struct Appearance {
+    pub ui_font: FontId,
+    pub code_font: FontId,
+    pub diff_colors: Vec<Color32>,
+    pub theme: eframe::Theme,
+
+    // Applied by theme
+    #[serde(skip)]
+    pub text_color: Color32, // GRAY
+    #[serde(skip)]
+    pub emphasized_text_color: Color32, // LIGHT_GRAY
+    #[serde(skip)]
+    pub deemphasized_text_color: Color32, // DARK_GRAY
+    #[serde(skip)]
+    pub highlight_color: Color32, // WHITE
+    #[serde(skip)]
+    pub replace_color: Color32, // LIGHT_BLUE
+    #[serde(skip)]
+    pub insert_color: Color32, // GREEN
+    #[serde(skip)]
+    pub delete_color: Color32, // RED
+
+    // Global
+    #[serde(skip)]
+    pub utc_offset: UtcOffset,
+}
+
+impl Default for Appearance {
+    fn default() -> Self {
+        Self {
+            ui_font: FontId { size: 12.0, family: FontFamily::Proportional },
+            code_font: FontId { size: 14.0, family: FontFamily::Monospace },
+            diff_colors: DEFAULT_COLOR_ROTATION.to_vec(),
+            theme: eframe::Theme::Dark,
+            text_color: Color32::GRAY,
+            emphasized_text_color: Color32::LIGHT_GRAY,
+            deemphasized_text_color: Color32::DARK_GRAY,
+            highlight_color: Color32::WHITE,
+            replace_color: Color32::LIGHT_BLUE,
+            insert_color: Color32::GREEN,
+            delete_color: Color32::from_rgb(200, 40, 41),
+            utc_offset: UtcOffset::UTC,
+        }
+    }
+}
+
+impl Appearance {
+    pub fn apply(&mut self, style: &egui::Style) -> egui::Style {
+        let mut style = style.clone();
+        style.text_styles.insert(TextStyle::Body, FontId {
+            size: (self.ui_font.size * 0.75).floor(),
+            family: self.ui_font.family.clone(),
+        });
+        style.text_styles.insert(TextStyle::Body, self.ui_font.clone());
+        style.text_styles.insert(TextStyle::Button, self.ui_font.clone());
+        style.text_styles.insert(TextStyle::Heading, FontId {
+            size: (self.ui_font.size * 1.5).floor(),
+            family: self.ui_font.family.clone(),
+        });
+        style.text_styles.insert(TextStyle::Monospace, self.code_font.clone());
+        match self.theme {
+            eframe::Theme::Dark => {
+                style.visuals = egui::Visuals::dark();
+                self.text_color = Color32::GRAY;
+                self.emphasized_text_color = Color32::LIGHT_GRAY;
+                self.deemphasized_text_color = Color32::DARK_GRAY;
+                self.highlight_color = Color32::WHITE;
+                self.replace_color = Color32::LIGHT_BLUE;
+                self.insert_color = Color32::GREEN;
+                self.delete_color = Color32::from_rgb(200, 40, 41);
+            }
+            eframe::Theme::Light => {
+                style.visuals = egui::Visuals::light();
+                self.text_color = Color32::GRAY;
+                self.emphasized_text_color = Color32::DARK_GRAY;
+                self.deemphasized_text_color = Color32::LIGHT_GRAY;
+                self.highlight_color = Color32::BLACK;
+                self.replace_color = Color32::DARK_BLUE;
+                self.insert_color = Color32::DARK_GREEN;
+                self.delete_color = Color32::from_rgb(200, 40, 41);
+            }
+        }
+        style
+    }
+}
+
+pub const DEFAULT_COLOR_ROTATION: [Color32; 9] = [
+    Color32::from_rgb(255, 0, 255),
+    Color32::from_rgb(0, 255, 255),
+    Color32::from_rgb(0, 128, 0),
+    Color32::from_rgb(255, 0, 0),
+    Color32::from_rgb(255, 255, 0),
+    Color32::from_rgb(255, 192, 203),
+    Color32::from_rgb(0, 0, 255),
+    Color32::from_rgb(0, 255, 0),
+    Color32::from_rgb(213, 138, 138),
+];
+
+pub fn appearance_window(ctx: &egui::Context, show: &mut bool, appearance: &mut Appearance) {
+    egui::Window::new("Appearance").open(show).show(ctx, |ui| {
+        egui::ComboBox::from_label("Theme")
+            .selected_text(format!("{:?}", appearance.theme))
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut appearance.theme, eframe::Theme::Dark, "Dark");
+                ui.selectable_value(&mut appearance.theme, eframe::Theme::Light, "Light");
+            });
+        ui.label("UI font:");
+        egui::introspection::font_id_ui(ui, &mut appearance.ui_font);
+        ui.separator();
+        ui.label("Code font:");
+        egui::introspection::font_id_ui(ui, &mut appearance.code_font);
+        ui.separator();
+        ui.label("Diff colors:");
+        if ui.button("Reset").clicked() {
+            appearance.diff_colors = DEFAULT_COLOR_ROTATION.to_vec();
+        }
+        let mut remove_at: Option<usize> = None;
+        let num_colors = appearance.diff_colors.len();
+        for (idx, color) in appearance.diff_colors.iter_mut().enumerate() {
+            ui.horizontal(|ui| {
+                ui.color_edit_button_srgba(color);
+                if num_colors > 1 && ui.small_button("-").clicked() {
+                    remove_at = Some(idx);
+                }
+            });
+        }
+        if let Some(idx) = remove_at {
+            appearance.diff_colors.remove(idx);
+        }
+        if ui.small_button("+").clicked() {
+            appearance.diff_colors.push(Color32::BLACK);
+        }
+    });
+}

src/views/data_diff.rs

@@ -5,10 +5,12 @@ use egui_extras::{Column, TableBuilder};
 use time::format_description;
 
 use crate::{
-    app::{SymbolReference, View, ViewConfig, ViewState},
-    jobs::Job,
     obj::{ObjDataDiff, ObjDataDiffKind, ObjInfo, ObjSection},
-    views::write_text,
+    views::{
+        appearance::Appearance,
+        symbol_diff::{DiffViewState, SymbolReference, View},
+        write_text,
+    },
 };
 
 const BYTES_PER_ROW: usize = 16;
@@ -17,29 +19,29 @@ fn find_section<'a>(obj: &'a ObjInfo, selected_symbol: &SymbolReference) -> Opti
     obj.sections.iter().find(|section| section.name == selected_symbol.section_name)
 }
 
-fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], config: &ViewConfig) {
+fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], appearance: &Appearance) {
     if diffs.iter().any(|d| d.kind != ObjDataDiffKind::None) {
         ui.painter().rect_filled(ui.available_rect_before_wrap(), 0.0, ui.visuals().faint_bg_color);
     }
     let mut job = LayoutJob::default();
     write_text(
         format!("{address:08X}: ").as_str(),
-        config.text_color,
+        appearance.text_color,
         &mut job,
-        config.code_font.clone(),
+        appearance.code_font.clone(),
     );
     let mut cur_addr = 0usize;
     for diff in diffs {
         let base_color = match diff.kind {
-            ObjDataDiffKind::None => config.text_color,
-            ObjDataDiffKind::Replace => config.replace_color,
-            ObjDataDiffKind::Delete => config.delete_color,
-            ObjDataDiffKind::Insert => config.insert_color,
+            ObjDataDiffKind::None => appearance.text_color,
+            ObjDataDiffKind::Replace => appearance.replace_color,
+            ObjDataDiffKind::Delete => appearance.delete_color,
+            ObjDataDiffKind::Insert => appearance.insert_color,
         };
         if diff.data.is_empty() {
             let mut str = "   ".repeat(diff.len);
             str.push_str(" ".repeat(diff.len / 8).as_str());
-            write_text(str.as_str(), base_color, &mut job, config.code_font.clone());
+            write_text(str.as_str(), base_color, &mut job, appearance.code_font.clone());
             cur_addr += diff.len;
         } else {
             let mut text = String::new();
@@ -50,7 +52,7 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], config:
                     text.push(' ');
                 }
             }
-            write_text(text.as_str(), base_color, &mut job, config.code_font.clone());
+            write_text(text.as_str(), base_color, &mut job, appearance.code_font.clone());
         }
     }
     if cur_addr < BYTES_PER_ROW {
@@ -58,22 +60,22 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], config:
         let mut str = " ".to_string();
         str.push_str("   ".repeat(n).as_str());
         str.push_str(" ".repeat(n / 8).as_str());
-        write_text(str.as_str(), config.text_color, &mut job, config.code_font.clone());
+        write_text(str.as_str(), appearance.text_color, &mut job, appearance.code_font.clone());
     }
-    write_text(" ", config.text_color, &mut job, config.code_font.clone());
+    write_text(" ", appearance.text_color, &mut job, appearance.code_font.clone());
     for diff in diffs {
         let base_color = match diff.kind {
-            ObjDataDiffKind::None => config.text_color,
-            ObjDataDiffKind::Replace => config.replace_color,
-            ObjDataDiffKind::Delete => config.delete_color,
-            ObjDataDiffKind::Insert => config.insert_color,
+            ObjDataDiffKind::None => appearance.text_color,
+            ObjDataDiffKind::Replace => appearance.replace_color,
+            ObjDataDiffKind::Delete => appearance.delete_color,
+            ObjDataDiffKind::Insert => appearance.insert_color,
         };
         if diff.data.is_empty() {
             write_text(
                 " ".repeat(diff.len).as_str(),
                 base_color,
                 &mut job,
-                config.code_font.clone(),
+                appearance.code_font.clone(),
             );
         } else {
             let mut text = String::new();
@@ -85,7 +87,7 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], config:
                     text.push('.');
                 }
             }
-            write_text(text.as_str(), base_color, &mut job, config.code_font.clone());
+            write_text(text.as_str(), base_color, &mut job, appearance.code_font.clone());
         }
     }
     ui.add(Label::new(job).sense(Sense::click()));
@@ -133,7 +135,7 @@ fn data_table_ui(
     left_obj: &ObjInfo,
     right_obj: &ObjInfo,
     selected_symbol: &SymbolReference,
-    config: &ViewConfig,
+    config: &Appearance,
 ) -> Option<()> {
     let left_section = find_section(left_obj, selected_symbol)?;
     let right_section = find_section(right_obj, selected_symbol)?;
@@ -161,11 +163,10 @@ fn data_table_ui(
     Some(())
 }
 
-pub fn data_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
-    let mut rebuild = false;
-    let (Some(result), Some(selected_symbol)) = (&view_state.build, &view_state.selected_symbol)
+pub fn data_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &Appearance) {
+    let (Some(result), Some(selected_symbol)) = (&state.build, &state.symbol_state.selected_symbol)
     else {
-        return rebuild;
+        return;
     };
 
     // Header
@@ -183,16 +184,13 @@ pub fn data_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                     ui.set_width(column_width);
 
                     if ui.button("Back").clicked() {
-                        view_state.current_view = View::SymbolDiff;
+                        state.current_view = View::SymbolDiff;
                     }
 
                     ui.scope(|ui| {
                         ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
                         ui.style_mut().wrap = Some(false);
-                        ui.colored_label(
-                            view_state.view_config.highlight_color,
-                            &selected_symbol.symbol_name,
-                        );
+                        ui.colored_label(appearance.highlight_color, &selected_symbol.symbol_name);
                         ui.label("Diff target:");
                     });
                 },
@@ -206,14 +204,17 @@ pub fn data_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                     ui.set_width(column_width);
 
                     ui.horizontal(|ui| {
-                        if ui.button("Build").clicked() {
-                            rebuild = true;
+                        if ui
+                            .add_enabled(!state.build_running, egui::Button::new("Build"))
+                            .clicked()
+                        {
+                            state.queue_build = true;
                         }
                         ui.scope(|ui| {
                             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
                             ui.style_mut().wrap = Some(false);
-                            if view_state.jobs.iter().any(|job| job.job_type == Job::ObjDiff) {
-                                ui.label("Building...");
+                            if state.build_running {
+                                ui.colored_label(appearance.replace_color, "Building…");
                             } else {
                                 ui.label("Last built:");
                                 let format =
@@ -221,7 +222,7 @@ pub fn data_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                                 ui.label(
                                     result
                                         .time
-                                        .to_offset(view_state.utc_offset)
+                                        .to_offset(appearance.utc_offset)
                                         .format(&format)
                                         .unwrap(),
                                 );
@@ -251,8 +252,6 @@ pub fn data_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
             .resizable(false)
             .auto_shrink([false, false])
             .min_scrolled_height(available_height);
-        data_table_ui(table, left_obj, right_obj, selected_symbol, &view_state.view_config);
+        data_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
     }
-
-    rebuild
 }

src/views/demangle.rs

@@ -0,0 +1,34 @@
+use egui::TextStyle;
+
+use crate::views::appearance::Appearance;
+
+#[derive(Default)]
+pub struct DemangleViewState {
+    pub text: String,
+}
+
+pub fn demangle_window(
+    ctx: &egui::Context,
+    show: &mut bool,
+    state: &mut DemangleViewState,
+    appearance: &Appearance,
+) {
+    egui::Window::new("Demangle").open(show).show(ctx, |ui| {
+        ui.text_edit_singleline(&mut state.text);
+        ui.add_space(10.0);
+        if let Some(demangled) = cwdemangle::demangle(&state.text, &Default::default()) {
+            ui.scope(|ui| {
+                ui.style_mut().override_text_style = Some(TextStyle::Monospace);
+                ui.colored_label(appearance.replace_color, &demangled);
+            });
+            if ui.button("Copy").clicked() {
+                ui.output_mut(|output| output.copied_text = demangled);
+            }
+        } else {
+            ui.scope(|ui| {
+                ui.style_mut().override_text_style = Some(TextStyle::Monospace);
+                ui.colored_label(appearance.replace_color, "[invalid]");
+            });
+        }
+    });
+}

src/views/function_diff.rs

@@ -8,13 +8,15 @@ use ppc750cl::Argument;
 use time::format_description;
 
 use crate::{
-    app::{SymbolReference, View, ViewConfig, ViewState},
-    jobs::Job,
     obj::{
         ObjInfo, ObjIns, ObjInsArg, ObjInsArgDiff, ObjInsDiff, ObjInsDiffKind, ObjReloc,
         ObjRelocKind, ObjSymbol,
     },
-    views::{symbol_diff::match_color_for_symbol, write_text},
+    views::{
+        appearance::Appearance,
+        symbol_diff::{match_color_for_symbol, DiffViewState, SymbolReference, View},
+        write_text,
+    },
 };
 
 fn write_reloc_name(
@@ -22,10 +24,10 @@ fn write_reloc_name(
     color: Color32,
     job: &mut LayoutJob,
     font_id: FontId,
-    config: &ViewConfig,
+    appearance: &Appearance,
 ) {
     let name = reloc.target.demangled_name.as_ref().unwrap_or(&reloc.target.name);
-    write_text(name, config.emphasized_text_color, job, font_id.clone());
+    write_text(name, appearance.emphasized_text_color, job, font_id.clone());
     match reloc.target.addend.cmp(&0i64) {
         Ordering::Greater => {
             write_text(&format!("+{:#X}", reloc.target.addend), color, job, font_id)
@@ -42,52 +44,52 @@ fn write_reloc(
     color: Color32,
     job: &mut LayoutJob,
     font_id: FontId,
-    config: &ViewConfig,
+    appearance: &Appearance,
 ) {
     match reloc.kind {
         ObjRelocKind::PpcAddr16Lo => {
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text("@l", color, job, font_id);
         }
         ObjRelocKind::PpcAddr16Hi => {
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text("@h", color, job, font_id);
         }
         ObjRelocKind::PpcAddr16Ha => {
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text("@ha", color, job, font_id);
         }
         ObjRelocKind::PpcEmbSda21 => {
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text("@sda21", color, job, font_id);
         }
         ObjRelocKind::MipsHi16 => {
             write_text("%hi(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text(")", color, job, font_id);
         }
         ObjRelocKind::MipsLo16 => {
             write_text("%lo(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text(")", color, job, font_id);
         }
         ObjRelocKind::MipsGot16 => {
             write_text("%got(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text(")", color, job, font_id);
         }
         ObjRelocKind::MipsCall16 => {
             write_text("%call16(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text(")", color, job, font_id);
         }
         ObjRelocKind::MipsGpRel16 => {
             write_text("%gp_rel(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), config);
+            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
             write_text(")", color, job, font_id);
         }
         ObjRelocKind::PpcRel24 | ObjRelocKind::PpcRel14 | ObjRelocKind::Mips26 => {
-            write_reloc_name(reloc, color, job, font_id, config);
+            write_reloc_name(reloc, color, job, font_id, appearance);
         }
         ObjRelocKind::Absolute | ObjRelocKind::MipsGpRel32 => {
             write_text("[INVALID]", color, job, font_id);
@@ -101,51 +103,51 @@ fn write_ins(
     args: &[Option<ObjInsArgDiff>],
     base_addr: u32,
     job: &mut LayoutJob,
-    config: &ViewConfig,
+    appearance: &Appearance,
 ) {
     let base_color = match diff_kind {
         ObjInsDiffKind::None | ObjInsDiffKind::OpMismatch | ObjInsDiffKind::ArgMismatch => {
-            config.text_color
+            appearance.text_color
         }
-        ObjInsDiffKind::Replace => config.replace_color,
-        ObjInsDiffKind::Delete => config.delete_color,
-        ObjInsDiffKind::Insert => config.insert_color,
+        ObjInsDiffKind::Replace => appearance.replace_color,
+        ObjInsDiffKind::Delete => appearance.delete_color,
+        ObjInsDiffKind::Insert => appearance.insert_color,
     };
     write_text(
         &format!("{:<11}", ins.mnemonic),
         match diff_kind {
-            ObjInsDiffKind::OpMismatch => config.replace_color,
+            ObjInsDiffKind::OpMismatch => appearance.replace_color,
             _ => base_color,
         },
         job,
-        config.code_font.clone(),
+        appearance.code_font.clone(),
     );
     let mut writing_offset = false;
     for (i, arg) in ins.args.iter().enumerate() {
         if i == 0 {
-            write_text(" ", base_color, job, config.code_font.clone());
+            write_text(" ", base_color, job, appearance.code_font.clone());
         }
         if i > 0 && !writing_offset {
-            write_text(", ", base_color, job, config.code_font.clone());
+            write_text(", ", base_color, job, appearance.code_font.clone());
         }
         let color = if let Some(diff) = args.get(i).and_then(|a| a.as_ref()) {
-            config.diff_colors[diff.idx % config.diff_colors.len()]
+            appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
         } else {
             base_color
         };
         match arg {
             ObjInsArg::PpcArg(arg) => match arg {
                 Argument::Offset(val) => {
-                    write_text(&format!("{val}"), color, job, config.code_font.clone());
-                    write_text("(", base_color, job, config.code_font.clone());
+                    write_text(&format!("{val}"), color, job, appearance.code_font.clone());
+                    write_text("(", base_color, job, appearance.code_font.clone());
                     writing_offset = true;
                     continue;
                 }
                 Argument::Uimm(_) | Argument::Simm(_) => {
-                    write_text(&format!("{arg}"), color, job, config.code_font.clone());
+                    write_text(&format!("{arg}"), color, job, appearance.code_font.clone());
                 }
                 _ => {
-                    write_text(&format!("{arg}"), color, job, config.code_font.clone());
+                    write_text(&format!("{arg}"), color, job, appearance.code_font.clone());
                 }
             },
             ObjInsArg::Reloc => {
@@ -153,8 +155,8 @@ fn write_ins(
                     ins.reloc.as_ref().unwrap(),
                     base_color,
                     job,
-                    config.code_font.clone(),
-                    config,
+                    appearance.code_font.clone(),
+                    appearance,
                 );
             }
             ObjInsArg::RelocWithBase => {
@@ -162,10 +164,10 @@ fn write_ins(
                     ins.reloc.as_ref().unwrap(),
                     base_color,
                     job,
-                    config.code_font.clone(),
-                    config,
+                    appearance.code_font.clone(),
+                    appearance,
                 );
-                write_text("(", base_color, job, config.code_font.clone());
+                write_text("(", base_color, job, appearance.code_font.clone());
                 writing_offset = true;
                 continue;
             }
@@ -174,7 +176,7 @@ fn write_ins(
                     str.strip_prefix('$').unwrap_or(str),
                     color,
                     job,
-                    config.code_font.clone(),
+                    appearance.code_font.clone(),
                 );
             }
             ObjInsArg::MipsArgWithBase(str) => {
@@ -182,25 +184,25 @@ fn write_ins(
                     str.strip_prefix('$').unwrap_or(str),
                     color,
                     job,
-                    config.code_font.clone(),
+                    appearance.code_font.clone(),
                 );
-                write_text("(", base_color, job, config.code_font.clone());
+                write_text("(", base_color, job, appearance.code_font.clone());
                 writing_offset = true;
                 continue;
             }
             ObjInsArg::BranchOffset(offset) => {
                 let addr = offset + ins.address as i32 - base_addr as i32;
-                write_text(&format!("{addr:x}"), color, job, config.code_font.clone());
+                write_text(&format!("{addr:x}"), color, job, appearance.code_font.clone());
             }
         }
         if writing_offset {
-            write_text(")", base_color, job, config.code_font.clone());
+            write_text(")", base_color, job, appearance.code_font.clone());
             writing_offset = false;
         }
     }
 }
 
-fn ins_hover_ui(ui: &mut egui::Ui, ins: &ObjIns, config: &ViewConfig) {
+fn ins_hover_ui(ui: &mut egui::Ui, ins: &ObjIns, appearance: &Appearance) {
     ui.scope(|ui| {
         ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
         ui.style_mut().wrap = Some(false);
@@ -226,16 +228,19 @@ fn ins_hover_ui(ui: &mut egui::Ui, ins: &ObjIns, config: &ViewConfig) {
 
         if let Some(reloc) = &ins.reloc {
             ui.label(format!("Relocation type: {:?}", reloc.kind));
-            ui.colored_label(config.highlight_color, format!("Name: {}", reloc.target.name));
+            ui.colored_label(appearance.highlight_color, format!("Name: {}", reloc.target.name));
             if let Some(section) = &reloc.target_section {
-                ui.colored_label(config.highlight_color, format!("Section: {section}"));
+                ui.colored_label(appearance.highlight_color, format!("Section: {section}"));
                 ui.colored_label(
-                    config.highlight_color,
+                    appearance.highlight_color,
                     format!("Address: {:x}", reloc.target.address),
                 );
-                ui.colored_label(config.highlight_color, format!("Size: {:x}", reloc.target.size));
+                ui.colored_label(
+                    appearance.highlight_color,
+                    format!("Size: {:x}", reloc.target.size),
+                );
             } else {
-                ui.colored_label(config.highlight_color, "Extern".to_string());
+                ui.colored_label(appearance.highlight_color, "Extern".to_string());
             }
         }
     });
@@ -306,7 +311,12 @@ fn find_symbol<'a>(obj: &'a ObjInfo, selected_symbol: &SymbolReference) -> Optio
     })
 }
 
-fn asm_row_ui(ui: &mut egui::Ui, ins_diff: &ObjInsDiff, symbol: &ObjSymbol, config: &ViewConfig) {
+fn asm_row_ui(
+    ui: &mut egui::Ui,
+    ins_diff: &ObjInsDiff,
+    symbol: &ObjSymbol,
+    appearance: &Appearance,
+) {
     if ins_diff.kind != ObjInsDiffKind::None {
         ui.painter().rect_filled(ui.available_rect_before_wrap(), 0.0, ui.visuals().faint_bg_color);
     }
@@ -318,45 +328,50 @@ fn asm_row_ui(ui: &mut egui::Ui, ins_diff: &ObjInsDiff, symbol: &ObjSymbol, conf
 
     let base_color = match ins_diff.kind {
         ObjInsDiffKind::None | ObjInsDiffKind::OpMismatch | ObjInsDiffKind::ArgMismatch => {
-            config.text_color
+            appearance.text_color
         }
-        ObjInsDiffKind::Replace => config.replace_color,
-        ObjInsDiffKind::Delete => config.delete_color,
-        ObjInsDiffKind::Insert => config.insert_color,
+        ObjInsDiffKind::Replace => appearance.replace_color,
+        ObjInsDiffKind::Delete => appearance.delete_color,
+        ObjInsDiffKind::Insert => appearance.insert_color,
     };
     let mut pad = 6;
     if let Some(line) = ins.line {
         let line_str = format!("{line} ");
-        write_text(&line_str, config.deemphasized_text_color, &mut job, config.code_font.clone());
+        write_text(
+            &line_str,
+            appearance.deemphasized_text_color,
+            &mut job,
+            appearance.code_font.clone(),
+        );
         pad = 12 - line_str.len();
     }
     write_text(
         &format!("{:<1$}", format!("{:x}: ", ins.address - symbol.address as u32), pad),
         base_color,
         &mut job,
-        config.code_font.clone(),
+        appearance.code_font.clone(),
     );
     if let Some(branch) = &ins_diff.branch_from {
         write_text(
             "~> ",
-            config.diff_colors[branch.branch_idx % config.diff_colors.len()],
+            appearance.diff_colors[branch.branch_idx % appearance.diff_colors.len()],
             &mut job,
-            config.code_font.clone(),
+            appearance.code_font.clone(),
         );
     } else {
-        write_text("   ", base_color, &mut job, config.code_font.clone());
+        write_text("   ", base_color, &mut job, appearance.code_font.clone());
     }
-    write_ins(ins, &ins_diff.kind, &ins_diff.arg_diff, symbol.address as u32, &mut job, config);
+    write_ins(ins, &ins_diff.kind, &ins_diff.arg_diff, symbol.address as u32, &mut job, appearance);
     if let Some(branch) = &ins_diff.branch_to {
         write_text(
             " ~>",
-            config.diff_colors[branch.branch_idx % config.diff_colors.len()],
+            appearance.diff_colors[branch.branch_idx % appearance.diff_colors.len()],
             &mut job,
-            config.code_font.clone(),
+            appearance.code_font.clone(),
         );
     }
     ui.add(Label::new(job).sense(Sense::click()))
-        .on_hover_ui_at_pointer(|ui| ins_hover_ui(ui, ins, config))
+        .on_hover_ui_at_pointer(|ui| ins_hover_ui(ui, ins, appearance))
         .context_menu(|ui| ins_context_menu(ui, ins));
 }
 
@@ -365,21 +380,21 @@ fn asm_table_ui(
     left_obj: &ObjInfo,
     right_obj: &ObjInfo,
     selected_symbol: &SymbolReference,
-    config: &ViewConfig,
+    appearance: &Appearance,
 ) -> Option<()> {
     let left_symbol = find_symbol(left_obj, selected_symbol);
     let right_symbol = find_symbol(right_obj, selected_symbol);
     let instructions_len = left_symbol.or(right_symbol).map(|s| s.instructions.len())?;
     table.body(|body| {
-        body.rows(config.code_font.size, instructions_len, |row_index, mut row| {
+        body.rows(appearance.code_font.size, instructions_len, |row_index, mut row| {
             row.col(|ui| {
                 if let Some(symbol) = left_symbol {
-                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, config);
+                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, appearance);
                 }
             });
             row.col(|ui| {
                 if let Some(symbol) = right_symbol {
-                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, config);
+                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, appearance);
                 }
             });
         });
@@ -387,11 +402,10 @@ fn asm_table_ui(
     Some(())
 }
 
-pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
-    let mut rebuild = false;
-    let (Some(result), Some(selected_symbol)) = (&view_state.build, &view_state.selected_symbol)
+pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &Appearance) {
+    let (Some(result), Some(selected_symbol)) = (&state.build, &state.symbol_state.selected_symbol)
     else {
-        return rebuild;
+        return;
     };
 
     // Header
@@ -409,15 +423,15 @@ pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                     ui.set_width(column_width);
 
                     if ui.button("Back").clicked() {
-                        view_state.current_view = View::SymbolDiff;
+                        state.current_view = View::SymbolDiff;
                     }
 
                     let demangled = demangle(&selected_symbol.symbol_name, &Default::default());
                     let name = demangled.as_deref().unwrap_or(&selected_symbol.symbol_name);
                     let mut job = LayoutJob::simple(
                         name.to_string(),
-                        view_state.view_config.code_font.clone(),
-                        view_state.view_config.highlight_color,
+                        appearance.code_font.clone(),
+                        appearance.highlight_color,
                         column_width,
                     );
                     job.wrap.break_anywhere = true;
@@ -439,14 +453,17 @@ pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                     ui.set_width(column_width);
 
                     ui.horizontal(|ui| {
-                        if ui.button("Build").clicked() {
-                            rebuild = true;
+                        if ui
+                            .add_enabled(!state.build_running, egui::Button::new("Build"))
+                            .clicked()
+                        {
+                            state.queue_build = true;
                         }
                         ui.scope(|ui| {
                             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
                             ui.style_mut().wrap = Some(false);
-                            if view_state.jobs.iter().any(|job| job.job_type == Job::ObjDiff) {
-                                ui.label("Building...");
+                            if state.build_running {
+                                ui.colored_label(appearance.replace_color, "Building…");
                             } else {
                                 ui.label("Last built:");
                                 let format =
@@ -454,7 +471,7 @@ pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                                 ui.label(
                                     result
                                         .time
-                                        .to_offset(view_state.utc_offset)
+                                        .to_offset(appearance.utc_offset)
                                         .format(&format)
                                         .unwrap(),
                                 );
@@ -471,7 +488,7 @@ pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
                             .and_then(|symbol| symbol.match_percent)
                         {
                             ui.colored_label(
-                                match_color_for_symbol(match_percent, &view_state.view_config),
+                                match_color_for_symbol(match_percent, appearance),
                                 &format!("{match_percent:.0}%"),
                             );
                         } else {
@@ -495,7 +512,6 @@ pub fn function_diff_ui(ui: &mut egui::Ui, view_state: &mut ViewState) -> bool {
             .resizable(false)
             .auto_shrink([false, false])
             .min_scrolled_height(available_height);
-        asm_table_ui(table, left_obj, right_obj, selected_symbol, &view_state.view_config);
+        asm_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
     }
-    rebuild
 }