Introduce tester feature flag
This commit is contained in:
Héctor Ramón Jiménez
parent
ed528c9c53
commit
1821dc7ff0
13 changed files with 488 additions and 640 deletions
|
|
@ -1,6 +1,4 @@
|
|||
// Generated automatically by iced_fontello at build time.
|
||||
// Do not edit manually. Source: ../fonts/iced_devtools-icons.toml
|
||||
// 3139a163a989c992b8f038da359b59e9292fc49f031e760b61a8d76e2037aee2
|
||||
#![allow(unused)]
|
||||
use crate::core::Font;
|
||||
use crate::program;
|
||||
use crate::widget::{Text, text};
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#![allow(missing_docs)]
|
||||
use iced_debug as debug;
|
||||
use iced_program as program;
|
||||
#[cfg(feature = "tester")]
|
||||
use iced_test as test;
|
||||
use iced_widget::core;
|
||||
use iced_widget::runtime;
|
||||
|
|
@ -12,26 +13,29 @@ mod icon;
|
|||
mod time_machine;
|
||||
mod widget;
|
||||
|
||||
use crate::core::alignment::Horizontal::Right;
|
||||
#[cfg(feature = "tester")]
|
||||
mod tester;
|
||||
|
||||
#[cfg(not(feature = "tester"))]
|
||||
#[path = "tester/null.rs"]
|
||||
mod tester;
|
||||
|
||||
use crate::tester::Tester;
|
||||
|
||||
use crate::core::border;
|
||||
use crate::core::keyboard;
|
||||
use crate::core::theme::{self, Base, Theme};
|
||||
use crate::core::time::seconds;
|
||||
use crate::core::window;
|
||||
use crate::core::{
|
||||
Alignment::Center, Color, Element, Font, Length::Fill, Size,
|
||||
};
|
||||
use crate::core::{Alignment::Center, Color, Element, Length::Fill};
|
||||
use crate::futures::Subscription;
|
||||
use crate::program::Program;
|
||||
use crate::runtime::Task;
|
||||
use crate::runtime::font;
|
||||
use crate::test::Emulator;
|
||||
use crate::test::emulator;
|
||||
use crate::test::instruction;
|
||||
use crate::time_machine::TimeMachine;
|
||||
use crate::widget::{
|
||||
Text, bottom_right, button, center, column, container, horizontal_space,
|
||||
opaque, row, scrollable, stack, text, text_input, themer,
|
||||
bottom_right, button, center, column, container, horizontal_space,
|
||||
monospace, opaque, row, scrollable, stack, text, themer,
|
||||
};
|
||||
|
||||
use std::fmt;
|
||||
|
|
@ -127,49 +131,29 @@ where
|
|||
P: Program,
|
||||
{
|
||||
state: P::State,
|
||||
size: Size,
|
||||
mode: Mode<P>,
|
||||
show_notification: bool,
|
||||
time_machine: TimeMachine<P>,
|
||||
mode: Mode<P>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Message {
|
||||
HideNotification,
|
||||
Toggle,
|
||||
ToggleComet,
|
||||
CometLaunched(comet::launch::Result),
|
||||
InstallComet,
|
||||
Installing(comet::install::Result),
|
||||
CancelSetup,
|
||||
ChangeWidth(String),
|
||||
ChangeHeight(String),
|
||||
Record,
|
||||
Stop,
|
||||
Recorded(core::Event),
|
||||
Play,
|
||||
Toggle,
|
||||
Tester(tester::Message),
|
||||
}
|
||||
|
||||
enum Mode<P: Program> {
|
||||
Hidden,
|
||||
Open { recorder: Recorder<P> },
|
||||
Open { tester: Tester<P> },
|
||||
Setup(Setup),
|
||||
}
|
||||
|
||||
struct Recorder<P: Program> {
|
||||
instructions: Vec<test::Instruction>,
|
||||
state: State<P>,
|
||||
}
|
||||
|
||||
enum State<P: Program> {
|
||||
Idle,
|
||||
Recording,
|
||||
Playing {
|
||||
emulator: Emulator<P>,
|
||||
current: usize,
|
||||
},
|
||||
}
|
||||
|
||||
enum Setup {
|
||||
Idle { goal: Goal },
|
||||
Running { logs: Vec<String> },
|
||||
|
|
@ -188,7 +172,6 @@ where
|
|||
(
|
||||
Self {
|
||||
state,
|
||||
size: Size::new(512.0, 512.0),
|
||||
mode: Mode::Hidden,
|
||||
show_notification: true,
|
||||
time_machine: TimeMachine::new(),
|
||||
|
|
@ -217,18 +200,10 @@ where
|
|||
match &self.mode {
|
||||
Mode::Hidden => {
|
||||
self.mode = Mode::Open {
|
||||
recorder: Recorder {
|
||||
instructions: Vec::new(),
|
||||
state: State::Idle,
|
||||
},
|
||||
tester: Tester::new(),
|
||||
};
|
||||
}
|
||||
Mode::Open {
|
||||
recorder:
|
||||
Recorder {
|
||||
state: State::Idle, ..
|
||||
},
|
||||
} => {
|
||||
Mode::Open { tester } if !tester.is_busy() => {
|
||||
self.mode = Mode::Hidden;
|
||||
}
|
||||
Mode::Setup(_) | Mode::Open { .. } => {}
|
||||
|
|
@ -318,92 +293,12 @@ where
|
|||
|
||||
Task::none()
|
||||
}
|
||||
Message::ChangeWidth(width) => {
|
||||
if let Ok(width) = width.parse() {
|
||||
self.size.width = width;
|
||||
}
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::ChangeHeight(height) => {
|
||||
if let Ok(height) = height.parse() {
|
||||
self.size.height = height;
|
||||
}
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::Record => {
|
||||
let Mode::Open { recorder } = &mut self.mode else {
|
||||
Message::Tester(message) => {
|
||||
let Mode::Open { tester } = &mut self.mode else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
recorder.instructions.clear();
|
||||
recorder.state = State::Recording;
|
||||
|
||||
let (state, task) = program.boot();
|
||||
self.state = state;
|
||||
|
||||
task.map(Event::Program)
|
||||
}
|
||||
Message::Recorded(event) => {
|
||||
let Mode::Open { recorder } = &mut self.mode else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
let Some(interaction) =
|
||||
instruction::Interaction::from_event(event)
|
||||
else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
if let Some(test::Instruction::Interact(last_interaction)) =
|
||||
recorder.instructions.pop()
|
||||
{
|
||||
let (last_interaction, new_interaction) =
|
||||
last_interaction.merge(interaction);
|
||||
|
||||
recorder.instructions.push(
|
||||
test::Instruction::Interact(last_interaction),
|
||||
);
|
||||
|
||||
if let Some(new_interaction) = new_interaction {
|
||||
recorder.instructions.push(
|
||||
test::Instruction::Interact(new_interaction),
|
||||
);
|
||||
}
|
||||
} else {
|
||||
recorder
|
||||
.instructions
|
||||
.push(test::Instruction::Interact(interaction));
|
||||
}
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::Stop => {
|
||||
let Mode::Open { recorder } = &mut self.mode else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
recorder.state = State::Idle;
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::Play => {
|
||||
let Mode::Open { recorder } = &mut self.mode else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
let (sender, receiver) =
|
||||
futures::futures::channel::mpsc::channel(1);
|
||||
|
||||
let emulator = Emulator::new(program, self.size, sender);
|
||||
|
||||
recorder.state = State::Playing {
|
||||
emulator,
|
||||
current: 0,
|
||||
};
|
||||
|
||||
Task::run(receiver, Event::Emulator)
|
||||
tester.update(program, message).map(Event::Tester)
|
||||
}
|
||||
},
|
||||
Event::Program(message) => {
|
||||
|
|
@ -436,33 +331,12 @@ where
|
|||
|
||||
Task::none()
|
||||
}
|
||||
Event::Emulator(event) => {
|
||||
let Mode::Open {
|
||||
recorder:
|
||||
Recorder {
|
||||
state: State::Playing { emulator, current },
|
||||
instructions,
|
||||
},
|
||||
} = &mut self.mode
|
||||
else {
|
||||
Event::Tester(tick) => {
|
||||
let Mode::Open { tester } = &mut self.mode else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
match event {
|
||||
emulator::Event::Action(action) => {
|
||||
emulator.perform(program, action);
|
||||
}
|
||||
emulator::Event::Ready => {
|
||||
if let Some(instruction) =
|
||||
instructions.get(*current).cloned()
|
||||
{
|
||||
emulator.run(program, instruction);
|
||||
*current += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Task::none()
|
||||
tester.tick(program, tick).map(Event::Tester)
|
||||
}
|
||||
Event::Discard => Task::none(),
|
||||
}
|
||||
|
|
@ -476,25 +350,23 @@ where
|
|||
let state = self.state();
|
||||
|
||||
let view = {
|
||||
let view = match &self.mode {
|
||||
Mode::Open {
|
||||
recorder:
|
||||
Recorder {
|
||||
state: State::Playing { emulator, .. },
|
||||
..
|
||||
},
|
||||
} => emulator.view(program),
|
||||
_ => program.view(state, window),
|
||||
let view = || {
|
||||
let theme = program.theme(state, window);
|
||||
let view: Element<'_, _, Theme, _> =
|
||||
themer(theme, program.view(&self.state, window)).into();
|
||||
|
||||
if self.time_machine.is_rewinding() {
|
||||
view.map(|_| Event::Discard)
|
||||
} else {
|
||||
view.map(Event::Program)
|
||||
}
|
||||
};
|
||||
|
||||
let theme = program.theme(state, window);
|
||||
|
||||
let view: Element<'_, _, Theme, _> = themer(theme, view).into();
|
||||
|
||||
if self.time_machine.is_rewinding() {
|
||||
view.map(|_| Event::Discard)
|
||||
} else {
|
||||
view.map(Event::Program)
|
||||
match &self.mode {
|
||||
Mode::Open { tester } => {
|
||||
tester.view(program, window, view, Event::Tester)
|
||||
}
|
||||
_ => view(),
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -536,104 +408,11 @@ where
|
|||
))
|
||||
});
|
||||
|
||||
let sidebar = if let Mode::Open { recorder } = &self.mode {
|
||||
let sidebar = if let Mode::Open { tester } = &self.mode {
|
||||
let title = monospace("Developer Tools");
|
||||
let tester = tester.controls().map(Message::Tester);
|
||||
|
||||
let recorder = {
|
||||
let events = container(if recorder.instructions.is_empty() {
|
||||
Element::from(center(
|
||||
monospace("No instructions recorded yet!")
|
||||
.size(14)
|
||||
.width(Fill)
|
||||
.center(),
|
||||
))
|
||||
} else {
|
||||
scrollable(
|
||||
column(recorder.instructions.iter().enumerate().map(
|
||||
|(i, instruction)| {
|
||||
monospace(instruction.to_string())
|
||||
.size(10)
|
||||
.style(move |theme: &Theme| text::Style {
|
||||
color: match &recorder.state {
|
||||
State::Playing {
|
||||
current, ..
|
||||
} => {
|
||||
if *current == i {
|
||||
Some(
|
||||
theme.palette().primary,
|
||||
)
|
||||
} else if *current > i {
|
||||
Some(
|
||||
theme
|
||||
.extended_palette()
|
||||
.success
|
||||
.strong
|
||||
.color,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
_ => None,
|
||||
},
|
||||
})
|
||||
.into()
|
||||
},
|
||||
))
|
||||
.spacing(5),
|
||||
)
|
||||
.spacing(5)
|
||||
.into()
|
||||
})
|
||||
.width(Fill)
|
||||
.height(Fill)
|
||||
.padding(5);
|
||||
|
||||
let controls = {
|
||||
row![
|
||||
button(icon::play().size(14).width(Fill).center())
|
||||
.on_press_maybe(
|
||||
(!matches!(recorder.state, State::Recording)
|
||||
&& !recorder.instructions.is_empty())
|
||||
.then_some(Message::Play),
|
||||
),
|
||||
if let State::Recording = &recorder.state {
|
||||
button(icon::stop().size(14).width(Fill).center())
|
||||
.on_press(Message::Stop)
|
||||
.style(button::success)
|
||||
} else {
|
||||
button(icon::record().size(14).width(Fill).center())
|
||||
.on_press_maybe(
|
||||
matches!(recorder.state, State::Idle)
|
||||
.then_some(Message::Record),
|
||||
)
|
||||
.style(button::danger)
|
||||
}
|
||||
]
|
||||
.spacing(10)
|
||||
};
|
||||
|
||||
column![events, controls].spacing(10).align_x(Center)
|
||||
};
|
||||
|
||||
let viewport = row![
|
||||
text_input("Width", &self.size.width.to_string())
|
||||
.size(14)
|
||||
.on_input(Message::ChangeWidth),
|
||||
monospace("x"),
|
||||
text_input("Height", &self.size.height.to_string())
|
||||
.size(14)
|
||||
.on_input(Message::ChangeHeight),
|
||||
]
|
||||
.spacing(10)
|
||||
.align_y(Center);
|
||||
|
||||
let tools = column![
|
||||
title,
|
||||
labeled("Viewport", viewport),
|
||||
labeled("Tester", recorder)
|
||||
]
|
||||
.spacing(10);
|
||||
let tools = column![title, tester].spacing(10);
|
||||
|
||||
let sidebar = container(tools)
|
||||
.padding(10)
|
||||
|
|
@ -646,65 +425,7 @@ where
|
|||
None
|
||||
};
|
||||
|
||||
let content = row![if let Mode::Open { recorder } = &self.mode {
|
||||
let status = match &recorder.state {
|
||||
State::Idle => monospace("Idle").style(|theme| text::Style {
|
||||
color: Some(
|
||||
theme.extended_palette().background.strongest.color,
|
||||
),
|
||||
}),
|
||||
State::Recording => {
|
||||
monospace("Recording").style(|theme| text::Style {
|
||||
color: Some(theme.palette().danger),
|
||||
})
|
||||
}
|
||||
State::Playing { .. } => {
|
||||
monospace("Playing").style(|theme| text::Style {
|
||||
color: Some(theme.palette().primary),
|
||||
})
|
||||
}
|
||||
};
|
||||
|
||||
let viewport = container(
|
||||
scrollable(
|
||||
container(if let State::Recording = &recorder.state {
|
||||
widget::recorder(view)
|
||||
.on_event(|event| {
|
||||
Event::Message(Message::Recorded(event))
|
||||
})
|
||||
.into()
|
||||
} else {
|
||||
view
|
||||
})
|
||||
.width(self.size.width)
|
||||
.height(self.size.height),
|
||||
)
|
||||
.direction(scrollable::Direction::Both {
|
||||
vertical: scrollable::Scrollbar::default(),
|
||||
horizontal: scrollable::Scrollbar::default(),
|
||||
}),
|
||||
)
|
||||
.style(|theme| {
|
||||
let palette = theme.extended_palette();
|
||||
|
||||
container::Style {
|
||||
border: border::width(2.0).color(match &recorder.state {
|
||||
State::Idle => palette.background.strongest.color,
|
||||
State::Recording => palette.danger.base.color,
|
||||
State::Playing { .. } => palette.primary.base.color,
|
||||
}),
|
||||
..container::Style::default()
|
||||
}
|
||||
})
|
||||
.padding(10);
|
||||
|
||||
center(column![status, viewport].spacing(10).align_x(Right))
|
||||
.padding(10)
|
||||
.into()
|
||||
} else {
|
||||
view
|
||||
}]
|
||||
.push_maybe(sidebar);
|
||||
let content = row![view].push_maybe(sidebar);
|
||||
|
||||
themer(
|
||||
theme,
|
||||
|
|
@ -724,8 +445,13 @@ where
|
|||
let hotkeys =
|
||||
futures::keyboard::on_key_press(|key, _modifiers| match key {
|
||||
keyboard::Key::Named(keyboard::key::Named::F12) => {
|
||||
Some(Message::Toggle)
|
||||
Some(if cfg!(feature = "tester") {
|
||||
Message::Toggle
|
||||
} else {
|
||||
Message::ToggleComet
|
||||
})
|
||||
}
|
||||
#[cfg(feature = "tester")]
|
||||
keyboard::Key::Named(keyboard::key::Named::F11) => {
|
||||
Some(Message::ToggleComet)
|
||||
}
|
||||
|
|
@ -761,7 +487,7 @@ where
|
|||
{
|
||||
Message(Message),
|
||||
Program(P::Message),
|
||||
Emulator(emulator::Event<P>),
|
||||
Tester(tester::Tick<P>),
|
||||
Command(debug::Command),
|
||||
Discard,
|
||||
}
|
||||
|
|
@ -774,7 +500,7 @@ where
|
|||
match self {
|
||||
Self::Message(message) => message.fmt(f),
|
||||
Self::Program(message) => message.fmt(f),
|
||||
Self::Emulator(_) => f.write_str("Emulator"),
|
||||
Self::Tester(_) => f.write_str("Tester"),
|
||||
Self::Command(command) => command.fmt(f),
|
||||
Self::Discard => f.write_str("Discard"),
|
||||
}
|
||||
|
|
@ -791,7 +517,7 @@ where
|
|||
Self::Message(message) => Self::Message(message.clone()),
|
||||
Self::Program(message) => Self::Program(message.clone()),
|
||||
Self::Command(command) => Self::Command(*command),
|
||||
Self::Emulator(_) => Self::Discard, // Time traveling an emulator?!
|
||||
Self::Tester(_) => Self::Discard, // Time traveling an emulator?!
|
||||
Self::Discard => Self::Discard,
|
||||
}
|
||||
}
|
||||
|
|
@ -926,25 +652,3 @@ where
|
|||
.padding([2, 4])
|
||||
.into()
|
||||
}
|
||||
|
||||
fn monospace<'a, Renderer>(
|
||||
fragment: impl text::IntoFragment<'a>,
|
||||
) -> Text<'a, Theme, Renderer>
|
||||
where
|
||||
Renderer: program::Renderer + 'a,
|
||||
{
|
||||
text(fragment).font(Font::MONOSPACE)
|
||||
}
|
||||
|
||||
fn labeled<'a, Message, Renderer>(
|
||||
fragment: impl text::IntoFragment<'a>,
|
||||
content: impl Into<Element<'a, Message, Theme, Renderer>>,
|
||||
) -> Element<'a, Message, Theme, Renderer>
|
||||
where
|
||||
Message: 'a,
|
||||
Renderer: program::Renderer + 'a,
|
||||
{
|
||||
column![monospace(fragment).size(14), content.into()]
|
||||
.spacing(5)
|
||||
.into()
|
||||
}
|
||||
|
|
|
|||
346
devtools/src/tester.rs
Normal file
346
devtools/src/tester.rs
Normal file
|
|
@ -0,0 +1,346 @@
|
|||
mod recorder;
|
||||
|
||||
use recorder::recorder;
|
||||
|
||||
use crate::Program;
|
||||
use crate::core::Alignment::Center;
|
||||
use crate::core::Length::Fill;
|
||||
use crate::core::alignment::Horizontal::Right;
|
||||
use crate::core::border;
|
||||
use crate::core::window;
|
||||
use crate::core::{Element, Event, Size, Theme};
|
||||
use crate::futures::futures::channel::mpsc;
|
||||
use crate::icon;
|
||||
use crate::program;
|
||||
use crate::runtime::Task;
|
||||
use crate::test::emulator;
|
||||
use crate::test::instruction;
|
||||
use crate::test::{Emulator, Instruction};
|
||||
use crate::widget::{
|
||||
button, center, column, container, monospace, row, scrollable, text,
|
||||
text_input, themer,
|
||||
};
|
||||
|
||||
pub struct Tester<P: Program> {
|
||||
viewport: Size,
|
||||
instructions: Vec<Instruction>,
|
||||
state: State<P>,
|
||||
}
|
||||
|
||||
enum State<P: Program> {
|
||||
Idle,
|
||||
Recording {
|
||||
state: P::State,
|
||||
},
|
||||
Playing {
|
||||
emulator: Emulator<P>,
|
||||
current: usize,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Message {
|
||||
ChangeViewport(Size),
|
||||
Record,
|
||||
Stop,
|
||||
Play,
|
||||
}
|
||||
|
||||
#[allow(missing_debug_implementations)]
|
||||
pub enum Tick<P: Program> {
|
||||
Program(P::Message),
|
||||
Recorder(Event),
|
||||
Emulator(emulator::Event<P>),
|
||||
}
|
||||
|
||||
impl<P: Program + 'static> Tester<P> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
viewport: Size::new(512.0, 512.0),
|
||||
instructions: Vec::new(),
|
||||
state: State::Idle,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_busy(&self) -> bool {
|
||||
matches!(self.state, State::Idle | State::Playing { .. })
|
||||
}
|
||||
|
||||
pub fn update(&mut self, program: &P, message: Message) -> Task<Tick<P>> {
|
||||
match message {
|
||||
Message::ChangeViewport(viewport) => {
|
||||
self.viewport = viewport;
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::Record => {
|
||||
self.instructions.clear();
|
||||
|
||||
let (state, task) = program.boot();
|
||||
self.state = State::Recording { state };
|
||||
|
||||
task.map(Tick::Program)
|
||||
}
|
||||
Message::Stop => {
|
||||
self.state = State::Idle;
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Message::Play => {
|
||||
let (sender, receiver) = mpsc::channel(1);
|
||||
let emulator = Emulator::new(program, self.viewport, sender);
|
||||
|
||||
self.state = State::Playing {
|
||||
emulator,
|
||||
current: 0,
|
||||
};
|
||||
|
||||
Task::run(receiver, Tick::Emulator)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn tick(&mut self, program: &P, tick: Tick<P>) -> Task<Tick<P>> {
|
||||
match tick {
|
||||
Tick::Program(message) => {
|
||||
let State::Recording { state } = &mut self.state else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
program.update(state, message).map(Tick::Program)
|
||||
}
|
||||
Tick::Recorder(event) => {
|
||||
let Some(interaction) =
|
||||
instruction::Interaction::from_event(event)
|
||||
else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
if let Some(Instruction::Interact(last_interaction)) =
|
||||
self.instructions.pop()
|
||||
{
|
||||
let (last_interaction, new_interaction) =
|
||||
last_interaction.merge(interaction);
|
||||
|
||||
self.instructions
|
||||
.push(Instruction::Interact(last_interaction));
|
||||
|
||||
if let Some(new_interaction) = new_interaction {
|
||||
self.instructions
|
||||
.push(Instruction::Interact(new_interaction));
|
||||
}
|
||||
} else {
|
||||
self.instructions.push(Instruction::Interact(interaction));
|
||||
}
|
||||
|
||||
Task::none()
|
||||
}
|
||||
Tick::Emulator(event) => {
|
||||
let State::Playing { emulator, current } = &mut self.state
|
||||
else {
|
||||
return Task::none();
|
||||
};
|
||||
|
||||
match event {
|
||||
emulator::Event::Action(action) => {
|
||||
emulator.perform(program, action);
|
||||
}
|
||||
emulator::Event::Ready => {
|
||||
if let Some(instruction) =
|
||||
self.instructions.get(*current).cloned()
|
||||
{
|
||||
emulator.run(program, instruction);
|
||||
*current += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Task::none()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn view<'a, T: 'static>(
|
||||
&'a self,
|
||||
program: &P,
|
||||
window: window::Id,
|
||||
current: impl FnOnce() -> Element<'a, T, Theme, P::Renderer>,
|
||||
emulate: impl Fn(Tick<P>) -> T + 'a,
|
||||
) -> Element<'a, T, Theme, P::Renderer> {
|
||||
let status = match &self.state {
|
||||
State::Idle => monospace("Idle").style(|theme| text::Style {
|
||||
color: Some(
|
||||
theme.extended_palette().background.strongest.color,
|
||||
),
|
||||
}),
|
||||
State::Recording { .. } => {
|
||||
monospace("Recording").style(|theme| text::Style {
|
||||
color: Some(theme.palette().danger),
|
||||
})
|
||||
}
|
||||
State::Playing { .. } => {
|
||||
monospace("Playing").style(|theme| text::Style {
|
||||
color: Some(theme.palette().primary),
|
||||
})
|
||||
}
|
||||
};
|
||||
|
||||
let viewport = container(
|
||||
scrollable(
|
||||
container(match &self.state {
|
||||
State::Idle => current(),
|
||||
State::Recording { state } => {
|
||||
let theme = program.theme(state, window);
|
||||
let view =
|
||||
program.view(state, window).map(Tick::Program);
|
||||
|
||||
Element::from(
|
||||
recorder(themer(theme, view))
|
||||
.on_event(Tick::Recorder),
|
||||
)
|
||||
.map(emulate)
|
||||
}
|
||||
State::Playing { emulator, .. } => {
|
||||
let theme = emulator.theme(program);
|
||||
let view = emulator.view(program).map(Tick::Program);
|
||||
|
||||
Element::from(themer(theme, view)).map(emulate)
|
||||
}
|
||||
})
|
||||
.width(self.viewport.width)
|
||||
.height(self.viewport.height),
|
||||
)
|
||||
.direction(scrollable::Direction::Both {
|
||||
vertical: scrollable::Scrollbar::default(),
|
||||
horizontal: scrollable::Scrollbar::default(),
|
||||
}),
|
||||
)
|
||||
.style(|theme: &Theme| {
|
||||
let palette = theme.extended_palette();
|
||||
|
||||
container::Style {
|
||||
border: border::width(2.0).color(match &self.state {
|
||||
State::Idle => palette.background.strongest.color,
|
||||
State::Recording { .. } => palette.danger.base.color,
|
||||
State::Playing { .. } => palette.primary.base.color,
|
||||
}),
|
||||
..container::Style::default()
|
||||
}
|
||||
})
|
||||
.padding(10);
|
||||
|
||||
center(column![status, viewport].spacing(10).align_x(Right))
|
||||
.padding(10)
|
||||
.into()
|
||||
}
|
||||
|
||||
pub fn controls(&self) -> Element<'_, Message, Theme, P::Renderer> {
|
||||
let viewport = row![
|
||||
text_input("Width", &self.viewport.width.to_string())
|
||||
.size(14)
|
||||
.on_input(|width| Message::ChangeViewport(Size {
|
||||
width: width.parse().unwrap_or(self.viewport.width),
|
||||
..self.viewport
|
||||
})),
|
||||
monospace("x"),
|
||||
text_input("Height", &self.viewport.height.to_string())
|
||||
.size(14)
|
||||
.on_input(|height| Message::ChangeViewport(Size {
|
||||
height: height.parse().unwrap_or(self.viewport.height),
|
||||
..self.viewport
|
||||
})),
|
||||
]
|
||||
.spacing(10)
|
||||
.align_y(Center);
|
||||
|
||||
let player = {
|
||||
let events = container(if self.instructions.is_empty() {
|
||||
Element::from(center(
|
||||
monospace("No instructions recorded yet!")
|
||||
.size(14)
|
||||
.width(Fill)
|
||||
.center(),
|
||||
))
|
||||
} else {
|
||||
scrollable(
|
||||
column(self.instructions.iter().enumerate().map(
|
||||
|(i, instruction)| {
|
||||
monospace(instruction.to_string())
|
||||
.size(10)
|
||||
.style(move |theme: &Theme| text::Style {
|
||||
color: match &self.state {
|
||||
State::Playing { current, .. } => {
|
||||
if *current == i {
|
||||
Some(theme.palette().primary)
|
||||
} else if *current > i {
|
||||
Some(
|
||||
theme
|
||||
.extended_palette()
|
||||
.success
|
||||
.strong
|
||||
.color,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
_ => None,
|
||||
},
|
||||
})
|
||||
.into()
|
||||
},
|
||||
))
|
||||
.spacing(5),
|
||||
)
|
||||
.spacing(5)
|
||||
.into()
|
||||
})
|
||||
.width(Fill)
|
||||
.height(Fill)
|
||||
.padding(5);
|
||||
|
||||
let controls = {
|
||||
row![
|
||||
button(icon::play().size(14).width(Fill).center())
|
||||
.on_press_maybe(
|
||||
(!matches!(self.state, State::Recording { .. })
|
||||
&& !self.instructions.is_empty())
|
||||
.then_some(Message::Play),
|
||||
),
|
||||
if let State::Recording { .. } = &self.state {
|
||||
button(icon::stop().size(14).width(Fill).center())
|
||||
.on_press(Message::Stop)
|
||||
.style(button::success)
|
||||
} else {
|
||||
button(icon::record().size(14).width(Fill).center())
|
||||
.on_press_maybe(
|
||||
matches!(self.state, State::Idle)
|
||||
.then_some(Message::Record),
|
||||
)
|
||||
.style(button::danger)
|
||||
}
|
||||
]
|
||||
.spacing(10)
|
||||
};
|
||||
|
||||
column![events, controls].spacing(10).align_x(Center)
|
||||
};
|
||||
|
||||
column![labeled("Viewport", viewport), labeled("Tester", player)]
|
||||
.spacing(10)
|
||||
.into()
|
||||
}
|
||||
}
|
||||
|
||||
fn labeled<'a, Message, Renderer>(
|
||||
fragment: impl text::IntoFragment<'a>,
|
||||
content: impl Into<Element<'a, Message, Theme, Renderer>>,
|
||||
) -> Element<'a, Message, Theme, Renderer>
|
||||
where
|
||||
Message: 'a,
|
||||
Renderer: program::Renderer + 'a,
|
||||
{
|
||||
column![monospace(fragment).size(14), content.into()]
|
||||
.spacing(5)
|
||||
.into()
|
||||
}
|
||||
51
devtools/src/tester/null.rs
Normal file
51
devtools/src/tester/null.rs
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
use crate::Program;
|
||||
use crate::core::window;
|
||||
use crate::core::{Element, Theme};
|
||||
use crate::runtime::Task;
|
||||
use crate::widget::horizontal_space;
|
||||
|
||||
use std::marker::PhantomData;
|
||||
|
||||
pub struct Tester<P: Program> {
|
||||
_type: PhantomData<P::Message>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Message {}
|
||||
|
||||
#[allow(missing_debug_implementations)]
|
||||
pub struct Tick<P: Program> {
|
||||
_type: PhantomData<P::Message>,
|
||||
}
|
||||
|
||||
impl<P: Program> Tester<P> {
|
||||
pub fn new() -> Self {
|
||||
Self { _type: PhantomData }
|
||||
}
|
||||
|
||||
pub fn is_busy(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
pub fn update(&mut self, _program: &P, _message: Message) -> Task<Tick<P>> {
|
||||
Task::none()
|
||||
}
|
||||
|
||||
pub fn tick(&mut self, _program: &P, _tick: Tick<P>) -> Task<Tick<P>> {
|
||||
Task::none()
|
||||
}
|
||||
|
||||
pub fn view<'a, T: 'static>(
|
||||
&'a self,
|
||||
_program: &P,
|
||||
_window: window::Id,
|
||||
_current: impl FnOnce() -> Element<'a, T, Theme, P::Renderer>,
|
||||
_emulate: impl Fn(Tick<P>) -> T + 'a,
|
||||
) -> Element<'a, T, Theme, P::Renderer> {
|
||||
horizontal_space().into()
|
||||
}
|
||||
|
||||
pub fn controls(&self) -> Element<'_, Message, Theme, P::Renderer> {
|
||||
horizontal_space().into()
|
||||
}
|
||||
}
|
||||
|
|
@ -8,6 +8,12 @@ use crate::core::{
|
|||
Size, Widget,
|
||||
};
|
||||
|
||||
pub fn recorder<'a, Message, Theme, Renderer>(
|
||||
content: impl Into<Element<'a, Message, Theme, Renderer>>,
|
||||
) -> Recorder<'a, Message, Theme, Renderer> {
|
||||
Recorder::new(content)
|
||||
}
|
||||
|
||||
#[allow(missing_debug_implementations)]
|
||||
pub struct Recorder<'a, Message, Theme, Renderer> {
|
||||
content: Element<'a, Message, Theme, Renderer>,
|
||||
|
|
@ -30,6 +30,7 @@ where
|
|||
}
|
||||
|
||||
pub fn rewind(&mut self, program: &P, message: usize) {
|
||||
crate::debug::disable();
|
||||
let (mut state, _) = program.boot();
|
||||
|
||||
if message < self.messages.len() {
|
||||
|
|
@ -40,7 +41,6 @@ where
|
|||
}
|
||||
|
||||
self.state = Some(state);
|
||||
crate::debug::disable();
|
||||
}
|
||||
|
||||
pub fn go_to_present(&mut self) {
|
||||
|
|
|
|||
|
|
@ -1,12 +1,13 @@
|
|||
mod recorder;
|
||||
|
||||
pub use iced_widget::*;
|
||||
pub use recorder::Recorder;
|
||||
|
||||
use crate::core::Element;
|
||||
use crate::core::Font;
|
||||
use crate::program;
|
||||
|
||||
pub fn recorder<'a, Message, Theme, Renderer>(
|
||||
content: impl Into<Element<'a, Message, Theme, Renderer>>,
|
||||
) -> Recorder<'a, Message, Theme, Renderer> {
|
||||
Recorder::new(content)
|
||||
pub fn monospace<'a, Renderer>(
|
||||
fragment: impl text::IntoFragment<'a>,
|
||||
) -> Text<'a, Theme, Renderer>
|
||||
where
|
||||
Renderer: program::Renderer + 'a,
|
||||
{
|
||||
text(fragment).font(Font::MONOSPACE)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue