feat: initial layout with zi

Author: bytefall

Cargo.lock

@@ -5,6 +5,8 @@ authors = ["Oleg Scherbakov <scherbakov.oleg@gmail.com>"]
 edition = "2021"
 
 [dependencies]
-iced = "0.3"
-pollster = "0.2"
-zbus = "2.0.0-beta.7"
+anyhow = { version = "1.0", features = ["backtrace"] }
+serde = { version = "1.0", features = ["serde_derive"] }
+zbus = "3.14"
+zi = "0.3"
+zi-term = "0.3"

Cargo.toml

@@ -0,0 +1,40 @@
+use serde::Deserialize;
+use zbus::zvariant::Type;
+
+#[derive(Copy, Clone, Default)]
+pub struct Cpu {
+	pub regs: Registers,
+}
+
+#[derive(Copy, Clone, Default, Deserialize, PartialEq, Type)]
+pub struct Registers {
+	pub eax: u32,
+	pub ebx: u32,
+	pub ecx: u32,
+	pub edx: u32,
+	pub esi: u32,
+	pub edi: u32,
+	pub ebp: u32,
+	pub esp: u32,
+	pub eip: u32,
+	pub cs: u16,
+	pub ds: u16,
+	pub es: u16,
+	pub _fs: u16,
+	pub _gs: u16,
+	pub ss: u16,
+	pub _cf: bool,
+	pub _pf: bool,
+	pub _af: bool,
+	pub zf: bool,
+	pub _sf: bool,
+	pub _tf: bool,
+	pub _if: bool,
+	pub _df: bool,
+	pub _of: bool,
+	pub _iopl: u8,
+	pub _nt: bool,
+	pub _vm: bool,
+	pub _ac: bool,
+	pub _id: bool,
+}

src/cpu.rs

@@ -1,9 +1,16 @@
-use iced::{Sandbox, Settings};
+use anyhow::Result;
+use zbus::blocking::Connection;
+use zi::prelude::*;
 
-use crate::gui::DebugBox;
+mod cpu;
+mod tui;
 
-mod gui;
+use crate::tui::debugbox::DebugBox;
 
