987 lines
34 KiB
Rust
987 lines
34 KiB
Rust
use crossterm::event::{
|
||
Event, KeyCode as K, KeyEvent, KeyModifiers as M, MouseButton as MB, MouseEvent,
|
||
MouseEventKind as MK,
|
||
};
|
||
use ratatui::{backend::TestBackend, layout::Rect, Terminal};
|
||
use std::{
|
||
fs,
|
||
path::PathBuf,
|
||
sync::atomic::{AtomicUsize, Ordering},
|
||
};
|
||
use tb_frontend::forms::{self, ObjectClass as C};
|
||
use tb_ide::{
|
||
app::{App, DialogKind, Field, Hit, Mode, WindowKind},
|
||
commands::Command,
|
||
designer::{self, DesignId},
|
||
documents::{Destination, Project},
|
||
};
|
||
use tb_ui::{forms::PropertyValue as V, frm};
|
||
struct Temp(PathBuf);
|
||
impl Temp {
|
||
fn new() -> Self {
|
||
static N: AtomicUsize = AtomicUsize::new(0);
|
||
let p = std::env::temp_dir().join(format!(
|
||
"tb-designer-{}-{}",
|
||
std::process::id(),
|
||
N.fetch_add(1, Ordering::Relaxed)
|
||
));
|
||
fs::create_dir_all(&p).unwrap();
|
||
Self(p.canonicalize().unwrap())
|
||
}
|
||
fn app(&self) -> App {
|
||
let mut a = App::new(&self.0, self.0.join("options"), (100, 30)).unwrap();
|
||
a.options.syntax_checking = false;
|
||
a.execute(Command::NewForm);
|
||
assert_eq!(a.mode, Mode::Designer);
|
||
a
|
||
}
|
||
}
|
||
impl Drop for Temp {
|
||
fn drop(&mut self) {
|
||
let _ = fs::remove_dir_all(&self.0);
|
||
}
|
||
}
|
||
fn key(a: &mut App, k: K, m: M) {
|
||
a.handle(Event::Key(KeyEvent::new(k, m)));
|
||
}
|
||
fn plain(a: &mut App, k: K) {
|
||
key(a, k, M::NONE);
|
||
}
|
||
fn root(a: &mut App) -> DesignId {
|
||
a.design_objects().unwrap()[0].0
|
||
}
|
||
fn node(a: &mut App, id: DesignId) -> frm::FormNode {
|
||
a.design_objects()
|
||
.unwrap()
|
||
.into_iter()
|
||
.find(|(i, _)| *i == id)
|
||
.unwrap()
|
||
.1
|
||
}
|
||
fn number(a: &mut App, id: DesignId, p: &str) -> i32 {
|
||
match designer::value(&node(a, id), p).unwrap() {
|
||
V::Integer(n) => n,
|
||
_ => panic!(),
|
||
}
|
||
}
|
||
fn draw(a: &mut App) -> String {
|
||
let mut t = Terminal::new(TestBackend::new(100, 30)).unwrap();
|
||
t.draw(|f| a.render(f)).unwrap();
|
||
t.backend()
|
||
.buffer()
|
||
.content
|
||
.iter()
|
||
.map(|c| c.symbol())
|
||
.collect()
|
||
}
|
||
fn mouse(a: &mut App, kind: MK, x: u16, y: u16, m: M) {
|
||
a.handle(Event::Mouse(MouseEvent {
|
||
kind,
|
||
column: x,
|
||
row: y,
|
||
modifiers: m,
|
||
}));
|
||
}
|
||
fn click(a: &mut App, x: u16, y: u16) {
|
||
mouse(a, MK::Down(MB::Left), x, y, M::NONE);
|
||
mouse(a, MK::Up(MB::Left), x, y, M::NONE);
|
||
}
|
||
fn property(a: &mut App, p: &str, v: &str) {
|
||
a.design_property(p, v).unwrap();
|
||
}
|
||
#[test]
|
||
fn all_metadata_tools_persist_and_preview_matches_runtime_without_events() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
property(&mut a, "WIDTH", "70");
|
||
property(&mut a, "HEIGHT", "24");
|
||
for (i, (_, class, style)) in designer::tools().iter().enumerate() {
|
||
a.design_place(
|
||
*class,
|
||
*style,
|
||
root,
|
||
Rect::new(1 + (i % 8) as u16 * 8, 1 + (i / 8) as u16 * 6, 6, 3),
|
||
)
|
||
.unwrap();
|
||
}
|
||
let timer = a
|
||
.design_objects()
|
||
.unwrap()
|
||
.into_iter()
|
||
.find(|(_, n)| n.class == C::Timer)
|
||
.unwrap()
|
||
.0;
|
||
a.design_select(timer, false).unwrap();
|
||
property(&mut a, "INTERVAL", "1");
|
||
let doc = a.design_document().unwrap();
|
||
a.project.replace_text(doc,0..0,"SUB Form_Load\nPRINT \"NO PREVIEW EXECUTION\"\nEND SUB\nSUB Timer1_Timer\nPRINT \"NO TIMER\"\nEND SUB\n").unwrap();
|
||
let form = a.design_form().unwrap().clone();
|
||
let (mut model, screen) = designer::preview(&form, (100, 30)).unwrap();
|
||
assert!(model.events.is_empty());
|
||
assert!(model.next_deadline().is_none());
|
||
model.timers(10_000);
|
||
assert!(model.next_event().is_none());
|
||
assert!(a.session.vm.is_none());
|
||
let mut runtime = tb_ui::forms::FormsModel::new(form.catalog().objects, 100, 30);
|
||
form.apply(&mut runtime).unwrap();
|
||
runtime.show(0, false).unwrap();
|
||
let mut expected = tb_runtime::screen::TextScreen::with_size(100, 30);
|
||
runtime.render(&mut expected);
|
||
for y in 1..=30 {
|
||
for x in 1..=100 {
|
||
assert_eq!(screen.cell(y, x), expected.cell(y, x));
|
||
}
|
||
}
|
||
let path = t.0.join("designed.frm");
|
||
a.project
|
||
.save_file(doc, Some(&Destination::new(&path)))
|
||
.unwrap();
|
||
let reopened = Project::open(&path, vec![]).unwrap();
|
||
let tb_vm::project_io::Content::Form(f) =
|
||
reopened.document(reopened.members()[0]).unwrap().content()
|
||
else {
|
||
panic!()
|
||
};
|
||
assert_equivalent(&f.root, &form.root);
|
||
assert_eq!(f.root.children.len(), designer::tools().len());
|
||
tb_vm::project_io::load_program(&path).unwrap();
|
||
let listed = a
|
||
.menus()
|
||
.into_iter()
|
||
.find(|m| m.title == "Tools")
|
||
.unwrap()
|
||
.items;
|
||
assert_eq!(listed.len(), designer::tools().len());
|
||
}
|
||
#[test]
|
||
fn container_multiselect_keyboard_drag_resize_and_undo() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let frame = a
|
||
.design_place(C::Frame, 0, root, Rect::new(3, 2, 28, 10))
|
||
.unwrap();
|
||
let b1 = a
|
||
.design_place(C::CommandButton, 0, frame, Rect::new(2, 2, 8, 2))
|
||
.unwrap();
|
||
let b2 = a
|
||
.design_place(C::TextBox, 0, frame, Rect::new(12, 2, 8, 2))
|
||
.unwrap();
|
||
a.design_select(b1, false).unwrap();
|
||
a.design_select(b2, true).unwrap();
|
||
key(&mut a, K::Right, M::CONTROL);
|
||
assert_eq!(number(&mut a, b1, "LEFT"), 7);
|
||
assert_eq!(number(&mut a, b2, "LEFT"), 17);
|
||
assert_eq!(number(&mut a, frame, "LEFT"), 3);
|
||
a.execute(Command::Undo);
|
||
assert_eq!(number(&mut a, b1, "LEFT"), 2);
|
||
assert_eq!(number(&mut a, b2, "LEFT"), 12);
|
||
a.design_select(b1, false).unwrap();
|
||
key(&mut a, K::Right, M::SHIFT);
|
||
assert_eq!(number(&mut a, b1, "WIDTH"), 9);
|
||
a.execute(Command::Undo);
|
||
draw(&mut a);
|
||
let r = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(id, _)| *id == b1)
|
||
.unwrap()
|
||
.1;
|
||
assert_eq!(r.x, a.designer.viewport.x + 3 + 2);
|
||
assert_eq!(r.y, a.designer.viewport.y + 2 + 2);
|
||
mouse(&mut a, MK::Down(MB::Left), r.x + 2, r.y, M::NONE);
|
||
mouse(&mut a, MK::Drag(MB::Left), r.x + 3, r.y + 1, M::NONE);
|
||
mouse(&mut a, MK::Up(MB::Left), r.x + 3, r.y + 1, M::NONE);
|
||
assert_eq!(number(&mut a, b1, "LEFT"), 3);
|
||
assert_eq!(number(&mut a, b1, "TOP"), 3);
|
||
draw(&mut a);
|
||
let r = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(id, _)| *id == b1)
|
||
.unwrap()
|
||
.1;
|
||
mouse(
|
||
&mut a,
|
||
MK::Down(MB::Left),
|
||
r.right() - 1,
|
||
r.bottom() - 1,
|
||
M::NONE,
|
||
);
|
||
mouse(&mut a, MK::Up(MB::Left), r.right(), r.bottom(), M::NONE);
|
||
assert_eq!(number(&mut a, b1, "WIDTH"), 9);
|
||
assert_eq!(number(&mut a, b1, "HEIGHT"), 3);
|
||
let before = a.design_form().unwrap().clone();
|
||
assert!(a.design_geometry(-100, 0, false).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
a.design_select(b1, false).unwrap();
|
||
plain(&mut a, K::Tab);
|
||
assert_eq!(
|
||
a.designer.selections[&a.design_document().unwrap()],
|
||
vec![b2]
|
||
);
|
||
plain(&mut a, K::BackTab);
|
||
assert_eq!(
|
||
a.designer.selections[&a.design_document().unwrap()],
|
||
vec![b1]
|
||
);
|
||
draw(&mut a);
|
||
let r = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(id, _)| *id == b2)
|
||
.unwrap()
|
||
.1;
|
||
mouse(&mut a, MK::Down(MB::Left), r.x + 1, r.y, M::CONTROL);
|
||
mouse(&mut a, MK::Up(MB::Left), r.x + 1, r.y, M::CONTROL);
|
||
assert_eq!(
|
||
a.designer.selections[&a.design_document().unwrap()].len(),
|
||
2
|
||
);
|
||
}
|
||
#[test]
|
||
fn property_bar_types_readonly_and_no_status_line() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, root, Rect::new(2, 3, 8, 2))
|
||
.unwrap();
|
||
let before = a.design_form().unwrap().clone();
|
||
for (p, v) in [
|
||
("HEIGHT", "0"),
|
||
("WIDTH", "x"),
|
||
("BACKCOLOR", "16"),
|
||
("ENABLED", "yes"),
|
||
("PARENT", "anything"),
|
||
] {
|
||
let e = a.design_property(p, v).unwrap_err();
|
||
assert!(format!("{e:#}").contains(p));
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
}
|
||
a.designer.property = forms::properties(C::CommandButton)
|
||
.iter()
|
||
.position(|p| p.name == "CAPTION")
|
||
.unwrap();
|
||
plain(&mut a, K::F(2));
|
||
assert!(a.value_focus);
|
||
key(&mut a, K::Char('a'), M::CONTROL);
|
||
for c in "Hallo".chars() {
|
||
plain(&mut a, K::Char(c));
|
||
}
|
||
plain(&mut a, K::Enter);
|
||
assert_eq!(
|
||
designer::value(&node(&mut a, b), "CAPTION"),
|
||
Some(V::String("Hallo".into()))
|
||
);
|
||
let screen = draw(&mut a);
|
||
assert!(screen.contains("2,3"));
|
||
assert!(screen.contains("8×2"));
|
||
assert!(!screen.contains("Shift+F1=Help"));
|
||
plain(&mut a, K::F(10));
|
||
assert!(!a.properties && a.menu.is_some());
|
||
plain(&mut a, K::F(10));
|
||
assert!(a.properties && a.menu.is_none());
|
||
let spin = a
|
||
.design_place(C::Spin, 0, root, Rect::new(15, 3, 1, 2))
|
||
.unwrap();
|
||
assert!(a.design_property("WIDTH", "4").is_err());
|
||
property(&mut a, "STYLE", "1");
|
||
assert_eq!(number(&mut a, spin, "WIDTH"), 2);
|
||
assert_eq!(number(&mut a, spin, "HEIGHT"), 1);
|
||
}
|
||
#[test]
|
||
fn clipboard_children_arrays_and_delete_preserve_code() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let frame = a
|
||
.design_place(C::Frame, 0, root, Rect::new(1, 1, 20, 10))
|
||
.unwrap();
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, frame, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
property(&mut a, "INDEX", "0");
|
||
a.design_event(b, "CLICK").unwrap();
|
||
a.design_event(b, "CLICK").unwrap();
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
let code = a.design_form().unwrap().code.clone();
|
||
a.design_select(frame, false).unwrap();
|
||
a.execute(Command::Copy);
|
||
a.design_select(root, false).unwrap();
|
||
a.execute(Command::Paste);
|
||
assert!(a.dialog.is_none(), "{:?}", a.dialog);
|
||
let f = a.design_form().unwrap();
|
||
assert_eq!(f.root.children.len(), 2);
|
||
let copied = &f.root.children[1];
|
||
assert_eq!(copied.children.len(), 1);
|
||
assert_ne!(copied.children[0].name, f.root.children[0].children[0].name);
|
||
assert_eq!(designer::node_key(&copied.children[0]).1, Some(0));
|
||
a.execute(Command::Undo);
|
||
assert_eq!(a.design_form().unwrap().root.children.len(), 1);
|
||
a.design_select(frame, false).unwrap();
|
||
a.execute(Command::Cut);
|
||
assert_eq!(a.design_form().unwrap().code, code);
|
||
assert!(a.message.contains("ungebunden"));
|
||
plain(&mut a, K::Esc);
|
||
a.execute(Command::Undo);
|
||
assert_eq!(a.design_form().unwrap().root.children.len(), 1);
|
||
assert_eq!(node(&mut a, b).class, C::CommandButton);
|
||
}
|
||
#[test]
|
||
fn bound_rename_across_documents_is_atomic_and_undo_restores_all() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, root, Rect::new(2, 2, 8, 2))
|
||
.unwrap();
|
||
let name = node(&mut a, b).name;
|
||
let form = a.design_form().unwrap().root.name.clone();
|
||
let doc = a.design_document().unwrap();
|
||
let code=format!("SUB {name}_Click\n{name}.Caption = \"{name} unchanged\"\n' {name}.Caption unchanged\nEND SUB\n");
|
||
a.project.replace_text(doc, 0..0, &code).unwrap();
|
||
let other = a.project.new_module("Other").unwrap();
|
||
let external = format!("PRINT {form}!{name}.Caption\n");
|
||
a.project.replace_text(other, 0..0, &external).unwrap();
|
||
a.design_rename("GoButton").unwrap();
|
||
assert_eq!(node(&mut a, b).name, "GoButton");
|
||
assert!(a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains("SUB GoButton_CLICK"));
|
||
assert!(a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains("GoButton.Caption"));
|
||
assert!(a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains(&format!("\"{name} unchanged\"")));
|
||
assert!(a
|
||
.project
|
||
.document(other)
|
||
.unwrap()
|
||
.code()
|
||
.contains("!GoButton.Caption"));
|
||
a.project.undo(other).unwrap();
|
||
assert_eq!(a.project.document(other).unwrap().code(), external);
|
||
assert_eq!(a.project.document(doc).unwrap().code(), code);
|
||
assert_eq!(node(&mut a, b).name, name);
|
||
let conflict = a
|
||
.design_place(C::TextBox, 0, root, Rect::new(14, 2, 8, 2))
|
||
.unwrap();
|
||
let conflict_name = node(&mut a, conflict).name;
|
||
a.design_select(b, false).unwrap();
|
||
let before = a.design_form().unwrap().clone();
|
||
assert!(a.design_rename(&conflict_name).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
a.project.replace_text(other, 0..0, "IF \n").unwrap();
|
||
assert!(a.design_rename("Unsafe").is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
}
|
||
#[test]
|
||
fn event_array_signature_twice_and_shared_form_identity() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let b = a
|
||
.design_place(C::TextBox, 0, root, Rect::new(2, 2, 8, 2))
|
||
.unwrap();
|
||
property(&mut a, "INDEX", "0");
|
||
let doc = a.design_document().unwrap();
|
||
let structure = a.design_form().unwrap().root.clone();
|
||
a.design_event(b, "DRAGOVER").unwrap();
|
||
assert_eq!(a.mode, Mode::Environment);
|
||
let code = a.project.document(doc).unwrap().code().to_owned();
|
||
assert!(code.contains(
|
||
"Index AS INTEGER, SOURCE AS CONTROL, X AS SINGLE, Y AS SINGLE, STATE AS INTEGER"
|
||
));
|
||
a.compile_current().unwrap();
|
||
let view = if let WindowKind::Code(v) = a.active_window().unwrap().kind {
|
||
v
|
||
} else {
|
||
panic!()
|
||
};
|
||
let cursor = a.project.view(view).unwrap().cursor;
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
assert_eq!(a.mode, Mode::Designer);
|
||
assert_eq!(a.active_document(), Some(doc));
|
||
assert_eq!(a.design_form().unwrap().root, structure);
|
||
assert_eq!(a.designer.selections[&doc], vec![b]);
|
||
a.design_event(b, "DRAGOVER").unwrap();
|
||
assert_eq!(a.project.document(doc).unwrap().code(), code);
|
||
assert_eq!(a.project.view(view).unwrap().cursor, cursor);
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
plain(&mut a, K::F(12));
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignObject(_)
|
||
));
|
||
plain(&mut a, K::Enter);
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignEvent(_)
|
||
));
|
||
plain(&mut a, K::Enter);
|
||
assert_eq!(a.mode, Mode::Environment);
|
||
assert!(a.dialog.is_none());
|
||
}
|
||
#[test]
|
||
fn menu_hierarchy_arrays_shortcuts_and_palette_use_events() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let title = a.design_place(C::Menu, 0, root, Rect::default()).unwrap();
|
||
property(&mut a, "CAPTION", "&File");
|
||
let sub = a.design_place(C::Menu, 0, title, Rect::default()).unwrap();
|
||
property(&mut a, "CAPTION", "&Open");
|
||
property(&mut a, "INDEX", "0");
|
||
property(&mut a, "SHORTCUT", "F3");
|
||
let second = a.design_place(C::Menu, 0, title, Rect::default()).unwrap();
|
||
property(&mut a, "CAPTION", "-");
|
||
property(&mut a, "SEPARATOR", "true");
|
||
assert!(a.design_property("CHECKED", "true").is_err());
|
||
a.design_select(sub, false).unwrap();
|
||
a.design_menu_move("down").unwrap();
|
||
a.design_menu_move("up").unwrap();
|
||
assert!(a.design_property("SHORTCUT", "F11").is_err());
|
||
a.execute(Command::MenuDesign);
|
||
draw(&mut a);
|
||
assert_eq!(a.active_window().unwrap().kind, WindowKind::MenuDesign);
|
||
plain(&mut a, K::Enter);
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignMenu(_)
|
||
));
|
||
a.dialog.as_mut().unwrap().fields[2] = Field::text("Tag", "kept");
|
||
plain(&mut a, K::Enter);
|
||
assert!(a.dialog.is_none(), "{:?}", a.dialog);
|
||
a.design_select(root, false).unwrap();
|
||
a.execute(Command::Palette);
|
||
plain(&mut a, K::Enter);
|
||
a.dialog.as_mut().unwrap().fields[0] =
|
||
Field::choice("ForeColor", (0..16).map(|n| n.to_string()).collect(), 4);
|
||
a.dialog.as_mut().unwrap().fields[1] =
|
||
Field::choice("BackColor", (0..16).map(|n| n.to_string()).collect(), 1);
|
||
a.dialog.as_mut().unwrap().fields[2] = Field::toggle("Form", true);
|
||
plain(&mut a, K::Enter);
|
||
assert_eq!(number(&mut a, root, "FORECOLOR"), 4);
|
||
assert_eq!(number(&mut a, root, "BACKCOLOR"), 1);
|
||
let path = t.0.join("menu.frm");
|
||
let doc = a.design_document().unwrap();
|
||
a.project
|
||
.save_file(doc, Some(&Destination::new(&path)))
|
||
.unwrap();
|
||
let reopened = frm::read_text("menu", &fs::read_to_string(&path).unwrap()).unwrap();
|
||
assert_equivalent(&reopened.root, &a.design_form().unwrap().root);
|
||
tb_vm::project_io::load_program(&path).unwrap();
|
||
assert_eq!(node(&mut a, second).name, "Menu3");
|
||
}
|
||
#[test]
|
||
fn toolbox_double_click_tool_drag_grid_and_window_form_selection() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
a.execute(Command::Toolbox);
|
||
draw(&mut a);
|
||
let r = a
|
||
.hits
|
||
.iter()
|
||
.find_map(|(r, h)| matches!(h, Hit::DesignTool(2)).then_some(*r))
|
||
.unwrap();
|
||
click(&mut a, r.x + 1, r.y);
|
||
click(&mut a, r.x + 1, r.y);
|
||
assert_eq!(a.design_form().unwrap().root.children.len(), 1);
|
||
a.execute(Command::Tool("TextBox"));
|
||
draw(&mut a);
|
||
let r = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(i, _)| *i == root)
|
||
.unwrap()
|
||
.1;
|
||
mouse(&mut a, MK::Down(MB::Left), r.x + 15, r.y + 3, M::NONE);
|
||
mouse(&mut a, MK::Drag(MB::Left), r.x + 22, r.y + 4, M::NONE);
|
||
mouse(&mut a, MK::Up(MB::Left), r.x + 22, r.y + 4, M::NONE);
|
||
assert!(a.dialog.is_none(), "{:?}", a.dialog);
|
||
let textbox = a.design_form().unwrap().root.children.last().unwrap();
|
||
assert_eq!(textbox.class, C::TextBox);
|
||
assert_eq!(designer::value(textbox, "LEFT"), Some(V::Integer(15)));
|
||
assert_eq!(designer::value(textbox, "WIDTH"), Some(V::Integer(8)));
|
||
a.execute(Command::Grid);
|
||
assert!(a.designer.grid);
|
||
assert!(draw(&mut a).contains('·'));
|
||
a.execute(Command::Grid);
|
||
assert!(!a.designer.grid);
|
||
let first = a.design_document().unwrap();
|
||
a.execute(Command::NewForm);
|
||
let second = a.design_document().unwrap();
|
||
assert_ne!(first, second);
|
||
let command=a.window_commands().into_iter().find(|(_,c)|matches!(c,Command::FocusWindow(id) if a.windows.iter().any(|w|w.id==*id&&matches!(w.kind,WindowKind::Code(v) if a.project.view(v).unwrap().document()==first)))).unwrap().1;
|
||
a.execute(command);
|
||
assert_eq!(a.design_document().unwrap(), first);
|
||
}
|
||
#[test]
|
||
fn binary_designer_import_requires_text_target_and_compiles() {
|
||
let t = Temp::new();
|
||
let bytes: Vec<u8> = include_str!("../../tb-ui/tests/data/new.frm.hex")
|
||
.split_whitespace()
|
||
.map(|s| u8::from_str_radix(s, 16).unwrap())
|
||
.collect();
|
||
let source = t.0.join("binary.frm");
|
||
fs::write(&source, &bytes).unwrap();
|
||
let mut a = App::new(&t.0, t.0.join("options"), (100, 30)).unwrap();
|
||
a.load_initial_project(source.clone()).unwrap();
|
||
a.execute(Command::Form);
|
||
plain(&mut a, K::Enter);
|
||
let root = root(&mut a);
|
||
a.design_select(root, false).unwrap();
|
||
property(&mut a, "CAPTION", "Imported and edited");
|
||
let doc = a.design_document().unwrap();
|
||
assert!(a.project.save_file(doc, None).is_err());
|
||
let path = t.0.join("text.frm");
|
||
a.project
|
||
.save_file(doc, Some(&Destination::new(&path)))
|
||
.unwrap();
|
||
assert_eq!(fs::read(&source).unwrap(), bytes);
|
||
tb_vm::project_io::load_program(&path).unwrap();
|
||
}
|
||
|
||
fn assert_equivalent(a: &frm::FormNode, b: &frm::FormNode) {
|
||
assert_eq!(
|
||
(a.class, &a.name, designer::node_key(a)),
|
||
(b.class, &b.name, designer::node_key(b))
|
||
);
|
||
for p in forms::properties(a.class) {
|
||
assert_eq!(
|
||
designer::value(a, p.name),
|
||
designer::value(b, p.name),
|
||
"{}.{}",
|
||
a.name,
|
||
p.name
|
||
);
|
||
}
|
||
assert_eq!(a.children.len(), b.children.len());
|
||
for (a, b) in a.children.iter().zip(&b.children) {
|
||
assert_equivalent(a, b);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn rename_preserves_shadowed_names_and_handles_form_aliases_and_include_calls() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, r, Rect::new(2, 2, 8, 2))
|
||
.unwrap();
|
||
let doc = a.design_document().unwrap();
|
||
let name = node(&mut a, b).name;
|
||
let form = node(&mut a, r).name;
|
||
let code=format!("SUB {name}_Click\nDIM {name}_Click AS INTEGER\n{name}_Click = 7\nPRINT {name}_Click\nEND SUB\nSUB {form}_Load\n{name}.Caption=\"Hi\"\nEND SUB\n");
|
||
a.project.replace_text(doc, 0..0, &code).unwrap();
|
||
// In eine andere Datei gebundene Aufrufe müssen mit umbenannt werden.
|
||
let other = a.project.new_module("Calls").unwrap();
|
||
let call = format!("DECLARE SUB {name}_Click ()\nCALL {name}_Click\n");
|
||
a.project.replace_text(other, 0..0, &call).unwrap();
|
||
a.design_rename("Launch").unwrap();
|
||
let changed = a.project.document(doc).unwrap().code();
|
||
assert!(changed.contains(&format!("DIM {name}_Click AS INTEGER")));
|
||
assert!(changed.contains(&format!("PRINT {name}_Click")));
|
||
assert!(changed.contains("SUB Launch_CLICK"));
|
||
assert!(a
|
||
.project
|
||
.document(other)
|
||
.unwrap()
|
||
.code()
|
||
.contains("CALL Launch_CLICK"));
|
||
a.design_select(r, false).unwrap();
|
||
a.design_event(r, "LOAD").unwrap();
|
||
assert!(!a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains("SUB Form_LOAD"));
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
a.design_select(r, false).unwrap();
|
||
a.design_rename("MainForm").unwrap();
|
||
assert_eq!(node(&mut a, r).name, "MainForm");
|
||
assert!(a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains("SUB MainForm_LOAD"));
|
||
}
|
||
#[test]
|
||
fn existing_default_typed_event_and_all_metadata_signatures_compile() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, r, Rect::new(2, 2, 8, 2))
|
||
.unwrap();
|
||
property(&mut a, "INDEX", "0");
|
||
let name = node(&mut a, b).name;
|
||
let doc = a.design_document().unwrap();
|
||
let code = format!("DEFINT I,K,S\nSUB {name}_KeyDown (Index, KeyCode, Shift)\nEND SUB\n");
|
||
a.project.replace_text(doc, 0..0, &code).unwrap();
|
||
a.design_event(b, "KEYDOWN").unwrap();
|
||
assert_eq!(a.project.document(doc).unwrap().code(), code);
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
for event in forms::events(C::CommandButton) {
|
||
a.design_event(b, event).unwrap();
|
||
a.compile_current().unwrap();
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
}
|
||
}
|
||
#[test]
|
||
fn all_eight_handles_resize_transactionally_and_preserve_identity_after_structure_edits() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let b = a
|
||
.design_place(C::TextBox, 0, r, Rect::new(8, 5, 10, 5))
|
||
.unwrap();
|
||
for (horizontal, vertical) in [
|
||
(-1, -1),
|
||
(0, -1),
|
||
(1, -1),
|
||
(-1, 0),
|
||
(1, 0),
|
||
(-1, 1),
|
||
(0, 1),
|
||
(1, 1),
|
||
] {
|
||
a.design_select(b, false).unwrap();
|
||
draw(&mut a);
|
||
let rect = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(id, _)| *id == b)
|
||
.unwrap()
|
||
.1;
|
||
let x = match horizontal {
|
||
-1 => rect.x,
|
||
0 => rect.x + rect.width / 2,
|
||
_ => rect.right() - 1,
|
||
};
|
||
let y = match vertical {
|
||
-1 => rect.y,
|
||
0 => rect.y + rect.height / 2,
|
||
_ => rect.bottom() - 1,
|
||
};
|
||
let before = a.design_form().unwrap().clone();
|
||
mouse(&mut a, MK::Down(MB::Left), x, y, M::NONE);
|
||
mouse(&mut a, MK::Up(MB::Left), x + 1, y + 1, M::NONE);
|
||
assert!(a.dialog.is_none(), "{:?}", a.dialog);
|
||
assert_eq!(number(&mut a, b, "WIDTH"), 10 + horizontal);
|
||
assert_eq!(number(&mut a, b, "HEIGHT"), 5 + vertical);
|
||
assert_eq!(number(&mut a, b, "LEFT"), 8 + i32::from(horizontal < 0));
|
||
assert_eq!(number(&mut a, b, "TOP"), 5 + i32::from(vertical < 0));
|
||
a.execute(Command::Undo);
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
}
|
||
let old_id = b;
|
||
a.design_select(b, false).unwrap();
|
||
property(&mut a, "INDEX", "0");
|
||
assert_eq!(node(&mut a, old_id).class, C::TextBox);
|
||
a.execute(Command::Undo);
|
||
assert_eq!(designer::node_key(&node(&mut a, old_id)).1, None);
|
||
a.design_select(b, false).unwrap();
|
||
a.execute(Command::Clear);
|
||
plain(&mut a, K::Esc);
|
||
let replacement = a
|
||
.design_place(C::TextBox, 0, r, Rect::new(1, 1, 5, 2))
|
||
.unwrap();
|
||
assert_ne!(replacement, b);
|
||
a.execute(Command::Undo);
|
||
a.execute(Command::Undo);
|
||
assert_eq!(node(&mut a, b).class, C::TextBox);
|
||
}
|
||
#[test]
|
||
fn menu_indent_outdent_rename_and_field_changes_have_one_undo() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let title = a.design_place(C::Menu, 0, r, Rect::default()).unwrap();
|
||
let child = a.design_place(C::Menu, 0, title, Rect::default()).unwrap();
|
||
let sibling = a.design_place(C::Menu, 0, title, Rect::default()).unwrap();
|
||
a.design_menu_move("in").unwrap();
|
||
assert_eq!(node(&mut a, child).children.len(), 1);
|
||
a.design_menu_move("out").unwrap();
|
||
assert_eq!(node(&mut a, title).children.len(), 2);
|
||
let before = a.design_form().unwrap().clone();
|
||
a.execute(Command::MenuDesign);
|
||
plain(&mut a, K::Enter);
|
||
let d = a.dialog.as_mut().unwrap();
|
||
d.fields[0] = Field::text("CtlName", "SaveMenu");
|
||
d.fields[1] = Field::text("Caption", "&Save");
|
||
d.fields[2] = Field::text("Tag", "saved");
|
||
d.fields[3] = Field::text("Index", "0");
|
||
plain(&mut a, K::Enter);
|
||
assert!(a.dialog.is_none(), "{:?}", a.dialog);
|
||
assert_eq!(node(&mut a, sibling).name, "SaveMenu");
|
||
a.execute(Command::Undo);
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
assert_eq!(node(&mut a, sibling).name, "Menu3");
|
||
}
|
||
|
||
#[test]
|
||
fn property_menu_buttons_palette_drag_and_modal_mouse_are_connected() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let before = a.design_form().unwrap().code.clone();
|
||
plain(&mut a, K::Char('x'));
|
||
assert_eq!(a.design_form().unwrap().code, before);
|
||
draw(&mut a);
|
||
click(&mut a, 1, 0);
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignProperty
|
||
));
|
||
plain(&mut a, K::Enter);
|
||
assert!(a.value_focus);
|
||
plain(&mut a, K::Esc);
|
||
a.execute(Command::Palette);
|
||
draw(&mut a);
|
||
let swatch = a
|
||
.hits
|
||
.iter()
|
||
.find_map(|(r, h)| matches!(h, Hit::DesignPaint("BACKCOLOR", 5)).then_some(*r))
|
||
.unwrap();
|
||
let form = a
|
||
.designer
|
||
.objects
|
||
.iter()
|
||
.find(|(id, _)| *id == r)
|
||
.unwrap()
|
||
.1;
|
||
mouse(&mut a, MK::Down(MB::Left), swatch.x, swatch.y, M::NONE);
|
||
mouse(
|
||
&mut a,
|
||
MK::Drag(MB::Left),
|
||
form.right() - 3,
|
||
form.bottom() - 3,
|
||
M::NONE,
|
||
);
|
||
mouse(
|
||
&mut a,
|
||
MK::Up(MB::Left),
|
||
form.right() - 3,
|
||
form.bottom() - 3,
|
||
M::NONE,
|
||
);
|
||
assert_eq!(number(&mut a, r, "BACKCOLOR"), 5);
|
||
a.execute(Command::MenuDesign);
|
||
draw(&mut a);
|
||
let insert = a
|
||
.hits
|
||
.iter()
|
||
.find_map(|(r, h)| matches!(h, Hit::DesignAction("insert")).then_some(*r))
|
||
.unwrap();
|
||
click(&mut a, insert.x, insert.y);
|
||
assert_eq!(a.design_form().unwrap().root.children.len(), 1);
|
||
draw(&mut a);
|
||
let edit = a
|
||
.hits
|
||
.iter()
|
||
.find_map(|(r, h)| matches!(h, Hit::DesignAction("menu")).then_some(*r))
|
||
.unwrap();
|
||
click(&mut a, edit.x, edit.y);
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignMenu(_)
|
||
));
|
||
draw(&mut a);
|
||
let before = a.design_form().unwrap().clone();
|
||
click(&mut a, 1, 0);
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
assert!(matches!(
|
||
a.dialog.as_ref().unwrap().kind,
|
||
DialogKind::DesignMenu(_)
|
||
));
|
||
}
|
||
#[test]
|
||
fn shared_include_ambiguity_aborts_rename_and_event_defaults_use_includes() {
|
||
let t = Temp::new();
|
||
fs::write(t.0.join("shared.bi"), "PRINT Button.Caption\n").unwrap();
|
||
for (file, name) in [("a.frm", "AForm"), ("b.frm", "BForm")] {
|
||
fs::write(t.0.join(file),format!("VERSION 1.00\nBegin Form {name}\n Width=40\n Height=15\n Begin CommandButton Button\n Width=8\n End\nEnd\n'$INCLUDE: 'shared.bi'\n")).unwrap();
|
||
}
|
||
fs::write(t.0.join("p.mak"), "a.frm\nb.frm\n").unwrap();
|
||
let mut a = App::new(&t.0, t.0.join("options"), (100, 30)).unwrap();
|
||
a.load_initial_project(t.0.join("p.mak")).unwrap();
|
||
a.options.syntax_checking = false;
|
||
a.execute(Command::Form);
|
||
plain(&mut a, K::Enter);
|
||
let b = a.design_objects().unwrap()[1].0;
|
||
a.design_select(b, false).unwrap();
|
||
let before: Vec<_> = a
|
||
.project
|
||
.documents()
|
||
.map(|(id, d)| (id, d.content().clone()))
|
||
.collect();
|
||
assert!(a.design_rename("Changed").is_err());
|
||
for (id, c) in before {
|
||
assert_eq!(*a.project.document(id).unwrap().content(), c);
|
||
}
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, r, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
fs::write(t.0.join("defaults.bi"), "DEFINT A-Z\n").unwrap();
|
||
let doc = a.design_document().unwrap();
|
||
a.project
|
||
.replace_text(doc, 0..0, "'$INCLUDE: 'defaults.bi'\n")
|
||
.unwrap();
|
||
a.design_event(b, "CLICK").unwrap();
|
||
assert!(a
|
||
.project
|
||
.document(doc)
|
||
.unwrap()
|
||
.code()
|
||
.contains("DEFINT A-Z\n\nEND SUB"));
|
||
a.compile_current().unwrap();
|
||
}
|
||
|
||
#[test]
|
||
fn imported_type_shadow_is_not_an_object_reference_during_rename() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r = root(&mut a);
|
||
let b = a
|
||
.design_place(C::CommandButton, 0, r, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
let doc = a.design_document().unwrap();
|
||
let name = node(&mut a, b).name;
|
||
let types = a.project.new_module("Types").unwrap();
|
||
a.project
|
||
.replace_text(types, 0..0, "TYPE Imported\nCaption AS STRING\nEND TYPE\n")
|
||
.unwrap();
|
||
let code = format!(
|
||
"DIM {name} AS Imported\n{name}.Caption = \"UDT field\"\nSUB {name}_Click\nEND SUB\n"
|
||
);
|
||
a.project.replace_text(doc, 0..0, &code).unwrap();
|
||
a.design_rename("RunButton").unwrap();
|
||
let code = a.project.document(doc).unwrap().code();
|
||
assert!(code.contains(&format!("{name}.Caption = \"UDT field\"")));
|
||
assert!(code.contains("SUB RunButton_CLICK"));
|
||
}
|
||
|
||
#[test]
|
||
fn events_with_the_same_name_are_local_to_their_form() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let r1 = root(&mut a);
|
||
let b1 = a
|
||
.design_place(C::CommandButton, 0, r1, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
let d1 = a.design_document().unwrap();
|
||
a.design_event(b1, "CLICK").unwrap();
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
a.design_event(r1, "LOAD").unwrap();
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
a.execute(Command::NewForm);
|
||
let r2 = root(&mut a);
|
||
let b2 = a
|
||
.design_place(C::CommandButton, 0, r2, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
let d2 = a.design_document().unwrap();
|
||
a.design_event(b2, "CLICK").unwrap();
|
||
assert_eq!(a.active_document(), Some(d2));
|
||
key(&mut a, K::F(12), M::SHIFT);
|
||
a.design_event(r2, "LOAD").unwrap();
|
||
assert_eq!(a.active_document(), Some(d2));
|
||
a.compile_current().unwrap();
|
||
assert!(a
|
||
.project
|
||
.document(d1)
|
||
.unwrap()
|
||
.code()
|
||
.contains("SUB Form_LOAD"));
|
||
assert!(a
|
||
.project
|
||
.document(d2)
|
||
.unwrap()
|
||
.code()
|
||
.contains("SUB Form_LOAD"));
|
||
}
|
||
|
||
#[test]
|
||
fn indexed_controls_merge_atomically_with_bindings_and_undo() {
|
||
let t = Temp::new();
|
||
let mut a = t.app();
|
||
let root = root(&mut a);
|
||
let first = a
|
||
.design_place(C::CommandButton, 0, root, Rect::new(1, 1, 8, 2))
|
||
.unwrap();
|
||
property(&mut a, "INDEX", "0");
|
||
let target = node(&mut a, first).name;
|
||
let second = a
|
||
.design_place(C::CommandButton, 0, root, Rect::new(1, 4, 8, 2))
|
||
.unwrap();
|
||
let old = node(&mut a, second).name;
|
||
// Scalar and duplicate-index merges must leave every document untouched.
|
||
let before = a.design_form().unwrap().clone();
|
||
assert!(a.design_rename(&target).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
property(&mut a, "INDEX", "0");
|
||
let before = a.design_form().unwrap().clone();
|
||
assert!(a.design_rename(&target).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
property(&mut a, "INDEX", "1");
|
||
let unrelated = a
|
||
.design_place(C::TextBox, 0, root, Rect::new(20, 1, 8, 2))
|
||
.unwrap();
|
||
let unrelated_name = node(&mut a, unrelated).name;
|
||
property(&mut a, "INDEX", "2");
|
||
let before = a.design_form().unwrap().clone();
|
||
assert!(a.design_rename(&target).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
a.design_select(second, false).unwrap();
|
||
let doc = a.design_document().unwrap();
|
||
let source = format!("SUB {old}_Click(Index AS INTEGER)\n{old}(1).Caption = {target}(0).Caption\n{unrelated_name}(2).Text = \"kept\"\nEND SUB\n");
|
||
a.project.replace_text(doc, 0..0, &source).unwrap();
|
||
let before = a.design_form().unwrap().clone();
|
||
a.design_rename(&target).unwrap();
|
||
assert_eq!(node(&mut a, second).name, target);
|
||
let code = &a.design_form().unwrap().code;
|
||
assert!(code
|
||
.to_uppercase()
|
||
.contains(&format!("SUB {}_CLICK", target.to_uppercase())));
|
||
assert!(code.contains(&format!("{target}(1).Caption")));
|
||
assert!(code.contains(&format!("{unrelated_name}(2).Text")));
|
||
a.execute(Command::Undo);
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
// Two handlers for the merged event are ambiguous and cannot be committed.
|
||
a.project
|
||
.replace_text(
|
||
doc,
|
||
0..0,
|
||
&format!("SUB {target}_Click(Index AS INTEGER)\nEND SUB\n"),
|
||
)
|
||
.unwrap();
|
||
let before = a.design_form().unwrap().clone();
|
||
a.design_select(second, false).unwrap();
|
||
assert!(a.design_rename(&target).is_err());
|
||
assert_eq!(*a.design_form().unwrap(), before);
|
||
}
|