Slint

https://docs.slint.dev/latest/docs/rust/slint/
Admin
Slint is a declarative UI framework and toolkit for building native user interfaces in Rust using...
Tokens:417,520
Snippets:4,261
Trust Score:9.5
Update:1 week ago
Show doc for...
Tokens:
Raw
### Import example library in Slint

Source: https://docs.slint.dev/latest/docs/rust/slint_build/struct.CompilerConfiguration

Imports the 'example' library in ui/main.slint using the @library syntax.

```slint
import { Example } from "@example";
```

--------------------------------

### Compile with library paths example

Source: https://docs.slint.dev/latest/docs/rust/slint_build/struct.CompilerConfiguration

Compiles ui/main.slint with an 'example' library path using with_library_paths.

```rust
let manifest_dir = std::path::PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap());
let library_paths = std::collections::HashMap::from([(
    "example".to_string(),
    manifest_dir.join("third_party/example/ui/lib.slint"),
)]);
let config = slint_build::CompilerConfiguration::new().with_library_paths(library_paths);
slint_build::compile_with_config("ui/main.slint", config).unwrap();
```

--------------------------------

### Get property example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/api/struct.ComponentInstance.html

Shows how to create a component instance and retrieve a public property value using get_property. The example builds a component from source with a property my_property set to 42, then asserts the retrieved value equals 42.

```rust
use slint_interpreter::{ComponentDefinition, Compiler, Value, SharedString};
let code = r#"
    export component MyWin inherits Window {
        in-out property <int> my_property: 42;
    }
"#;
let mut compiler = Compiler::default();
let result = spin_on::spin_on(
    compiler.build_from_source(code.into(), Default::default()));
assert_eq!(result.diagnostics().count(), 0, "{:?}", result.diagnostics().collect::<Vec<_>>());
let instance = result.component("MyWin").unwrap().create().unwrap();
assert_eq!(instance.get_property("my_property").unwrap(), Value::from(42));
```

--------------------------------

### starts_with example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Checks whether the slice starts with the given prefix. Returns `true` when the needle is a prefix or equal to the slice.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

--------------------------------

### Timer::start example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.Timer

Example showing how to create a repeated timer that prints a message every 200ms using Timer::start.

```rust
use slint::{Timer, TimerMode};
let timer = Timer::default();
timer.start(TimerMode::Repeated, std::time::Duration::from_millis(200), move || {
   println!("This will be printed every 200ms.");
});
// ... more initialization ...
slint::run_event_loop();
```

--------------------------------

### Install cargo-apk

Source: https://docs.slint.dev/latest/docs/rust/slint/android/index.html

Installs the cargo-apk subcommand for building, signing, and deploying Android APKs.

```bash
cargo install cargo-apk
```

--------------------------------

### array_windows example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Shows how to use array_windows to iterate over overlapping windows of N elements. The example uses N=2 and demonstrates the sequence of windows and the final None.

```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());
```

--------------------------------

### as_simd example with portable_simd

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Nightly-only example of as_simd with the portable_simd feature. Shows splitting a slice into prefix, middle, and suffix, and a basic SIMD sum function.

```rust
#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### split_at example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Shows how to use split_at to divide a slice into two parts at a given index. The example demonstrates splitting at 0, 2, and 3.

```rust
let v = ['a', 'b', 'c'];

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

