use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::runtime::{Runtime, RuntimeError, RuntimeFailure, Value};
const STATE: &str = "menu state";
const STATE_CLASS: &str = "menu-state";
fn fail(message: impl Into<String>, line: u32) -> RuntimeFailure {
RuntimeFailure::Error(RuntimeError {
message: message.into(),
line,
})
}
struct Item {
name: String,
callback: Option<String>,
function: Option<Value>,
submenu: Option<Value>,
checked: bool,
enabled: bool,
}
struct MenuState {
items: Vec<Item>,
default: String,
click_count: i64,
}
fn state(this: &Value, line: u32) -> Result<MenuState, RuntimeFailure> {
let Value::Object(object) = this else {
return Err(fail("this value is not a menu.", line));
};
let inner = match object.borrow().value_of(STATE) {
Some(Value::Object(inner)) => inner.clone(),
_ => return Err(fail("this value is not a menu.", line)),
};
let inner = inner.borrow();
let mut items = Vec::new();
if let Some(Value::List(entries)) = inner.value_of("items") {
for entry in entries {
let Value::List(parts) = entry else {
continue;
};
let mut iterator = parts.iter();
let Some(name) = iterator.next() else {
continue;
};
let name = name.to_text();
let checked = iterator
.next()
.map(|value| value.to_text() == "1")
.unwrap_or(false);
let enabled = iterator
.next()
.map(|value| value.to_text() == "1")
.unwrap_or(true);
match iterator.next() {
Some(target @ Value::Object(object)) => {
let class = object.borrow().class.clone();
if class == "menu" || class == "menubar" {
items.push(Item {
name,
callback: None,
function: None,
submenu: Some(target.clone()),
checked,
enabled,
});
} else {
let callback = object
.borrow()
.properties
.get("name")
.map(|held| held.value.to_text())
.unwrap_or_default();
items.push(Item {
name,
callback: Some(callback),
function: Some(target.clone()),
submenu: None,
checked,
enabled,
});
}
}
Some(Value::Text(callback)) if callback.is_empty() => {
items.push(Item {
name,
callback: None,
function: None,
submenu: None,
checked,
enabled,
});
}
Some(Value::Text(callback)) => {
items.push(Item {
name,
callback: Some(callback.clone()),
function: None,
submenu: None,
checked,
enabled,
});
}
_ => items.push(Item {
name,
callback: None,
function: None,
submenu: None,
checked,
enabled,
}),
}
}
}
let default = inner
.value_of("default")
.map(|value| value.to_text())
.unwrap_or_default();
let click_count = inner
.value_of("clickcount")
.map(|value| value.to_text().parse().unwrap_or(1))
.unwrap_or(1);
Ok(MenuState {
items,
default,
click_count,
})
}
fn restore(this: &Value, menu: &MenuState) {
let Value::Object(object) = this else { return };
let mut entries: Vec<Value> = Vec::new();
for item in &menu.items {
let target = match (&item.function, &item.callback, &item.submenu) {
(Some(function), _, _) => function.clone(),
(None, Some(callback), _) => Value::Text(callback.clone()),
(None, None, Some(submenu)) => submenu.clone(),
(None, None, None) => Value::Text(String::new()),
};
entries.push(Value::List(vec![
Value::Text(item.name.clone()),
Value::Text(if item.checked { "1" } else { "0" }.to_string()),
Value::Text(if item.enabled { "1" } else { "0" }.to_string()),
target,
]));
}
let inner = crate::classes::object_with(
STATE_CLASS,
vec![
("items", Value::List(entries)),
("default", Value::Text(menu.default.clone())),
("clickcount", Value::Text(menu.click_count.to_string())),
],
);
crate::runtime::put(&mut object.borrow_mut().properties, STATE, inner);
}
pub(crate) fn construct(
_arguments: &[Value],
_rt: &mut Runtime,
_line: u32,
) -> Result<Value, RuntimeFailure> {
let state_object = crate::classes::object_with(
STATE_CLASS,
vec![
("items", Value::List(Vec::new())),
("default", Value::Text(String::new())),
("clickcount", Value::Text("1".to_string())),
],
);
Ok(crate::classes::object_with(
"Menu",
vec![(STATE, state_object)],
))
}
pub(crate) fn the_callback_of(this: &Value, item: &str, line: u32) -> Option<(Value, i64)> {
let menu = state(this, line).ok()?;
let index = menu.items.iter().position(|held| held.name == item)?;
let held = &menu.items[index];
let function = match (&held.function, &held.callback) {
(Some(function), _) => function.clone(),
(None, Some(callback)) => Value::Text(callback.clone()),
(None, None) => return None,
};
Some((function, index as i64 + 1))
}
pub(crate) fn the_default_of(this: &Value) -> Option<String> {
let menu = state(this, 0).ok()?;
if menu.default.is_empty() {
None
} else {
Some(menu.default.clone())
}
}
pub(crate) fn set_property(
name: &str,
this: &Value,
value: &Value,
rt: &mut Runtime,
line: u32,
) -> Option<Result<(), RuntimeFailure>> {
let mut menu = state(this, line).ok()?;
if name.eq_ignore_ascii_case("default") {
menu.default = value.to_text();
restore(this, &menu);
let _ = rt;
return Some(Ok(()));
}
if name.eq_ignore_ascii_case("clickcount") {
menu.click_count = value.to_text().parse().unwrap_or(1);
restore(this, &menu);
let _ = rt;
return Some(Ok(()));
}
None
}