Struct slint_interpreter::ComponentInstance

#[repr(C)]
pub struct ComponentInstance { /* private fields */ }

This represent an instance of a dynamic component

You can create an instance with the ComponentDefinition::create function.

Properties and callback can be accessed using the associated functions.

An instance can be put on screen with the ComponentInstance::run function.

Implementations

impl ComponentInstance

pub fn definition(&self) -> ComponentDefinition

Return the ComponentDefinition that was used to create this instance.

pub fn get_property(&self, name: &str) -> Result<Value, GetPropertyError>

Return the value for a public property of this component.

Examples

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));

pub fn set_property( &self, name: &str, value: Value, ) -> Result<(), SetPropertyError>

Set the value for a public property of this component.

pub fn set_callback( &self, name: &str, callback: impl Fn(&[Value]) -> Value + 'static, ) -> Result<(), SetCallbackError>

Set a handler for the callback with the given name. A callback with that name must be defined in the document otherwise an error will be returned.

Note: Since the ComponentInstance holds the handler, the handler itself should not contain a strong reference to the instance. So if you need to capture the instance, you should use Self::as_weak to create a weak reference.

Examples

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));

pub fn invoke(&self, name: &str, args: &[Value]) -> Result<Value, InvokeError>

Call the given callback or function with the arguments

Examples

See the documentation of Self::set_callback for an example

pub fn get_global_property( &self, global: &str, property: &str, ) -> Result<Value, GetPropertyError>

Return the value for a property within an exported global singleton used by this component.

The global parameter is the exported name of the global singleton. The property argument is the name of the property

Examples

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));

pub fn set_global_property( &self, global: &str, property: &str, value: Value, ) -> Result<(), SetPropertyError>

Set the value for a property within an exported global singleton used by this component.

pub fn set_global_callback( &self, global: &str, name: &str, callback: impl Fn(&[Value]) -> Value + 'static, ) -> Result<(), SetCallbackError>

Set a handler for the callback in the exported global singleton. A callback with that name must be defined in the specified global and the global must be exported from the main document otherwise an error will be returned.

Examples

use slint_interpreter::{Compiler, Value, SharedString};
use core::convert::TryInto;
let code = r#"
    export global Logic {
        pure callback to_uppercase(string) -> string;
    }
    export component MyWin inherits Window {
        out property <string> hello: Logic.to_uppercase("world");
    }
"#;
let result = spin_on::spin_on(
    Compiler::default().build_from_source(code.into(), Default::default()));
let instance = result.component("MyWin").unwrap().create().unwrap();
instance.set_global_callback("Logic", "to_uppercase", |args: &[Value]| -> Value {
    let arg: SharedString = args[0].clone().try_into().unwrap();
    Value::from(SharedString::from(arg.to_uppercase()))
}).unwrap();

let res = instance.get_property("hello").unwrap();
assert_eq!(res, Value::from(SharedString::from("WORLD")));

let abc = instance.invoke_global("Logic", "to_uppercase", &[
    SharedString::from("abc").into()
]).unwrap();
assert_eq!(abc, Value::from(SharedString::from("ABC")));

pub fn invoke_global( &self, global: &str, callable_name: &str, args: &[Value], ) -> Result<Value, InvokeError>

Call the given callback or function within a global singleton with the arguments

Examples

See the documentation of Self::set_global_callback for an example

pub fn component_positions(&self, path: &Path, offset: u32) -> Vec<LogicalRect>

Find all positions of the components which are pointed by a given source location.

WARNING: this is not part of the public API

pub fn element_positions(&self, element: &ElementRc) -> Vec<LogicalRect>

Find the position of the element.

WARNING: this is not part of the public API

pub fn element_node_at_source_code_position( &self, path: &Path, offset: u32, ) -> Vec<(ElementRc, usize)>

Find the the element that was defined at the text position.

WARNING: this is not part of the public API

Trait Implementations

impl ComponentHandle for ComponentInstance

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

where Self: Sized,

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 run(&self) -> Result<(), PlatformError>

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

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 global<'a, T: Global<'a, Self>>(&'a self) -> T

where Self: Sized,

This function provides access to instances of global singletons exported in .slint. See Global for an example how to export and access globals from .slint markup.

impl From<ComponentInstance> for VRc<ItemTreeVTable, ErasedItemTreeBox>

fn from(value: ComponentInstance) -> Self

Converts to this type from the input type.