{
    let (left, right) = v.split_at(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}
```

--------------------------------

### Example: constructing and using ModelRc

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.ModelRc

Complete example showing how to create a VecModel, wrap it in a ModelRc, pass it to a Slint component, and update it from callbacks using either a strong reference or a getter with downcast.

```rust
use slint::{slint, SharedString, ModelRc, Model, VecModel};
use std::rc::Rc;
slint!{
    import { Button } from "std-widgets.slint";
    export component Example {
        callback add_item <=> btn.clicked;
        in property <[string]> the_model;
        HorizontalLayout {
            for it in the_model : Text { text: it; }
            btn := Button { text: "Add"; }
        }
    }
}
let ui = Example::new().unwrap();
// Create a VecModel and put it in an Rc.
let the_model : Rc<VecModel<SharedString>> =
        Rc::new(VecModel::from(vec!["Hello".into(), "World".into()]));
// Convert it to a ModelRc.
let the_model_rc = ModelRc::from(the_model.clone());
// Pass the model to the ui: The generated set_the_model setter from the
// the_model property takes a ModelRc.
ui.set_the_model(the_model_rc);

// We have kept a strong reference to the_model, to modify it in a callback.
ui.on_add_item(move || {
    // Use VecModel API: VecModel uses the Model notification mechanism to let Slint
    // know it needs to refresh the UI.
    the_model.push("SomeValue".into());
});

// Alternative: we can re-use a getter.
let ui_weak = ui.as_weak();
ui.on_add_item(move || {
    let ui = ui_weak.unwrap();
    let the_model_rc = ui.get_the_model();
    let the_model = the_model_rc.as_any().downcast_ref::<VecModel<SharedString>>()
        .expect("We know we set a VecModel earlier");
    the_model.push("An Item".into());
});
```

--------------------------------

### transparentize example: decrease opacity by 20%

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.Color

Example for the transparentize method, decreasing the opacity of a blue color by 20%.

```rust
let blue = Color::from_argb_f32(1.0, 0.0, 0.0, 1.0);
assert_eq!(blue.transparentize(0.2), Color::from_argb_f32(0.8, 0.0, 0.0, 1.0));
```

--------------------------------

### Example: using init_with_event_listener in android_main

Source: https://docs.slint.dev/latest/docs/rust/slint/android/fn.init_with_event_listener

Example usage of `init_with_event_listener` inside the `android_main` entry point. The listener prints each event using `eprintln!`. The function is called with `unwrap()` and the rest of the application follows.

```rust
#[unsafe(no_mangle)]
fn android_main(app: slint::android_activity::AndroidApp) {
    slint::android::init_with_event_listener(
       app,
       |event| { eprintln!("got event {event:?}") }
    ).unwrap();

    // ... rest of your application ...

}

```

--------------------------------

### ModelExt::map shortcut example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.MapModel

Shows the shortcut ModelExt::map to create a mapped model directly from a VecModel, using the same formatting closure as the MapModel::new example.

```rust
let mapped_model = VecModel::from(vec![
    Name { first: "Hans".to_string(), last: "Emil".to_string() },
    Name { first: "Max".to_string(), last: "Mustermann".to_string() },
    Name { first: "Roman".to_string(), last: "Tisch".to_string() },
])
.map(|n| slint::format!("{}, {}", n.last, n.first));
```

--------------------------------

### transparentize example: decrease opacity by half

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.Color

Example for the transparentize method, decreasing the opacity of a red color by half.

```rust
let red = Color::from_argb_f32(1.0, 1.0, 0.0, 0.0);
assert_eq!(red.transparentize(0.5), Color::from_argb_f32(0.5, 1.0, 0.0, 0.0));
```

--------------------------------

### starts_with examples

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Shows starts_with with &str and with a slice of chars. The char slice is only checked against the first character, so the second example's both assertions succeed.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Timer::single_shot example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.Timer

Example showing how to create a one-shot timer that prints a message after 200ms using Timer::single_shot.

```rust
use slint::Timer;
Timer::single_shot(std::time::Duration::from_millis(200), move || {
   println!("This will be printed after 200ms.");
});
```

--------------------------------

### KeyReleased example

Source: https://docs.slint.dev/latest/docs/rust/slint/platform/enum.WindowEvent

Example for the KeyReleased variant, showing how to map a specific key to a unicode representation using the Key enum.

```rust
let _ = slint::platform::WindowEvent::KeyReleased { text: slint::platform::Key::Shift.into() };
```

--------------------------------

### chunk_by example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Shows how to use chunk_by to split a slice into non-overlapping runs based on a predicate. The example uses equality to group equal elements.

```rust
let slice = &[1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.chunk_by(|a, b| a == b);

assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
assert_eq!(iter.next(), Some(&[3, 3][..]));
assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
assert_eq!(iter.next(), None);
```

--------------------------------

### find complex patterns example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Shows how to use find with more complex patterns: function pointers like char::is_whitespace and closures. The closure examples combine conditions.

```rust
let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(char::is_whitespace), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));
assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
```

--------------------------------

### WGPUConfiguration::Manual

Source: https://docs.slint.dev/latest/docs/rust/slint/wgpu_29/enum.WGPUConfiguration

Use Manual if you have initialized WGPU and want to supply the instance, adapter, device, and queue for use.

```APIDOC
## WGPUConfiguration::Manual

