use core::ffi::c_void;
use std::panic::{self, AssertUnwindSafe};
use crate::canvas::{self, Draw, IntoUpdate};
use crate::{
Call, Config, IntoResponse, Response, WindowHandle, delivery, encoding, entry, host, worker,
};
const MAX_INPUT_UNITS: usize = 1 << 16;
pub type ExportFn = unsafe extern "system" fn(
main_window: *mut c_void,
active_window: *mut c_void,
data: *mut c_void,
parms: *mut c_void,
show: i32,
no_pause: i32,
) -> i32;
pub const CONFIG_MARKER: i32 = 0x6D69_7275;
pub unsafe fn provide_config(
main_window: *mut c_void,
data: *mut c_void,
show: i32,
config: &'static Config,
) -> i32 {
if main_window.is_null() && show == CONFIG_MARKER && !data.is_null() {
unsafe { data.cast::<*const Config>().write(config) };
CONFIG_MARKER
} else {
1
}
}
pub unsafe fn dispatch<F, R>(
main_window: *mut c_void,
active_window: *mut c_void,
data: *mut c_void,
parms: *mut c_void,
show: i32,
no_pause: i32,
f: F,
) -> i32
where
F: FnOnce(Call) -> R,
R: IntoResponse,
{
let main_window = WindowHandle::from_raw(main_window);
let legacy = entry::begin_legacy_call(main_window);
let host = host::host();
let (capacity, encoding) = (host.capacity(), host.encoding());
let is_dllcall = !main_window.is_current_thread();
let guard = worker::begin_call(is_dllcall);
let call = Call {
data: unsafe { encoding::read(data, capacity.max(MAX_INPUT_UNITS), encoding) },
main_window,
active_window: WindowHandle::from_raw(active_window),
show: show != 0,
no_pause: no_pause != 0,
is_dllcall,
stop: guard.token.clone(),
host,
};
let response =
panic::catch_unwind(AssertUnwindSafe(|| f(call).into_response())).unwrap_or(Response::Halt);
let response = if is_dllcall && host.keep_loaded() {
delivery::intercept(response)
} else {
response
};
unsafe {
match &response {
Response::Halt | Response::Continue => {}
Response::Return(value) => encoding::write(value, data, capacity, encoding),
Response::Command {
command,
parms: args,
} => {
encoding::write(command, data, capacity, encoding);
encoding::write(args, parms, capacity, encoding);
}
}
}
drop(guard);
drop(legacy);
response.code()
}
pub unsafe fn dispatch_draw<F, R>(
main_window: *mut c_void,
active_window: *mut c_void,
data: *mut c_void,
_parms: *mut c_void,
_show: i32,
_no_pause: i32,
f: F,
) -> i32
where
F: FnOnce(Draw) -> R,
R: IntoUpdate,
{
let host = host::host();
let (capacity, encoding) = (host.capacity(), host.encoding());
let text = unsafe { encoding::read(data, capacity.max(MAX_INPUT_UNITS), encoding) };
let Some(draw) = canvas::prepare(
&text,
WindowHandle::from_raw(main_window),
WindowHandle::from_raw(active_window),
host,
) else {
return Response::Continue.code();
};
let update = match panic::catch_unwind(AssertUnwindSafe(|| f(draw).into_update())) {
Ok(update) => update,
Err(_) => return Response::Halt.code(),
};
unsafe { encoding::write(&update.reply(), data, capacity, encoding) };
Response::Return(String::new()).code()
}
pub fn deliver(call: Call) -> Response {
delivery::deliver(call.max_response_len())
}
pub fn run_next(_: Call) -> Response {
delivery::run_next()
}