-fn main() -> iced::Result {
-	DebugBox::run(Settings::default())
+fn main() -> Result<()> {
+	let app = DebugBox::with(Connection::session()?);
+
+	zi_term::incremental()?.run_event_loop(app)?;
+
+	Ok(())
 }

src/gui/main.rs

@@ -0,0 +1,38 @@
+use zi::{
+	components::text::{Text, TextAlign, TextProperties},
+	prelude::*,
+};
+
+pub struct Properties {
+	pub attached: bool,
+	pub cs: u16,
+	pub eip: u32,
+}
+
+pub struct Code {
+	attached: bool,
+	cs: u16,
+	eip: u32,
+}
+
+impl Component for Code {
+	type Message = ();
+	type Properties = Properties;
+
+	fn create(props: Self::Properties, _: Rect, _: ComponentLink<Self>) -> Self {
+		let Self::Properties { attached, cs, eip } = props;
+
+		Self { attached, cs, eip }
+	}
+
+	fn view(&self) -> Layout {
+		let tc = TextProperties::new().style(super::STYLE).align(TextAlign::Centre);
+		let tc = if self.attached {
+			tc.content(format!("{:04X}:{:08X}", self.cs, self.eip))
+		} else {
+			tc.content("This is a code")
+		};
+
+		Text::with_key("code", tc).into()
+	}
+}

src/gui/mod.rs

@@ -0,0 +1,127 @@
+use anyhow::Result;
+use zbus::blocking::Connection;
+use zi::prelude::*;
+
+use crate::cpu::Cpu;
+use crate::tui::code::{Code, Properties as CodeProperties};
+use crate::tui::registers::Registers;
+use crate::tui::status_bar::{Status, StatusBar};
+
+pub enum Message {
+	Reload,
+	Run,
+	StepOver,
+	TraceInto,
+}
+
+pub struct DebugBox {
+	link: ComponentLink<Self>,
+	conn: Connection,
+	status: Status,
+	cpu: Cpu,
+}
+
+impl DebugBox {
+	fn update(&mut self) -> Result<()> {
+		self.cpu.regs = self
+			.conn
+			.call_method(Some("com.dosbox"), "/cpu/regs", Some("com.dosbox"), "get", &())?
+			.body_unchecked()?;
+
+		Ok(())
+	}
+
+	fn run(&self) -> Result<()> {
+		self.conn
+			.call_method(Some("com.dosbox"), "/cpu", Some("com.dosbox"), "run", &())?;
+
+		Ok(())
+	}
+}
+
+impl Component for DebugBox {
+	type Message = Message;
+	type Properties = Connection;
+
+	fn create(conn: Self::Properties, _frame: Rect, link: ComponentLink<Self>) -> Self {
+		let mut this = Self {
+			link,
+			conn,
+			status: Status::Detached(None),
+			cpu: Default::default(),
+		};
+
+		// TODO: need to handle timeout with `monitor_activity` (Call failed: Connection timed out)
+		this.status = if let Err(e) = this.update() {
+			Status::Detached(Some(e.to_string()))
+		} else {
+			Status::Attached
+		};
+
+		this
+	}
+
+	fn update(&mut self, message: Self::Message) -> ShouldRender {
+		let mut update = || -> Result<bool> {
+			match message {
+				Message::Reload => {
+					self.update()?;
+					self.status = Status::Attached;
+
+					Ok(true)
+				}
+				Message::Run => {
+					if self.status != Status::Attached {
+						return Ok(false);
+					}
+
+					self.run()?;
+					self.status = Status::Detached(None);
+
+					Ok(true)
+				}
+				Message::StepOver => Ok(true),
+				Message::TraceInto => Ok(true),
+			}
+		};
+
+		update()
+			.unwrap_or_else(|e| {
+				self.status = Status::Detached(Some(e.to_string()));
+				true
+			})
+			.into()
+	}
+
+	fn bindings(&self, bindings: &mut Bindings<Self>) {
+		if !bindings.is_empty() {
+			return;
+		}
+
+		bindings.set_focus(true);
+
+		bindings.command("reload", || Message::Reload).with([Key::Ctrl('r')]);
+		bindings.command("run", || Message::Run).with([Key::F(5)]);
+		bindings.command("step-over", || Message::StepOver).with([Key::F(10)]);
+		bindings.command("trace-into", || Message::TraceInto).with([Key::F(11)]);
+
+		bindings
+			.command("exit", |this: &Self| this.link.exit())
+			.with([Key::Ctrl('c')])
+			.with([Key::Esc]);
+	}
+
+	fn view(&self) -> Layout {
+		Layout::column([
+			Item::auto(Layout::row([
+				Item::auto(Code::with(CodeProperties {
+					attached: self.status == Status::Attached,
+					cs: self.cpu.regs.cs,
+					eip: self.cpu.regs.eip,
+				})),
+				Item::fixed(50)(Registers::with(self.cpu.regs)),
+			])),
+			Item::fixed(1)(StatusBar::with(self.status.clone())),
+		])
+	}
+}

src/main.rs

@@ -0,0 +1,12 @@
+use zi::{Colour, Style};
+
+pub mod code;
+pub mod debugbox;
+pub mod registers;
+pub mod status_bar;
+
+const BACKGROUND: Colour = Colour::rgb(33, 34, 44);
+const BACKGROUND_DARK: Colour = Colour::rgb(14, 20, 25);
+const FOREGROUND: Colour = Colour::rgb(80, 250, 123);
+const FOREGROUND_GRAY: Colour = Colour::rgb(248, 248, 242);
+const STYLE: Style = Style::bold(BACKGROUND_DARK, FOREGROUND);

src/tui/code.rs

@@ -0,0 +1,58 @@
+use zi::{
+	components::text::{Text, TextProperties},
+	prelude::*,
+};
+
+use crate::cpu::Registers as Regs;
+
+pub struct Registers {
+	regs: Regs,
+}
+
+impl Component for Registers {
+	type Message = ();
+	type Properties = Regs;
+
+	fn create(regs: Self::Properties, _: Rect, _: ComponentLink<Self>) -> Self {
+		Self { regs }
+	}
+
+	fn change(&mut self, regs: Self::Properties) -> ShouldRender {
+		if self.regs != regs {
+			self.regs = regs;
+
+			true
+		} else {
+			false
+		}
+		.into()
+	}
+
+	fn view(&self) -> Layout {
+		let r = self.regs;
+
+		let regs = [
+			[("EAX", r.eax), ("EBX", r.ebx), ("ECX", r.ecx), ("EDX", r.edx)],
+			[("ESI", r.esi), ("EDI", r.edi), ("EBP", r.ebp), ("ESP", r.esp)],
+			[
+				("CS", r.cs.into()),
+				("DS", r.ds.into()),
+				("ES", r.es.into()),
+				("SS", r.ss.into()),
+			],
+		];
+
+		Layout::row(regs.map(|col| {
+			Item::auto(Layout::column(col.map(|(name, value)| {
+				Item::fixed(1)(Text::with_key(
+					name,
+					TextProperties::new().style(super::STYLE).content(if name.len() == 2 {
+						format!("{name}={value:04X}")
+					} else {
+						format!("{name}={value:08X}")
+					}),
+				))
+			})))
+		}))
+	}
+}