### Description
Use `Manual` if you've initialized WGPU and want to supply the instance, adapter, device, and queue for use.

### Variant
`Manual`

### Fields
- **instance** (`Instance`) - The WGPU instance to use.
- **adapter** (`Adapter`) - The WGPU adapter to use.
- **device** (`Device`) - The WGPU device to use.
- **queue** (`Queue`) - The WGPU queue to use.

### Example
```rust
let config = WGPUConfiguration::Manual {
    instance,
    adapter,
    device,
    queue,
};
```
```

--------------------------------

### element_offset basic example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Basic usage of `element_offset` to get the index of an element reference. Returns `Some(index)` when the reference points to the start of an element.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

--------------------------------

### Using match_indices to get match indices

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedString

Example for the `match_indices` method, which returns an iterator over disjoint matches along with the starting index. For overlapping matches, only the first match's index is returned.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### get() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns a reference to an element or subslice depending on the type of index. Example shows getting an element by position and a subslice by range, and None for out-of-bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### split separators at start or end example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Shows that separators at the start or end of a string are neighbored by empty strings. The string starts and ends with '0'.

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

--------------------------------

### Create Window from custom WindowAdapter

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.Window

Example for creating a Window from a custom WindowAdapter. Use this when implementing a custom backend with Platform::create_window_adapter. The window adapter must own the Window, so this uses Rc::new_cyclic.

```rust
use std::rc::Rc;
use slint::platform::{WindowAdapter, Renderer};
use slint::{Window, PhysicalSize};
struct MyWindowAdapter {
    window: Window,
    //...
}
impl WindowAdapter for MyWindowAdapter {
   fn window(&self) -> &Window { &self.window }
   fn size(&self) -> PhysicalSize { unimplemented!() }
   fn renderer(&self) -> &dyn Renderer { unimplemented!() }
}

fn create_window_adapter() -> Rc<dyn WindowAdapter> {
   Rc::<MyWindowAdapter>::new_cyclic(|weak| {
       MyWindowAdapter {
          window: Window::new(weak.clone()),
          //...
       }
   })
}
```

--------------------------------

### substr_range example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Uses substr_range with split to get the byte ranges of each substring.

```rust
use core::range::Range;

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(Range { start: 0, end: 1 }));
assert_eq!(iter.next(), Some(Range { start: 3, end: 4 }));
assert_eq!(iter.next(), Some(Range { start: 6, end: 7 }));
assert_eq!(iter.next(), Some(Range { start: 9, end: 10 }));
```

--------------------------------

### get_unchecked() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns a reference to an element or subslice without bounds checking. Unsafe; calling with an out-of-bounds index is undefined behavior. Example shows getting an element at index 1.

```rust
let x = &[1, 2, 4];

unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}
```

--------------------------------

### windows examples

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Examples for the `windows` method. The first shows overlapping windows of size 3, the second shows that a slice shorter than the window size yields no values, and the third demonstrates using `Cell::as_slice_of_cells` to mutate elements through windows.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

```rust
use std::cell::Cell;

let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
let slice = &mut array[..];
let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
for w in slice_of_cells.windows(3) {
    Cell::swap(&w[0], &w[2]);
}
assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);
```

--------------------------------

### Main file include_modules and HelloWorld

Source: https://docs.slint.dev/latest/docs/rust/slint_build

In the main file, use slint::include_modules!() to include the generated code, then instantiate and run the HelloWorld component.

```rust
slint::include_modules!();
fn main() {
    HelloWorld::new().run();
}

