use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::runtime::{Runtime, RuntimeError, Value};
fn the_listview(rt: &mut Runtime<'_>, line: u32) -> Result<u64, RuntimeError> {
let (window, number) = rt.the_default_listview_of_the_v1().ok_or(RuntimeError {
message: "there is no list view of the script.".to_string(),
line,
})?;
rt.desktop()
.v1_gui_use_window(&window)
.map_err(|reason| the_failure(reason, line))?;
Ok(number)
}
fn the_treeview(rt: &mut Runtime<'_>, line: u32) -> Result<u64, RuntimeError> {
let (window, number) = rt.the_default_treeview_of_the_v1().ok_or(RuntimeError {
message: "there is no tree view of the script.".to_string(),
line,
})?;
rt.desktop()
.v1_gui_use_window(&window)
.map_err(|reason| the_failure(reason, line))?;
Ok(number)
}
fn text_of(values: &[Value], at: usize) -> String {
values
.get(at)
.map(|value| value.to_text())
.unwrap_or_default()
}
fn number_of(values: &[Value], at: usize) -> i64 {
values
.get(at)
.and_then(|value| value.to_number())
.unwrap_or(0.0) as i64
}
fn the_failure(reason: String, line: u32) -> RuntimeError {
RuntimeError {
message: reason,
line,
}
}
fn the_text_is_row_options(text: &str) -> bool {
if text.trim().is_empty() {
return true;
}
text.split_whitespace().all(|word| {
let lower = word.to_ascii_lowercase();
let name = lower.trim_start_matches('-').trim_start_matches('+');
matches!(name, "check" | "focus" | "select" | "vis")
|| name
.strip_prefix("icon")
.is_some_and(|n| n.parse::<i32>().is_ok())
|| name
.strip_prefix("col")
.is_some_and(|n| n.parse::<i64>().is_ok())
})
}
fn the_cells(values: &[Value], from: usize) -> Vec<String> {
values
.iter()
.skip(from)
.map(|value| value.to_text())
.collect()
}
pub(crate) fn lv_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let first_is_options = match values.first() {
Some(Value::Int(_) | Value::Float(_)) => false,
Some(value) => the_text_is_row_options(&value.to_text()),
None => false,
};
let (options, from) = if first_is_options {
(text_of(values, 0), 1)
} else {
(String::new(), 0)
};
let cells = the_cells(values, from);
let row = rt
.desktop()
.v1_lv_add(number, &options, &cells)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(row))
}
pub(crate) fn lv_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let row = number_of(values, 0);
let answer = rt
.desktop()
.v1_lv_delete(number, row)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn lv_getcount(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let mode = text_of(values, 0);
let count = rt
.desktop()
.v1_lv_count(number, &mode)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(count))
}
pub(crate) fn lv_getnext(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let start = number_of(values, 0);
let mode = text_of(values, 1);
let row = rt
.desktop()
.v1_lv_next(number, start, &mode)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(row))
}
pub(crate) fn lv_gettext(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let row = number_of(values, 1);
let col = if values.get(2).is_some() {
number_of(values, 2)
} else {
1
};
let count = rt
.desktop()
.v1_lv_count(number, "")
.map_err(|reason| the_failure(reason, line))?;
if row < 1 || row > count {
return Ok(Value::Int(0));
}
let text = rt
.desktop()
.v1_lv_text(number, row, col.max(1))
.map_err(|reason| the_failure(reason, line))?;
if let Some(output) = values.first() {
rt.write_reference(output, Value::Text(text));
}
Ok(Value::Int(1))
}
pub(crate) fn lv_modify(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let row = number_of(values, 0);
let second_is_options = match values.get(1) {
Some(Value::Int(_) | Value::Float(_)) => false,
Some(value) => the_text_is_row_options(&value.to_text()),
None => false,
};
let (options, from) = if second_is_options {
(text_of(values, 1), 2)
} else {
(String::new(), 1)
};
let cells = the_cells(values, from);
let answer = rt
.desktop()
.v1_lv_modify(number, row, &options, &cells)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn lv_modifycol(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let col = number_of(values, 0);
let options = text_of(values, 1);
let title = values.get(2).map(|value| value.to_text());
let answer = rt
.desktop()
.v1_lv_modifycol(number, col, &options, title.as_deref())
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn lv_setimagelist(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_listview(rt, line)?;
let list = number_of(values, 0);
let large = number_of(values, 1) != 0;
rt.desktop()
.v1_lv_setimagelist(number, list, large)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(1))
}
pub(crate) fn il_create(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let initial = number_of(values, 0) as i32;
let grow = number_of(values, 1) as i32;
let large = number_of(values, 2) != 0;
let handle = rt
.desktop()
.v1_il_create(initial, grow, large)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(handle))
}
pub(crate) fn il_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let list = number_of(values, 0);
let source = text_of(values, 1);
let icon = if values.get(2).is_some() {
number_of(values, 2)
} else {
1
};
let index = rt
.desktop()
.v1_il_add(list, &source, icon)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(index))
}
pub(crate) fn il_destroy(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let list = number_of(values, 0);
let answer = rt
.desktop()
.v1_il_destroy(list)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn tv_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let text = text_of(values, 0);
let parent = number_of(values, 1);
let options = text_of(values, 2);
let item = rt
.desktop()
.v1_tv_add(number, &text, parent, &options)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(item))
}
pub(crate) fn tv_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 0);
let answer = rt
.desktop()
.v1_tv_delete(number, item)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn tv_getcount(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let count = rt
.desktop()
.v1_tv_count(number)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(count))
}
pub(crate) fn tv_gettext(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 1);
if item == 0 {
return Ok(Value::Int(0));
}
let text = rt
.desktop()
.v1_tv_text(number, item)
.map_err(|reason| the_failure(reason, line))?;
if let Some(output) = values.first() {
rt.write_reference(output, Value::Text(text));
}
Ok(Value::Int(1))
}
pub(crate) fn tv_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 0);
let attribute = text_of(values, 1);
let answer = rt
.desktop()
.v1_tv_get(number, item, &attribute)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn tv_getchild(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let parent = number_of(values, 0);
let item = rt
.desktop()
.v1_tv_child(number, parent)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(item))
}
pub(crate) fn tv_getparent(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 0);
let parent = rt
.desktop()
.v1_tv_parent(number, item)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(parent))
}
pub(crate) fn tv_getnext(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 0);
let mode = text_of(values, 1);
let next = rt
.desktop()
.v1_tv_next(number, item, &mode)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(next))
}
pub(crate) fn tv_getselection(
rt: &mut Runtime<'_>,
_values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = rt
.desktop()
.v1_tv_selection(number)
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(item))
}
pub(crate) fn tv_modify(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_treeview(rt, line)?;
let item = number_of(values, 0);
let options = if values.get(1).is_some() {
text_of(values, 1)
} else {
"Select Vis".to_string()
};
let text = values.get(2).map(|value| value.to_text());
let answer = rt
.desktop()
.v1_tv_modify(number, item, &options, text.as_deref())
.map_err(|reason| the_failure(reason, line))?;
Ok(Value::Int(answer as i64))
}
pub(crate) fn obj_raw_set(
_rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let object = values
.first()
.cloned()
.unwrap_or(Value::Text(String::new()));
let Value::Object(obj) = &object else {
return Err(RuntimeError {
message: crate::runtime::requires(1, "ObjRawSet", crate::runtime::TypeName::Object, &object),
line,
});
};
let key = text_of(values, 1);
let value = values
.get(2)
.cloned()
.unwrap_or(Value::Text(String::new()));
obj.borrow_mut().put(&key, value.clone());
Ok(value)
}
pub(crate) fn exception(
_rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(crate::classes::object_with(
"object",
alloc::vec![
("Message", Value::Text(text_of(values, 0))),
("What", Value::Text(text_of(values, 1))),
("Extra", Value::Text(text_of(values, 2))),
],
))
}