Struct slint::docs::generated_code::SampleComponent

pub struct SampleComponent {}

This an example of the API that is generated for a component in .slint design markup. This may help you understand what functions you can call and how you can pass data in and out.

This is the source code:

export component SampleComponent inherits Window {
    in-out property<int> counter;
    // note that dashes will be replaced by underscores in the generated code
    in-out property<string> user-name;
    callback hello;
    public function do-something(x: int) -> bool { return x > 0; }
    // ... maybe more elements here
}

Implementations

impl SampleComponent

pub fn new() -> Result<Self, PlatformError>

Creates a new instance that is reference counted and pinned in memory.

pub fn get_counter(&self) -> i32

A getter is generated for each property declared at the root of the component. In this case, this is the getter that returns the value of the counter property declared in the .slint design markup.

pub fn set_counter(&self, value: i32)

A setter is generated for each property declared at the root of the component, In this case, this is the setter that sets the value of the counter property declared in the .slint design markup.

pub fn get_user_name(&self) -> SharedString

Returns the value of the user_name property declared in the .slint design markup.

pub fn set_user_name(&self, value: SharedString)

Assigns a new value to the user_name property.

pub fn invoke_hello(&self)

For each callback declared at the root of the component, a function to call that callback is generated. This is the function that calls the hello callback declared in the .slint design markup.

pub fn on_hello(&self, f: impl Fn() + 'static)

For each callback declared at the root of the component, a function connect to that callback is generated. This is the function that registers the function f as callback when the callback hello is emitted. In order to access the component in the callback, you’d typically capture a weak reference obtained using ComponentHandle::as_weak and then upgrade it to a strong reference when the callback is run:

    let sample = SampleComponent::new().unwrap();
    let sample_weak = sample.as_weak();
    sample.as_ref().on_hello(move || {
        let sample = sample_weak.unwrap();
        sample.as_ref().set_counter(42);
    });

pub fn invoke_do_something(&self, d: i32) -> bool

For each public function declared at the root of the component, a function to call that function is generated. This is the function that calls the do-something function declared in the .slint design markup.

Trait Implementations

impl Clone for SampleComponent

fn clone(&self) -> SampleComponent

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ComponentHandle for SampleComponent

fn as_weak(&self) -> Weak<Self>

Returns a new weak pointer.

fn clone_strong(&self) -> Self

Returns a clone of this handle that’s a strong reference.

fn show(&self) -> Result<(), PlatformError>

Convenience function for crate::Window::show(). This shows the window on the screen and maintains an extra strong reference while the window is visible. To react to events from the windowing system, such as draw requests or mouse/touch input, it is still necessary to spin the event loop, using crate::run_event_loop.

fn hide(&self) -> Result<(), PlatformError>

Convenience function for crate::Window::hide(). Hides the window, so that it is not visible anymore. The additional strong reference on the associated component, that was created when show() was called, is dropped.

fn window(&self) -> &Window

Returns the Window associated with this component. The window API can be used to control different aspects of the integration into the windowing system, such as the position on the screen.

fn run(&self) -> Result<(), PlatformError>

This is a convenience function that first calls Self::show, followed by crate::run_event_loop() and Self::hide.

fn global<'a, T: Global<'a, Self>>(&'a self) -> T

This function provides access to instances of global singletons exported in .slint.