use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use crate::builtins::{self, BuiltinHandler};
use crate::runtime::{Runtime, RuntimeError, Value};
pub(crate) use super::write_the_answer;
fn the_answer_that_goes_on(
rt: &mut Runtime<'_>,
name: &str,
values: &[Value],
line: u32,
answer: Result<Value, RuntimeError>,
error_level: bool,
) -> Result<Value, RuntimeError> {
match answer {
Ok(value) => {
write_the_answer(rt, name, values, 0, value.clone(), line)?;
if error_level {
rt.set_the_error_level(Value::Int(0));
}
Ok(value)
}
Err(failure) => {
write_the_answer(rt, name, values, 0, Value::Text(String::new()), line)?;
if error_level {
rt.set_the_error_level(Value::Int(1));
}
rt.note(format!(
"the command {name} did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
fn the_function_of_the_v2(
rt: &mut Runtime<'_>,
handler: BuiltinHandler,
values: &[Value],
line: u32,
) -> Result<Value, RuntimeError> {
handler(rt, values, line, 0)
}
pub(crate) fn reg_read(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::reg_read(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "RegRead", values, line, answer, true)
}
pub(crate) fn reg_write(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut reordered: Vec<Value> = Vec::with_capacity(values.len());
reordered.push(values.get(4).cloned().unwrap_or(Value::Int(0)));
reordered.push(values.first().cloned().unwrap_or(Value::Int(0)));
reordered.push(values.get(1).cloned().unwrap_or(Value::Int(0)));
reordered.push(values.get(2).cloned().unwrap_or(Value::Int(0)));
let answer = builtins::reg_write(rt, &reordered, line, 0);
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command RegWrite did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn reg_delete(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::reg_delete(rt, values, line, 0);
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command RegDelete did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn sys_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let sub_command = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let number = values.get(2).map(|value| value.to_text()).unwrap_or_default();
let answer = the_answer_of_the_sub_command(rt, values, &sub_command, &number, line);
the_answer_that_goes_on(rt, "SysGet", values, line, answer, false)
}
fn write_the_variable(rt: &mut Runtime<'_>, name: &str, value: Value) {
rt.write_reference(
&Value::Reference(crate::runtime::Reference {
name: name.to_string(),
scope: crate::runtime::Scope::Global,
alias: true,
}),
value,
);
}
fn the_name_of_the_monitor_variable(values: &[Value], index: usize) -> String {
let base = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let suffix = match index {
0 => "Left",
1 => "Top",
2 => "Right",
_ => "Bottom",
};
format!("{base}{suffix}")
}
fn the_answer_of_the_sub_command(
rt: &mut Runtime<'_>,
values: &[Value],
sub_command: &str,
number: &str,
line: u32,
) -> Result<Value, RuntimeError> {
match sub_command.to_ascii_lowercase().as_str() {
"" => {
let metric = number.trim().parse::<i64>().unwrap_or(0);
builtins::sys_get(rt, &[Value::Int(metric)], line, 0)
}
_ if sub_command.trim().parse::<i64>().is_ok() => {
let metric = sub_command.trim().parse::<i64>().unwrap_or(0);
builtins::sys_get(rt, &[Value::Int(metric)], line, 0)
}
"monitorcount" => builtins::monitor_get_count(rt, &[], line, 0),
"monitorprimary" => builtins::monitor_get_primary(rt, &[], line, 0),
"monitor" | "monitorworkarea" => {
let index = number.trim().parse::<usize>().unwrap_or(1);
let monitors = rt
.desktop()
.monitors()
.map_err(|reason| builtins::desktop_failure(reason, line))?;
let Some(monitor) = monitors.get(index.saturating_sub(1)) else {
return Ok(Value::Text(String::new()));
};
let places = [
Value::Int(monitor.left),
Value::Int(monitor.top),
Value::Int(monitor.right),
Value::Int(monitor.bottom),
];
for (index, place) in places.iter().enumerate() {
let name = the_name_of_the_monitor_variable(values, index);
write_the_variable(rt, &name, place.clone());
}
Ok(Value::Text(String::new()))
}
"monitorname" => builtins::monitor_get_name(rt, &[Value::Text(number.to_string())], line, 0),
_ => Err(RuntimeError {
message: format!("the sub-command {sub_command} of the SysGet is not known."),
line,
}),
}
}
pub(crate) fn control_get_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_get_text(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "ControlGetText", values, line, answer, true)
}
pub(crate) fn control_get_focus(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_get_focus(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "ControlGetFocus", values, line, answer, true)
}
pub(crate) fn control_get_pos(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_get_pos(rt, values, line, 0);
match answer {
Ok(value) => Ok(value),
Err(failure) => {
for index in 0..4 {
if values.get(index).is_some() {
write_the_answer(
rt,
"ControlGetPos",
values,
index,
Value::Text(String::new()),
line,
)?;
}
}
rt.note(format!(
"the command ControlGetPos did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn control_click(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_act(rt, values, line, 0);
the_answer_of_an_act(rt, "ControlClick", answer)
}
pub(crate) fn control_focus(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_act(rt, values, line, 1);
the_answer_of_an_act(rt, "ControlFocus", answer)
}
pub(crate) fn control_move(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_move(rt, values, line, 0);
the_answer_of_an_act(rt, "ControlMove", answer)
}
pub(crate) fn control_send(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_send(rt, values, line, 0);
the_answer_of_an_act(rt, "ControlSend", answer)
}
pub(crate) fn control_set_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::control_set_text(rt, values, line, 0);
the_answer_of_an_act(rt, "ControlSetText", answer)
}
fn the_answer_of_an_act(
rt: &mut Runtime<'_>,
name: &str,
answer: Result<Value, RuntimeError>,
) -> Result<Value, RuntimeError> {
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command {name} did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn control_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let sub_command = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let control = values.get(2).map(|value| value.to_text()).unwrap_or_default();
let title = values.get(3).map(|value| value.to_text()).unwrap_or_default();
let answer = the_answer_of_the_control(rt, &sub_command, &control, &title, line);
the_answer_that_goes_on(rt, "ControlGet", values, line, answer, true)
}
fn the_answer_of_the_flag(
flag: crate::desktop::ControlFlag,
line: u32,
) -> Result<Value, RuntimeError> {
match flag {
crate::desktop::ControlFlag::Yes => Ok(Value::Int(1)),
crate::desktop::ControlFlag::No => Ok(Value::Int(0)),
crate::desktop::ControlFlag::NoSuchWindow => Err(RuntimeError {
message: builtins::TARGET_WINDOW.to_string(),
line,
}),
crate::desktop::ControlFlag::NoSuchControl => Err(RuntimeError {
message: builtins::TARGET_CONTROL.to_string(),
line,
}),
}
}
fn the_answer_of_the_control(
rt: &mut Runtime<'_>,
sub_command: &str,
control: &str,
title: &str,
line: u32,
) -> Result<Value, RuntimeError> {
match sub_command.to_ascii_lowercase().as_str() {
"enabled" => {
let flag = rt
.desktop()
.control_enabled(control, title)
.map_err(|reason| builtins::desktop_failure(reason, line))?;
the_answer_of_the_flag(flag, line)
}
"visible" => {
let flag = rt
.desktop()
.control_visible(control, title)
.map_err(|reason| builtins::desktop_failure(reason, line))?;
the_answer_of_the_flag(flag, line)
}
"style" => rt
.desktop()
.control_style(control, title, false)
.map(Value::Int)
.map_err(|reason| builtins::desktop_failure(reason, line)),
"exstyle" => rt
.desktop()
.control_style(control, title, true)
.map(Value::Int)
.map_err(|reason| builtins::desktop_failure(reason, line)),
"hwnd" => rt
.desktop()
.gui_number_named(control)
.map(Value::Int)
.map_err(|reason| builtins::desktop_failure(reason, line)),
"list" => {
let joined = rt
.desktop()
.gui_controls()
.map_err(|reason| builtins::desktop_failure(reason, line))?;
Ok(Value::Text(joined))
}
_ => Err(RuntimeError {
message: format!("the sub-command {sub_command} of the ControlGet is not known."),
line,
}),
}
}
pub(crate) fn group_add(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::group_add(rt, values, line, 0);
the_answer_of_an_act(rt, "GroupAdd", answer)
}
pub(crate) fn group_activate(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::group_activate(rt, values, line, 0);
the_answer_of_an_act(rt, "GroupActivate", answer)
}
pub(crate) fn group_close(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::group_close(rt, values, line, 0);
the_answer_of_an_act(rt, "GroupClose", answer)
}
pub(crate) fn group_deactivate(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::group_close(rt, values, line, 0);
the_answer_of_an_act(rt, "GroupDeactivate", answer)
}
pub(crate) fn file_create_shortcut(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::file_create_shortcut(rt, values, line, 0);
the_answer_of_an_act(rt, "FileCreateShortcut", answer)
}
pub(crate) fn file_get_shortcut(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::file_get_shortcut(rt, values, line, 0);
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command FileGetShortcut did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn file_get_version(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::file_get_version(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "FileGetVersion", values, line, answer, false)
}
pub(crate) fn file_recycle(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::file_recycle(rt, values, line, 0);
the_answer_of_an_act(rt, "FileRecycle", answer)
}
pub(crate) fn file_recycle_empty(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::file_recycle_empty(rt, values, line, 0);
the_answer_of_an_act(rt, "FileRecycleEmpty", answer)
}
pub(crate) fn sound_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let component = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let control = values
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
let device = values.get(3).map(|value| value.to_text()).unwrap_or_default();
let answer = rt
.desktop()
.sound_control(&component, &control, &device)
.map(|answer| match answer {
crate::desktop::SoundControl::Volume(volume) => Value::Float(volume),
crate::desktop::SoundControl::Switch(on) => {
Value::Text(if on { "On".into() } else { "Off".into() })
}
})
.map_err(|failure| RuntimeError {
message: failure.the_words_of_the_v1().to_string(),
line,
});
match answer {
Ok(value) => {
write_the_answer(rt, "SoundGet", values, 0, value.clone(), line)?;
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
write_the_answer(rt, "SoundGet", values, 0, Value::Text(String::new()), line)?;
rt.set_the_error_level(Value::Text(failure.message.clone()));
rt.note(format!(
"the command SoundGet did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn sound_set(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let setting = values.first().map(|value| value.to_text()).unwrap_or_default();
let component = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let control = values
.get(2)
.map(|value| value.to_text())
.unwrap_or_default();
let device = values.get(3).map(|value| value.to_text()).unwrap_or_default();
let number = crate::v1::the_number_at_the_start_of_a_text(&setting)
.and_then(|value| value.to_number())
.unwrap_or(0.0);
let answer = rt
.desktop()
.sound_control_is_set(&component, &control, number, &device)
.map_err(|failure| RuntimeError {
message: failure.the_words_of_the_v1().to_string(),
line,
});
match answer {
Ok(()) => {
rt.set_the_error_level(Value::Int(0));
Ok(Value::Text(String::new()))
}
Err(failure) => {
rt.set_the_error_level(Value::Text(failure.message.clone()));
rt.note(format!(
"the command SoundSet did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn sound_get_wave_volume(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let device = values.get(1).map(|value| value.to_text()).unwrap_or_default();
let answer = rt
.desktop()
.sound_control("wave", "volume", &device)
.map(|answer| match answer {
crate::desktop::SoundControl::Volume(volume) => Value::Float(volume),
crate::desktop::SoundControl::Switch(on) => {
Value::Text(if on { "On".into() } else { "Off".into() })
}
})
.map_err(|failure| RuntimeError {
message: failure.the_words_of_the_v1().to_string(),
line,
});
match answer {
Ok(value) => {
write_the_answer(
rt,
"SoundGetWaveVolume",
values,
0,
value.clone(),
line,
)?;
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
write_the_answer(
rt,
"SoundGetWaveVolume",
values,
0,
Value::Text(String::new()),
line,
)?;
rt.set_the_error_level(Value::Text(failure.message.clone()));
rt.note(format!(
"the command SoundGetWaveVolume did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn sound_set_wave_volume(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let percent = values.first().map(|value| value.to_text()).unwrap_or_default();
let device = values.get(1).map(|value| value.to_text()).unwrap_or_default();
let number = crate::v1::the_number_at_the_start_of_a_text(&percent)
.and_then(|value| value.to_number())
.unwrap_or(0.0);
let answer = rt
.desktop()
.sound_control_is_set("wave", "volume", number, &device)
.map_err(|failure| RuntimeError {
message: failure.the_words_of_the_v1().to_string(),
line,
});
match answer {
Ok(()) => {
rt.set_the_error_level(Value::Int(0));
Ok(Value::Text(String::new()))
}
Err(failure) => {
rt.set_the_error_level(Value::Text(failure.message.clone()));
rt.note(format!(
"the command SoundSetWaveVolume did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn drive_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let sub_command = values
.get(1)
.map(|value| value.to_text())
.unwrap_or_default();
let drive = values.get(2).map(|value| value.to_text()).unwrap_or_default();
let answer = match sub_command.to_ascii_lowercase().as_str() {
"label" => builtins::drive_get_label(rt, &[Value::Text(drive)], line, 0),
"serial" => builtins::drive_get_serial(rt, &[Value::Text(drive)], line, 0),
"type" => builtins::drive_get_type(rt, &[Value::Text(drive)], line, 0),
"capacity" => builtins::drive_get_capacity(rt, &[Value::Text(drive)], line, 0),
"filesystem" => builtins::drive_get_filesystem(rt, &[Value::Text(drive)], line, 0),
"list" => {
let list = rt
.desktop()
.drive_list()
.map_err(|reason| builtins::desktop_failure(reason, line))?;
Ok(Value::Text(list.join("\n")))
}
_ => Err(RuntimeError {
message: format!("the sub-command {sub_command} of the DriveGet is not known."),
line,
}),
};
the_answer_that_goes_on(rt, "DriveGet", values, line, answer, false)
}
pub(crate) fn drive_space_free(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::drive_get_space_free(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "DriveSpaceFree", values, line, answer, false)
}
pub(crate) fn process(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let sub_command = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let which = values.get(1).map(|value| value.to_text()).unwrap_or_default();
let answer = match sub_command.to_ascii_lowercase().as_str() {
"exist" => rt
.desktop()
.process_exist(Some(&which))
.map(|pid| {
if pid == 0 {
Value::Int(0)
} else {
Value::Int(pid as i64)
}
})
.map_err(|reason| builtins::desktop_failure(reason, line)),
"close" => rt
.desktop()
.process_close(&which)
.map(|pid| Value::Int(pid as i64))
.map_err(|reason| builtins::desktop_failure(reason, line)),
"priority" => {
let level = values.get(2).map(|value| value.to_text()).unwrap_or_default();
rt.desktop()
.process_set_priority(&level, Some(&which))
.map(|pid| match pid {
Some(pid) => Value::Int(pid as i64),
None => Value::Int(0),
})
.map_err(|reason| builtins::desktop_failure(reason, line))
}
"wait" => {
let timeout = values.get(2).map(|value| value.to_text()).unwrap_or_default();
let timeout = timeout.trim().parse::<f64>().ok();
rt.desktop()
.process_wait(&which, timeout)
.map(|pid| Value::Int(pid as i64))
.map_err(|reason| builtins::desktop_failure(reason, line))
}
"waitclose" => {
let timeout = values.get(2).map(|value| value.to_text()).unwrap_or_default();
let timeout = timeout.trim().parse::<f64>().ok();
rt.desktop()
.process_wait_close(&which, timeout)
.map(|pid| Value::Int(pid as i64))
.map_err(|reason| builtins::desktop_failure(reason, line))
}
_ => Err(RuntimeError {
message: format!("the sub-command {sub_command} of the Process is not known."),
line,
}),
};
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command Process did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn com_obj_active(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_active, values, line)
}
pub(crate) fn com_obj_connect(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_connect, values, line)
}
pub(crate) fn com_obj_flags(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_flags, values, line)
}
pub(crate) fn com_obj_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_get, values, line)
}
pub(crate) fn com_obj_query(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_query, values, line)
}
pub(crate) fn com_obj_type(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_type, values, line)
}
pub(crate) fn com_obj_value(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::com_obj_value, values, line)
}
pub(crate) fn str_get(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::str_get, values, line)
}
pub(crate) fn str_put(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_function_of_the_v2(rt, builtins::str_put, values, line)
}
pub(crate) fn block_input(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::block_input(rt, values, line, 0);
the_answer_of_an_act(rt, "BlockInput", answer)
}
pub(crate) fn edit(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::edit(rt, values, line, 0);
the_answer_of_an_act(rt, "Edit", answer)
}
pub(crate) fn key_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
variant: u8,
) -> Result<Value, RuntimeError> {
let name = values.first().map(|v| v.to_text()).unwrap_or_default();
if crate::keys::resolve_name(&name).is_err() {
return Err(RuntimeError {
message: format!("Parameter #1 invalid.\n Specifically: {name}"),
line,
});
}
builtins::key_wait(rt, values, line, variant)
}
pub(crate) fn key_history(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = crate::hotkeys::key_history(rt, values, line, 0);
the_answer_of_an_act(rt, "KeyHistory", answer)
}
pub(crate) fn list_hotkeys(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = crate::hotkeys::list_hotkeys(rt, values, line, 0);
the_answer_of_an_act(rt, "ListHotkeys", answer)
}
pub(crate) fn list_lines(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::list_lines(rt, values, line, 0);
the_answer_of_an_act(rt, "ListLines", answer)
}
pub(crate) fn list_vars(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::list_vars(rt, values, line, 0);
the_answer_of_an_act(rt, "ListVars", answer)
}
pub(crate) fn on_message(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::on_message(rt, values, line, 0);
the_answer_of_an_act(rt, "OnMessage", answer)
}
pub(crate) fn output_debug(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::output_debug(rt, values, line, 0);
the_answer_of_an_act(rt, "OutputDebug", answer)
}
pub(crate) fn pause(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::pause(rt, values, line, 0);
the_answer_of_an_act(rt, "Pause", answer)
}
pub(crate) fn post_message(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let mut ordered: Vec<Value> = values.iter().take(3).cloned().collect();
if let Some(title) = values.get(4) {
ordered.push(title.clone());
}
let answer = builtins::post_message(rt, &ordered, line, 0);
the_answer_of_an_act(rt, "PostMessage", answer)
}
pub(crate) fn reload(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::reload(rt, values, line, 0);
the_answer_of_an_act(rt, "Reload", answer)
}
pub(crate) fn run_as(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::run_as(rt, values, line, 0);
the_answer_of_an_act(rt, "RunAs", answer)
}
pub(crate) fn shutdown(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::shutdown(rt, values, line, 0);
the_answer_of_an_act(rt, "Shutdown", answer)
}
pub(crate) fn suspend(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::suspend(rt, values, line, 0);
the_answer_of_an_act(rt, "Suspend", answer)
}
pub(crate) fn thread(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let sub_command = values
.first()
.map(|value| value.to_text())
.unwrap_or_default();
let answer = match sub_command.to_ascii_lowercase().as_str() {
"priority" | "interrupt" | "notimers" => {
builtins::thread_command(rt, values, line, 0)
}
_ => Err(RuntimeError {
message: "Parameter #1 invalid.".to_string(),
line,
}),
};
match answer {
Ok(value) => {
rt.set_the_error_level(Value::Int(0));
Ok(value)
}
Err(failure) => {
rt.set_the_error_level(Value::Int(1));
rt.note(format!(
"the command Thread did not do the thing: {}",
failure.message
));
Ok(Value::Text(String::new()))
}
}
}
pub(crate) fn tool_tip(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::tooltip(rt, values, line, 0);
the_answer_of_an_act(rt, "ToolTip", answer)
}
pub(crate) fn tray_tip(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = crate::dialogs::tray_tip(rt, values, line, 0);
the_answer_of_an_act(rt, "TrayTip", answer)
}
pub(crate) fn status_bar_get_text(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::status_bar_get_text(rt, values.get(1..).unwrap_or(&[]), line, 0);
the_answer_that_goes_on(rt, "StatusBarGetText", values, line, answer, false)
}
pub(crate) fn status_bar_wait(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let answer = builtins::status_bar_wait(rt, values, line, 0);
the_answer_of_an_act(rt, "StatusBarWait", answer)
}