196 lines
7.1 KiB
Rust
196 lines
7.1 KiB
Rust
mod error;
|
|
use error::ProgErr;
|
|
|
|
use cairo;
|
|
use gio::prelude::*;
|
|
use gtk::prelude::*;
|
|
use gtk::Builder;
|
|
|
|
mod emulator;
|
|
mod graphic;
|
|
mod handler;
|
|
use graphic::{Color, Image};
|
|
use handler::{Cmd, ThreadedEmulator};
|
|
|
|
macro_rules! gtk_rs {
|
|
($builder:expr=>$name:expr) => {
|
|
$builder
|
|
.get_object($name)
|
|
.unwrap_or_else(|| panic!("Object {} could't be found", $name))
|
|
};
|
|
}
|
|
|
|
pub fn init(app: >k::Application) -> Result<(), ProgErr> {
|
|
use std::sync::{Arc, Mutex};
|
|
let img_m = Arc::from(Mutex::from(Image::new()));
|
|
let palette: Arc<Mutex<_>> = Arc::from(Mutex::from([Color::default(); 16]));
|
|
|
|
let emulator = ThreadedEmulator::new();
|
|
|
|
/*
|
|
// Handle emulator CMDs
|
|
let (tcmd, rcmd) = std::sync::mpsc::channel::<Cmd>();
|
|
let (tdata, rdata) = glib::MainContext::channel(glib::source::Priority::default());
|
|
let emulator = Arc::from(Mutex::from(System::new()));
|
|
{
|
|
let emulator = emulator.clone();
|
|
std::thread::spawn(move || loop {
|
|
if let Ok(cmd) = rcmd.recv() {
|
|
if let Ok(mut emulator) = emulator.try_lock() {
|
|
match cmd {
|
|
Cmd::Step => {
|
|
if let Err(e) = emulator.step() {
|
|
println!("{:#?}", e);
|
|
}
|
|
}
|
|
Cmd::Reset => {
|
|
emulator.restart();
|
|
emulator.ram = *include_bytes!("color.hex");
|
|
}
|
|
Cmd::Run => loop {
|
|
if let Ok(_) = rcmd.recv_timeout(std::time::Duration::from_millis(1)) {
|
|
break;
|
|
} else {
|
|
if let Err(e) = emulator.step() {
|
|
println!("Emulator error: {:?}", e);
|
|
break;
|
|
}
|
|
println!("Tick {}", emulator.cycles);
|
|
let page_02 = Vec::from(&emulator.ram[0x200..0x300]);
|
|
tdata.send(page_02);
|
|
}
|
|
},
|
|
_ => {}
|
|
};
|
|
println!("Tick {}", emulator.cycles);
|
|
let page_02 = Vec::from(&emulator.ram[0x200..0x300]);
|
|
tdata.send(page_02);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
*/
|
|
let builder: Builder = Builder::new_from_string(include_str!("ui.glade"));
|
|
//let window: Option<gtk::ApplicationWindow> = builder.get_object("Window");
|
|
let window: gtk::ApplicationWindow = gtk_rs!(builder=>"Window");
|
|
let drawing_area: gtk::DrawingArea = gtk_rs!(builder=>"Display");
|
|
//let drawing_area = Arc::from(drawing_area);
|
|
{
|
|
let img_m = img_m.clone();
|
|
drawing_area.connect_draw(
|
|
move |drawing_area: >k::DrawingArea, ctx: &cairo::Context| {
|
|
let widget_width = drawing_area.get_allocated_width();
|
|
let widget_height = drawing_area.get_allocated_height();
|
|
let img: Result<_, _> = img_m.try_lock();
|
|
if let Ok(img) = img {
|
|
img.draw(&ctx, (widget_width, widget_height));
|
|
}
|
|
glib::signal::Inhibit(false)
|
|
},
|
|
);
|
|
}
|
|
|
|
for widget_name in &["Step", "Reset", "Run", "Stop"] {
|
|
let tcmd = emulator.tcmd.clone();
|
|
let widget: gtk::Button = gtk_rs!(builder=>widget_name); // builder.get_object(widget_name).expect("Not found");
|
|
widget.connect_clicked(move |s: >k::Button| {
|
|
let name = s.get_widget_name().unwrap();
|
|
let name = name.as_str();
|
|
println!("Sending from {}", name);
|
|
tcmd.send(Cmd::from(name)).expect("Couldn't send cmd");
|
|
});
|
|
}
|
|
|
|
// Ram Display
|
|
/* {
|
|
let ram_display_window: gtk::Window = gtk_rs!(builder=>"RamDisplayWindow"); // builder.get_object().unwrap();
|
|
let switch: gtk::Switch = gtk_rs!(builder=>"RamDisplay"); // builder.get_object().expect("Not Found");
|
|
switch.connect_state_set(move |switch: >k::Switch, state: bool| {
|
|
if state {
|
|
ram_display_window.show_all();
|
|
} else {
|
|
ram_display_window.close();
|
|
}
|
|
println!("{}", state);
|
|
|
|
Inhibit(false)
|
|
});
|
|
let ram_list: gtk::Window = gtk_rs!(builder=>"RamList");
|
|
} */
|
|
|
|
let registers: gtk::Label = gtk_rs!(builder=>"Registers");
|
|
|
|
// Receive GPU page
|
|
{
|
|
let drawing_area = drawing_area.clone();
|
|
let palette = palette.clone();
|
|
let img_m = img_m.clone();
|
|
let system = emulator.system.clone();
|
|
emulator.rdata.attach(None, move |data: Vec<_>| {
|
|
println!("Received page");
|
|
for line in data.chunks(16) {
|
|
println!(
|
|
"{}",
|
|
line.iter()
|
|
.map(|h| format!("{:02X}", h))
|
|
.collect::<String>()
|
|
)
|
|
}
|
|
if let Ok(mut img) = img_m.try_lock() {
|
|
let (w, h) = (img.width, img.height);
|
|
let pixels: &mut [Color] = &mut img.pixels;
|
|
let palette = palette.lock().expect("Couldn't get palette");
|
|
for y in 0..h {
|
|
for x in 0..w {
|
|
let i = y * w + x;
|
|
pixels[i] = palette[data[i] as usize & 0x0F];
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Ok(system) = system.try_lock() {
|
|
registers.set_text(&format!("{:#?}", system.registers));
|
|
}
|
|
drawing_area.queue_draw();
|
|
glib::Continue(true)
|
|
});
|
|
}
|
|
|
|
// Color palette
|
|
{
|
|
for i in 0..16 {
|
|
let drawing_area = drawing_area.clone();
|
|
let palette = palette.clone();
|
|
let color_button = &format!("ColorPalette{}", i);
|
|
let color_button: gtk::ColorButton = gtk_rs!(builder=>color_button);
|
|
color_button.connect_color_set(move |s: >k::ColorButton| {
|
|
let color = s.get_rgba();
|
|
let color = Color::from((color.red, color.green, color.blue));
|
|
let mut palette = palette.lock().expect("Couldn't acquire palette lock");
|
|
palette[i] = color;
|
|
println!("New color: {:?}", color);
|
|
drawing_area.queue_draw();
|
|
});
|
|
color_button.emit("color-set", &[])?;
|
|
}
|
|
}
|
|
|
|
window.set_application(Some(app));
|
|
window.show_all();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn main() -> Result<(), ProgErr> {
|
|
let app: gtk::Application =
|
|
gtk::Application::new(Some("com.ducklings_corp.emulator"), Default::default())?;
|
|
app.connect_activate(|app| init(app).expect("Init failed"));
|
|
app.run(&std::env::args().collect::<Vec<_>>());
|
|
Ok(())
|
|
}
|