```

--------------------------------

### Get global property example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/api/struct.ComponentInstance.html

Shows how to retrieve a property from an exported global singleton using get_global_property. The example defines a global Glob with property my_property, exports it as TheGlobal, and then retrieves the value from the component instance.

```rust
use slint_interpreter::{Compiler, Value, SharedString};
let code = r#"
    global Glob {
        in-out property <int> my_property: 42;
    }
    export { Glob as TheGlobal }
    export component MyWin inherits Window {
    }
"#;
let mut compiler = Compiler::default();
let result = spin_on::spin_on(compiler.build_from_source(code.into(), Default::default()));
assert_eq!(result.diagnostics().count(), 0, "{:?}", result.diagnostics().collect::<Vec<_>>());
let instance = result.component("MyWin").unwrap().create().unwrap();
assert_eq!(instance.get_global_property("TheGlobal", "my_property").unwrap(), Value::from(42));
```

--------------------------------

### WGPUSettings

Source: https://docs.slint.dev/latest/docs/rust/slint/wgpu_30/index.html

This data structure provides settings for initializing WGPU renderers.

```APIDOC
## WGPUSettings

### Description
This data structure provides settings for initializing WGPU renderers.

### Fields
- **No fields documented** - The source does not list specific fields.
```

--------------------------------

### strip_prefix example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates the strip_prefix method on slices. It returns Some with the subslice after the prefix if the slice starts with the prefix, or None otherwise. The example includes cases with empty prefix, full match, and a string prefix converted to bytes.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### init_with_event_listener

Source: https://docs.slint.dev/latest/docs/rust/slint/android/fn.init_with_event_listener

Documentation for the `init_with_event_listener` function, including its signature, parameters, return type, availability, and an example.

```APIDOC
## init_with_event_listener

### Description
Initializes the Slint platform for Android, similar to `init()`, but also allows listening to android-activity's events. The listener is called with a `android_activity::PollEvent` for each event.

### Function Signature
```rust
pub fn init_with_event_listener(
    app: AndroidApp,
    listener: impl Fn(&PollEvent<'_>) + 'static,
) -> Result<(), SetPlatformError>
```

### Parameters
- **app** (AndroidApp) - Required - The Android application handle.
- **listener** (impl Fn(&PollEvent<'_>) + 'static) - Required - A closure that receives a reference to a `android_activity::PollEvent` for each event.

### Return Value
- **Result<(), SetPlatformError>** - Returns `Ok(())` on success, or a `SetPlatformError` on failure.

### Availability
- **Platform**: Android only
- **Crate features**: `backend-android-activity-05` or `backend-android-activity-06`

### Example
```rust
#[unsafe(no_mangle)]
fn android_main(app: slint::android_activity::AndroidApp) {
    slint::android::init_with_event_listener(
       app,
       |event| { eprintln!("got event {event:?}") }
    ).unwrap();

    // ... rest of your application ...
}
```
```

--------------------------------

### strip_circumfix example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates the strip_circumfix method on slices. It returns Some with the subslice after the prefix and before the suffix if the slice starts with the prefix, ends with the suffix, and they do not overlap; otherwise returns None. The example includes cases with empty prefix/suffix and overlapping prefix/suffix.

```rust
let v = &[10, 50, 40, 30];
assert_eq!(v.strip_circumfix(&[10], &[30]), Some(&[50, 40][..]));
assert_eq!(v.strip_circumfix(&[10], &[40, 30]), Some(&[50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[40, 30]), Some(&[][..]));
assert_eq!(v.strip_circumfix(&[50], &[30]), None);
assert_eq!(v.strip_circumfix(&[10], &[40]), None);
assert_eq!(v.strip_circumfix(&[], &[40, 30]), Some(&[10, 50][..]));
assert_eq!(v.strip_circumfix(&[10, 50], &[]), Some(&[40, 30][..]));
assert_eq!(v.strip_circumfix(&[10, 50, 40], &[50, 40, 30]), None);
```

--------------------------------

### WGPUSettings

Source: https://docs.slint.dev/latest/docs/rust/slint/wgpu_30

Data structure providing settings for initializing WGPU renderers.

```APIDOC
## WGPUSettings

### Description
Data structure providing settings for initializing WGPU renderers.

### Fields
- **required_features** (wgpu::Features) - Required features for the WGPU device.
- **required_limits** (wgpu::Limits) - Required limits for the WGPU device.

### Usage
Pass this structure to `slint::BackendSelector::require_wgpu_30()` to configure WGPU initialization.
```

--------------------------------

### split simple patterns example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Shows how to use split with simple patterns: char, string slice, and function pointers. Demonstrates behavior with empty strings and multiple separators.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

--------------------------------

### trim_prefix example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates the trim_prefix method on slices. It returns the subslice after the prefix if the slice starts with the prefix, otherwise returns the original slice. The example includes cases with prefix present, prefix absent, and a string prefix converted to bytes.

```rust
let v = &[10, 40, 30];

// Prefix present - removes it
assert_eq!(v.trim_prefix(&[10]), &[40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 40]), &[30][..]);
assert_eq!(v.trim_prefix(&[10, 40, 30]), &[][..]);

// Prefix absent - returns original slice
assert_eq!(v.trim_prefix(&[50]), &[10, 40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 50]), &[10, 40, 30][..]);

