Files
qbz/crates/vendor/i-slint-core-1.16.1/context.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

174 lines
6.8 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
use crate::Property;
use crate::api::PlatformError;
use crate::input::InternalKeyboardModifierState;
use crate::platform::{EventLoopProxy, Platform};
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::cell::Cell;
crate::thread_local! {
pub(crate) static GLOBAL_CONTEXT : once_cell::unsync::OnceCell<SlintContext>
= const { once_cell::unsync::OnceCell::new() }
}
pub(crate) struct SlintContextInner {
platform: Box<dyn Platform>,
pub(crate) window_count: core::cell::RefCell<isize>,
/// This property is read by all translations, and marked dirty when the language changes,
/// so that every translated string gets re-translated. The property's value is the current selected
/// language when bundling translations.
pub(crate) translations_dirty: core::pin::Pin<Box<Property<usize>>>,
pub(crate) translations_bundle_languages:
core::cell::RefCell<Option<alloc::vec::Vec<&'static str>>>,
pub(crate) window_shown_hook:
core::cell::RefCell<Option<Box<dyn FnMut(&Rc<dyn crate::platform::WindowAdapter>)>>>,
#[cfg(all(unix, not(target_os = "macos")))]
xdg_app_id: core::cell::RefCell<Option<crate::SharedString>>,
#[cfg(feature = "tr")]
external_translator: core::cell::RefCell<Option<Box<dyn tr::Translator>>>,
#[cfg(feature = "shared-parley")]
pub(crate) font_context: core::cell::RefCell<parley::FontContext>,
#[cfg(feature = "shared-swash")]
pub(crate) swash_scale_context: core::cell::RefCell<swash::scale::ScaleContext>,
pub(crate) modifiers: Cell<InternalKeyboardModifierState>,
}
/// This context is meant to hold the state and the backend.
/// Currently it is not possible to have several platform at the same time in one process, but in the future it might be.
/// See issue #4294
#[derive(Clone)]
pub struct SlintContext(pub(crate) Rc<SlintContextInner>);
impl SlintContext {
/// Create a new context with a given platform
pub fn new(platform: Box<dyn Platform + 'static>) -> Self {
#[cfg(feature = "shared-parley")]
let collection = i_slint_common::sharedfontique::create_collection(true);
Self(Rc::new(SlintContextInner {
platform,
window_count: 0.into(),
translations_dirty: Box::pin(Property::new_named(0, "SlintContext::translations")),
translations_bundle_languages: Default::default(),
window_shown_hook: Default::default(),
#[cfg(all(unix, not(target_os = "macos")))]
xdg_app_id: Default::default(),
#[cfg(feature = "tr")]
external_translator: Default::default(),
#[cfg(feature = "shared-parley")]
font_context: {
let font_context = parley::FontContext {
collection: collection.inner,
source_cache: collection.source_cache,
};
core::cell::RefCell::new(font_context)
},
#[cfg(feature = "shared-swash")]
swash_scale_context: core::cell::RefCell::new(swash::scale::ScaleContext::new()),
modifiers: Cell::new(Default::default()),
}))
}
/// Return a reference to the platform abstraction
pub fn platform(&self) -> &dyn Platform {
&*self.0.platform
}
/// Return a reference to the font context
#[cfg(feature = "shared-parley")]
pub fn font_context(&self) -> &core::cell::RefCell<parley::FontContext> {
&self.0.font_context
}
/// Return a reference to the swash scale context
#[cfg(feature = "shared-swash")]
pub fn swash_scale_context(&self) -> &core::cell::RefCell<swash::scale::ScaleContext> {
&self.0.swash_scale_context
}
/// Return an event proxy
// FIXME: Make EvenLoopProxy cloneable, and maybe wrap in a struct
pub fn event_loop_proxy(&self) -> Option<Box<dyn EventLoopProxy>> {
self.0.platform.new_event_loop_proxy()
}
#[cfg(target_has_atomic = "ptr")]
/// Context specific version of `slint::spawn_local`
pub fn spawn_local<F: core::future::Future + 'static>(
&self,
fut: F,
) -> Result<crate::future::JoinHandle<F::Output>, crate::api::EventLoopError> {
crate::future::spawn_local_with_ctx(self, fut)
}
pub fn run_event_loop(&self) -> Result<(), PlatformError> {
self.0.platform.run_event_loop()
}
pub fn set_xdg_app_id(&self, _app_id: crate::SharedString) {
#[cfg(all(unix, not(target_os = "macos")))]
{
self.0.xdg_app_id.replace(Some(_app_id));
}
}
#[cfg(all(unix, not(target_os = "macos")))]
pub fn xdg_app_id(&self) -> Option<crate::SharedString> {
self.0.xdg_app_id.borrow().clone()
}
#[cfg(not(all(unix, not(target_os = "macos"))))]
pub fn xdg_app_id(&self) -> Option<crate::SharedString> {
None
}
#[cfg(feature = "tr")]
pub fn set_external_translator(&self, translator: Option<Box<dyn tr::Translator>>) {
*self.0.external_translator.borrow_mut() = translator;
self.0.translations_dirty.mark_dirty();
}
#[cfg(feature = "tr")]
pub fn external_translator(&self) -> Option<core::cell::Ref<'_, Box<dyn tr::Translator>>> {
core::cell::Ref::filter_map(self.0.external_translator.borrow(), |maybe_translator| {
maybe_translator.as_ref()
})
.ok()
}
}
/// Internal function to access the context.
/// The factory function is called if the platform abstraction is not yet
/// initialized, and should be given by the platform_selector
pub fn with_global_context<R>(
factory: impl FnOnce() -> Result<Box<dyn Platform + 'static>, PlatformError>,
f: impl FnOnce(&SlintContext) -> R,
) -> Result<R, PlatformError> {
GLOBAL_CONTEXT.with(|p| match p.get() {
Some(ctx) => Ok(f(ctx)),
None => {
if crate::platform::with_event_loop_proxy(|proxy| proxy.is_some()) {
return Err(PlatformError::SetPlatformError(
crate::platform::SetPlatformError::AlreadySet,
));
}
crate::platform::set_platform(factory()?).map_err(PlatformError::SetPlatformError)?;
Ok(f(p.get().unwrap()))
}
})
}
/// Internal function to set a hook that's invoked whenever a slint::Window is shown. This
/// is used by the system testing module. Returns a previously set hook, if any.
pub fn set_window_shown_hook(
hook: Option<Box<dyn FnMut(&Rc<dyn crate::platform::WindowAdapter>)>>,
) -> Result<Option<Box<dyn FnMut(&Rc<dyn crate::platform::WindowAdapter>)>>, PlatformError> {
GLOBAL_CONTEXT.with(|p| match p.get() {
Some(ctx) => Ok(ctx.0.window_shown_hook.replace(hook)),
None => Err(PlatformError::NoPlatform),
})
}