diff --git a/godot-core/src/meta/mod.rs b/godot-core/src/meta/mod.rs index e516df64f..9a6e3880d 100644 --- a/godot-core/src/meta/mod.rs +++ b/godot-core/src/meta/mod.rs @@ -54,10 +54,12 @@ mod signature; mod traits; pub mod error; +pub mod property_update; pub use args::*; pub use class_name::ClassName; pub use godot_convert::{FromGodot, GodotConvert, ToGodot}; +pub use property_update::PropertyUpdate; pub use traits::{ArrayElement, GodotType, PackedArrayElement}; pub(crate) use array_type_info::ArrayTypeInfo; diff --git a/godot-core/src/meta/property_update.rs b/godot-core/src/meta/property_update.rs new file mode 100644 index 000000000..b037f1abd --- /dev/null +++ b/godot-core/src/meta/property_update.rs @@ -0,0 +1,14 @@ +pub struct PropertyUpdate<'a, C, T> { + pub new_value: T, + pub field_name: &'a str, // might also be &'a StringName, depending on what's available + pub get_field_mut: fn(&mut C) -> &mut T, +} + +impl PropertyUpdate<'_, C, T> { + pub fn set(self, obj: &mut C) { + *(self.get_field_mut)(obj) = self.new_value; + } + pub fn set_custom(self, obj: &mut C, value: T) { + *(self.get_field_mut)(obj) = value; + } +} diff --git a/godot-macros/src/class/data_models/field_var.rs b/godot-macros/src/class/data_models/field_var.rs index de403ecc5..a099b5efa 100644 --- a/godot-macros/src/class/data_models/field_var.rs +++ b/godot-macros/src/class/data_models/field_var.rs @@ -49,6 +49,30 @@ fn parse_notify(parser: &mut KvParser, key: &str) -> ParseResult> } } +fn parse_setter_ex(parser: &mut KvParser, key: &str) -> ParseResult> { + match parser.handle_any(key) { + // No `notify` argument + None => Ok(None), + Some(value) => match value { + // `notify` without value is an error + None => { + bail!( + parser.span(), + "The correct syntax is 'setter_ex = callback_fn'" + ) + } + // `notify = expr` + Some(value) => match value.ident() { + Ok(ident) => Ok(Some(ident)), + Err(_) => bail!( + parser.span(), + "The correct syntax is 'setter_ex = callback_fn'" + ), + }, + }, + } +} + impl FieldVar { /// Parse a `#[var]` attribute to a `FieldVar` struct. /// @@ -62,8 +86,9 @@ impl FieldVar { let mut getter = GetterSetter::parse(parser, "get")?; let mut setter = GetterSetter::parse(parser, "set")?; let notify = parse_notify(parser, "notify")?; + let setter_ex = parse_setter_ex(parser, "set_ex")?; - if getter.is_omitted() && setter.is_omitted() { + if getter.is_omitted() && setter.is_omitted() && setter_ex.is_none() { getter = GetterSetter::Generated; setter = GetterSetter::Generated; } @@ -75,6 +100,17 @@ impl FieldVar { ); } + if setter_ex.is_some() && !setter.is_omitted() { + return bail!( + parser.span(), + "You may not use 'set' and 'set_ex' at the same time, remove one" + ); + } + + if let Some(ident) = setter_ex { + setter = GetterSetter::Ex(ident); + } + let hint = parser.handle_ident("hint")?; let hint = if let Some(hint) = hint { @@ -120,6 +156,9 @@ pub enum GetterSetter { /// Getter/setter is handwritten by the user, and here is its identifier. Custom(Ident), + + /// only applicable to setter. A generic setter that takes 'PropertyUpdate' is handwritten by the user + Ex(Ident), } impl GetterSetter { @@ -157,6 +196,12 @@ impl GetterSetter { GetterSetter::Custom(function_name) => { Some(GetterSetterImpl::from_custom_impl(function_name)) } + GetterSetter::Ex(function_name) => { + assert!(matches!(kind, GetSet::SetEx(_))); + Some(GetterSetterImpl::from_generated_impl( + class_name, kind, notify, field, + )) + } } } @@ -170,17 +215,18 @@ impl GetterSetter { } /// Used to determine whether a [`GetterSetter`] is supposed to be a getter or setter. -#[derive(Copy, Clone, Eq, PartialEq, Debug)] +#[derive(Clone, Eq, PartialEq, Debug)] pub enum GetSet { Get, Set, + SetEx(Ident), } impl GetSet { pub fn prefix(&self) -> &'static str { match self { GetSet::Get => "get_", - GetSet::Set => "set_", + GetSet::Set | GetSet::SetEx(_) => "set_", } } } @@ -228,6 +274,37 @@ impl GetterSetterImpl { <#field_type as ::godot::register::property::Var>::set_property(&mut self.#field_name, #field_name); }; + function_body = match notify { + Some(ident) => { + quote! { + let prev_value = self.#field_name; + #function_body_set + if prev_value != self.#field_name { + self.#ident(); + } + } + } + None => function_body_set, + }; + } + GetSet::SetEx(callback_fn_ident) => { + signature = quote! { + fn #function_name(&mut self, #field_name: <#field_type as ::godot::meta::GodotConvert>::Via) + }; + + let field_name_string_constant = field_name.to_string(); + + let function_body_set = quote! { + + let new_value = ::godot::meta::FromGodot::from_godot(#field_name); + let property_update = ::godot::meta::PropertyUpdate { + new_value: new_value, + field_name: #field_name_string_constant, + get_field_mut: |c: &mut #class_name|&mut c.#field_name + }; + self.#callback_fn_ident(property_update); + }; + function_body = match notify { Some(ident) => { quote! { diff --git a/godot-macros/src/class/data_models/property.rs b/godot-macros/src/class/data_models/property.rs index 15839984b..029248ff2 100644 --- a/godot-macros/src/class/data_models/property.rs +++ b/godot-macros/src/class/data_models/property.rs @@ -7,7 +7,7 @@ //! Parsing the `var` and `export` attributes on fields. -use crate::class::{Field, FieldVar, Fields, GetSet, GetterSetterImpl, UsageFlags}; +use crate::class::{Field, FieldVar, Fields, GetSet, GetterSetter, GetterSetterImpl, UsageFlags}; use proc_macro2::{Ident, TokenStream}; use quote::quote; @@ -139,8 +139,12 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream { &mut getter_setter_impls, &mut export_tokens, ); + let setter_kind = match &setter { + GetterSetter::Ex(ident) => GetSet::SetEx(ident.clone()), + _ => GetSet::Set, + }; let setter_name = make_getter_setter( - setter.to_impl(class_name, GetSet::Set, notify, field), + setter.to_impl(class_name, setter_kind, notify, field), &mut getter_setter_impls, &mut export_tokens, ); diff --git a/itest/rust/src/object_tests/property_test.rs b/itest/rust/src/object_tests/property_test.rs index 545bc58db..ebdac8e96 100644 --- a/itest/rust/src/object_tests/property_test.rs +++ b/itest/rust/src/object_tests/property_test.rs @@ -486,3 +486,46 @@ fn test_var_notify() { class.free(); } + +// --------------------------------------------------------------- + +#[derive(GodotClass)] +#[class(base=Node, init)] +struct SetExTest { + #[var(set_ex = custom_set)] + a: i32, + #[var(set_ex = custom_set)] + b: i32, + + pub call_count: u32, +} + +impl SetExTest { + fn custom_set(&mut self, update: godot::meta::property_update::PropertyUpdate) { + // pre-set checks + + update.set(self); + + // post-set actions + self.call_count += 1; + } +} + +#[itest] +fn test_var_set_ex() { + let mut class = NotifyTest::new_alloc(); + + assert_eq!(class.bind().call_count, 0); + + class.call("set_a", &[3.to_variant()]); + assert_eq!(class.bind().a, 3); + assert_eq!(class.bind().call_count, 1); + + class.call("set_b", &[5.to_variant()]); + assert_eq!(class.bind().b, 5); + assert_eq!(class.bind().call_count, 2); + + class.free(); +} + +// ---------------------------------------------------------------