Struct slint_interpreter::ComponentCompiler

pub struct ComponentCompiler { /* private fields */ }

ComponentCompiler is the entry point to the Slint interpreter that can be used to load .slint files or compile them on-the-fly from a string.

Implementations

impl ComponentCompiler

pub fn new() -> Self

Returns a new ComponentCompiler.

pub fn set_include_paths(&mut self, include_paths: Vec<PathBuf>)

Sets the include paths used for looking up .slint imports to the specified vector of paths.

pub fn include_paths(&self) -> &Vec<PathBuf>

Returns the include paths the component compiler is currently configured with.

pub fn set_library_paths(&mut self, library_paths: HashMap<String, PathBuf>)

Sets the library paths used for looking up @library imports to the specified map of library names to paths.

pub fn library_paths(&self) -> &HashMap<String, PathBuf>

Returns the library paths the component compiler is currently configured with.

pub fn set_style(&mut self, style: String)

Sets the style to be used for widgets.

Use the “material” style as widget style when compiling:

use slint_interpreter::{ComponentDefinition, ComponentCompiler, ComponentHandle};

let mut compiler = ComponentCompiler::default();
compiler.set_style("material".into());
let definition =
    spin_on::spin_on(compiler.build_from_path("hello.slint"));

pub fn style(&self) -> Option<&String>

Returns the widget style the compiler is currently using when compiling .slint files.

pub fn set_translation_domain(&mut self, domain: String)

The domain used for translations

pub fn set_file_loader( &mut self, file_loader_fallback: impl Fn(&Path) -> Pin<Box<dyn Future<Output = Option<Result<String>>>>> + 'static )

Sets the callback that will be invoked when loading imported .slint files. The specified file_loader_callback parameter will be called with a canonical file path as argument and is expected to return a future that, when resolved, provides the source code of the .slint file to be imported as a string. If an error is returned, then the build will abort with that error. If None is returned, it means the normal resolution algorithm will proceed as if the hook was not in place (i.e: load from the file system following the include paths)

pub fn diagnostics(&self) -> &Vec<Diagnostic>

Returns the diagnostics that were produced in the last call to Self::build_from_path or Self::build_from_source.

pub async fn build_from_path<P: AsRef<Path>>( &mut self, path: P ) -> Option<ComponentDefinition>

Compile a .slint file into a ComponentDefinition

Returns the compiled ComponentDefinition if there were no errors.

Any diagnostics produced during the compilation, such as warnings or errors, are collected in this ComponentCompiler and can be retrieved after the call using the Self::diagnostics() function. The print_diagnostics function can be used to display the diagnostics to the users.

Diagnostics from previous calls are cleared when calling this function.

If the path is "-", the file will be read from stdin. If the extension of the file .rs, the first slint! macro from a rust file will be extracted

This function is async but in practice, this is only asynchronous if Self::set_file_loader was called and its future is actually asynchronous. If that is not used, then it is fine to use a very simple executor, such as the one provided by the spin_on crate

pub async fn build_from_source( &mut self, source_code: String, path: PathBuf ) -> Option<ComponentDefinition>

Compile some .slint code into a ComponentDefinition

The path argument will be used for diagnostics and to compute relative paths while importing.

Any diagnostics produced during the compilation, such as warnings or errors, are collected in this ComponentCompiler and can be retrieved after the call using the Self::diagnostics() function. The print_diagnostics function can be used to display the diagnostics to the users.

Diagnostics from previous calls are cleared when calling this function.

This function is async but in practice, this is only asynchronous if Self::set_file_loader is set and its future is actually asynchronous. If that is not used, then it is fine to use a very simple executor, such as the one provided by the spin_on crate

Trait Implementations

impl Default for ComponentCompiler

fn default() -> Self

Returns the “default value” for a type.