use std::cell::RefCell;
use std::panic::Location;
use crabshell_reactive::{ReadSignal, Signal, untrack};
use crate::cx::Cx;
use crate::prop::{IntoProp, PropKind};
use crate::screencopy::{CaptureFrame, CaptureSource, next_id};
thread_local! {
static CAPTURES: RefCell<Vec<Capture>> = const { RefCell::new(Vec::new()) };
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Capture {
source: Signal<Option<CaptureSource>>,
frame: Signal<Option<CaptureFrame>>,
ready: Signal<bool>,
asked: Signal<Option<u64>>,
}
impl Cx {
#[track_caller]
pub fn capture(&self, source: impl IntoProp<CaptureSource>) -> Capture {
let capture = Capture {
source: self.signal(None),
frame: self.signal(None),
ready: self.signal(false),
asked: self.signal(None),
};
match source.into_prop().0 {
PropKind::Value(source) => capture.retarget(source),
PropKind::Binding(mut compute) => {
let place = self
.owner()
.name()
.map(|name| format!(" in {name}"))
.unwrap_or_default();
let label = format!("cx.capture source at {}{place}", Location::caller());
self
.effect(move || {
let source = compute();
untrack(|| capture.retarget(source));
})
.named(label);
}
}
CAPTURES.with(|captures| captures.borrow_mut().push(capture));
capture
}
}
impl Capture {
pub fn ready(&self) -> ReadSignal<bool> {
self.ready.read_only()
}
pub fn refresh(&self) {
if untrack(|| self.source.try_with(Option::is_some)) == Some(true) {
self.ready.try_set(false);
self.asked.try_set(Some(next_id()));
}
}
fn retarget(&self, source: CaptureSource) {
if self.source.try_with(|now| now.as_ref() == Some(&source)) != Some(false) {
return;
}
self.source.try_set(Some(source));
if self.frame.try_with(Option::is_some) == Some(true) {
self.frame.try_set(None);
}
if self.ready.try_get() == Some(true) {
self.ready.try_set(false);
}
self.asked.try_set(Some(next_id()));
}
pub(crate) fn frame(&self) -> Option<CaptureFrame> {
self.frame.try_get().flatten()
}
}
pub fn wanted_captures() -> Vec<(u64, CaptureSource)> {
untrack(|| {
CAPTURES.with(|captures| {
let mut captures = captures.borrow_mut();
captures.retain(|capture| capture.asked.try_get().is_some());
captures
.iter()
.filter_map(|capture| {
let asked = capture.asked.try_get().flatten()?;
Some((asked, capture.source.try_get().flatten()?))
})
.collect()
})
})
}
pub fn deliver_capture(asked: u64, frame: CaptureFrame) -> bool {
let found = CAPTURES.with(|captures| {
let captures = captures.borrow();
let mut all = captures.iter();
all
.find(|capture| untrack(|| capture.asked.try_get()) == Some(Some(asked)))
.copied()
});
let Some(capture) = found else {
return false;
};
capture.asked.try_set(None);
capture.frame.try_set(Some(frame));
capture.ready.try_set(true);
true
}