let prefix : &str = "he";
assert_eq!(b"hello".trim_prefix(prefix.as_bytes()), b"llo".as_ref());
```

--------------------------------

### init

Source: https://docs.slint.dev/latest/docs/rust/slint/android/fn.init

Initializes the Android backend for Slint. Must be called from the `android_main` function before any Slint calls that require a backend.

```APIDOC
## init

### Description
Initializes the Android backend for Slint. This function must be called from the `android_main` function before any call to Slint that needs a backend.

### Function Signature
`pub fn init(app: AndroidApp) -> Result<(), SetPlatformError>`

### Parameters
- **app** (AndroidApp) - Required - The Android application handle.

### Return Value
- `Result<(), SetPlatformError>` - Returns `Ok(())` on success, or a `SetPlatformError` on failure.

### Availability
- **Platform**: Android
- **Crate features**: `backend-android-activity-05` or `backend-android-activity-06`

### Notes
- This function is only available on Android with the `backend-android-activity-06` feature.
- Must be called from the `android_main` function before any call to Slint that needs a backend.
- See the module documentation for an example on how to create an Android application.
- See also `init_with_event_listener`.
```

--------------------------------

### match_indices examples

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Returns an iterator over matches along with the starting index of each match. Shows the indices for non-overlapping matches of a string literal.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);
```

--------------------------------

### starts_with: Check if slice starts with a prefix

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedVector

Returns true if the given slice is a prefix of the slice or equal to it. This example checks various prefixes and non-prefixes.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

```

--------------------------------

### new

Source: https://docs.slint.dev/latest/docs/rust/slint/platform/femtovg_renderer/struct.FemtoVGWGPURenderer

Creates a new FemtoVGWGPURenderer with the given WGPU instance, device, and queue.

```APIDOC
## new

### Description
Creates a new FemtoVGWGPURenderer. The `instance`, `device` and `queue` are the WGPU resources used for rendering. These are also provided to `Window::set_rendering_notifier()` callbacks via `GraphicsAPI::WGPU30`.

### Method
Constructor

### Signature
`pub fn new(instance: Instance, device: Device, queue: Queue) -> Result<FemtoVGWGPURenderer, PlatformError>`

### Parameters
- **instance** (Instance) - Required - The WGPU instance used for rendering.
- **device** (Device) - Required - The WGPU device used for rendering.
- **queue** (Queue) - Required - The WGPU queue used for rendering.

### Returns
- **Result<FemtoVGWGPURenderer, PlatformError>** - A new FemtoVGWGPURenderer instance, or a PlatformError if creation fails.
```

--------------------------------

### as_ptr example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedVector

Shows how to use as_ptr to get a raw pointer to the slice's buffer and access elements safely inside an unsafe block.

```rust
let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
    }
}

