pub struct ComponentInstance { /* private fields */ }
Expand description

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ยง

sourceยง

impl ComponentInstance

source

pub fn definition(&self) -> ComponentDefinition

Return the ComponentDefinition that was used to create this instance.

source

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, ComponentCompiler, Value, SharedString};
let code = r#"
    export component MyWin inherits Window {
        in-out property <int> my_property: 42;
    }
"#;
let mut compiler = ComponentCompiler::default();
let definition = spin_on::spin_on(
    compiler.build_from_source(code.into(), Default::default()));
assert!(compiler.diagnostics().is_empty(), "{:?}", compiler.diagnostics());
let instance = definition.unwrap().create().unwrap();
assert_eq!(instance.get_property("my_property").unwrap(), Value::from(42));
source

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

Set the value for a public property of this component.

source

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::{ComponentDefinition, ComponentCompiler, Value, SharedString, ComponentHandle};
use core::convert::TryInto;
let code = r#"
    component MyWin inherits Window {
        callback foo(int) -> int;
        in-out property <int> my_prop: 12;
    }
"#;
let definition = spin_on::spin_on(
    ComponentCompiler::default().build_from_source(code.into(), Default::default()));
let instance = definition.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));
source

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

source

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::{ComponentDefinition, ComponentCompiler, Value, SharedString};
let code = r#"
    global Glob {
        in-out property <int> my_property: 42;
    }
    export { Glob as TheGlobal }
    component MyWin inherits Window {
    }
"#;
let mut compiler = ComponentCompiler::default();
let definition = spin_on::spin_on(
    compiler.build_from_source(code.into(), Default::default()));
assert!(compiler.diagnostics().is_empty(), "{:?}", compiler.diagnostics());
let instance = definition.unwrap().create().unwrap();
assert_eq!(instance.get_global_property("TheGlobal", "my_property").unwrap(), Value::from(42));
source

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.

source

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::{ComponentDefinition, ComponentCompiler, Value, SharedString};
use core::convert::TryInto;
let code = r#"
    export global Logic {
        pure callback to_uppercase(string) -> string;
    }
    component MyWin inherits Window {
        out property <string> hello: Logic.to_uppercase("world");
    }
"#;
let definition = spin_on::spin_on(
    ComponentCompiler::default().build_from_source(code.into(), Default::default()));
let instance = definition.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")));
source

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

source

pub fn highlight(&self, path: PathBuf, offset: u32)

Highlight the elements which are pointed by a given source location.

WARNING: this is not part of the public API

source

pub fn set_design_mode(&self, active: bool)

Request information on clicked object

WARNING: this is not part of the public API

source

pub fn on_element_selected( &self, callback: Box<dyn Fn(&str, u32, u32, u32, u32)> )

Register callback to handle current item information

The callback will be called with the file name, the start line and column followed by the end line and column.

WARNING: this is not part of the public API

Trait Implementationsยง

sourceยง

impl ComponentHandle for ComponentInstance

sourceยง

fn as_weak(&self) -> Weak<Self>where Self: Sized,

Returns a new weak pointer.
sourceยง

fn clone_strong(&self) -> Self

Returns a clone of this handle thatโ€™s a strong reference.
sourceยง

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.
sourceยง

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.
sourceยง

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

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

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.
sourceยง

fn global<'a, T: Global<'a, Self>>(&'a self) -> Twhere 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.
sourceยง

impl From<ComponentInstance> for VRc<ComponentVTable, ErasedComponentBox>

sourceยง

fn from(value: ComponentInstance) -> Self

Converts to this type from the input type.

Auto Trait Implementationsยง

Blanket Implementationsยง

sourceยง

impl<T> Any for Twhere T: 'static + ?Sized,

sourceยง

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
sourceยง

impl<T> Borrow<T> for Twhere T: ?Sized,

sourceยง

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
sourceยง

impl<T> BorrowMut<T> for Twhere T: ?Sized,

sourceยง

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
ยง

impl<T> Downcast for Twhere T: Any,

ยง

fn into_any(self: Box<T, Global>) -> Box<dyn Any, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
ยง

fn into_any_rc(self: Rc<T, Global>) -> Rc<dyn Any, Global>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
ยง

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Anyโ€™s vtable from &Traitโ€™s.
ยง

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Anyโ€™s vtable from &mut Traitโ€™s.
sourceยง

impl<T> From<T> for T

sourceยง

fn from(t: T) -> T

Returns the argument unchanged.

sourceยง

impl<T> Instrument for T

sourceยง

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
sourceยง

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
sourceยง

impl<T, U> Into<U> for Twhere U: From<T>,

sourceยง

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

ยง

impl<T> Pointable for T

ยง

const ALIGN: usize = _

The alignment of pointer.
ยง

type Init = T

The type for initializers.
ยง

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
ยง

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
ยง

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
ยง

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
sourceยง

impl<T> Same<T> for T

ยง

type Output = T

Should always be Self
sourceยง

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

ยง

type Error = Infallible

The type returned in the event of a conversion error.
sourceยง

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
sourceยง

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

ยง

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
sourceยง

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
ยง

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

ยง

fn vzip(self) -> V

sourceยง

impl<T> WithSubscriber for T

sourceยง

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
sourceยง

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more