- Bundle translations for WASM/Android only (not for native builds)
- Load Noto Sans CJK fonts dynamically from GitHub at runtime
- Implement register_font_from_memory() with Result<FontHandle, RegisterFontError>
- Make API automatically available with std feature (no explicit feature flag needed)
- Export load_font_from_bytes() for WASM font loading from JavaScript
- Change from wasm_bindgen(start) to explicit main() call for better control
Fonts are loaded before app initialization to ensure proper CJK text
rendering across all major browsers without bundling font files.
Native builds load translations from lang/ directory at runtime.
WASM/Android builds bundle translations at compile time and detect
browser/system language automatically.
API is now available when std feature is enabled, since we always
have fontique with std. No need for experimental-register-font feature.
`ImageCacheKey` has a different size depending on the feature `std`
which is not reflected by cbindgen. Ensure that it is always the same
for C++ build
Fixes#10077
(Another option would have been to add "frature=std" in
cbindgen::Config::defines, but the problem is that there is no
SLINT_FEATURE_STD (it is SLINT_FEATURE_FREESTANDING and has the opposite
meaning), and because of the order of includes it wouldn't be defined
when then ImageCacheKey struct is declared)
* Add support for CSS conic-gradient 'from <angle>' syntax
Implement rotation support for conic gradients by adding the 'from <angle>'
syntax, which rotates the entire gradient by the specified angle.
- Add `from_angle` field to ConicGradient expression
- Parse 'from <angle>' syntax in compiler (defaults to 0deg when omitted)
- Normalize angles to 0-1 range (0.0 = 0°, 1.0 = 360°)
- Add `ConicGradientBrush::rotated_stops()` method that:
* Applies rotation by adding from_angle to each stop position
* Adds boundary stops at 0.0 and 1.0 with interpolated colors
* Handles stops outside [0, 1] range for boundary interpolation
- Update all renderers (Skia, FemtoVG, Qt, Software) to use rotated_stops()
The rotation is applied at render time by the rotated_stops() method,
which ensures all renderers consistently handle the gradient rotation.
* Add screenshot to rotated conic gradient docs example
Wraps the rotated conic gradient example in CodeSnippetMD to automatically
generate and display a visual screenshot of the gradient rotation effect.
This makes it easier for users to understand how the 'from' parameter rotates
the gradient.
* Make ConicGradientBrush fields private
The from_angle and stops fields don't need to be pub since:
- Rust code in the same module can access them without pub
- C++ FFI access works through cbindgen-generated struct (C++ struct members are public by default)
* Optimize ConicGradientBrush::rotated_stops to avoid allocations
- Changed return type from Vec to SharedVector
- When from_angle is zero, returns a clone of internal SharedVector
(only increments reference count instead of allocating new Vec)
- Removed break from duplicate position separation loop to handle
all duplicate pairs, not just the first one
- Updated documentation to match actual implementation
* Remove automatic sorting in ConicGradientBrush::new() to match CSS spec
- CSS conic-gradient does not automatically sort color stops
- Stops are processed in the order specified by the user
- Changed boundary stop interpolation logic to use max_by/min_by
instead of relying on sorted order
- This allows CSS-style hard transitions when stops are out of order
* Move conic gradient rotation processing to construction time
Major changes:
- ConicGradientBrush::new() now applies rotation and boundary stop
processing immediately, instead of deferring to rotated_stops()
- Removed rotated_stops() method - backends now use stops() directly
- Changed to LinearGradientBrush pattern: store angle in first dummy stop
- Added angle() method to retrieve the stored angle
- Maintained #[repr(transparent)] by removing from_angle field
- All backends updated: rotated_stops() -> stops()
- Qt backend
- Skia renderer
- femtovg renderer
- Software renderer
C++ API changes:
- Added FFI function slint_conic_gradient_new() for C++ to call Rust's new()
- Updated make_conic_gradient() to call FFI function instead of manually
constructing SharedVector
- Ensures C++-created gradients get full rotation processing
Benefits:
- Eliminates per-frame rotation calculations
- Reduces memory usage (no from_angle field)
- Consistent with LinearGradientBrush design
- C++ and Rust APIs now produce identical results
* Change ConicGradientBrush::new() from_angle parameter to use degrees
- Changed from_angle parameter from normalized form (0.0-1.0) to degrees
- Matches LinearGradientBrush API convention (angle in degrees)
- Updated internal conversion: from_angle / 360.0 for normalization
- Stores angle as-is in degrees in the first dummy stop
- FFI function slint_conic_gradient_new() passes degrees directly
Example usage:
ConicGradientBrush::new(90.0, stops) // 90 degrees
LinearGradientBrush::new(90.0, stops) // 90 degrees (consistent)
* Fix ConicGradient color transformation methods to preserve angle
Changed brighter(), darker(), transparentize(), and with_alpha() methods
to clone and modify the gradient in-place instead of calling new().
- Clones the existing gradient (preserves angle and rotation)
- Modifies only color stops (skips first stop which contains angle)
- Avoids re-running expensive rotation processing
- Maintains the original angle information
Before: ConicGradientBrush::new(0.0, ...) // Lost angle information
After: Clone + modify colors in-place // Preserves angle
* Use premultiplied alpha interpolation for conic gradient colors
- Changed interpolate_color() to use premultiplied RGBA interpolation
- Updated signature to match Color::mix convention (&Color, factor)
- Added documentation explaining why we can't use Color::mix() here
(Sass algorithm vs CSS gradient color interpolation)
- Reference: https://www.w3.org/TR/css-images-4/#color-interpolation
This ensures correct visual interpolation of semi-transparent colors
in gradient boundaries, following CSS gradient specification.
* Run rustfmt on conic gradient code
* Fix ConicGradientBrush edge cases and add comprehensive tests
- Handle stops that are all below 0.0 or all above 1.0
- Add default transparent gradient when no valid stops remain
- Add 7 unit tests covering basic functionality and edge cases
* Apply clippy suggestion: use retain() instead of filter().collect()
* Fix radial-gradient parsing to allow empty gradients
Allow @radial-gradient(circle) without color stops, fixing syntax test
regression from commit 820ae2b04.
The previous logic required a comma after 'circle', but it should only
error if there's something that is NOT a comma.
* Fix conic-gradient syntax test error markers
Update error markers to match actual compiler error positions.
The 'from 2' case produces two errors:
- One at the @conic-gradient expression level
- One at the literal '2' position
Auto-updated using SLINT_SYNTAX_TEST_UPDATE=1.
* Refactor ConicGradientBrush epsilon adjustment and update tests
- Move epsilon adjustment for first stop into rotation block
(only needed when rotation is applied)
- Update property_view test to reflect boundary stops added by
ConicGradientBrush::new()
* Update conic-gradient screenshot reference image
Update the reference screenshot to match the current rendering output.
The small pixel differences (1% different pixels, max color diff 3.46)
are due to minor rounding differences in the conic gradient implementation.
* Fix ConicGradientBrush C++ FFI to avoid C-linkage return type error
Refactored ConicGradientBrush construction to match LinearGradientBrush
pattern, fixing macOS Clang error about returning C++ types from extern "C"
functions.
Changes:
- Rust: Split ConicGradientBrush::new into simple construction + separate
normalize_stops() and apply_rotation() methods
- Rust: Added FFI functions slint_conic_gradient_normalize_stops() and
slint_conic_gradient_apply_rotation() that take pointers (no return value)
- C++: Construct SharedVector directly in make_conic_gradient(), then call
Rust functions via pointer (matching LinearGradientBrush pattern)
- Optimized both methods to only copy when changes are needed
This resolves the macOS Clang error:
"'slint_conic_gradient_new' has C-linkage specified, but returns incomplete
type 'ConicGradientBrush' which could be incompatible with C"
The new approach maintains ABI compatibility while keeping complex gradient
processing logic in Rust.
* Fix C++ header generation to avoid GradientStop redefinition error
Resolves the macOS CI compilation error where GradientStop and
ConicGradientBrush were being defined in multiple headers
(slint_color_internal.h, slint_image_internal.h, and slint_brush_internal.h).
Changes:
- cbindgen.rs: Add ConicGradientBrush and FFI functions to slint_brush_internal.h include list
- cbindgen.rs: Add GradientStop, ConicGradientBrush, and FFI functions to exclude list for other headers
- slint_color.h: Add forward declaration for ConicGradientBrush
- slint_color.h: Add friend declaration for ConicGradientBrush to allow access to Color::inner
Root cause: After adding extern "C" functions in graphics/brush.rs,
cbindgen automatically detects and tries to include them in all headers
that use graphics/brush.rs as a source. The exclude list + filter logic
ensures these types only appear in slint_brush_internal.h.
This fixes the C++ compilation errors:
- "redefinition of 'GradientStop'"
- "ConicGradientBrush does not name a type"
- "Color::inner is private within this context"
* Prepare ConicGradientBrush FFI for Rust 2024 edition
Update FFI functions to use the new `#[unsafe(no_mangle)]` attribute
syntax and safe function signatures in preparation for Rust 2024 edition.
- Add `#![allow(unsafe_code)]` to graphics module for `#[unsafe(no_mangle)]`
- Add `#[cfg(feature = "ffi")]` to conditionally compile FFI functions
- Change from raw pointers to safe references (&mut)
- Remove manual null checks and unsafe blocks
* Change Color type to be f32 internally but no other changes
* Add missing clamp
* Add round function as we're not on MSRV 1.90+
* Prepare for being able to switch between u8s and f32s
* [autofix.ci] apply automated fixes
* Fix Display impl
* Add feature flag for 8-bit color values. Name to be bikeshed
* Fix brighter-darker test
* Update test screenshot
* Remove unused Float trait import
* Add cfg thing for not(cbindgen)
* Change Channel to float in cbindgen
* Change the cpp color type for uint8_t for now
* Opt cpp into 8-bit-color
* Switch feature around
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* Use htmlparser
* Parse color values
* Cargo fmt
* Use imported Color
* Actually handle colors via overrides
* Check that the tags match
* Use color parsing feature
* Make htmlparser optional
* Error handling
* [autofix.ci] apply automated fixes
* debug_log!
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
* must be format!() instead of format()
* line 1192 uses a debug_name local variable, which got removed
Amends commit e11015e7b3
("Two way binding with struct for the interpreter")
* parley: Move the code for creating the ranged builders into a separate struct
This makes it easier to see what's needed for create the builders and reduces the lines of code for the layout function.
* parley: Move the parley::Layout building into LayoutWithoutLineBreaksBuilder
That way we can make sure that the text applied to the ranged_builder and the final layout is the same.
* parley: Separate creation of parley layouts from applying the line breaks and positioning
In the future, once fully separated, we can cache the layout without the line breaks.
* parley: Simplify LayoutWithoutLineBreaksBuilder::build
We only need the contexts within, so remove the argument.
* parley: Move pixel size computation into LayoutWithoutLineBreaksBuilder constructor
That's the only place where we need to compute it.
* parley: Reduce fields in LayoutOptions
Remove font_request and stroke, as that's only needed in LayoutWithoutLineBreaksBuilder, which is now passed into layout().
This is, again, in preparation of further separating the creation of the layouts (mainly shaping) and the line breaking and positioning.
* parley: Separate text layout steps further
With this PR, text layout is now split into three phrases:
1. Set up parley
2. Create paragraphs of text with formatting applied - stored in essentially a vec of parley layouts. This step includes shaping.
3. Apply line breaking to the layouts. This step includes glyph positioning.
* parley: Move selection handling into LayoutWithoutLineBreaksBuilder
It's only needed there, and only set from draw_text_input.
* parley: Move text wrap into LayoutWithoutLineBreaksBuilder
* parley: Move LayoutOptions creations right to the call where needed
* parley: In draw_text() initialize variables closes to their use-site
* parley: In draw_text_input() initialize variables closer to their use-site
This is done with the exceptions of opportunities for early returns, as those can then also avoid unnecessary property dependencies.
* parley: In text_size(), improve localty if variable declaration and use-site slightly
* parley: Improve variable locality in link_under_cursor
* parley: Improve variable locality in text_input_cursor_rect_for_byte_offset
* parley: Improve variable locality in text_input_byte_offset_for_position
* parley: Avoid unnecessary pixel_size computation in text_input_cursor_rect_for_byte_offset
* parley: Simplify cursor drawing code
Instead, hide access to the string behind a RenderString trait.
The objective in the future is to cache the layout, which means that we need to query the text and other properties only if the cache is dirty.
Instead of each caller obtaining the scale factor, the renderer can do that, too. This also eliminates the dependency to the scale factor where it's not needed, such as for the font metrics.
This line was added by mistake in a previous commit.
But the feature can't work for C++ and the interpreter for now because
they can't re-use the same binding.
It would also break for eust if there was another layer of two way
binding.
That's because `impl BindingCallable for TwoWayBindingWithMap` doesn't
(and can't) implement intercept_set_binding
* Add an open-url function
* Add cpp implementation
* Add workspace dep
* Add core::open_url function
* Remove pub use webbrowser
* Put open_url behind a flag
* [autofix.ci] apply automated fixes
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
No extra safety constraints that is not expressed in the type system
(eg, if they don't take any raw pointers)
Fix UB in slint_interpreter_value_to_array (The vector was already constructed in C++)
* Add `stroke-line-join` for `Path`
* Add `LineJoin` enum
* Add `stroke-line-join` property for `Path`
* Set line_join in Skia and FemtoVG renders
* Set pen_join_style in Qt backend
* Add example test case
* Docs: Add `stroke-line-join` property for `Path`
Instead of always creating an array with fallbacks + 1 that's padded with SystemUi, create two arrays depending on the existence of a user-specified family.
Share the fallback to SansSerif/SystemUi across all the fontique/parley fallbacks and (most importantly for this fix) in embed_glyphs.rs set families on the query always as a list that ends up with the fallbacks, instead of just the family that could not be found.
Fixes#9879
... when there are two level of indirection, as it is the case with the
interpreter as it tries to create mapping to Value as one first level of
indirection
* Underscores and links
* Add color options
* Store links seperately
Gate the links field
* [autofix.ci] apply automated fixes
* Change fill_rectangle to use a brush instead
* Change if let to if is_some
* Fix skia
* Gate structs again
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Instead of changing the CURRENT_BINDING in the evaluate function from
the vtable, change it from the caller.
This requires the pointer to be passed to the evaluate to be `*const`,
which required a few changes in the ChangeTracker.
