Compare commits
No commits in common. "main" and "v0.4.8" have entirely different histories.
|
|
@ -1832,7 +1832,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
|
|||
|
||||
[[package]]
|
||||
name = "lemur"
|
||||
version = "0.7.0"
|
||||
version = "0.4.8"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"atoi",
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ description = "An emulator for the Virtual Boy."
|
|||
repository = "https://git.virtual-boy.com/PVB/lemur"
|
||||
publish = false
|
||||
license = "MIT"
|
||||
version = "0.7.0"
|
||||
version = "0.4.8"
|
||||
edition = "2024"
|
||||
|
||||
[dependencies]
|
||||
|
|
|
|||
16
src/app.rs
16
src/app.rs
|
|
@ -24,8 +24,7 @@ use crate::{
|
|||
persistence::Persistence,
|
||||
window::{
|
||||
AboutWindow, AppWindow, BgMapWindow, CharacterDataWindow, FrameBufferWindow, GameWindow,
|
||||
GdbServerWindow, HotkeysWindow, InputWindow, ObjectWindow, RegisterWindow, TerminalWindow,
|
||||
WorldWindow,
|
||||
GdbServerWindow, InputWindow, ObjectWindow, RegisterWindow, ShortcutsWindow, WorldWindow,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
@ -244,10 +243,6 @@ impl ApplicationHandler<UserEvent> for Application {
|
|||
let registers = RegisterWindow::new(sim_id, &self.memory);
|
||||
self.open(event_loop, Box::new(registers));
|
||||
}
|
||||
UserEvent::OpenTerminal(sim_id) => {
|
||||
let terminal = TerminalWindow::new(sim_id, &self.client);
|
||||
self.open(event_loop, Box::new(terminal));
|
||||
}
|
||||
UserEvent::OpenDebugger(sim_id) => {
|
||||
let debugger =
|
||||
GdbServerWindow::new(sim_id, self.client.clone(), self.proxy.clone());
|
||||
|
|
@ -257,9 +252,9 @@ impl ApplicationHandler<UserEvent> for Application {
|
|||
let input = InputWindow::new(self.mappings.clone());
|
||||
self.open(event_loop, Box::new(input));
|
||||
}
|
||||
UserEvent::OpenHotkeys => {
|
||||
let hotkeys = HotkeysWindow::new(self.shortcuts.clone());
|
||||
self.open(event_loop, Box::new(hotkeys));
|
||||
UserEvent::OpenShortcuts => {
|
||||
let shortcuts = ShortcutsWindow::new(self.shortcuts.clone());
|
||||
self.open(event_loop, Box::new(shortcuts));
|
||||
}
|
||||
UserEvent::OpenPlayer2 => {
|
||||
let p2 = GameWindow::new(
|
||||
|
|
@ -518,10 +513,9 @@ pub enum UserEvent {
|
|||
OpenWorlds(SimId),
|
||||
OpenFrameBuffers(SimId),
|
||||
OpenRegisters(SimId),
|
||||
OpenTerminal(SimId),
|
||||
OpenDebugger(SimId),
|
||||
OpenInput,
|
||||
OpenHotkeys,
|
||||
OpenShortcuts,
|
||||
OpenPlayer2,
|
||||
Quit(SimId),
|
||||
}
|
||||
|
|
|
|||
22
src/audio.rs
22
src/audio.rs
|
|
@ -3,20 +3,18 @@ use std::time::Duration;
|
|||
use anyhow::{Result, bail};
|
||||
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
||||
use itertools::Itertools;
|
||||
use rubato::{FastFixedOut, Resampler};
|
||||
use rubato::{FftFixedInOut, Resampler};
|
||||
use tracing::error;
|
||||
|
||||
pub struct Audio {
|
||||
#[allow(unused)]
|
||||
stream: cpal::Stream,
|
||||
sampler: FastFixedOut<f32>,
|
||||
sampler: FftFixedInOut<f32>,
|
||||
input_buffer: Vec<Vec<f32>>,
|
||||
output_buffer: Vec<Vec<f32>>,
|
||||
sample_sink: rtrb::Producer<f32>,
|
||||
}
|
||||
|
||||
const VB_FREQUENCY: usize = 41700;
|
||||
|
||||
impl Audio {
|
||||
pub fn init() -> Result<Self> {
|
||||
let host = cpal::default_host();
|
||||
|
|
@ -30,15 +28,7 @@ impl Audio {
|
|||
bail!("No suitable output config available");
|
||||
};
|
||||
let mut config = config.with_max_sample_rate().config();
|
||||
let resample_ratio = config.sample_rate.0 as f64 / VB_FREQUENCY as f64;
|
||||
let chunk_size = (834.0 * resample_ratio) as usize;
|
||||
let sampler = FastFixedOut::new(
|
||||
resample_ratio,
|
||||
64.0,
|
||||
rubato::PolynomialDegree::Cubic,
|
||||
chunk_size,
|
||||
2,
|
||||
)?;
|
||||
let sampler = FftFixedInOut::new(41700, config.sample_rate.0 as usize, 834, 2)?;
|
||||
config.buffer_size = cpal::BufferSize::Fixed(sampler.output_frames_max() as u32);
|
||||
|
||||
let input_buffer = sampler.input_buffer_allocate(true);
|
||||
|
|
@ -111,10 +101,4 @@ impl Audio {
|
|||
std::thread::sleep(Duration::from_micros(500));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_speed(&mut self, speed: f64) -> Result<()> {
|
||||
self.sampler
|
||||
.set_resample_ratio_relative(1.0 / speed, false)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,13 +43,6 @@ impl SimId {
|
|||
Self::Player2 => 1,
|
||||
}
|
||||
}
|
||||
pub const fn from_index(index: usize) -> Option<Self> {
|
||||
match index {
|
||||
0 => Some(Self::Player1),
|
||||
1 => Some(Self::Player2),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Display for SimId {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
|
|
@ -176,9 +169,8 @@ pub struct Emulator {
|
|||
renderers: HashMap<SimId, TextureSink>,
|
||||
messages: HashMap<SimId, mpsc::Sender<Toast>>,
|
||||
debuggers: HashMap<SimId, DebugInfo>,
|
||||
stdouts: HashMap<SimId, mpsc::Sender<String>>,
|
||||
watched_regions: HashMap<MemoryRange, Weak<MemoryRegion>>,
|
||||
eye_contents: [Vec<u8>; 2],
|
||||
eye_contents: Vec<u8>,
|
||||
audio_samples: Vec<f32>,
|
||||
buffer: Vec<u8>,
|
||||
}
|
||||
|
|
@ -203,9 +195,8 @@ impl Emulator {
|
|||
renderers: HashMap::new(),
|
||||
messages: HashMap::new(),
|
||||
debuggers: HashMap::new(),
|
||||
stdouts: HashMap::new(),
|
||||
watched_regions: HashMap::new(),
|
||||
eye_contents: [vec![0u8; 384 * 224 * 2], vec![0u8; 384 * 224 * 2]],
|
||||
eye_contents: vec![0u8; 384 * 224 * 2],
|
||||
audio_samples: Vec::with_capacity(EXPECTED_FRAME_SIZE),
|
||||
buffer: vec![],
|
||||
})
|
||||
|
|
@ -237,15 +228,8 @@ impl Emulator {
|
|||
|
||||
let index = sim_id.to_index();
|
||||
while self.sims.len() <= index {
|
||||
let new_index = self.sims.len();
|
||||
self.sims.push(Sim::new());
|
||||
if self
|
||||
.stdouts
|
||||
.contains_key(&SimId::from_index(new_index).unwrap())
|
||||
{
|
||||
self.sims[new_index].watch_stdout(true);
|
||||
}
|
||||
self.sim_state[new_index].store(SimState::NoGame, Ordering::Release);
|
||||
self.sim_state[index].store(SimState::NoGame, Ordering::Release);
|
||||
}
|
||||
let sim = &mut self.sims[index];
|
||||
sim.reset();
|
||||
|
|
@ -327,10 +311,6 @@ impl Emulator {
|
|||
}
|
||||
}
|
||||
|
||||
fn set_speed(&mut self, speed: f64) -> Result<()> {
|
||||
self.audio.set_speed(speed)
|
||||
}
|
||||
|
||||
fn save_sram(&mut self, sim_id: SimId) -> Result<()> {
|
||||
let sim = self.sims.get_mut(sim_id.to_index());
|
||||
let cart = self.carts[sim_id.to_index()].as_mut();
|
||||
|
|
@ -487,20 +467,6 @@ impl Emulator {
|
|||
self.state.store(EmulatorState::Paused, Ordering::Release);
|
||||
}
|
||||
|
||||
// stdout
|
||||
self.stdouts.retain(|sim_id, stdout| {
|
||||
let Some(sim) = self.sims.get_mut(sim_id.to_index()) else {
|
||||
return true;
|
||||
};
|
||||
if let Some(text) = sim.take_stdout() {
|
||||
if stdout.send(text).is_err() {
|
||||
sim.watch_stdout(false);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
});
|
||||
|
||||
// Debug state
|
||||
if state == EmulatorState::Debugging {
|
||||
for sim_id in SimId::values() {
|
||||
|
|
@ -528,12 +494,9 @@ impl Emulator {
|
|||
let Some(sim) = self.sims.get_mut(sim_id.to_index()) else {
|
||||
continue;
|
||||
};
|
||||
if sim.read_pixels(&mut self.eye_contents[sim_id.to_index()]) {
|
||||
if sim.read_pixels(&mut self.eye_contents) {
|
||||
idle = false;
|
||||
if renderer
|
||||
.queue_render(&self.eye_contents[sim_id.to_index()])
|
||||
.is_err()
|
||||
{
|
||||
if renderer.queue_render(&self.eye_contents).is_err() {
|
||||
self.renderers.remove(&sim_id);
|
||||
}
|
||||
}
|
||||
|
|
@ -604,11 +567,6 @@ impl Emulator {
|
|||
EmulatorCommand::FrameAdvance => {
|
||||
self.frame_advance();
|
||||
}
|
||||
EmulatorCommand::SetSpeed(speed) => {
|
||||
if let Err(error) = self.set_speed(speed) {
|
||||
self.report_error(SimId::Player1, format!("Error setting speed: {error}"));
|
||||
}
|
||||
}
|
||||
EmulatorCommand::StartDebugging(sim_id, debugger) => {
|
||||
self.start_debugging(sim_id, debugger);
|
||||
}
|
||||
|
|
@ -678,13 +636,6 @@ impl Emulator {
|
|||
};
|
||||
sim.remove_watchpoint(address, length, watch);
|
||||
}
|
||||
EmulatorCommand::WatchStdout(sim_id, stdout_sink) => {
|
||||
self.stdouts.insert(sim_id, stdout_sink);
|
||||
let Some(sim) = self.sims.get_mut(sim_id.to_index()) else {
|
||||
return;
|
||||
};
|
||||
sim.watch_stdout(true);
|
||||
}
|
||||
EmulatorCommand::SetAudioEnabled(p1, p2) => {
|
||||
self.audio_on[SimId::Player1.to_index()].store(p1, Ordering::Release);
|
||||
self.audio_on[SimId::Player2.to_index()].store(p2, Ordering::Release);
|
||||
|
|
@ -705,10 +656,6 @@ impl Emulator {
|
|||
sim.set_keys(keys);
|
||||
}
|
||||
}
|
||||
EmulatorCommand::Screenshot(sim_id, sender) => {
|
||||
let contents = self.eye_contents[sim_id.to_index()].clone();
|
||||
let _ = sender.send(contents);
|
||||
}
|
||||
EmulatorCommand::Exit(done) => {
|
||||
for sim_id in SimId::values() {
|
||||
if let Err(error) = self.save_sram(sim_id) {
|
||||
|
|
@ -747,7 +694,6 @@ pub enum EmulatorCommand {
|
|||
Pause,
|
||||
Resume,
|
||||
FrameAdvance,
|
||||
SetSpeed(f64),
|
||||
StartDebugging(SimId, DebugSender),
|
||||
StopDebugging(SimId),
|
||||
DebugInterrupt(SimId),
|
||||
|
|
@ -762,13 +708,11 @@ pub enum EmulatorCommand {
|
|||
RemoveBreakpoint(SimId, u32),
|
||||
AddWatchpoint(SimId, u32, usize, VBWatchpointType),
|
||||
RemoveWatchpoint(SimId, u32, usize, VBWatchpointType),
|
||||
WatchStdout(SimId, mpsc::Sender<String>),
|
||||
SetAudioEnabled(bool, bool),
|
||||
Link,
|
||||
Unlink,
|
||||
Reset(SimId),
|
||||
SetKeys(SimId, VBKey),
|
||||
Screenshot(SimId, oneshot::Sender<Vec<u8>>),
|
||||
Exit(oneshot::Sender<()>),
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ extern "C" fn on_write(
|
|||
sim: *mut VB,
|
||||
address: u32,
|
||||
_type: VBDataType,
|
||||
value: *mut i32,
|
||||
_value: *mut i32,
|
||||
_cycles: *mut u32,
|
||||
_cancel: *mut c_int,
|
||||
) -> c_int {
|
||||
|
|
@ -238,14 +238,6 @@ extern "C" fn on_write(
|
|||
// There is no way for the userdata to be null or otherwise invalid.
|
||||
let data: &mut VBState = unsafe { &mut *vb_get_user_data(sim).cast() };
|
||||
|
||||
// If we're monitoring stdout, track this write
|
||||
if let Some(stdout) = data.stdout.as_mut() {
|
||||
let normalized_hw_address = address & 0x0700003f;
|
||||
if normalized_hw_address == 0x02000030 {
|
||||
stdout.push(unsafe { *value } as u8);
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(start) = data.write_watchpoints.start_of_range_containing(address) {
|
||||
let watch = if data.read_watchpoints.contains(address) {
|
||||
VBWatchpointType::Access
|
||||
|
|
@ -271,7 +263,6 @@ struct VBState {
|
|||
breakpoints: Vec<u32>,
|
||||
read_watchpoints: AddressSet,
|
||||
write_watchpoints: AddressSet,
|
||||
stdout: Option<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl VBState {
|
||||
|
|
@ -315,7 +306,6 @@ impl Sim {
|
|||
breakpoints: vec![],
|
||||
read_watchpoints: AddressSet::new(),
|
||||
write_watchpoints: AddressSet::new(),
|
||||
stdout: None,
|
||||
};
|
||||
unsafe { vb_set_user_data(sim, Box::into_raw(Box::new(state)).cast()) };
|
||||
unsafe { vb_set_frame_callback(sim, Some(on_frame)) };
|
||||
|
|
@ -574,9 +564,7 @@ impl Sim {
|
|||
state.write_watchpoints.remove(address, length);
|
||||
let needs_execute = state.needs_execute_callback();
|
||||
if state.write_watchpoints.is_empty() {
|
||||
if state.stdout.is_none() {
|
||||
unsafe { vb_set_write_callback(self.sim, None) };
|
||||
}
|
||||
unsafe { vb_set_write_callback(self.sim, None) };
|
||||
if !needs_execute {
|
||||
unsafe { vb_set_execute_callback(self.sim, None) };
|
||||
}
|
||||
|
|
@ -598,40 +586,11 @@ impl Sim {
|
|||
data.breakpoints.clear();
|
||||
data.read_watchpoints.clear();
|
||||
data.write_watchpoints.clear();
|
||||
let needs_write = data.stdout.is_some();
|
||||
unsafe { vb_set_read_callback(self.sim, None) };
|
||||
if !needs_write {
|
||||
unsafe { vb_set_write_callback(self.sim, None) };
|
||||
}
|
||||
unsafe { vb_set_write_callback(self.sim, None) };
|
||||
unsafe { vb_set_execute_callback(self.sim, None) };
|
||||
}
|
||||
|
||||
pub fn watch_stdout(&mut self, watch: bool) {
|
||||
let data = self.get_state();
|
||||
if watch {
|
||||
if data.stdout.is_none() {
|
||||
data.stdout = Some(vec![]);
|
||||
unsafe { vb_set_write_callback(self.sim, Some(on_write)) };
|
||||
}
|
||||
} else {
|
||||
data.stdout.take();
|
||||
if data.write_watchpoints.is_empty() {
|
||||
unsafe { vb_set_write_callback(self.sim, None) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn take_stdout(&mut self) -> Option<String> {
|
||||
let data = self.get_state();
|
||||
let stdout = data.stdout.take()?;
|
||||
let string = match String::from_utf8(stdout) {
|
||||
Ok(str) => str,
|
||||
Err(err) => String::from_utf8_lossy(err.as_bytes()).into_owned(),
|
||||
};
|
||||
data.stdout = Some(vec![]);
|
||||
Some(string)
|
||||
}
|
||||
|
||||
pub fn stop_reason(&mut self) -> Option<StopReason> {
|
||||
let data = self.get_state();
|
||||
let reason = data.stop_reason.take();
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ impl RegisterInfo {
|
|||
pub fn to_description(&self) -> String {
|
||||
let mut string = format!("name:{}", self.name);
|
||||
if let Some(alt) = self.alt_name {
|
||||
string.push_str(&format!(";alt-name:{alt}"));
|
||||
string.push_str(&format!(";alt-name:{}", alt));
|
||||
}
|
||||
string.push_str(&format!(
|
||||
";bitsize:32;offset:{};encoding:uint;format:hex;set:{};dwarf:{}",
|
||||
|
|
@ -21,7 +21,7 @@ impl RegisterInfo {
|
|||
self.dwarf
|
||||
));
|
||||
if let Some(generic) = self.generic {
|
||||
string.push_str(&format!(";generic:{generic}"));
|
||||
string.push_str(&format!(";generic:{}", generic));
|
||||
}
|
||||
string
|
||||
}
|
||||
|
|
|
|||
172
src/input.rs
172
src/input.rs
|
|
@ -1,13 +1,13 @@
|
|||
use std::{
|
||||
cmp::Ordering,
|
||||
collections::{HashMap, hash_map::Entry},
|
||||
collections::{HashMap, HashSet, hash_map::Entry},
|
||||
fmt::Display,
|
||||
str::FromStr,
|
||||
sync::{Arc, Mutex, RwLock},
|
||||
};
|
||||
|
||||
use anyhow::anyhow;
|
||||
use egui::{Event, Key, KeyboardShortcut, Modifiers};
|
||||
use egui::{Key, KeyboardShortcut, Modifiers};
|
||||
use gilrs::{Axis, Button, Gamepad, GamepadId, ev::Code};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use winit::keyboard::{KeyCode, PhysicalKey};
|
||||
|
|
@ -227,7 +227,7 @@ impl Mappings for InputMapping {
|
|||
for (keyboard_key, keys) in &self.keys {
|
||||
let name = match keyboard_key {
|
||||
PhysicalKey::Code(code) => format!("{code:?}"),
|
||||
k => format!("{k:?}"),
|
||||
k => format!("{:?}", k),
|
||||
};
|
||||
for key in keys.iter() {
|
||||
results.entry(key).or_default().push(name.clone());
|
||||
|
|
@ -468,23 +468,19 @@ pub enum Command {
|
|||
OpenRom,
|
||||
Quit,
|
||||
FrameAdvance,
|
||||
FastForward(u32),
|
||||
Reset,
|
||||
PauseResume,
|
||||
Screenshot,
|
||||
// if you update this, update Command::all and add a default
|
||||
}
|
||||
|
||||
impl Command {
|
||||
pub fn all() -> [Self; 7] {
|
||||
pub fn all() -> [Self; 5] {
|
||||
[
|
||||
Self::OpenRom,
|
||||
Self::Quit,
|
||||
Self::PauseResume,
|
||||
Self::Reset,
|
||||
Self::FrameAdvance,
|
||||
Self::FastForward(0),
|
||||
Self::Screenshot,
|
||||
]
|
||||
}
|
||||
|
||||
|
|
@ -495,8 +491,6 @@ impl Command {
|
|||
Self::PauseResume => "Pause/Resume",
|
||||
Self::Reset => "Reset",
|
||||
Self::FrameAdvance => "Frame Advance",
|
||||
Self::FastForward(_) => "Fast Forward",
|
||||
Self::Screenshot => "Screenshot",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -538,14 +532,6 @@ impl Default for Shortcuts {
|
|||
Command::FrameAdvance,
|
||||
KeyboardShortcut::new(Modifiers::NONE, Key::F6),
|
||||
);
|
||||
shortcuts.set(
|
||||
Command::FastForward(0),
|
||||
KeyboardShortcut::new(Modifiers::NONE, Key::Space),
|
||||
);
|
||||
shortcuts.set(
|
||||
Command::Screenshot,
|
||||
KeyboardShortcut::new(Modifiers::NONE, Key::F12),
|
||||
);
|
||||
shortcuts
|
||||
}
|
||||
}
|
||||
|
|
@ -571,11 +557,13 @@ impl Shortcuts {
|
|||
}
|
||||
}
|
||||
|
||||
fn save(&self, saved: &mut PersistedSettings) {
|
||||
fn save(&self) -> PersistedShortcuts {
|
||||
let mut shortcuts = PersistedShortcuts { shortcuts: vec![] };
|
||||
for command in Command::all() {
|
||||
let shortcut = self.by_command.get(&command).copied();
|
||||
saved.shortcuts.push((command, shortcut));
|
||||
shortcuts.shortcuts.push((command, shortcut));
|
||||
}
|
||||
shortcuts
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -601,123 +589,52 @@ fn specificity(modifiers: egui::Modifiers) -> usize {
|
|||
mods
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Default)]
|
||||
struct PersistedSettings {
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct PersistedShortcuts {
|
||||
shortcuts: Vec<(Command, Option<KeyboardShortcut>)>,
|
||||
#[serde(default)]
|
||||
ff_settings: FastForwardSettings,
|
||||
}
|
||||
|
||||
#[derive(Default, Clone)]
|
||||
struct ShortcutState {
|
||||
ff_toggled: bool,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Settings {
|
||||
shortcuts: Shortcuts,
|
||||
ff_settings: FastForwardSettings,
|
||||
state: ShortcutState,
|
||||
}
|
||||
|
||||
impl Settings {
|
||||
fn save(&self) -> PersistedSettings {
|
||||
let mut saved = PersistedSettings {
|
||||
shortcuts: vec![],
|
||||
ff_settings: self.ff_settings.clone(),
|
||||
};
|
||||
self.shortcuts.save(&mut saved);
|
||||
saved
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct ShortcutProvider {
|
||||
persistence: Persistence,
|
||||
settings: Arc<Mutex<Settings>>,
|
||||
shortcuts: Arc<Mutex<Shortcuts>>,
|
||||
}
|
||||
|
||||
impl ShortcutProvider {
|
||||
pub fn new(persistence: Persistence) -> Self {
|
||||
let mut settings = Settings::default();
|
||||
if let Ok(saved) = persistence.load_config::<PersistedSettings>("shortcuts") {
|
||||
let mut shortcuts = Shortcuts::default();
|
||||
if let Ok(saved) = persistence.load_config::<PersistedShortcuts>("shortcuts") {
|
||||
for (command, shortcut) in saved.shortcuts {
|
||||
if let Some(shortcut) = shortcut {
|
||||
settings.shortcuts.set(command, shortcut);
|
||||
shortcuts.set(command, shortcut);
|
||||
} else {
|
||||
settings.shortcuts.unset(command);
|
||||
shortcuts.unset(command);
|
||||
}
|
||||
}
|
||||
settings.ff_settings = saved.ff_settings;
|
||||
};
|
||||
}
|
||||
Self {
|
||||
persistence,
|
||||
settings: Arc::new(Mutex::new(settings)),
|
||||
shortcuts: Arc::new(Mutex::new(shortcuts)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn shortcut_for(&self, command: Command) -> Option<KeyboardShortcut> {
|
||||
let lock = self.settings.lock().unwrap();
|
||||
lock.shortcuts.by_command.get(&command).copied()
|
||||
let lock = self.shortcuts.lock().unwrap();
|
||||
lock.by_command.get(&command).copied()
|
||||
}
|
||||
|
||||
pub fn ff_settings(&self) -> FastForwardSettings {
|
||||
let lock = self.settings.lock().unwrap();
|
||||
lock.ff_settings.clone()
|
||||
}
|
||||
|
||||
pub fn consume_all(&self, input: &mut egui::InputState) -> Vec<Command> {
|
||||
let mut lock = self.settings.lock().unwrap();
|
||||
let mut state = lock.state.clone();
|
||||
let mut consumed = vec![];
|
||||
for (command, shortcut) in &lock.shortcuts.all {
|
||||
input.events.retain(|event| {
|
||||
let Event::Key {
|
||||
key,
|
||||
pressed,
|
||||
repeat,
|
||||
modifiers,
|
||||
..
|
||||
} = event
|
||||
else {
|
||||
return true;
|
||||
};
|
||||
if shortcut.logical_key != *key || !shortcut.modifiers.contains(*modifiers) {
|
||||
return true;
|
||||
}
|
||||
if matches!(command, Command::FastForward(_)) {
|
||||
if *repeat {
|
||||
return true;
|
||||
}
|
||||
let sped_up = if lock.ff_settings.toggle {
|
||||
if !*pressed {
|
||||
return true;
|
||||
}
|
||||
state.ff_toggled = !state.ff_toggled;
|
||||
state.ff_toggled
|
||||
} else {
|
||||
*pressed
|
||||
};
|
||||
let speed = if sped_up { lock.ff_settings.speed } else { 1 };
|
||||
consumed.push(Command::FastForward(speed));
|
||||
false
|
||||
} else {
|
||||
if !*pressed {
|
||||
return true;
|
||||
}
|
||||
consumed.push(*command);
|
||||
false
|
||||
}
|
||||
});
|
||||
}
|
||||
lock.state = state;
|
||||
consumed
|
||||
pub fn consume_all(&self, input: &mut egui::InputState) -> HashSet<Command> {
|
||||
let lock = self.shortcuts.lock().unwrap();
|
||||
lock.all
|
||||
.iter()
|
||||
.filter_map(|(command, shortcut)| input.consume_shortcut(shortcut).then_some(*command))
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn set(&self, command: Command, shortcut: KeyboardShortcut) {
|
||||
let updated = {
|
||||
let mut lock = self.settings.lock().unwrap();
|
||||
lock.shortcuts.set(command, shortcut);
|
||||
let mut lock = self.shortcuts.lock().unwrap();
|
||||
lock.set(command, shortcut);
|
||||
lock.save()
|
||||
};
|
||||
let _ = self.persistence.save_config("shortcuts", &updated);
|
||||
|
|
@ -725,20 +642,8 @@ impl ShortcutProvider {
|
|||
|
||||
pub fn unset(&self, command: Command) {
|
||||
let updated = {
|
||||
let mut lock = self.settings.lock().unwrap();
|
||||
lock.shortcuts.unset(command);
|
||||
lock.save()
|
||||
};
|
||||
let _ = self.persistence.save_config("shortcuts", &updated);
|
||||
}
|
||||
|
||||
pub fn update_ff_settings(&self, ff_settings: FastForwardSettings) {
|
||||
let updated = {
|
||||
let mut lock = self.settings.lock().unwrap();
|
||||
lock.ff_settings = ff_settings;
|
||||
if !lock.ff_settings.toggle {
|
||||
lock.state.ff_toggled = false;
|
||||
}
|
||||
let mut lock = self.shortcuts.lock().unwrap();
|
||||
lock.unset(command);
|
||||
lock.save()
|
||||
};
|
||||
let _ = self.persistence.save_config("shortcuts", &updated);
|
||||
|
|
@ -746,25 +651,10 @@ impl ShortcutProvider {
|
|||
|
||||
pub fn reset(&self) {
|
||||
let updated = {
|
||||
let mut lock = self.settings.lock().unwrap();
|
||||
*lock = Settings::default();
|
||||
let mut lock = self.shortcuts.lock().unwrap();
|
||||
*lock = Shortcuts::default();
|
||||
lock.save()
|
||||
};
|
||||
let _ = self.persistence.save_config("shortcuts", &updated);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone)]
|
||||
pub struct FastForwardSettings {
|
||||
pub toggle: bool,
|
||||
pub speed: u32,
|
||||
}
|
||||
|
||||
impl Default for FastForwardSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
toggle: false,
|
||||
speed: 10,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
10
src/main.rs
10
src/main.rs
|
|
@ -44,9 +44,9 @@ fn set_panic_handler() {
|
|||
std::panic::set_hook(Box::new(|info| {
|
||||
let mut message = String::new();
|
||||
if let Some(msg) = info.payload().downcast_ref::<&str>() {
|
||||
message += &format!("{msg}\n");
|
||||
message += &format!("{}\n", msg);
|
||||
} else if let Some(msg) = info.payload().downcast_ref::<String>() {
|
||||
message += &format!("{msg}\n");
|
||||
message += &format!("{}\n", msg);
|
||||
}
|
||||
if let Some(location) = info.location() {
|
||||
message += &format!(
|
||||
|
|
@ -56,9 +56,9 @@ fn set_panic_handler() {
|
|||
);
|
||||
}
|
||||
let backtrace = std::backtrace::Backtrace::force_capture();
|
||||
message += &format!("stack trace:\n{backtrace:#}\n");
|
||||
message += &format!("stack trace:\n{:#}\n", backtrace);
|
||||
|
||||
eprint!("{message}");
|
||||
eprint!("{}", message);
|
||||
|
||||
let Some(project_dirs) = directories::ProjectDirs::from("com", "virtual-boy", "Lemur")
|
||||
else {
|
||||
|
|
@ -72,7 +72,7 @@ fn set_panic_handler() {
|
|||
.duration_since(SystemTime::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_millis();
|
||||
let logfile_name = format!("crash-{timestamp}.txt");
|
||||
let logfile_name = format!("crash-{}.txt", timestamp);
|
||||
let _ = std::fs::write(data_dir.join(logfile_name), message);
|
||||
}));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,9 +2,8 @@ pub use about::AboutWindow;
|
|||
use egui::{Context, ViewportBuilder, ViewportId};
|
||||
pub use game::GameWindow;
|
||||
pub use gdb::GdbServerWindow;
|
||||
pub use hotkeys::HotkeysWindow;
|
||||
pub use input::InputWindow;
|
||||
pub use terminal::TerminalWindow;
|
||||
pub use shortcuts::ShortcutsWindow;
|
||||
pub use vip::{
|
||||
BgMapWindow, CharacterDataWindow, FrameBufferWindow, ObjectWindow, RegisterWindow, WorldWindow,
|
||||
};
|
||||
|
|
@ -16,9 +15,8 @@ mod about;
|
|||
mod game;
|
||||
mod game_screen;
|
||||
mod gdb;
|
||||
mod hotkeys;
|
||||
mod input;
|
||||
mod terminal;
|
||||
mod shortcuts;
|
||||
mod utils;
|
||||
mod vip;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,12 +6,11 @@ use crate::{
|
|||
input::{Command, ShortcutProvider},
|
||||
persistence::Persistence,
|
||||
};
|
||||
use anyhow::Context as _;
|
||||
use egui::{
|
||||
Align2, Button, CentralPanel, Color32, Context, Direction, Frame, TopBottomPanel, Ui, Vec2,
|
||||
ViewportBuilder, ViewportCommand, ViewportId, Window, menu,
|
||||
};
|
||||
use egui_toast::{Toast, ToastKind, ToastOptions, Toasts};
|
||||
use egui_toast::{Toast, Toasts};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use winit::event_loop::EventLoopProxy;
|
||||
|
||||
|
|
@ -70,7 +69,7 @@ impl GameWindow {
|
|||
}
|
||||
}
|
||||
|
||||
fn show_menu(&mut self, ctx: &Context, ui: &mut Ui, toasts: &mut Toasts) {
|
||||
fn show_menu(&mut self, ctx: &Context, ui: &mut Ui) {
|
||||
let state = self.client.emulator_state();
|
||||
let is_ready = self.client.sim_state(self.sim_id) == SimState::Ready;
|
||||
let can_pause = is_ready && state == EmulatorState::Running;
|
||||
|
|
@ -110,20 +109,6 @@ impl GameWindow {
|
|||
self.client.send_command(EmulatorCommand::FrameAdvance);
|
||||
}
|
||||
}
|
||||
Command::FastForward(speed) => {
|
||||
self.client
|
||||
.send_command(EmulatorCommand::SetSpeed(speed as f64));
|
||||
}
|
||||
Command::Screenshot => {
|
||||
let autopause = state == EmulatorState::Running && can_pause;
|
||||
if autopause {
|
||||
self.client.send_command(EmulatorCommand::Pause);
|
||||
}
|
||||
pollster::block_on(self.take_screenshot(toasts));
|
||||
if autopause {
|
||||
self.client.send_command(EmulatorCommand::Resume);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -189,17 +174,6 @@ impl GameWindow {
|
|||
self.client.send_command(EmulatorCommand::FrameAdvance);
|
||||
ui.close_menu();
|
||||
}
|
||||
ui.separator();
|
||||
if ui
|
||||
.add_enabled(
|
||||
is_ready,
|
||||
self.button_for(ui.ctx(), "Screenshot", Command::Screenshot),
|
||||
)
|
||||
.clicked()
|
||||
{
|
||||
pollster::block_on(self.take_screenshot(toasts));
|
||||
ui.close_menu();
|
||||
}
|
||||
});
|
||||
ui.menu_button("Options", |ui| self.show_options_menu(ctx, ui));
|
||||
ui.menu_button("Multiplayer", |ui| {
|
||||
|
|
@ -226,12 +200,6 @@ impl GameWindow {
|
|||
}
|
||||
});
|
||||
ui.menu_button("Tools", |ui| {
|
||||
if ui.button("Terminal").clicked() {
|
||||
self.proxy
|
||||
.send_event(UserEvent::OpenTerminal(self.sim_id))
|
||||
.unwrap();
|
||||
ui.close_menu();
|
||||
}
|
||||
if ui.button("GDB Server").clicked() {
|
||||
self.proxy
|
||||
.send_event(UserEvent::OpenDebugger(self.sim_id))
|
||||
|
|
@ -284,56 +252,6 @@ impl GameWindow {
|
|||
});
|
||||
}
|
||||
|
||||
async fn take_screenshot(&self, toasts: &mut Toasts) {
|
||||
match self.try_take_screenshot().await {
|
||||
Ok(Some(path)) => {
|
||||
toasts.add(
|
||||
Toast::new()
|
||||
.kind(ToastKind::Info)
|
||||
.options(ToastOptions::default().duration_in_seconds(5.0))
|
||||
.text(format!("Saved to {path}")),
|
||||
);
|
||||
}
|
||||
Ok(None) => {}
|
||||
Err(error) => {
|
||||
toasts.add(
|
||||
Toast::new()
|
||||
.kind(ToastKind::Error)
|
||||
.options(ToastOptions::default().duration_in_seconds(5.0))
|
||||
.text(format!("{error:#}")),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn try_take_screenshot(&self) -> anyhow::Result<Option<String>> {
|
||||
let (tx, rx) = oneshot::channel();
|
||||
self.client
|
||||
.send_command(EmulatorCommand::Screenshot(self.sim_id, tx));
|
||||
let bytes = rx.await.context("Could not take screenshot")?;
|
||||
let file = rfd::AsyncFileDialog::new()
|
||||
.add_filter("PNG images", &["png"])
|
||||
.set_file_name("screenshot.png")
|
||||
.save_file()
|
||||
.await;
|
||||
let Some(file) = file else {
|
||||
return Ok(None);
|
||||
};
|
||||
if bytes.len() != 384 * 224 * 2 {
|
||||
anyhow::bail!("Unexpected screenshot size");
|
||||
}
|
||||
let mut screencap = image::GrayImage::new(384 * 2, 224);
|
||||
for (index, pixel) in bytes.into_iter().enumerate() {
|
||||
let x = (index / 2) % 384 + ((index % 2) * 384);
|
||||
let y = (index / 2) / 384;
|
||||
screencap.put_pixel(x as u32, y as u32, image::Luma([pixel]));
|
||||
}
|
||||
screencap
|
||||
.save(&file.path())
|
||||
.context("Could not save screenshot")?;
|
||||
Ok(Some(file.path().display().to_string()))
|
||||
}
|
||||
|
||||
fn show_options_menu(&mut self, ctx: &Context, ui: &mut Ui) {
|
||||
ui.menu_button("Video", |ui| {
|
||||
ui.menu_button("Screen Size", |ui| {
|
||||
|
|
@ -440,8 +358,8 @@ impl GameWindow {
|
|||
ui.close_menu();
|
||||
}
|
||||
});
|
||||
if ui.button("Hotkeys").clicked() {
|
||||
self.proxy.send_event(UserEvent::OpenHotkeys).unwrap();
|
||||
if ui.button("Key Shortcuts").clicked() {
|
||||
self.proxy.send_event(UserEvent::OpenShortcuts).unwrap();
|
||||
ui.close_menu();
|
||||
}
|
||||
}
|
||||
|
|
@ -550,7 +468,7 @@ impl AppWindow for GameWindow {
|
|||
.exact_height(22.0)
|
||||
.show(ctx, |ui| {
|
||||
menu::bar(ui, |ui| {
|
||||
self.show_menu(ctx, ui, &mut toasts);
|
||||
self.show_menu(ctx, ui);
|
||||
});
|
||||
});
|
||||
if self.color_picker.is_some() {
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ impl GameScreen {
|
|||
module: &shader,
|
||||
entry_point: Some(entry_point),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: render_state.target_format,
|
||||
format: wgpu::TextureFormat::Bgra8Unorm,
|
||||
blend: Some(wgpu::BlendState::REPLACE),
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
|
|
|
|||
|
|
@ -1,150 +0,0 @@
|
|||
use egui::{
|
||||
Button, CentralPanel, Context, Event, KeyboardShortcut, Label, Layout, Slider, Ui,
|
||||
ViewportBuilder, ViewportId,
|
||||
};
|
||||
use egui_extras::{Column, TableBuilder};
|
||||
|
||||
use crate::input::{Command, ShortcutProvider};
|
||||
|
||||
use super::{AppWindow, utils::UiExt};
|
||||
|
||||
pub struct HotkeysWindow {
|
||||
shortcuts: ShortcutProvider,
|
||||
now_binding: Option<Command>,
|
||||
}
|
||||
|
||||
impl HotkeysWindow {
|
||||
pub fn new(shortcuts: ShortcutProvider) -> Self {
|
||||
Self {
|
||||
shortcuts,
|
||||
now_binding: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn show_shortcuts(&mut self, ui: &mut Ui) {
|
||||
let row_height = ui.spacing().interact_size.y;
|
||||
ui.section("Shortcuts", |ui| {
|
||||
let width = ui.available_width() - 16.0;
|
||||
TableBuilder::new(ui)
|
||||
.column(Column::exact(width * 0.3))
|
||||
.column(Column::exact(width * 0.5))
|
||||
.column(Column::exact(width * 0.2))
|
||||
.cell_layout(Layout::left_to_right(egui::Align::Center))
|
||||
.body(|mut body| {
|
||||
for command in Command::all() {
|
||||
body.row(row_height, |mut row| {
|
||||
row.col(|ui| {
|
||||
ui.add_sized(ui.available_size(), Label::new(command.name()));
|
||||
});
|
||||
row.col(|ui| {
|
||||
let button = if self.now_binding == Some(command) {
|
||||
Button::new("Binding...")
|
||||
} else if let Some(shortcut) = self.shortcuts.shortcut_for(command)
|
||||
{
|
||||
Button::new(ui.ctx().format_shortcut(&shortcut))
|
||||
} else {
|
||||
Button::new("")
|
||||
};
|
||||
if ui.add_sized(ui.available_size(), button).clicked() {
|
||||
self.now_binding = Some(command);
|
||||
}
|
||||
});
|
||||
row.col(|ui| {
|
||||
if ui
|
||||
.add_sized(ui.available_size(), Button::new("Clear"))
|
||||
.clicked()
|
||||
{
|
||||
self.shortcuts.unset(command);
|
||||
self.now_binding = None;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
if let Some(command) = self.now_binding {
|
||||
if let Some(shortcut) = ui.input_mut(|i| {
|
||||
i.events.iter().find_map(|event| match event {
|
||||
Event::Key {
|
||||
key,
|
||||
pressed: true,
|
||||
modifiers,
|
||||
..
|
||||
} => Some(KeyboardShortcut::new(*modifiers, *key)),
|
||||
_ => None,
|
||||
})
|
||||
}) {
|
||||
self.shortcuts.set(command, shortcut);
|
||||
self.now_binding = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn show_ff_settings(&mut self, ui: &mut Ui) {
|
||||
let row_height = ui.spacing().interact_size.y;
|
||||
ui.section("Fast Forward", |ui| {
|
||||
let width = ui.available_width() - 8.0;
|
||||
let mut ff_settings = self.shortcuts.ff_settings();
|
||||
let mut updated = false;
|
||||
TableBuilder::new(ui)
|
||||
.column(Column::exact(width * 0.5))
|
||||
.column(Column::exact(width * 0.5))
|
||||
.body(|mut body| {
|
||||
body.row(row_height, |mut row| {
|
||||
row.col(|ui| {
|
||||
ui.label("Treat button as toggle");
|
||||
});
|
||||
row.col(|ui| {
|
||||
if ui.checkbox(&mut ff_settings.toggle, "").changed() {
|
||||
updated = true;
|
||||
}
|
||||
});
|
||||
});
|
||||
body.row(row_height, |mut row| {
|
||||
row.col(|ui| {
|
||||
ui.label("Speed multiplier");
|
||||
});
|
||||
row.col(|ui| {
|
||||
if ui
|
||||
.add_sized(
|
||||
ui.available_size(),
|
||||
Slider::new(&mut ff_settings.speed, 1..=15),
|
||||
)
|
||||
.changed()
|
||||
{
|
||||
updated = true;
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
if updated {
|
||||
self.shortcuts.update_ff_settings(ff_settings);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
impl AppWindow for HotkeysWindow {
|
||||
fn viewport_id(&self) -> ViewportId {
|
||||
ViewportId::from_hash_of("shortcuts")
|
||||
}
|
||||
|
||||
fn initial_viewport(&self) -> ViewportBuilder {
|
||||
ViewportBuilder::default()
|
||||
.with_title("Keyboard Shortcuts")
|
||||
.with_inner_size((400.0, 400.0))
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
CentralPanel::default().show(ctx, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
if ui.button("Use defaults").clicked() {
|
||||
self.shortcuts.reset();
|
||||
}
|
||||
});
|
||||
ui.separator();
|
||||
self.show_shortcuts(ui);
|
||||
self.show_ff_settings(ui);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
use egui::{
|
||||
Button, CentralPanel, Context, Event, KeyboardShortcut, Label, Layout, Ui, ViewportBuilder,
|
||||
ViewportId,
|
||||
};
|
||||
use egui_extras::{Column, TableBuilder};
|
||||
|
||||
use crate::input::{Command, ShortcutProvider};
|
||||
|
||||
use super::AppWindow;
|
||||
|
||||
pub struct ShortcutsWindow {
|
||||
shortcuts: ShortcutProvider,
|
||||
now_binding: Option<Command>,
|
||||
}
|
||||
|
||||
impl ShortcutsWindow {
|
||||
pub fn new(shortcuts: ShortcutProvider) -> Self {
|
||||
Self {
|
||||
shortcuts,
|
||||
now_binding: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn show_shortcuts(&mut self, ui: &mut Ui) {
|
||||
ui.horizontal(|ui| {
|
||||
if ui.button("Use defaults").clicked() {
|
||||
self.shortcuts.reset();
|
||||
}
|
||||
});
|
||||
ui.separator();
|
||||
let row_height = ui.spacing().interact_size.y;
|
||||
let width = ui.available_width() - 20.0;
|
||||
TableBuilder::new(ui)
|
||||
.column(Column::exact(width * 0.3))
|
||||
.column(Column::exact(width * 0.5))
|
||||
.column(Column::exact(width * 0.2))
|
||||
.cell_layout(Layout::left_to_right(egui::Align::Center))
|
||||
.body(|mut body| {
|
||||
for command in Command::all() {
|
||||
body.row(row_height, |mut row| {
|
||||
row.col(|ui| {
|
||||
ui.add_sized(ui.available_size(), Label::new(command.name()));
|
||||
});
|
||||
row.col(|ui| {
|
||||
let button = if self.now_binding == Some(command) {
|
||||
Button::new("Binding...")
|
||||
} else if let Some(shortcut) = self.shortcuts.shortcut_for(command) {
|
||||
Button::new(ui.ctx().format_shortcut(&shortcut))
|
||||
} else {
|
||||
Button::new("")
|
||||
};
|
||||
if ui.add_sized(ui.available_size(), button).clicked() {
|
||||
self.now_binding = Some(command);
|
||||
}
|
||||
});
|
||||
row.col(|ui| {
|
||||
if ui
|
||||
.add_sized(ui.available_size(), Button::new("Clear"))
|
||||
.clicked()
|
||||
{
|
||||
self.shortcuts.unset(command);
|
||||
self.now_binding = None;
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
if let Some(command) = self.now_binding {
|
||||
if let Some(shortcut) = ui.input_mut(|i| {
|
||||
i.events.iter().find_map(|event| match event {
|
||||
Event::Key {
|
||||
key,
|
||||
pressed: true,
|
||||
modifiers,
|
||||
..
|
||||
} => Some(KeyboardShortcut::new(*modifiers, *key)),
|
||||
_ => None,
|
||||
})
|
||||
}) {
|
||||
self.shortcuts.set(command, shortcut);
|
||||
self.now_binding = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AppWindow for ShortcutsWindow {
|
||||
fn viewport_id(&self) -> ViewportId {
|
||||
ViewportId::from_hash_of("shortcuts")
|
||||
}
|
||||
|
||||
fn initial_viewport(&self) -> ViewportBuilder {
|
||||
ViewportBuilder::default()
|
||||
.with_title("Keyboard Shortcuts")
|
||||
.with_inner_size((400.0, 400.0))
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
CentralPanel::default().show(ctx, |ui| {
|
||||
self.show_shortcuts(ui);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
use std::{collections::VecDeque, sync::mpsc};
|
||||
|
||||
use egui::{
|
||||
Align, CentralPanel, Context, FontFamily, Label, RichText, ScrollArea, ViewportBuilder,
|
||||
ViewportId,
|
||||
};
|
||||
|
||||
use crate::emulator::{EmulatorClient, EmulatorCommand, SimId};
|
||||
|
||||
use super::AppWindow;
|
||||
|
||||
const SCROLLBACK: usize = 1000;
|
||||
|
||||
pub struct TerminalWindow {
|
||||
sim_id: SimId,
|
||||
receiver: mpsc::Receiver<String>,
|
||||
lines: VecDeque<String>,
|
||||
}
|
||||
|
||||
impl TerminalWindow {
|
||||
pub fn new(sim_id: SimId, client: &EmulatorClient) -> Self {
|
||||
let (sender, receiver) = mpsc::channel();
|
||||
client.send_command(EmulatorCommand::WatchStdout(sim_id, sender));
|
||||
let mut lines = VecDeque::new();
|
||||
lines.push_back(String::new());
|
||||
Self {
|
||||
sim_id,
|
||||
receiver,
|
||||
lines,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AppWindow for TerminalWindow {
|
||||
fn viewport_id(&self) -> ViewportId {
|
||||
ViewportId::from_hash_of(format!("terminal-{}", self.sim_id))
|
||||
}
|
||||
|
||||
fn sim_id(&self) -> SimId {
|
||||
self.sim_id
|
||||
}
|
||||
|
||||
fn initial_viewport(&self) -> ViewportBuilder {
|
||||
ViewportBuilder::default()
|
||||
.with_title(format!("Terminal ({})", self.sim_id))
|
||||
.with_inner_size((640.0, 480.0))
|
||||
}
|
||||
|
||||
fn show(&mut self, ctx: &Context) {
|
||||
if let Ok(text) = self.receiver.try_recv() {
|
||||
let mut rest = text.as_str();
|
||||
while let Some(index) = rest.find('\n') {
|
||||
let (line, lines) = rest.split_at(index);
|
||||
let current = self.lines.back_mut().unwrap();
|
||||
current.push_str(line);
|
||||
self.lines.push_back(String::new());
|
||||
if self.lines.len() > SCROLLBACK {
|
||||
self.lines.pop_front();
|
||||
}
|
||||
rest = &lines[1..];
|
||||
}
|
||||
self.lines.back_mut().unwrap().push_str(rest);
|
||||
}
|
||||
CentralPanel::default().show(ctx, |ui| {
|
||||
ScrollArea::vertical()
|
||||
.stick_to_bottom(true)
|
||||
.auto_shrink([false, false])
|
||||
.animated(false)
|
||||
.show(ui, |ui| {
|
||||
for line in &self.lines {
|
||||
let label = Label::new(RichText::new(line).family(FontFamily::Monospace))
|
||||
.halign(Align::LEFT)
|
||||
.wrap();
|
||||
ui.add(label);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue