Struct slint_interpreter::Compiler

pub struct Compiler { /* private fields */ }

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

Implementations

impl Compiler

pub fn new() -> Self

Returns a new Compiler.

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, Compiler, ComponentHandle};

let mut compiler = Compiler::default();
compiler.set_style("material".into());
let result = 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 async fn build_from_path<P: AsRef<Path>>( &self, path: P, ) -> CompilationResult

Compile a .slint file

Returns a structure that holds the diagnostics and the compiled components.

Any diagnostics produced during the compilation, such as warnings or errors, can be retrieved after the call using CompilationResult::diagnostics().

If the file was compiled without error, the list of component names can be obtained with CompilationResult::component_names, and the compiled components themselves with CompilationResult::component().

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( &self, source_code: String, path: PathBuf, ) -> CompilationResult

Compile some .slint code

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, can be retrieved after the call using CompilationResult::diagnostics().

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 Compiler

fn default() -> Self

Returns the “default value” for a type.