More optimization when the scale factor is constant

When compiled with a const scale factor, we don't want to register too
many dependencies to the scale factor.

Author: ogoffart

api/cpp/cbindgen.rs

@@ -545,7 +545,7 @@ fn gen_corelib(
             "slint_windowrc_hide",
             "slint_windowrc_is_visible",
             "slint_windowrc_get_scale_factor",
-            "slint_windowrc_set_scale_factor",
+            "slint_windowrc_set_const_scale_factor",
             "slint_windowrc_get_text_input_focused",
             "slint_windowrc_set_text_input_focused",
             "slint_windowrc_set_focus_item",

api/cpp/include/slint_window.h

@@ -82,7 +82,10 @@ class WindowAdapterRc
     bool is_visible() const { return slint_windowrc_is_visible(&inner); }
 
     float scale_factor() const { return slint_windowrc_get_scale_factor(&inner); }
-    void set_scale_factor(float value) const { slint_windowrc_set_scale_factor(&inner, value); }
+    void set_const_scale_factor(float value) const
+    {
+        slint_windowrc_set_const_scale_factor(&inner, value);
+    }
 
     cbindgen_private::ColorScheme color_scheme() const
     {

api/rs/build/lib.rs

@@ -170,11 +170,12 @@ impl CompilerConfiguration {
     /// as constant value. This is only intended for MCU environments. Use
     /// in combination with [`Self::embed_resources`] to pre-scale images and glyphs
     /// accordingly.
+    ///
+    /// If this is set, changing the scale factor at runtime will not have any effect.
     #[must_use]
-    pub fn with_scale_factor(self, factor: f32) -> Self {
-        let mut config = self.config;
-        config.const_scale_factor = factor as f64;
-        Self { config }
+    pub fn with_scale_factor(mut self, factor: f32) -> Self {
+        self.config.const_scale_factor = Some(factor);
+        self
     }
 
     /// Configures the compiler to bundle translations when compiling Slint code.

internal/compiler/expression_tree.rs

@@ -289,7 +289,9 @@ impl BuiltinFunction {
     /// It is const if the return value only depends on its argument and has no side effect
     fn is_const(&self, global_analysis: Option<&crate::passes::GlobalAnalysis>) -> bool {
         match self {
-            BuiltinFunction::GetWindowScaleFactor => false,
+            BuiltinFunction::GetWindowScaleFactor => {
+                global_analysis.is_some_and(|x| x.const_scale_factor.is_some())
+            }
             BuiltinFunction::GetWindowDefaultFontSize => {
                 global_analysis.is_some_and(|x| x.default_font_size.is_const())
             }

internal/compiler/generator/cpp.rs

@@ -6,7 +6,6 @@
 
 // cSpell:ignore cmath constexpr cstdlib decltype intptr itertools nullptr prepended struc subcomponent uintptr vals
 
-use lyon_path::geom::euclid::approxeq::ApproxEq;
 use std::collections::HashSet;
 use std::fmt::Write;
 use std::io::BufWriter;
@@ -769,11 +768,9 @@ pub fn generate(
         "   auto &window = self->m_window.emplace(slint::private_api::WindowAdapterRc());".into(),
     ];
 
-    if !compiler_config.const_scale_factor.approx_eq(&1.0) {
-        window_creation_code.push(format!(
-            "window.dispatch_scale_factor_change_event({});",
-            compiler_config.const_scale_factor
-        ));
+    if let Some(scale_factor) = compiler_config.const_scale_factor {
+        window_creation_code
+            .push(format!("window.window_handle().set_const_scale_factor({scale_factor});"));
     }
 
     window_creation_code.extend([

internal/compiler/generator/rust.rs

@@ -23,7 +23,6 @@ use crate::object_tree::Document;
 use crate::typeloader::LibraryInfo;
 use crate::CompilerConfiguration;
 use itertools::Either;
-use lyon_path::geom::euclid::approxeq::ApproxEq;
 use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote};
 use smol_str::SmolStr;
@@ -439,14 +438,9 @@ fn generate_shared_globals(
 
     let from_library_global_types =
         llr.globals.iter().filter(|g| g.from_library).map(global_inner_name).collect::<Vec<_>>();
-    let apply_constant_scale_factor = if !compiler_config.const_scale_factor.approx_eq(&1.0) {
-        let factor = compiler_config.const_scale_factor as f32;
-        Some(
-            quote!(adapter.window().try_dispatch_event(slint::platform::WindowEvent::ScaleFactorChanged{ scale_factor: #factor })?;),
-        )
-    } else {
-        None
-    };
+    let apply_constant_scale_factor = compiler_config.const_scale_factor.map(|factor| {
+        quote!(sp::WindowInner::from_pub(adapter.window()).set_const_scale_factor(#factor);)
+    });
 
     let library_global_vars = llr
         .globals

internal/compiler/lib.rs

@@ -128,8 +128,8 @@ pub struct CompilerConfiguration {
     pub inline_all_elements: bool,
 
     /// Compile time scale factor to apply to embedded resources such as images and glyphs.
-    /// If != 1.0 then the scale factor will be set on the `slint::Window`.
-    pub const_scale_factor: f64,
+    /// It will also be set as a const scale factor on the `slint::Window`.
+    pub const_scale_factor: Option<f32>,
 
     /// expose the accessible role and properties
     pub accessibility: bool,
@@ -209,9 +209,8 @@ impl CompilerConfiguration {
 
         let const_scale_factor = std::env::var("SLINT_SCALE_FACTOR")
             .ok()
-            .and_then(|x| x.parse::<f64>().ok())
-            .filter(|f| *f > 0.)
-            .unwrap_or(1.);
+            .and_then(|x| x.parse::<f32>().ok())
+            .filter(|f| *f > 0.);
 
         let enable_experimental = std::env::var_os("SLINT_ENABLE_EXPERIMENTAL_FEATURES").is_some();
 

internal/compiler/passes.rs

@@ -236,7 +236,7 @@ pub async fn run_passes(
     embed_images::embed_images(
         doc,
         type_loader.compiler_config.embed_resources,
-        type_loader.compiler_config.const_scale_factor,
+        type_loader.compiler_config.const_scale_factor.unwrap_or(1.),
         &type_loader.compiler_config.resource_url_mapper,
         diag,
     )
@@ -265,15 +265,12 @@ pub async fn run_passes(
         crate::EmbedResourcesKind::EmbedTextures => {
             let mut characters_seen = std::collections::HashSet::new();
 
+            let sf = type_loader.compiler_config.const_scale_factor.unwrap_or(1.) as f64;
+
             // Include at least the default font sizes used in the MCU backend
-            let mut font_pixel_sizes =
-                vec![(12. * type_loader.compiler_config.const_scale_factor) as i16];
+            let mut font_pixel_sizes = vec![(12. * sf) as i16];
             doc.visit_all_used_components(|component| {
-                embed_glyphs::collect_font_sizes_used(
-                    component,
-                    type_loader.compiler_config.const_scale_factor,
-                    &mut font_pixel_sizes,
-                );
+                embed_glyphs::collect_font_sizes_used(component, sf, &mut font_pixel_sizes);
                 embed_glyphs::scan_string_literals(component, &mut characters_seen);
             });
 

internal/compiler/passes/binding_analysis.rs

@@ -47,6 +47,7 @@ impl DefaultFontSize {
 #[derive(Debug, Clone, PartialEq, Default)]
 pub struct GlobalAnalysis {
     pub default_font_size: DefaultFontSize,
+    pub const_scale_factor: Option<f32>,
 }
 
 /// Maps the alias in the other direction than what the BindingExpression::two_way_binding does.
@@ -60,6 +61,7 @@ pub fn binding_analysis(
     diag: &mut BuildDiagnostics,
 ) -> GlobalAnalysis {
     let mut global_analysis = GlobalAnalysis::default();
+    global_analysis.const_scale_factor = compiler_config.const_scale_factor;
     let mut reverse_aliases = Default::default();
     mark_used_base_properties(doc);
     propagate_is_set_on_aliases(doc, &mut reverse_aliases);

internal/compiler/passes/const_propagation.rs

@@ -308,6 +308,9 @@ fn try_inline_builtin_function(
     let num = |n: f64| Some(Expression::NumberLiteral(n, Unit::None));
 
     match b {
+        BuiltinFunction::GetWindowScaleFactor => {
+            ga.const_scale_factor.map(|factor| Expression::NumberLiteral(factor as _, Unit::None))
+        }
         BuiltinFunction::GetWindowDefaultFontSize => match ga.default_font_size {
             crate::passes::binding_analysis::DefaultFontSize::LogicalValue(val) => {
                 Some(Expression::NumberLiteral(val as _, Unit::Px))
@@ -484,3 +487,35 @@ export component Foo inherits Window {{
         check_expression(&out1_binding);
     }
 }
+
+#[test]
+fn test_const_scale_factor() {
+    let source = r#"
+export component Foo inherits Window {
+    out property <length> test: 10phx;
+}"#;
+
+    let mut test_diags = crate::diagnostics::BuildDiagnostics::default();
+    let doc_node = crate::parser::parse(
+        source.to_string(),
+        Some(std::path::Path::new("HELLO")),
+        &mut test_diags,
+    );
+    let mut compiler_config =
+        crate::CompilerConfiguration::new(crate::generator::OutputFormat::Interpreter);
+    compiler_config.style = Some("fluent".into());
+    compiler_config.const_scale_factor = Some(2.);
+    let (doc, diag, _) =
+        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config));
+    assert!(!diag.has_errors(), "slint compile error {:#?}", diag.to_string_vec());
+
+    let bindings = &doc.inner_components.last().unwrap().root_element.borrow().bindings;
+    let mut test_binding = bindings.get("test").unwrap().borrow().expression.clone();
+    if let Expression::Cast { from, to: _ } = test_binding {
+        test_binding = *from;
+    }
+    assert!(
+        matches!(test_binding, Expression::NumberLiteral(val, _) if val == 5.0),
+        "Expression should be 5.0: {test_binding:?}"
+    );
+}