use alloc::string::{String, ToString};
use crate::desktop::{Image, ImageOptions, ImageSearch, PictureOptions};
use crate::runtime::{Runtime, RuntimeError, Value};
pub fn load_picture(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let filename = text_of(values, 0);
let options = the_options_of_the_picture(&text_of(values, 1));
let handle = rt
.desktop()
.load_picture(&filename, &options)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
if let Some(value) = values.get(2) {
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(3, "LoadPicture", "a VarRef", value),
line,
});
}
rt.write_reference(value, Value::Int(0));
}
Ok(Value::Int(handle.unwrap_or(0) as i64))
}
pub fn image_search(
rt: &mut Runtime<'_>,
values: &[Value],
line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
for index in 0..2 {
let Some(value) = values.get(index) else {
continue;
};
if !matches!(value, Value::Reference(_)) {
return Err(RuntimeError {
message: crate::runtime::wants_a_reference(
index + 1,
"ImageSearch",
"a VarRef",
value,
),
line,
});
}
}
let x1 = number_of(values, 2) as i64;
let y1 = number_of(values, 3) as i64;
let x2 = number_of(values, 4) as i64;
let y2 = number_of(values, 5) as i64;
let (image, options) = the_picture_of_the_search(&text_of(values, 6));
let answer = rt
.desktop()
.image_search(x1, y1, x2, y2, &image, &options)
.map_err(|reason| RuntimeError {
message: reason,
line,
})?;
match answer {
ImageSearch::Found(x, y) => {
rt.write_reference(&values[0], Value::Int(x));
rt.write_reference(&values[1], Value::Int(y));
Ok(Value::Int(1))
}
ImageSearch::NotFound => {
rt.write_reference(&values[0], Value::Text(String::new()));
rt.write_reference(&values[1], Value::Text(String::new()));
Ok(Value::Int(0))
}
ImageSearch::NotLoadable => Err(RuntimeError {
message: crate::runtime::invalid_parameter(7, "ImageSearch"),
line,
}),
}
}
fn the_options_of_the_picture(options: &str) -> PictureOptions {
let mut read = PictureOptions::default();
for token in options.split([' ', '\t']).filter(|token| !token.is_empty()) {
let mut letters = token.chars();
let letter = letters.next().unwrap_or_default().to_ascii_lowercase();
let rest = letters.as_str();
match letter {
'w' => read.width = the_number_of_an_option(rest),
'h' => read.height = the_number_of_an_option(rest),
'i' => read.icon = the_number_of_an_option(rest),
_ => {}
}
}
read
}
fn the_picture_of_the_search(text: &str) -> (Image, ImageOptions) {
let mut options = ImageOptions::default();
let mut rest = text.trim();
while let Some(after) = rest.strip_prefix('*') {
let (token, tail) = match after.find(' ') {
Some(at) => (&after[..at], after[at..].trim_start()),
None => (after, ""),
};
let mut letters = token.chars();
let letter = letters.next().unwrap_or_default().to_ascii_lowercase();
let number = letters.as_str();
match letter {
't' => {
let colour = if number.to_ascii_lowercase().starts_with("rans") {
&number[5..]
} else {
number
};
options.transparent = Some(colour.to_string());
}
'w' => options.width = the_number_of_an_option(number),
'h' => options.height = the_number_of_an_option(number),
'i' => {}
_ => options.variation = the_number_of_an_option(number).unwrap_or(0),
}
if tail.is_empty() {
rest = "";
break;
}
rest = tail;
}
(the_image_of_the_search(rest), options)
}
fn the_image_of_the_search(text: &str) -> Image {
let text = text.trim();
for prefix in ["HBITMAP:*", "HBITMAP:", "BITMAP:*"] {
if let Some(rest) = text.strip_prefix(prefix) {
if let Ok(handle) = rest.trim().parse::<u32>() {
return Image::Loaded(handle);
}
}
}
Image::File(text.to_string())
}
fn the_number_of_an_option(text: &str) -> Option<i64> {
if text.is_empty() {
return None;
}
text.parse::<f64>().ok().map(|number| number as i64)
}
fn text_of(values: &[Value], index: usize) -> String {
values
.get(index)
.map(|value| value.to_text())
.unwrap_or_default()
}
fn number_of(values: &[Value], index: usize) -> f64 {
values
.get(index)
.and_then(|value| value.to_number())
.unwrap_or(0.0)
}