```

--------------------------------

### init

Source: https://docs.slint.dev/latest/docs/rust/slint/android

Initializes the Android backend. This function must be called from the `android_main` entry point before using any Slint functionality.

```APIDOC
## [Function] init

### Description
Initializes the Android backend. This function must be called from the `android_main` entry point before using any Slint functionality.

### Signature
`pub fn init(app: AndroidApp) -> Result<(), PlatformError>`

### Parameters
- **app** (AndroidApp) - Required - The Android application handle passed to the `android_main` function.

### Return Value
- `Result<(), PlatformError>` - Returns `Ok(())` on success, or an error if initialization fails.

### Example
```rust
#[unsafe(no_mangle)]
fn android_main(app: slint::android::AndroidApp) {
    slint::android::init(app).unwrap();
    // ... rest of your code ...
}
```
```

--------------------------------

### trim_start directionality example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Shows the directionality of `trim_start`: it removes leading whitespace from the start of the byte string, which for right-to-left languages like Hebrew is the right side.

```rust
let s = "  English  ";
assert!(Some('E') == s.trim_start().chars().next());

let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### element_offset unaligned example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Shows `element_offset` returning `None` when the reference does not point to the start of an element. Uses `as_flattened` to create a flat slice and then constructs references that may be unaligned.

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

--------------------------------

### starts_with

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Documentation for the starts_with method on string slices.

```APIDOC
## starts_with

### Description
Returns `true` if the given pattern matches a prefix of this string slice. Returns `false` if it does not. The pattern can be a `&str`, `char`, a slice of `char`s, or a function or closure that determines if a character matches.

### Method
pub fn starts_with<P>(&self, pat: P) -> bool where P: Pattern

### Parameters
- **self** (&str) - Required - The string slice to check.
- **pat** (P) - Required - The pattern to match against the prefix. Can be a `&str`, `char`, a slice of `char`s, or a closure.

### Returns
- **bool** - `true` if the pattern matches a prefix, `false` otherwise.

### Examples
```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```
```

--------------------------------

### Using rsplit on a slice

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates the `rsplit` method, which returns an iterator over subslices separated by elements matching the predicate, starting from the end of the slice and working backwards. The matched element is not included in the subslices. The example splits `[11, 22, 33, 0, 44, 55]` on the element `0`.

```rust
let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);
```

--------------------------------

### Basic Android application example

Source: https://docs.slint.dev/latest/docs/rust/slint/android/index.html

A minimal Slint Android app that initializes the backend and runs a window with a text label. The `android_main` function must be marked with `#[unsafe(no_mangle)]`.

```rust
#[unsafe(no_mangle)]
fn android_main(app: slint::android::AndroidApp) {
    slint::android::init(app).unwrap();

    // ... rest of your code ...
    slint::slint!{
        export component MainWindow inherits Window {
            Text { text: "Hello World"; }
        }
    }
    MainWindow::new().unwrap().run().unwrap();
}
```

--------------------------------

### word_to_titlecase example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Example for the `word_to_titlecase` method, showing the expected output for a Greek phrase.

```rust
assert_eq!("Ο οδυσσέας βασιλιάς της ιθάκης", odysseus_king_of_ithaca.word_to_titlecase());
```

--------------------------------

### MinimalSoftwareWindow::new

Source: https://docs.slint.dev/latest/docs/rust/slint/platform/software_renderer/struct.MinimalSoftwareWindow

Instantiates a new MinimalSoftwareWindow with the specified repaint buffer type.

```APIDOC
## MinimalSoftwareWindow::new

### Description
Instantiate a new MinimalWindowAdaptor. The `repaint_buffer_type` parameter specifies what kind of buffer is passed to the `SoftwareRenderer`.

### Method
`pub fn new(repaint_buffer_type: RepaintBufferType) -> Rc<MinimalSoftwareWindow>`

### Parameters
- **repaint_buffer_type** (RepaintBufferType) - Required - Specifies the kind of buffer passed to the SoftwareRenderer.

### Returns
- `Rc<MinimalSoftwareWindow>` - A reference-counted handle to the new window.
```

