Files
qbz/crates/vendor/i-slint-core-1.16.1/future.rs
T
vicrodh 7401d2c3fd fix(text): always draw the first line under overflow: elide
Vendor i-slint-core 1.16.1 with a one-rule patch in sharedparley's
line culling: with overflow: elide, every line whose bottom edge
exceeded max_height was dropped — INCLUDING the first one, eliding the
text to literally nothing. CJK fallback fonts report line metrics
taller than snug fixed-height boxes (Hiragino at 14px measures ~21px
inside TrackRow's 20px title line), so on macOS every CJK track title
rendered blank while Latin titles fit; Linux survived because Noto's
metrics fit the box. Root-caused with a headless render matrix on the
Mac Mini: the verbatim TrackRow structure reproduced the blank title,
removing elide rendered it, and the patched core renders all variants.
The first line still receives the ellipsis treatment as the last
visible line.

This is the real #543 mechanism. The earlier femtovg render_glyph
retry (3a1c367d) addressed a different, hypothesized layer and stays
as harmless defense in depth.

Fixes #543

cc
2026-07-05 18:53:02 -06:00

149 lines
5.1 KiB
Rust

// Copyright © SixtyFPS GmbH <info@slint.dev>
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
#![cfg(target_has_atomic = "ptr")] // Arc is not available. TODO: implement using RawWarker
#![warn(missing_docs)]
//! This module contains the code that runs futures
use crate::SlintContext;
use crate::api::EventLoopError;
use alloc::boxed::Box;
use alloc::task::Wake;
use alloc::vec::Vec;
use core::future::Future;
use core::ops::DerefMut;
use core::pin::Pin;
use core::task::Poll;
use portable_atomic as atomic;
enum FutureState<T> {
Running(Pin<Box<dyn Future<Output = T>>>),
Finished(Option<T>),
}
struct FutureRunnerInner<T> {
fut: FutureState<T>,
wakers: Vec<core::task::Waker>,
}
struct FutureRunner<T> {
#[cfg(not(feature = "std"))]
inner: core::cell::RefCell<FutureRunnerInner<T>>,
#[cfg(feature = "std")]
inner: std::sync::Mutex<FutureRunnerInner<T>>,
aborted: atomic::AtomicBool,
proxy: Box<dyn crate::platform::EventLoopProxy>,
#[cfg(feature = "std")]
thread: std::thread::ThreadId,
}
impl<T> FutureRunner<T> {
fn inner(&self) -> impl DerefMut<Target = FutureRunnerInner<T>> + '_ {
#[cfg(feature = "std")]
return self.inner.lock().unwrap();
#[cfg(not(feature = "std"))]
return self.inner.borrow_mut();
}
}
// # Safety:
// The Future might not be Send, but we only poll the future from the main thread.
// (We even assert that)
// We may access the finished value from another thread only if T is Send
// (because JoinHandle only implement Send if T:Send)
#[allow(unsafe_code)]
unsafe impl<T> Send for FutureRunner<T> {}
#[allow(unsafe_code)]
unsafe impl<T> Sync for FutureRunner<T> {}
impl<T: 'static> Wake for FutureRunner<T> {
fn wake(self: alloc::sync::Arc<Self>) {
self.clone().proxy.invoke_from_event_loop(Box::new(move || {
#[cfg(feature = "std")]
assert_eq!(self.thread, std::thread::current().id(), "the future was moved to a thread despite we checked it was created in the event loop thread");
let waker = self.clone().into();
let mut inner = self.inner();
let mut cx = core::task::Context::from_waker(&waker);
if let FutureState::Running(fut) = &mut inner.fut {
if self.aborted.load(atomic::Ordering::Relaxed) {
inner.fut = FutureState::Finished(None);
} else {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(val) => {
inner.fut = FutureState::Finished(Some(val));
for w in core::mem::take(&mut inner.wakers) {
w.wake();
}
}
Poll::Pending => {}
}
}
}
}))
.expect("No event loop despite we checked");
}
}
/// The return value of the `spawn_local()` function
///
/// Can be used to abort the future, or to get the value from a different thread with `.await`
///
/// This trait implements future. Polling it after it finished or aborted may result in a panic.
pub struct JoinHandle<T>(alloc::sync::Arc<FutureRunner<T>>);
impl<T> Future for JoinHandle<T> {
type Output = T;
fn poll(self: Pin<&mut Self>, cx: &mut core::task::Context<'_>) -> Poll<Self::Output> {
let mut inner = self.0.inner();
match &mut inner.fut {
FutureState::Running(_) => {
let waker = cx.waker();
if !inner.wakers.iter().any(|w| w.will_wake(waker)) {
inner.wakers.push(waker.clone());
}
Poll::Pending
}
FutureState::Finished(x) => {
Poll::Ready(x.take().expect("Polling completed or aborted JoinHandle"))
}
}
}
}
impl<T> JoinHandle<T> {
/// If the future hasn't completed yet, this will make the event loop stop polling the corresponding future and it will be dropped
///
/// Once this handle has been aborted, it can no longer be polled
pub fn abort(self) {
self.0.aborted.store(true, atomic::Ordering::Relaxed);
}
/// Checks if the task associated with this `JoinHandle` has finished.
pub fn is_finished(&self) -> bool {
matches!(self.0.inner().fut, FutureState::Finished(_))
}
}
#[cfg(feature = "std")]
#[allow(unsafe_code)]
// Safety: JoinHandle doesn't access the future, only the
unsafe impl<T: Send> Send for JoinHandle<T> {}
/// Implementation for [`SlintContext::spawn_local`]
pub(crate) fn spawn_local_with_ctx<F: Future + 'static>(
ctx: &SlintContext,
fut: F,
) -> Result<JoinHandle<F::Output>, EventLoopError> {
let arc = alloc::sync::Arc::new(FutureRunner {
#[cfg(feature = "std")]
thread: std::thread::current().id(),
inner: FutureRunnerInner { fut: FutureState::Running(Box::pin(fut)), wakers: Vec::new() }
.into(),
aborted: Default::default(),
proxy: ctx.event_loop_proxy().ok_or(EventLoopError::NoEventLoopProvider)?,
});
arc.wake_by_ref();
Ok(JoinHandle(arc))
}