mirror of
https://github.com/slint-ui/slint.git
synced 2025-09-29 13:24:48 +00:00
8361ef4019
This is only meant to include the cases in which the property are optimized. Does not work yet for the dynamic component
1431 lines
59 KiB
Rust
1431 lines
59 KiB
Rust
/* LICENSE BEGIN
|
|
This file is part of the SixtyFPS Project -- https://sixtyfps.io
|
|
Copyright (c) 2020 Olivier Goffart <olivier.goffart@sixtyfps.io>
|
|
Copyright (c) 2020 Simon Hausmann <simon.hausmann@sixtyfps.io>
|
|
|
|
SPDX-License-Identifier: GPL-3.0-only
|
|
This file is also available under commercial licensing terms.
|
|
Please contact info@sixtyfps.io for more information.
|
|
LICENSE END */
|
|
/*! module for the Rust code generator
|
|
*/
|
|
|
|
use crate::diagnostics::{BuildDiagnostics, CompilerDiagnostic, Level, Spanned};
|
|
use crate::expression_tree::{
|
|
BuiltinFunction, EasingCurve, Expression, NamedReference, OperatorClass, Path,
|
|
};
|
|
use crate::layout::{gen::LayoutItemCodeGen, Layout, LayoutElement};
|
|
use crate::object_tree::{Component, Document, ElementRc};
|
|
use crate::typeregister::Type;
|
|
use proc_macro2::{Ident, TokenStream};
|
|
use quote::{format_ident, quote};
|
|
use std::rc::Rc;
|
|
|
|
fn rust_type(
|
|
ty: &Type,
|
|
span: &crate::diagnostics::Span,
|
|
) -> Result<proc_macro2::TokenStream, CompilerDiagnostic> {
|
|
match ty {
|
|
Type::Int32 => Ok(quote!(i32)),
|
|
Type::Float32 => Ok(quote!(f32)),
|
|
Type::String => Ok(quote!(sixtyfps::re_exports::SharedString)),
|
|
Type::Color => Ok(quote!(sixtyfps::re_exports::Color)),
|
|
Type::Duration => Ok(quote!(i64)),
|
|
Type::Length => Ok(quote!(f32)),
|
|
Type::LogicalLength => Ok(quote!(f32)),
|
|
Type::Bool => Ok(quote!(bool)),
|
|
Type::Resource => Ok(quote!(sixtyfps::re_exports::Resource)),
|
|
Type::Object(o) => {
|
|
let elem = o.values().map(|v| rust_type(v, span)).collect::<Result<Vec<_>, _>>()?;
|
|
// This will produce a tuple
|
|
Ok(quote!((#(#elem,)*)))
|
|
}
|
|
Type::Array(o) => {
|
|
let inner = rust_type(&o, span)?;
|
|
Ok(quote!(sixtyfps::re_exports::ModelHandle<#inner>))
|
|
}
|
|
Type::Component(c) if c.root_element.borrow().base_type == Type::Void => {
|
|
let c = format_ident!("{}", c.id);
|
|
Ok(quote!(#c))
|
|
}
|
|
_ => Err(CompilerDiagnostic {
|
|
message: format!("Cannot map property type {} to Rust", ty),
|
|
span: span.clone(),
|
|
level: Level::Error,
|
|
}),
|
|
}
|
|
}
|
|
|
|
/// Generate the rust code for the given component.
|
|
///
|
|
/// Fill the diagnostic in case of error.
|
|
pub fn generate(doc: &Document, diag: &mut BuildDiagnostics) -> Option<TokenStream> {
|
|
let (structs_ids, structs): (Vec<_>, Vec<_>) = doc
|
|
.exports()
|
|
.iter()
|
|
.filter(|(_, component)| component.root_element.borrow().base_type == Type::Void)
|
|
.map(|(_, component)| (component_id(component), generate_struct(component, diag)))
|
|
.unzip();
|
|
let compo = generate_component(&doc.root_component, diag)?;
|
|
let compo_id = component_id(&doc.root_component);
|
|
let compo_module = format_ident!("sixtyfps_generated_{}", compo_id);
|
|
/*let (version_major, version_minor, version_patch): (usize, usize, usize) = (
|
|
env!("CARGO_PKG_VERSION_MAJOR").parse().unwrap(),
|
|
env!("CARGO_PKG_VERSION_MINOR").parse().unwrap(),
|
|
env!("CARGO_PKG_VERSION_PATCH").parse().unwrap(),
|
|
);*/
|
|
let version_check = format_ident!(
|
|
"VersionCheck_{}_{}_{}",
|
|
env!("CARGO_PKG_VERSION_MAJOR"),
|
|
env!("CARGO_PKG_VERSION_MINOR"),
|
|
env!("CARGO_PKG_VERSION_PATCH"),
|
|
);
|
|
Some(quote! {
|
|
#[allow(non_snake_case)]
|
|
mod #compo_module {
|
|
#(#structs)*
|
|
#compo
|
|
const _THE_SAME_VERSION_MUST_BE_USED_FOR_THE_COMPILER_AND_THE_RUNTIME : sixtyfps::#version_check = sixtyfps::#version_check;
|
|
}
|
|
pub use #compo_module::{#compo_id #(,#structs_ids)* };
|
|
})
|
|
}
|
|
|
|
fn generate_struct(component: &Rc<Component>, diag: &mut BuildDiagnostics) -> TokenStream {
|
|
let component_id = component_id(component);
|
|
debug_assert_eq!(component.root_element.borrow().base_type, Type::Void);
|
|
let (declared_property_vars, declared_property_types): (Vec<_>, Vec<_>) = component
|
|
.root_element
|
|
.borrow()
|
|
.property_declarations
|
|
.iter()
|
|
.map(|(name, decl)| {
|
|
(
|
|
format_ident!("{}", name),
|
|
rust_type(&decl.property_type, &decl.type_node.span()).unwrap_or_else(|err| {
|
|
diag.push_internal_error(err.into());
|
|
quote!(())
|
|
}),
|
|
)
|
|
})
|
|
.unzip();
|
|
|
|
quote! {
|
|
#[derive(Default, PartialEq, Debug, Clone)]
|
|
pub struct #component_id {
|
|
#(pub #declared_property_vars : #declared_property_types),*
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Generate the rust code for the given component.
|
|
///
|
|
/// Fill the diagnostic in case of error.
|
|
fn generate_component(
|
|
component: &Rc<Component>,
|
|
diag: &mut BuildDiagnostics,
|
|
) -> Option<TokenStream> {
|
|
let mut extra_components = vec![];
|
|
let mut declared_property_vars = vec![];
|
|
let mut declared_property_types = vec![];
|
|
let mut declared_signals = vec![];
|
|
let mut declared_signals_types = vec![];
|
|
let mut property_and_signal_accessors: Vec<TokenStream> = vec![];
|
|
for (prop_name, property_decl) in component.root_element.borrow().property_declarations.iter() {
|
|
let prop_ident = format_ident!("{}", prop_name);
|
|
if let Type::Signal { args } = &property_decl.property_type {
|
|
declared_signals.push(prop_ident.clone());
|
|
let signal_args = args
|
|
.iter()
|
|
.map(|a| rust_type(a, &property_decl.type_node.span()))
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.unwrap_or_else(|err| {
|
|
diag.push_internal_error(err.into());
|
|
vec![]
|
|
});
|
|
|
|
if property_decl.expose_in_public_api {
|
|
let args_name =
|
|
(0..signal_args.len()).map(|i| format_ident!("arg_{}", i)).collect::<Vec<_>>();
|
|
let emitter_ident = format_ident!("emit_{}", prop_name);
|
|
property_and_signal_accessors.push(
|
|
quote!(
|
|
#[allow(dead_code)]
|
|
pub fn #emitter_ident(self: ::core::pin::Pin<&Self>, #(#args_name : #signal_args,)*) {
|
|
Self::FIELD_OFFSETS.#prop_ident.apply_pin(self).emit(&(#(#args_name,)*))
|
|
}
|
|
)
|
|
.into(),
|
|
);
|
|
let on_ident = format_ident!("on_{}", prop_name);
|
|
let args_index = (0..signal_args.len()).map(proc_macro2::Literal::usize_unsuffixed);
|
|
property_and_signal_accessors.push(
|
|
quote!(
|
|
#[allow(dead_code)]
|
|
pub fn #on_ident(self: ::core::pin::Pin<&Self>, f: impl Fn(#(#signal_args),*) + 'static) {
|
|
#[allow(unused)]
|
|
Self::FIELD_OFFSETS.#prop_ident.apply_pin(self).set_handler(
|
|
// FIXME: why do i need to clone here?
|
|
move |args| f(#(args.#args_index.clone()),*)
|
|
)
|
|
}
|
|
)
|
|
.into(),
|
|
);
|
|
}
|
|
declared_signals_types.push(signal_args);
|
|
} else {
|
|
let rust_property_type =
|
|
rust_type(&property_decl.property_type, &property_decl.type_node.span())
|
|
.unwrap_or_else(|err| {
|
|
diag.push_internal_error(err.into());
|
|
quote!().into()
|
|
});
|
|
if property_decl.expose_in_public_api {
|
|
let getter_ident = format_ident!("get_{}", prop_name);
|
|
let setter_ident = format_ident!("set_{}", prop_name);
|
|
|
|
let prop = if let Some(alias) = &property_decl.is_alias {
|
|
access_member(
|
|
&alias.element.upgrade().unwrap(),
|
|
&alias.name,
|
|
component,
|
|
quote!(self),
|
|
false,
|
|
)
|
|
} else {
|
|
quote!(Self::FIELD_OFFSETS.#prop_ident.apply_pin(self))
|
|
};
|
|
|
|
property_and_signal_accessors.push(
|
|
quote!(
|
|
#[allow(dead_code)]
|
|
pub fn #getter_ident(self: ::core::pin::Pin<&Self>) -> #rust_property_type {
|
|
#[allow(unused_imports)]
|
|
use sixtyfps::re_exports::*;
|
|
#prop.get()
|
|
}
|
|
)
|
|
.into(),
|
|
);
|
|
|
|
let set_value = property_set_value_tokens(
|
|
component,
|
|
&component.root_element,
|
|
prop_name,
|
|
quote!(value),
|
|
);
|
|
property_and_signal_accessors.push(
|
|
quote!(
|
|
#[allow(dead_code)]
|
|
pub fn #setter_ident(self: ::core::pin::Pin<&Self>, value: #rust_property_type) {
|
|
#[allow(unused_imports)]
|
|
use sixtyfps::re_exports::*;
|
|
#prop.#set_value
|
|
}
|
|
)
|
|
.into(),
|
|
);
|
|
}
|
|
|
|
if property_decl.is_alias.is_none() {
|
|
declared_property_vars.push(prop_ident.clone());
|
|
declared_property_types.push(rust_property_type.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
if diag.has_error() {
|
|
return None;
|
|
}
|
|
|
|
let component_id = component_id(component);
|
|
|
|
let mut item_tree_array = Vec::new();
|
|
let mut item_names = Vec::new();
|
|
let mut item_types = Vec::new();
|
|
let mut repeated_element_names = Vec::new();
|
|
let mut repeated_element_components = Vec::new();
|
|
let mut repeated_visit_branch = Vec::new();
|
|
let mut repeated_input_branch = Vec::new();
|
|
let mut init = Vec::new();
|
|
let mut maybe_window_field_decl = None;
|
|
let mut maybe_window_field_init = None;
|
|
super::build_array_helper(component, |item_rc, children_index, is_flickable_rect| {
|
|
let item = item_rc.borrow();
|
|
if is_flickable_rect {
|
|
let field_name = format_ident!("{}", item.id);
|
|
let children_count = item.children.len() as u32;
|
|
let children_index = item_tree_array.len() as u32 + 1;
|
|
|
|
item_tree_array.push(quote!(
|
|
sixtyfps::re_exports::ItemTreeNode::Item{
|
|
item: VOffset::new(#component_id::FIELD_OFFSETS.#field_name + sixtyfps::re_exports::Flickable::FIELD_OFFSETS.viewport),
|
|
chilren_count: #children_count,
|
|
children_index: #children_index,
|
|
}
|
|
));
|
|
} else if let Some(repeated) = &item.repeated {
|
|
let base_component = item.base_type.as_component();
|
|
let repeater_index = repeated_element_names.len();
|
|
let repeater_id = format_ident!("repeater_{}", item.id);
|
|
let rep_component_id = self::component_id(&*base_component);
|
|
|
|
extra_components.push(generate_component(&*base_component, diag).unwrap_or_else(
|
|
|| {
|
|
assert!(diag.has_error());
|
|
Default::default()
|
|
},
|
|
));
|
|
extra_components.push(if repeated.is_conditional_element {
|
|
quote! {
|
|
impl sixtyfps::re_exports::RepeatedComponent for #rep_component_id {
|
|
type Data = ();
|
|
fn update(&self, _: usize, _: Self::Data) { }
|
|
}
|
|
}
|
|
} else {
|
|
let data_type = rust_type(
|
|
&Expression::RepeaterModelReference { element: Rc::downgrade(item_rc) }.ty(),
|
|
&item.node.as_ref().map_or_else(Default::default, |n| n.span()),
|
|
)
|
|
.unwrap_or_else(|err| {
|
|
diag.push_internal_error(err.into());
|
|
quote!().into()
|
|
});
|
|
|
|
quote! {
|
|
impl sixtyfps::re_exports::RepeatedComponent for #rep_component_id {
|
|
type Data = #data_type;
|
|
fn update(&self, index: usize, data: Self::Data) {
|
|
self.index.set(index);
|
|
self.model_data.set(data)
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
let mut model = compile_expression(&repeated.model, component);
|
|
if repeated.is_conditional_element {
|
|
model = quote!(sixtyfps::re_exports::ModelHandle::Some(std::rc::Rc::<bool>::new(#model)))
|
|
}
|
|
|
|
// FIXME: there could be an optimization if `repeated.model.is_constant()`, we don't need a binding
|
|
init.push(quote! {
|
|
self_pinned.#repeater_id.set_model_binding({
|
|
let self_weak = sixtyfps::re_exports::PinWeak::downgrade(self_pinned.clone());
|
|
move || {
|
|
let self_pinned = self_weak.upgrade().unwrap();
|
|
let _self = self_pinned.as_ref();
|
|
(#model) as _
|
|
}
|
|
});
|
|
});
|
|
repeated_visit_branch.push(quote!(
|
|
#repeater_index => {
|
|
#component_id::FIELD_OFFSETS.#repeater_id.apply_pin(self_pinned).ensure_updated(
|
|
|| { #rep_component_id::new(self_pinned.self_weak.get().unwrap().clone()) }
|
|
);
|
|
self_pinned.#repeater_id.visit(order, visitor)
|
|
}
|
|
));
|
|
|
|
repeated_input_branch.push(quote!(
|
|
#repeater_index => self.#repeater_id.input_event(rep_index, event, window),
|
|
));
|
|
|
|
item_tree_array.push(quote!(
|
|
sixtyfps::re_exports::ItemTreeNode::DynamicTree {
|
|
index: #repeater_index,
|
|
}
|
|
));
|
|
|
|
repeated_element_names.push(repeater_id);
|
|
repeated_element_components.push(rep_component_id);
|
|
} else {
|
|
let field_name = format_ident!("{}", item.id);
|
|
let children_count =
|
|
if super::is_flickable(item_rc) { 1 } else { item.children.len() as u32 };
|
|
|
|
item_tree_array.push(quote!(
|
|
sixtyfps::re_exports::ItemTreeNode::Item{
|
|
item: VOffset::new(#component_id::FIELD_OFFSETS.#field_name),
|
|
chilren_count: #children_count,
|
|
children_index: #children_index,
|
|
}
|
|
));
|
|
for (k, binding_expression) in &item.bindings {
|
|
let rust_property_ident = format_ident!("{}", k);
|
|
let rust_property = if item.property_declarations.contains_key(k) {
|
|
quote!(#rust_property_ident)
|
|
} else if let Some(vp) = super::as_flickable_viewport_property(item_rc, k) {
|
|
let rust_property_ident = format_ident!("{}", vp);
|
|
quote!(#field_name.viewport.#rust_property_ident)
|
|
} else {
|
|
quote!(#field_name.#rust_property_ident)
|
|
};
|
|
let tokens_for_expression = compile_expression(binding_expression, &component);
|
|
|
|
if matches!(item.lookup_property(k.as_str()), Type::Signal{..}) {
|
|
init.push(quote!(
|
|
self_pinned.#rust_property.set_handler({
|
|
let self_weak = sixtyfps::re_exports::PinWeak::downgrade(self_pinned.clone());
|
|
move |args| {
|
|
let self_pinned = self_weak.upgrade().unwrap();
|
|
let _self = self_pinned.as_ref();
|
|
#tokens_for_expression;
|
|
}
|
|
});
|
|
));
|
|
} else {
|
|
let setter = if binding_expression.is_constant() {
|
|
quote!(set((#tokens_for_expression) as _))
|
|
} else {
|
|
property_set_binding_tokens(
|
|
component,
|
|
&item_rc,
|
|
k,
|
|
quote!({
|
|
let self_weak = sixtyfps::re_exports::PinWeak::downgrade(self_pinned.clone());
|
|
move || {
|
|
let self_pinned = self_weak.upgrade().unwrap();
|
|
let _self = self_pinned.as_ref();
|
|
(#tokens_for_expression) as _
|
|
}
|
|
}),
|
|
)
|
|
};
|
|
init.push(quote!(
|
|
self_pinned.#rust_property.#setter;
|
|
));
|
|
}
|
|
}
|
|
item_names.push(field_name);
|
|
item_types.push(format_ident!("{}", item.base_type.as_native().class_name));
|
|
}
|
|
});
|
|
|
|
let resource_symbols: Vec<proc_macro2::TokenStream> = if component.embed_file_resources.get() {
|
|
component
|
|
.referenced_file_resources
|
|
.borrow()
|
|
.iter()
|
|
.map(|(path, id)| {
|
|
let symbol = format_ident!("SFPS_EMBEDDED_RESOURCE_{}", id);
|
|
quote!(const #symbol: &'static [u8] = ::core::include_bytes!(#path);)
|
|
})
|
|
.collect()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
|
|
let layouts = compute_layout(component, &repeated_element_names);
|
|
let mut visibility = None;
|
|
let mut parent_component_type = None;
|
|
let mut has_window_impl = None;
|
|
if let Some(parent_element) = component.parent_element.upgrade() {
|
|
if !parent_element.borrow().repeated.as_ref().map_or(false, |r| r.is_conditional_element) {
|
|
declared_property_vars.push(format_ident!("index"));
|
|
declared_property_types.push(quote!(usize));
|
|
declared_property_vars.push(format_ident!("model_data"));
|
|
declared_property_types.push(
|
|
rust_type(
|
|
&Expression::RepeaterModelReference {
|
|
element: component.parent_element.clone(),
|
|
}
|
|
.ty(),
|
|
&parent_element
|
|
.borrow()
|
|
.node
|
|
.as_ref()
|
|
.map_or_else(Default::default, |n| n.span()),
|
|
)
|
|
.unwrap_or_else(|err| {
|
|
diag.push_internal_error(err.into());
|
|
quote!().into()
|
|
}),
|
|
);
|
|
}
|
|
|
|
parent_component_type = Some(self::component_id(
|
|
&parent_element.borrow().enclosing_component.upgrade().unwrap(),
|
|
));
|
|
} else {
|
|
// FIXME: This field is public for testing.
|
|
maybe_window_field_decl = Some(quote!(pub window: sixtyfps::re_exports::ComponentWindow));
|
|
maybe_window_field_init = Some(quote!(window: sixtyfps::create_window()));
|
|
|
|
let root_elem = component.root_element.borrow();
|
|
let root_item_name = format_ident!("{}", root_elem.id);
|
|
property_and_signal_accessors.push(quote! {
|
|
pub fn run(self : core::pin::Pin<std::rc::Rc<Self>>) {
|
|
use sixtyfps::re_exports::*;
|
|
let root_item = Self::FIELD_OFFSETS.#root_item_name.apply_pin(self.as_ref());
|
|
self.as_ref().window.run(VRef::new_pin(self.as_ref()), VRef::new_pin(root_item));
|
|
}
|
|
});
|
|
property_and_signal_accessors.push(quote! {
|
|
pub fn as_weak(self: core::pin::Pin<std::rc::Rc<Self>>) -> sixtyfps::re_exports::PinWeak<Self> {
|
|
sixtyfps::re_exports::PinWeak::downgrade(self)
|
|
}
|
|
});
|
|
visibility = Some(quote!(pub));
|
|
|
|
has_window_impl = Some(quote!(
|
|
impl sixtyfps::testing::HasWindow for #component_id {
|
|
fn component_window(&self) -> &sixtyfps::re_exports::ComponentWindow {
|
|
&self.window
|
|
}
|
|
}
|
|
))
|
|
};
|
|
|
|
// Trick so we can use `#()` as a `if let Some` in `quote!`
|
|
let parent_component_type = parent_component_type.iter().collect::<Vec<_>>();
|
|
|
|
let item_tree_array_len = item_tree_array.len();
|
|
|
|
if diag.has_error() {
|
|
return None;
|
|
}
|
|
|
|
let drop_impl = {
|
|
let guarded_window_ref = {
|
|
let mut root_component = component.clone();
|
|
let mut component_rust = quote!(self);
|
|
while let Some(p) = root_component.parent_element.upgrade() {
|
|
root_component = p.borrow().enclosing_component.upgrade().unwrap();
|
|
component_rust = quote!(if let Some(parent) = #component_rust.parent.upgrade() {
|
|
parent
|
|
} else {
|
|
return;
|
|
}.as_ref());
|
|
}
|
|
quote!(#component_rust.as_ref().window)
|
|
};
|
|
|
|
quote!(impl sixtyfps::re_exports::PinnedDrop for #component_id {
|
|
fn drop(self: core::pin::Pin<&mut #component_id>) {
|
|
use sixtyfps::re_exports::*;
|
|
#guarded_window_ref.free_graphics_resources(VRef::new_pin(self.as_ref()));
|
|
}
|
|
})
|
|
};
|
|
|
|
Some(quote!(
|
|
#(#resource_symbols)*
|
|
|
|
#[derive(sixtyfps::re_exports::FieldOffsets)]
|
|
#[const_field_offset(sixtyfps::re_exports::const_field_offset)]
|
|
#[repr(C)]
|
|
#[pin_drop]
|
|
#visibility struct #component_id {
|
|
#(#item_names : sixtyfps::re_exports::#item_types,)*
|
|
#(#declared_property_vars : sixtyfps::re_exports::Property<#declared_property_types>,)*
|
|
#(#declared_signals : sixtyfps::re_exports::Signal<(#(#declared_signals_types,)*)>,)*
|
|
#(#repeated_element_names : sixtyfps::re_exports::Repeater<#repeated_element_components>,)*
|
|
self_weak: sixtyfps::re_exports::OnceCell<sixtyfps::re_exports::PinWeak<#component_id>>,
|
|
#(parent : sixtyfps::re_exports::PinWeak<#parent_component_type>,)*
|
|
mouse_grabber: ::core::cell::Cell<sixtyfps::re_exports::VisitChildrenResult>,
|
|
#maybe_window_field_decl
|
|
}
|
|
|
|
impl sixtyfps::re_exports::Component for #component_id {
|
|
fn visit_children_item(self: ::core::pin::Pin<&Self>, index: isize, order: sixtyfps::re_exports::TraversalOrder, visitor: sixtyfps::re_exports::ItemVisitorRefMut)
|
|
-> sixtyfps::re_exports::VisitChildrenResult
|
|
{
|
|
use sixtyfps::re_exports::*;
|
|
return sixtyfps::re_exports::visit_item_tree(self, VRef::new_pin(self), Self::item_tree(), index, order, visitor, visit_dynamic);
|
|
#[allow(unused)]
|
|
fn visit_dynamic(self_pinned: ::core::pin::Pin<&#component_id>, order: sixtyfps::re_exports::TraversalOrder, visitor: ItemVisitorRefMut, dyn_index: usize) -> VisitChildrenResult {
|
|
match dyn_index {
|
|
#(#repeated_visit_branch)*
|
|
_ => panic!("invalid dyn_index {}", dyn_index),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn input_event(self: ::core::pin::Pin<&Self>, mouse_event : sixtyfps::re_exports::MouseEvent, window: &sixtyfps::re_exports::ComponentWindow) -> sixtyfps::re_exports::InputEventResult {
|
|
use sixtyfps::re_exports::*;
|
|
let mouse_grabber = self.mouse_grabber.get();
|
|
#[allow(unused)]
|
|
let (status, new_grab) = if let Some((item_index, rep_index)) = mouse_grabber.aborted_indexes() {
|
|
let tree = Self::item_tree();
|
|
let offset = item_offset(self, tree, item_index);
|
|
let mut event = mouse_event.clone();
|
|
event.pos -= offset.to_vector();
|
|
let res = match tree[item_index] {
|
|
ItemTreeNode::Item { item, .. } => {
|
|
item.apply_pin(self).as_ref().input_event(event, window)
|
|
}
|
|
ItemTreeNode::DynamicTree { index } => {
|
|
match index {
|
|
#(#repeated_input_branch)*
|
|
_ => panic!("invalid index {}", index),
|
|
}
|
|
}
|
|
};
|
|
match res {
|
|
InputEventResult::GrabMouse => (res, mouse_grabber),
|
|
_ => (res, VisitChildrenResult::CONTINUE),
|
|
}
|
|
} else {
|
|
process_ungrabbed_mouse_event(VRef::new_pin(self), mouse_event, window)
|
|
};
|
|
self.mouse_grabber.set(new_grab);
|
|
status
|
|
}
|
|
|
|
#layouts
|
|
}
|
|
|
|
impl #component_id{
|
|
pub fn new(#(parent: sixtyfps::re_exports::PinWeak::<#parent_component_type>)*)
|
|
-> core::pin::Pin<std::rc::Rc<Self>>
|
|
{
|
|
#![allow(unused)]
|
|
use sixtyfps::re_exports::*;
|
|
ComponentVTable_static!(static VT for #component_id);
|
|
let mut self_ = Self {
|
|
#(#item_names : ::core::default::Default::default(),)*
|
|
#(#declared_property_vars : ::core::default::Default::default(),)*
|
|
#(#declared_signals : ::core::default::Default::default(),)*
|
|
#(#repeated_element_names : ::core::default::Default::default(),)*
|
|
self_weak : ::core::default::Default::default(),
|
|
#(parent : parent as sixtyfps::re_exports::PinWeak::<#parent_component_type>,)*
|
|
mouse_grabber: ::core::cell::Cell::new(sixtyfps::re_exports::VisitChildrenResult::CONTINUE),
|
|
#maybe_window_field_init
|
|
};
|
|
let self_pinned = std::rc::Rc::pin(self_);
|
|
self_pinned.self_weak.set(PinWeak::downgrade(self_pinned.clone())).map_err(|_|())
|
|
.expect("Can only be pinned once");
|
|
#(#init)*
|
|
self_pinned
|
|
}
|
|
#(#property_and_signal_accessors)*
|
|
|
|
fn item_tree() -> &'static [sixtyfps::re_exports::ItemTreeNode<Self>] {
|
|
use sixtyfps::re_exports::*;
|
|
// FIXME: ideally this should be a const
|
|
static ITEM_TREE : Lazy<[sixtyfps::re_exports::ItemTreeNode<#component_id>; #item_tree_array_len]> =
|
|
Lazy::new(|| [#(#item_tree_array),*]);
|
|
&*ITEM_TREE
|
|
}
|
|
}
|
|
|
|
#drop_impl
|
|
|
|
#has_window_impl
|
|
|
|
#(#extra_components)*
|
|
))
|
|
}
|
|
|
|
/// Return an identifier suitable for this component
|
|
fn component_id(component: &Component) -> proc_macro2::Ident {
|
|
if component.id.is_empty() {
|
|
let s = &component.root_element.borrow().id;
|
|
// Capitalize first leter:
|
|
let mut it = s.chars();
|
|
let id =
|
|
it.next().map(|c| c.to_ascii_uppercase()).into_iter().chain(it).collect::<String>();
|
|
format_ident!("{}", id)
|
|
} else {
|
|
format_ident!("{}", component.id)
|
|
}
|
|
}
|
|
|
|
fn property_animation_tokens(
|
|
component: &Rc<Component>,
|
|
element: &ElementRc,
|
|
property_name: &str,
|
|
) -> Option<TokenStream> {
|
|
if let Some(animation) = element.borrow().property_animations.get(property_name) {
|
|
let bindings: Vec<TokenStream> = animation
|
|
.borrow()
|
|
.bindings
|
|
.iter()
|
|
.map(|(prop, initializer)| {
|
|
let prop_ident = format_ident!("{}", prop);
|
|
let initializer = compile_expression(initializer, component);
|
|
quote!(#prop_ident: #initializer as _)
|
|
})
|
|
.collect();
|
|
|
|
Some(quote!(&sixtyfps::re_exports::PropertyAnimation{
|
|
#(#bindings, )*
|
|
..::core::default::Default::default()
|
|
}))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn property_set_value_tokens(
|
|
component: &Rc<Component>,
|
|
element: &ElementRc,
|
|
property_name: &str,
|
|
value_tokens: TokenStream,
|
|
) -> TokenStream {
|
|
if let Some(animation_tokens) = property_animation_tokens(component, element, property_name) {
|
|
quote!(set_animated_value(#value_tokens, #animation_tokens))
|
|
} else {
|
|
quote!(set(#value_tokens))
|
|
}
|
|
}
|
|
|
|
fn property_set_binding_tokens(
|
|
component: &Rc<Component>,
|
|
element: &ElementRc,
|
|
property_name: &str,
|
|
binding_tokens: TokenStream,
|
|
) -> TokenStream {
|
|
if let Some(animation_tokens) = property_animation_tokens(component, element, property_name) {
|
|
quote!(set_animated_binding(#binding_tokens, #animation_tokens))
|
|
} else {
|
|
quote!(set_binding(#binding_tokens))
|
|
}
|
|
}
|
|
|
|
/// Returns the code that can access the given property or signal (but without the set or get)
|
|
///
|
|
/// to be used like:
|
|
/// ```ignore
|
|
/// let access = access_member(...)
|
|
/// quote!(#access.get())
|
|
/// ```
|
|
fn access_member(
|
|
element: &ElementRc,
|
|
name: &str,
|
|
component: &Rc<Component>,
|
|
component_rust: TokenStream,
|
|
is_special: bool,
|
|
) -> TokenStream {
|
|
let e = element.borrow();
|
|
|
|
let enclosing_component = e.enclosing_component.upgrade().unwrap();
|
|
if Rc::ptr_eq(component, &enclosing_component) {
|
|
let component_id = component_id(&enclosing_component);
|
|
let name_ident = format_ident!("{}", name);
|
|
if e.property_declarations.contains_key(name) || is_special {
|
|
quote!(#component_id::FIELD_OFFSETS.#name_ident.apply_pin(#component_rust))
|
|
} else if let Some(vp) = super::as_flickable_viewport_property(element, name) {
|
|
let name_ident = format_ident!("{}", vp);
|
|
let elem_ident = format_ident!("{}", e.id);
|
|
|
|
quote!((#component_id::FIELD_OFFSETS.#elem_ident
|
|
+ sixtyfps::re_exports::Flickable::FIELD_OFFSETS.viewport
|
|
+ sixtyfps::re_exports::Rectangle::FIELD_OFFSETS.#name_ident)
|
|
.apply_pin(#component_rust)
|
|
)
|
|
} else {
|
|
let elem_ident = format_ident!("{}", e.id);
|
|
let elem_ty = format_ident!("{}", e.base_type.as_native().class_name);
|
|
|
|
quote!((#component_id::FIELD_OFFSETS.#elem_ident + #elem_ty::FIELD_OFFSETS.#name_ident)
|
|
.apply_pin(#component_rust)
|
|
)
|
|
}
|
|
} else {
|
|
access_member(
|
|
element,
|
|
name,
|
|
&component
|
|
.parent_element
|
|
.upgrade()
|
|
.unwrap()
|
|
.borrow()
|
|
.enclosing_component
|
|
.upgrade()
|
|
.unwrap(),
|
|
quote!(#component_rust.parent.upgrade().unwrap().as_ref()),
|
|
is_special,
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Return an expression that gets the window
|
|
fn window_ref_expression(component: &Rc<Component>) -> TokenStream {
|
|
let mut root_component = component.clone();
|
|
let mut component_rust = quote!(_self);
|
|
while let Some(p) = root_component.parent_element.upgrade() {
|
|
root_component = p.borrow().enclosing_component.upgrade().unwrap();
|
|
component_rust = quote!(#component_rust.parent.upgrade().unwrap().as_ref());
|
|
}
|
|
quote!(#component_rust.as_ref().window)
|
|
}
|
|
|
|
fn compile_expression(e: &Expression, component: &Rc<Component>) -> TokenStream {
|
|
match e {
|
|
Expression::StringLiteral(s) => quote!(sixtyfps::re_exports::SharedString::from(#s)),
|
|
Expression::NumberLiteral(n, unit) => {
|
|
let n = unit.normalize(*n);
|
|
quote!(#n)
|
|
}
|
|
Expression::BoolLiteral(b) => quote!(#b),
|
|
Expression::Cast { from, to } => {
|
|
let f = compile_expression(&*from, &component);
|
|
match (from.ty(), to) {
|
|
(Type::Float32, Type::String) | (Type::Int32, Type::String) => {
|
|
quote!(sixtyfps::re_exports::SharedString::from(format!("{}", #f).as_str()))
|
|
}
|
|
(Type::Float32, Type::Model) | (Type::Int32, Type::Model) => {
|
|
quote!(sixtyfps::re_exports::ModelHandle::Some(std::rc::Rc::<usize>::new(#f as usize)))
|
|
}
|
|
(Type::Float32, Type::Color) => {
|
|
quote!(sixtyfps::re_exports::Color::from_argb_encoded(#f as u32))
|
|
}
|
|
(Type::Object(ref o), Type::Component(c)) => {
|
|
let fields = o.iter().enumerate().map(|(index, (name, _))| {
|
|
let index = proc_macro2::Literal::usize_unsuffixed(index);
|
|
let name = format_ident!("{}", name);
|
|
quote!(#name: obj.#index as _)
|
|
});
|
|
let id = component_id(c);
|
|
quote!({ let obj = #f; #id { #(#fields),*} })
|
|
}
|
|
_ => f,
|
|
}
|
|
}
|
|
Expression::PropertyReference(NamedReference { element, name }) => {
|
|
let access = access_member(
|
|
&element.upgrade().unwrap(),
|
|
name.as_str(),
|
|
component,
|
|
quote!(_self),
|
|
false,
|
|
);
|
|
quote!(#access.get())
|
|
}
|
|
Expression::BuiltinFunctionReference(funcref) => match funcref {
|
|
BuiltinFunction::GetWindowScaleFactor => {
|
|
let window_ref = window_ref_expression(component);
|
|
quote!(#window_ref.scale_factor)
|
|
}
|
|
BuiltinFunction::Debug => quote!((|x| println!("{:?}", x))),
|
|
},
|
|
Expression::RepeaterIndexReference { element } => {
|
|
let access = access_member(
|
|
&element.upgrade().unwrap().borrow().base_type.as_component().root_element,
|
|
"index",
|
|
component,
|
|
quote!(_self),
|
|
true,
|
|
);
|
|
quote!(#access.get())
|
|
}
|
|
Expression::RepeaterModelReference { element } => {
|
|
let access = access_member(
|
|
&element.upgrade().unwrap().borrow().base_type.as_component().root_element,
|
|
"model_data",
|
|
component,
|
|
quote!(_self),
|
|
true,
|
|
);
|
|
quote!(#access.get())
|
|
}
|
|
Expression::FunctionParameterReference { index, .. } => {
|
|
let i = proc_macro2::Literal::usize_unsuffixed(*index);
|
|
quote! {args.#i.clone()}
|
|
}
|
|
Expression::ObjectAccess { base, name } => match base.ty() {
|
|
Type::Object(ty) => {
|
|
let index = ty
|
|
.keys()
|
|
.position(|k| k == name)
|
|
.expect("Expression::ObjectAccess: Cannot find a key in an object");
|
|
let index = proc_macro2::Literal::usize_unsuffixed(index);
|
|
let base_e = compile_expression(base, component);
|
|
quote!((#base_e).#index )
|
|
}
|
|
Type::Component(c) if c.root_element.borrow().base_type == Type::Void => {
|
|
let base_e = compile_expression(base, component);
|
|
let name = format_ident!("{}", name);
|
|
quote!((#base_e).#name)
|
|
}
|
|
_ => panic!("Expression::ObjectAccess's base expression is not an Object type"),
|
|
},
|
|
Expression::CodeBlock(sub) => {
|
|
let map = sub.iter().map(|e| compile_expression(e, &component));
|
|
quote!({ #(#map);* })
|
|
}
|
|
Expression::SignalReference(NamedReference { element, name, .. }) => access_member(
|
|
&element.upgrade().unwrap(),
|
|
name.as_str(),
|
|
component,
|
|
quote!(_self),
|
|
false,
|
|
),
|
|
Expression::FunctionCall { function, arguments } => {
|
|
let f = compile_expression(function, &component);
|
|
let a = arguments.iter().map(|a| compile_expression(a, &component));
|
|
if let Type::Signal { args } = function.ty() {
|
|
let cast = args.iter().map(|ty| match ty {
|
|
Type::Bool => quote!(as bool),
|
|
Type::Int32 => quote!(as i32),
|
|
Type::Float32 => quote!(as f32),
|
|
_ => quote!(.clone()),
|
|
});
|
|
quote! { #f.emit(&(#((#a)#cast,)*).into())}
|
|
} else {
|
|
quote! { #f(#(#a.clone()),*)}
|
|
}
|
|
}
|
|
Expression::SelfAssignment { lhs, rhs, op } => match &**lhs {
|
|
Expression::PropertyReference(NamedReference { element, name }) => {
|
|
let lhs = access_member(
|
|
&element.upgrade().unwrap(),
|
|
name.as_str(),
|
|
component,
|
|
quote!(_self),
|
|
false,
|
|
);
|
|
let rhs = compile_expression(&*rhs, &component);
|
|
if *op == '=' {
|
|
quote!( #lhs.set((#rhs) as _) )
|
|
} else {
|
|
let op = proc_macro2::Punct::new(*op, proc_macro2::Spacing::Alone);
|
|
quote!( #lhs.set(((#lhs.get() as f64) #op (#rhs as f64)) as _) )
|
|
}
|
|
}
|
|
_ => panic!("typechecking should make sure this was a PropertyReference"),
|
|
},
|
|
Expression::BinaryExpression { lhs, rhs, op } => {
|
|
let conv = match crate::expression_tree::operator_class(*op) {
|
|
OperatorClass::ArithmeticOp => Some(quote!(as f64)),
|
|
OperatorClass::ComparisonOp
|
|
if matches!(
|
|
lhs.ty(),
|
|
Type::Int32
|
|
| Type::Float32
|
|
| Type::Duration
|
|
| Type::Length
|
|
| Type::LogicalLength
|
|
) =>
|
|
{
|
|
Some(quote!(as f64))
|
|
}
|
|
_ => None,
|
|
};
|
|
let lhs = compile_expression(&*lhs, &component);
|
|
let rhs = compile_expression(&*rhs, &component);
|
|
|
|
let op = match op {
|
|
'=' => quote!(==),
|
|
'!' => quote!(!=),
|
|
'≤' => quote!(<=),
|
|
'≥' => quote!(>=),
|
|
'&' => quote!(&&),
|
|
'|' => quote!(||),
|
|
_ => proc_macro2::TokenTree::Punct(proc_macro2::Punct::new(
|
|
*op,
|
|
proc_macro2::Spacing::Alone,
|
|
))
|
|
.into(),
|
|
};
|
|
quote!( ((#lhs #conv ) #op (#rhs #conv )) )
|
|
}
|
|
Expression::UnaryOp { sub, op } => {
|
|
let sub = compile_expression(&*sub, &component);
|
|
let op = proc_macro2::Punct::new(*op, proc_macro2::Spacing::Alone);
|
|
quote!( #op #sub )
|
|
}
|
|
Expression::ResourceReference { absolute_source_path } => {
|
|
if let Some(id) = component
|
|
.referenced_file_resources
|
|
.borrow()
|
|
.get(absolute_source_path)
|
|
.filter(|_| component.embed_file_resources.get())
|
|
{
|
|
let symbol = format_ident!("SFPS_EMBEDDED_RESOURCE_{}", id);
|
|
quote!(sixtyfps::re_exports::Resource::EmbeddedData(#symbol.into()))
|
|
} else {
|
|
quote!(sixtyfps::re_exports::Resource::AbsoluteFilePath(sixtyfps::re_exports::SharedString::from(#absolute_source_path)))
|
|
}
|
|
}
|
|
Expression::Condition { condition, true_expr, false_expr } => {
|
|
let condition_code = compile_expression(&*condition, component);
|
|
let true_code = compile_expression(&*true_expr, component);
|
|
let false_code = compile_expression(&*false_expr, component);
|
|
quote!(
|
|
if #condition_code {
|
|
#true_code
|
|
} else {
|
|
(#false_code) as _
|
|
}
|
|
)
|
|
}
|
|
Expression::Invalid | Expression::Uncompiled(_) | Expression::TwoWayBinding(_) => {
|
|
let error = format!("unsupported expression {:?}", e);
|
|
quote!(compile_error! {#error})
|
|
}
|
|
Expression::Array { values, element_ty } => {
|
|
let rust_element_ty = rust_type(&element_ty, &Default::default()).unwrap();
|
|
let val = values.iter().map(|e| compile_expression(e, component));
|
|
quote!(sixtyfps::re_exports::ModelHandle::Some(
|
|
std::rc::Rc::new(sixtyfps::re_exports::VecModel::<#rust_element_ty>::from(vec![#(#val as _),*]))
|
|
))
|
|
}
|
|
Expression::Object { ty, values } => {
|
|
if let Type::Object(ty) = ty {
|
|
let elem = ty.iter().map(|(k, t)| {
|
|
values.get(k).map(|e| {
|
|
let ce = compile_expression(e, component);
|
|
let t = rust_type(t, &Default::default()).unwrap_or_default();
|
|
quote!(#ce as #t)
|
|
})
|
|
});
|
|
// This will produce a tuple
|
|
quote!((#(#elem,)*))
|
|
} else {
|
|
panic!("Expression::Object is not a Type::Object")
|
|
}
|
|
}
|
|
Expression::PathElements { elements } => compile_path(elements, component),
|
|
Expression::StoreLocalVariable { name, value } => {
|
|
let value = compile_expression(value, component);
|
|
let name = format_ident!("{}", name);
|
|
quote!(let #name = #value;)
|
|
}
|
|
Expression::ReadLocalVariable { name, .. } => {
|
|
let name = format_ident!("{}", name);
|
|
quote!(#name)
|
|
}
|
|
Expression::EasingCurve(EasingCurve::Linear) => {
|
|
quote!(sixtyfps::re_exports::EasingCurve::Linear)
|
|
}
|
|
Expression::EasingCurve(EasingCurve::CubicBezier(a, b, c, d)) => {
|
|
quote!(sixtyfps::re_exports::EasingCurve::CubicBezier([#a, #b, #c, #d]))
|
|
}
|
|
Expression::EnumerationValue(value) => {
|
|
let base_ident = format_ident!("{}", value.enumeration.name);
|
|
let value_ident = format_ident!("{}", value.to_string());
|
|
quote!(sixtyfps::re_exports::#base_ident::#value_ident)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct RustLanguageLayoutGen;
|
|
impl crate::layout::gen::Language for RustLanguageLayoutGen {
|
|
type CompiledCode = TokenStream;
|
|
}
|
|
|
|
type LayoutTreeItem<'a> = crate::layout::gen::LayoutTreeItem<'a, RustLanguageLayoutGen>;
|
|
|
|
impl LayoutItemCodeGen<RustLanguageLayoutGen> for Layout {
|
|
fn get_property_ref(&self, name: &str) -> TokenStream {
|
|
let moved_property_name = match self.rect().mapped_property_name(name) {
|
|
Some(name) => name,
|
|
None => return quote!(None),
|
|
};
|
|
let n = format_ident!("{}", moved_property_name);
|
|
quote! {Some(&self.#n)}
|
|
}
|
|
fn get_layout_info_ref<'a, 'b>(
|
|
&'a self,
|
|
layout_tree: &'b mut Vec<LayoutTreeItem<'a>>,
|
|
component: &Rc<Component>,
|
|
) -> TokenStream {
|
|
let self_as_layout_tree_item = collect_layouts_recursively(layout_tree, &self, component);
|
|
match self_as_layout_tree_item {
|
|
LayoutTreeItem::GridLayout { cell_ref_variable, spacing, padding, .. } => {
|
|
quote!(grid_layout_info(&Slice::from_slice(&#cell_ref_variable), #spacing, #padding))
|
|
}
|
|
LayoutTreeItem::PathLayout(_) => todo!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl LayoutItemCodeGen<RustLanguageLayoutGen> for LayoutElement {
|
|
fn get_property_ref(&self, name: &str) -> TokenStream {
|
|
let e = format_ident!("{}", self.element.borrow().id);
|
|
if self.element.borrow().lookup_property(name) == Type::Length {
|
|
let n = format_ident!("{}", name);
|
|
quote! {Some(&self.#e.#n)}
|
|
} else {
|
|
quote! {None}
|
|
}
|
|
}
|
|
fn get_layout_info_ref<'a, 'b>(
|
|
&'a self,
|
|
layout_tree: &'b mut Vec<LayoutTreeItem<'a>>,
|
|
component: &Rc<Component>,
|
|
) -> TokenStream {
|
|
let e = format_ident!("{}", self.element.borrow().id);
|
|
let element_info = quote!(Self::FIELD_OFFSETS.#e.apply_pin(self).layouting_info(&window));
|
|
match &self.layout {
|
|
Some(layout) => {
|
|
let layout_info = layout.get_layout_info_ref(layout_tree, component);
|
|
quote!(#layout_info.merge(&#element_info))
|
|
}
|
|
None => element_info,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn collect_layouts_recursively<'a, 'b>(
|
|
layout_tree: &'b mut Vec<LayoutTreeItem<'a>>,
|
|
layout: &'a Layout,
|
|
component: &Rc<Component>,
|
|
) -> &'b LayoutTreeItem<'a> {
|
|
let get_property_ref = LayoutItemCodeGen::<RustLanguageLayoutGen>::get_property_ref;
|
|
match layout {
|
|
Layout::GridLayout(grid_layout) => {
|
|
let cells: Vec<TokenStream> = grid_layout
|
|
.elems
|
|
.iter()
|
|
.map(|cell| {
|
|
let width = get_property_ref(&cell.item, "width");
|
|
let height = get_property_ref(&cell.item, "height");
|
|
let x = get_property_ref(&cell.item, "x");
|
|
let y = get_property_ref(&cell.item, "y");
|
|
let (col, row, colspan, rowspan) =
|
|
(cell.col, cell.row, cell.colspan, cell.rowspan);
|
|
let mut layout_info = cell.item.get_layout_info_ref(layout_tree, component);
|
|
if cell.has_explicit_restrictions() {
|
|
let (name, expr): (Vec<_>, Vec<_>) = cell
|
|
.for_each_restrictions()
|
|
.iter()
|
|
.filter_map(|(e, s)| {
|
|
e.as_ref().map(|e| {
|
|
(format_ident!("{}", s), compile_expression(&e, component))
|
|
})
|
|
})
|
|
.unzip();
|
|
layout_info = quote!({
|
|
let mut layout_info = #layout_info;
|
|
#(layout_info.#name = #expr;)*
|
|
layout_info });
|
|
}
|
|
|
|
quote!(GridLayoutCellData {
|
|
x: #x,
|
|
y: #y,
|
|
width: #width,
|
|
height: #height,
|
|
col: #col,
|
|
row: #row,
|
|
colspan: #colspan,
|
|
rowspan: #rowspan,
|
|
constraint: #layout_info,
|
|
})
|
|
})
|
|
.collect();
|
|
|
|
let cell_ref_variable = format_ident!("cells_{}", layout_tree.len());
|
|
let cell_creation_code = quote!(let #cell_ref_variable = [#( #cells ),*];);
|
|
let (spacing, spacing_creation_code) = if let Some(spacing) = &grid_layout.spacing {
|
|
let variable = format_ident!("spacing_{}", layout_tree.len());
|
|
let spacing_code = compile_expression(spacing, component);
|
|
(quote!(#variable), Some(quote!(let #variable = #spacing_code;)))
|
|
} else {
|
|
(quote!(0.), None)
|
|
};
|
|
let padding = {
|
|
let padding_prop = |expr| {
|
|
if let Some(expr) = expr {
|
|
compile_expression(expr, component)
|
|
} else {
|
|
quote!(0.)
|
|
}
|
|
};
|
|
let left = padding_prop(grid_layout.padding.left.as_ref());
|
|
let right = padding_prop(grid_layout.padding.right.as_ref());
|
|
let top = padding_prop(grid_layout.padding.top.as_ref());
|
|
let bottom = padding_prop(grid_layout.padding.bottom.as_ref());
|
|
quote!(&sixtyfps::re_exports::Padding {
|
|
left: #left,
|
|
right: #right,
|
|
top: #top,
|
|
bottom: #bottom,
|
|
})
|
|
};
|
|
layout_tree.push(
|
|
LayoutTreeItem::GridLayout {
|
|
grid: grid_layout,
|
|
var_creation_code: quote!(#cell_creation_code #spacing_creation_code),
|
|
cell_ref_variable: quote!(#cell_ref_variable),
|
|
spacing,
|
|
padding,
|
|
}
|
|
.into(),
|
|
);
|
|
}
|
|
Layout::PathLayout(layout) => layout_tree.push(layout.into()),
|
|
}
|
|
layout_tree.last().unwrap()
|
|
}
|
|
|
|
impl<'a> LayoutTreeItem<'a> {
|
|
fn emit_solve_calls(&self, component: &Rc<Component>, code_stream: &mut Vec<TokenStream>) {
|
|
match self {
|
|
LayoutTreeItem::GridLayout { grid, cell_ref_variable, spacing, padding, .. } => {
|
|
let x_pos = compile_expression(&*grid.rect.x_reference, component);
|
|
let y_pos = compile_expression(&*grid.rect.y_reference, component);
|
|
let width = compile_expression(&*grid.rect.width_reference, component);
|
|
let height = compile_expression(&*grid.rect.height_reference, component);
|
|
|
|
code_stream.push(quote! {
|
|
solve_grid_layout(&GridLayoutData {
|
|
width: #width,
|
|
height: #height,
|
|
x: #x_pos as _,
|
|
y: #y_pos as _,
|
|
cells: Slice::from_slice(&#cell_ref_variable),
|
|
spacing: #spacing,
|
|
padding: #padding,
|
|
});
|
|
});
|
|
}
|
|
LayoutTreeItem::PathLayout(path_layout) => {
|
|
let path_layout_item_data =
|
|
|elem: &ElementRc, elem_rs: TokenStream, component_rust: TokenStream| {
|
|
let prop_ref = |n: &str| {
|
|
if elem.borrow().lookup_property(n) == Type::Length {
|
|
let n = format_ident!("{}", n);
|
|
quote! {Some(& #elem_rs.#n)}
|
|
} else {
|
|
quote! {None}
|
|
}
|
|
};
|
|
let prop_value = |n: &str| {
|
|
if elem.borrow().lookup_property(n) == Type::Length {
|
|
let accessor = access_member(
|
|
&elem,
|
|
n,
|
|
&elem.borrow().enclosing_component.upgrade().unwrap(),
|
|
component_rust.clone(),
|
|
false,
|
|
);
|
|
quote!(#accessor.get())
|
|
} else {
|
|
quote! {0.}
|
|
}
|
|
};
|
|
let x = prop_ref("x");
|
|
let y = prop_ref("y");
|
|
let width = prop_value("width");
|
|
let height = prop_value("height");
|
|
quote!(PathLayoutItemData {
|
|
x: #x,
|
|
y: #y,
|
|
width: #width,
|
|
height: #height,
|
|
})
|
|
};
|
|
let path_layout_item_data_for_elem = |elem: &ElementRc| {
|
|
let e = format_ident!("{}", elem.borrow().id);
|
|
path_layout_item_data(elem, quote!(self.#e), quote!(self))
|
|
};
|
|
|
|
let is_static_array =
|
|
path_layout.elements.iter().all(|elem| elem.borrow().repeated.is_none());
|
|
|
|
let slice = if is_static_array {
|
|
let items = path_layout.elements.iter().map(path_layout_item_data_for_elem);
|
|
quote!( Slice::from_slice(&[#( #items ),*]) )
|
|
} else {
|
|
let mut fixed_count = 0usize;
|
|
let mut repeated_count = quote!();
|
|
let mut push_code = quote!();
|
|
for elem in &path_layout.elements {
|
|
if elem.borrow().repeated.is_some() {
|
|
let repeater_id = format_ident!("repeater_{}", elem.borrow().id);
|
|
repeated_count = quote!(#repeated_count + self.#repeater_id.len());
|
|
let root_element =
|
|
elem.borrow().base_type.as_component().root_element.clone();
|
|
let root_id = format_ident!("{}", root_element.borrow().id);
|
|
let e = path_layout_item_data(
|
|
&root_element,
|
|
quote!(sub_comp.#root_id),
|
|
quote!(sub_comp.as_ref()),
|
|
);
|
|
push_code = quote! {
|
|
#push_code
|
|
let internal_vec = self.#repeater_id.components_vec();
|
|
for sub_comp in &internal_vec {
|
|
items_vec.push(#e)
|
|
}
|
|
}
|
|
} else {
|
|
fixed_count += 1;
|
|
let e = path_layout_item_data_for_elem(elem);
|
|
push_code = quote! {
|
|
#push_code
|
|
items_vec.push(#e);
|
|
}
|
|
}
|
|
}
|
|
|
|
code_stream.push(quote! {
|
|
let mut items_vec = Vec::with_capacity(#fixed_count #repeated_count);
|
|
#push_code
|
|
});
|
|
quote!(Slice::from_slice(items_vec.as_slice()))
|
|
};
|
|
|
|
let path = compile_path(&path_layout.path, &component);
|
|
|
|
let x_pos = compile_expression(&*path_layout.rect.x_reference, &component);
|
|
let y_pos = compile_expression(&*path_layout.rect.y_reference, &component);
|
|
let width = compile_expression(&*path_layout.rect.width_reference, &component);
|
|
let height = compile_expression(&*path_layout.rect.width_reference, &component);
|
|
let offset = compile_expression(&*path_layout.offset_reference, &component);
|
|
|
|
code_stream.push(quote! {
|
|
solve_path_layout(&PathLayoutData {
|
|
items: #slice,
|
|
elements: &#path,
|
|
x: #x_pos,
|
|
y: #y_pos,
|
|
width: #width,
|
|
height: #height,
|
|
offset: #offset,
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compute_layout(component: &Rc<Component>, repeated_element_names: &[Ident]) -> TokenStream {
|
|
let mut layouts = vec![];
|
|
component.layout_constraints.borrow().iter().for_each(|layout| {
|
|
let mut inverse_layout_tree = Vec::new();
|
|
|
|
collect_layouts_recursively(&mut inverse_layout_tree, layout, component);
|
|
|
|
layouts.extend(inverse_layout_tree.iter().filter_map(|layout| match layout {
|
|
LayoutTreeItem::GridLayout { var_creation_code, .. } => Some(var_creation_code.clone()),
|
|
LayoutTreeItem::PathLayout(_) => None,
|
|
}));
|
|
|
|
inverse_layout_tree
|
|
.iter()
|
|
.rev()
|
|
.for_each(|layout| layout.emit_solve_calls(component, &mut layouts));
|
|
});
|
|
|
|
let window_ref = window_ref_expression(component);
|
|
|
|
quote! {
|
|
fn layout_info(self: ::core::pin::Pin<&Self>) -> sixtyfps::re_exports::LayoutInfo {
|
|
todo!("Implement in rust.rs")
|
|
}
|
|
fn compute_layout(self: ::core::pin::Pin<&Self>) {
|
|
#![allow(unused)]
|
|
use sixtyfps::re_exports::*;
|
|
let dummy = Property::<f32>::default();
|
|
let _self = self;
|
|
let window = #window_ref.clone();
|
|
|
|
#(#layouts)*
|
|
|
|
#(self.#repeated_element_names.compute_layout();)*
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compile_path_events(events: &crate::expression_tree::PathEvents) -> TokenStream {
|
|
use lyon::path::Event;
|
|
|
|
let mut coordinates = Vec::new();
|
|
|
|
let converted_events: Vec<proc_macro2::TokenStream> = events
|
|
.iter()
|
|
.map(|event| match event {
|
|
Event::Begin { at } => {
|
|
coordinates.push(at);
|
|
quote!(sixtyfps::re_exports::PathEvent::Begin)
|
|
}
|
|
Event::Line { from, to } => {
|
|
coordinates.push(from);
|
|
coordinates.push(to);
|
|
quote!(sixtyfps::re_exports::PathEvent::Line)
|
|
}
|
|
Event::Quadratic { from, ctrl, to } => {
|
|
coordinates.push(from);
|
|
coordinates.push(ctrl);
|
|
coordinates.push(to);
|
|
quote!(sixtyfps::re_exports::PathEvent::Quadratic)
|
|
}
|
|
Event::Cubic { from, ctrl1, ctrl2, to } => {
|
|
coordinates.push(from);
|
|
coordinates.push(ctrl1);
|
|
coordinates.push(ctrl2);
|
|
coordinates.push(to);
|
|
quote!(sixtyfps::re_exports::PathEvent::Cubic)
|
|
}
|
|
Event::End { last, first, close } => {
|
|
debug_assert_eq!(coordinates.first(), Some(&first));
|
|
debug_assert_eq!(coordinates.last(), Some(&last));
|
|
if *close {
|
|
quote!(sixtyfps::re_exports::PathEvent::EndClosed)
|
|
} else {
|
|
quote!(sixtyfps::re_exports::PathEvent::EndOpen)
|
|
}
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
let coordinates: Vec<TokenStream> = coordinates
|
|
.into_iter()
|
|
.map(|pt| {
|
|
let x = pt.x;
|
|
let y = pt.y;
|
|
quote!(sixtyfps::re_exports::Point::new(#x, #y))
|
|
})
|
|
.collect();
|
|
|
|
quote!(sixtyfps::re_exports::SharedArray::<sixtyfps::re_exports::PathEvent>::from_slice(&[#(#converted_events),*]),
|
|
sixtyfps::re_exports::SharedArray::<sixtyfps::re_exports::Point>::from_slice(&[#(#coordinates),*]))
|
|
}
|
|
|
|
fn compile_path(path: &Path, component: &Rc<Component>) -> TokenStream {
|
|
match path {
|
|
Path::Elements(elements) => {
|
|
let converted_elements: Vec<TokenStream> = elements
|
|
.iter()
|
|
.map(|element| {
|
|
let mut bindings = element
|
|
.bindings
|
|
.iter()
|
|
.map(|(property, expr)| {
|
|
let prop_ident = format_ident!("{}", property);
|
|
let binding_expr = compile_expression(expr, component);
|
|
|
|
quote!(#prop_ident: #binding_expr as _).to_string()
|
|
})
|
|
.collect::<Vec<String>>();
|
|
|
|
if bindings.len() < element.element_type.properties.len() {
|
|
bindings.push("..Default::default()".into())
|
|
}
|
|
|
|
let bindings = bindings.join(",");
|
|
|
|
let ctor_format_string = element
|
|
.element_type
|
|
.native_class.rust_type_constructor
|
|
.as_ref()
|
|
.expect(
|
|
"Unexpected error in type registry: path element is lacking rust type name",
|
|
);
|
|
|
|
ctor_format_string
|
|
.replace("{}", &bindings)
|
|
.parse()
|
|
.expect("Error parsing rust path element constructor")
|
|
})
|
|
.collect();
|
|
|
|
quote!(sixtyfps::re_exports::PathData::Elements(
|
|
sixtyfps::re_exports::SharedArray::<sixtyfps::re_exports::PathElement>::from_slice(&[#(#converted_elements),*])
|
|
))
|
|
}
|
|
Path::Events(events) => {
|
|
let events = compile_path_events(events);
|
|
quote!(sixtyfps::re_exports::PathData::Events(#events))
|
|
}
|
|
}
|
|
}
|