--------------------------------

### Set callback example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/api/struct.ComponentInstance.html

Shows how to set a callback handler using set_callback. The example defines a callback foo(int) -> int and a property my_prop, then sets a handler that adds the argument to the property value. It uses as_weak to avoid a strong reference cycle, and invokes the callback to verify the result.

```rust
use slint_interpreter::{Compiler, Value, SharedString, ComponentHandle};
use core::convert::TryInto;
let code = r#"
    export component MyWin inherits Window {
        callback foo(int) -> int;
        in-out property <int> my_prop: 12;
    }
"#;
let result = spin_on::spin_on(
    Compiler::default().build_from_source(code.into(), Default::default()));
assert_eq!(result.diagnostics().count(), 0, "{:?}", result.diagnostics().collect::<Vec<_>>());
let instance = result.component("MyWin").unwrap().create().unwrap();
let instance_weak = instance.as_weak();
instance.set_callback("foo", move |args: &[Value]| -> Value {
    let arg: u32 = args[0].clone().try_into().unwrap();
    let my_prop = instance_weak.unwrap().get_property("my_prop").unwrap();
    let my_prop : u32 = my_prop.try_into().unwrap();
    Value::from(arg + my_prop)
}).unwrap();

let res = instance.invoke("foo", &[Value::from(500)]).unwrap();
assert_eq!(res, Value::from(500+12));
```

--------------------------------

### iter example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedVector

Shows how to iterate over a slice with iter and check each element.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);

```

--------------------------------

### to_ascii_lowercase example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Example of `to_ascii_lowercase` mapping ASCII letters to lowercase while leaving non-ASCII letters unchanged.

```rust
let s = "Grüße, Jürgen ❤";

assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
```

--------------------------------

### to_ascii_uppercase example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedString

Example of `to_ascii_uppercase` mapping ASCII letters to uppercase while leaving non-ASCII letters unchanged.

```rust
let s = "Grüße, Jürgen ❤";

assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
```

--------------------------------

### split_last() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns the last and all the rest of the elements of the slice, or None if it is empty. Example shows destructuring the result.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

--------------------------------

### split_first() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns the first and all the rest of the elements of the slice, or None if it is empty. Example shows destructuring the result.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

--------------------------------

### is_empty() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns true if the slice has a length of 0. Example shows a non-empty slice and an empty slice.

```rust
let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());
```

--------------------------------

### binary_search example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates binary_search on a sorted slice. Shows Ok for found, Err with insertion index for not found, and that multiple matches may return any index in the range.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### binary_search_by_key example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Demonstrates binary_search_by_key on a slice of pairs sorted by their second elements. Shows Ok with a unique index, Err with insertion points, and a range match for multiple matches.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### iter example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Example for the `iter` method. It creates an iterator over a slice and asserts that it yields each element in order and then returns `None`.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

--------------------------------

### windows example

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedVector

Shows windows iterating over overlapping windows of length 3.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());

```

--------------------------------

### last() example

Source: https://docs.slint.dev/latest/docs/rust/slint/struct.SharedVector

Returns the last element of the slice, or None if it is empty. Example shows a non-empty slice and an empty slice.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Compiler

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter

This is the entry point of the crate, it can be used to load a `.slint` file and compile it into a `CompilationResult`.

```APIDOC
## [Struct] Compiler

### Description
This is the entry point of the crate, it can be used to load a `.slint` file and compile it into a `CompilationResult`.

### Type
Struct

### Usage
Create a Compiler instance, load a `.slint` file, and compile it to obtain a CompilationResult.
```

--------------------------------

### windows example when slice is shorter than size

Source: https://docs.slint.dev/latest/docs/rust/slint_interpreter/struct.SharedVector

Shows windows returning no values when the slice is shorter than the window size.

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());

```
Tokens:
Raw