zng_app/event/args.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
use std::{
any::Any,
fmt,
sync::{
atomic::{AtomicBool, Ordering::Relaxed},
Arc,
},
};
/// [`Event<A>`] arguments.
///
/// See [`AnyEventArgs`] for the object safe part of event arguments.
///
/// [`Event<A>`]: crate::event::Event
pub trait EventArgs: AnyEventArgs + Clone {
/// Calls `handler` and stops propagation if propagation is still allowed.
///
/// Returns the `handler` result if it was called.
fn handle<F, R>(&self, handler: F) -> Option<R>
where
F: FnOnce(&Self) -> R,
{
if self.propagation().is_stopped() {
None
} else {
let r = handler(self);
self.propagation().stop();
Some(r)
}
}
}
/// Methods of [`EventArgs`] that are object safe.
pub trait AnyEventArgs: fmt::Debug + Send + Sync + Any {
/// Clone the event into a type erased box.
fn clone_any(&self) -> Box<dyn AnyEventArgs>;
/// Access to `dyn Any` methods.
fn as_any(&self) -> &dyn Any;
/// Gets the instant this event happened.
fn timestamp(&self) -> crate::DInstant;
/// Insert all targets of this event on the [`UpdateDeliveryList`].
fn delivery_list(&self, list: &mut UpdateDeliveryList);
/// Propagation handle associated with this event instance.
///
/// Cloned arguments share the same handle, some arguments may also share the handle
/// of another event if they share the same cause.
fn propagation(&self) -> &EventPropagationHandle;
}
/// Event propagation handle associated with one or multiple [`EventArgs`].
///
/// Event handlers can use this to signal subsequent handlers that the event is already handled and they should
/// operate as if the event was not received.
///
/// You can get the propagation handle of any event argument by using the [`AnyEventArgs::propagation`] method.
#[derive(Debug, Clone)]
pub struct EventPropagationHandle(Arc<AtomicBool>);
impl EventPropagationHandle {
/// New in the not stopped default state.
pub fn new() -> Self {
EventPropagationHandle(Arc::new(AtomicBool::new(false)))
}
/// Signal subsequent handlers that the event is already handled.
pub fn stop(&self) {
// Is `Arc` to make `EventArgs` send, but stop handle is only useful in the UI thread, so
// we don't need any ordering.
self.0.store(true, Relaxed);
}
/// If the handler must skip this event instance.
///
/// Note that property level handlers don't need to check this, as those handlers are
/// not called when this is `true`. Direct event listeners in [`UiNode`] and [`AppExtension`]
/// must check if this is `true`.
///
/// [`UiNode`]: crate::widget::node::UiNode
/// [`AppExtension`]: crate::AppExtension
pub fn is_stopped(&self) -> bool {
self.0.load(Relaxed)
}
}
impl Default for EventPropagationHandle {
fn default() -> Self {
EventPropagationHandle::new()
}
}
impl PartialEq for EventPropagationHandle {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0, &other.0)
}
}
impl Eq for EventPropagationHandle {}
impl std::hash::Hash for EventPropagationHandle {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
let ptr = Arc::as_ptr(&self.0) as usize;
std::hash::Hash::hash(&ptr, state);
}
}
///<span data-del-macro-root></span> Declares new [`EventArgs`] types.
///
/// The macro syntax is similar to `struct` declaration, but after the args struct members you must add `..` and then
/// the `fn delivery_list(&self, list: &mut UpdateDeliveryList) {}` method that inserts the widget targets.
///
/// After the `delivery_list` method you can also optionally add a `fn validate(&self) -> Result<(), Txt> { }` method
/// that validates the arguments.
///
/// The macro expansion implements the [`EventArgs`] and [`AnyEventArgs`] traits for the new structs, it generates a public `timestamp`
/// member and a `new` and `now` associated functions. The `new` function instantiates args with custom timestamp and propagation handle,
/// the `now` function provides the timestamp and propagation handle and is the primary way to instantiate args.
///
/// # Examples
///
/// ```
/// # use zng_app::{event::event_args, widget::info::WidgetPath};
/// # use zng_txt::*;
/// #
/// event_args! {
/// /// My event arguments.
/// pub struct MyEventArgs {
/// /// My argument.
/// pub arg: String,
/// /// My event target.
/// pub target: WidgetPath,
///
/// ..
///
/// fn delivery_list(&self, list: &mut UpdateDeliveryList) {
/// list.insert_wgt(&self.target);
/// }
///
/// /// Optional validation, if defined the generated `new` and `now` functions call it and unwrap the result.
/// ///
/// /// The error type can be any type that implement `Debug`.
/// fn validate(&self) -> Result<(), Txt> {
/// if self.arg.contains("error") {
/// return Err(formatx!("invalid arg `{}`", self.arg));
/// }
/// Ok(())
/// }
/// }
///
/// // multiple structs can be declared in the same call.
/// // pub struct MyOtherEventArgs { /**/ }
/// }
/// ```
///
/// [`EventArgs`]: crate::event::EventArgs
#[macro_export]
macro_rules! event_args {
($(
$(#[$outer:meta])*
$vis:vis struct $Args:ident {
$($(#[$arg_outer:meta])* $arg_vis:vis $arg:ident : $arg_ty:ty,)*
..
$(#[$delivery_list_outer:meta])*
fn delivery_list(&$self:ident, $delivery_list_ident:ident: &mut UpdateDeliveryList) { $($delivery_list:tt)* }
$(
$(#[$validate_outer:meta])*
fn validate(&$self_v:ident) -> Result<(), $ValidationError:path> { $($validate:tt)+ }
)?
}
)+) => {$(
$crate::__event_args! {
$(#[$outer])*
$vis struct $Args {
$($(#[$arg_outer])* $arg_vis $arg: $arg_ty,)*
..
$(#[$delivery_list_outer])*
fn delivery_list(&$self, $delivery_list_ident: &mut UpdateDeliveryList) { $($delivery_list)* }
$(
$(#[$validate_outer])*
fn validate(&$self_v) -> Result<(), $ValidationError> { $($validate)+ }
)?
}
}
)+};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __event_args {
// match validate
(
$(#[$outer:meta])*
$vis:vis struct $Args:ident {
$($(#[$arg_outer:meta])* $arg_vis:vis $arg:ident : $arg_ty:ty,)*
..
$(#[$delivery_list_outer:meta])*
fn delivery_list(&$self:ident, $delivery_list_ident:ident: &mut UpdateDeliveryList) { $($delivery_list:tt)* }
$(#[$validate_outer:meta])*
fn validate(&$self_v:ident) -> Result<(), $ValidationError:path> { $($validate:tt)+ }
}
) => {
$crate::__event_args! {common=>
$(#[$outer])*
$vis struct $Args {
$($(#[$arg_outer])* $arg_vis $arg: $arg_ty,)*
..
$(#[$delivery_list_outer])*
fn delivery_list(&$self, $delivery_list_ident: &mut UpdateDeliveryList) { $($delivery_list)* }
}
}
impl $Args {
/// New args from values that convert [into](Into) the argument types.
///
/// # Panics
///
/// Panics if the arguments are invalid.
#[allow(clippy::too_many_arguments)]
pub fn new(
timestamp: impl Into<$crate::DInstant>,
propagation_handle: $crate::event::EventPropagationHandle,
$($arg : impl Into<$arg_ty>),*
) -> Self {
let args = $Args {
timestamp: timestamp.into(),
$($arg: $arg.into(),)*
propagation_handle,
};
args.assert_valid();
args
}
/// New args from values that convert [into](Into) the argument types.
///
/// Returns an error if the constructed arguments are invalid.
#[allow(clippy::too_many_arguments)]
pub fn try_new(
timestamp: impl Into<$crate::DInstant>,
propagation_handle: $crate::event::EventPropagationHandle,
$($arg : impl Into<$arg_ty>),*
) -> Result<Self, $ValidationError> {
let args = $Args {
timestamp: timestamp.into(),
$($arg: $arg.into(),)*
propagation_handle,
};
args.validate()?;
Ok(args)
}
/// Arguments for event that happened now (`INSTANT.now`).
///
/// # Panics
///
/// Panics if the arguments are invalid.
#[allow(clippy::too_many_arguments)]
pub fn now($($arg : impl Into<$arg_ty>),*) -> Self {
Self::new($crate::INSTANT.now(), $crate::event::EventPropagationHandle::new(), $($arg),*)
}
/// Arguments for event that happened now (`INSTANT.now`).
///
/// Returns an error if the constructed arguments are invalid.
#[allow(clippy::too_many_arguments)]
pub fn try_now($($arg : impl Into<$arg_ty>),*) -> Result<Self, $ValidationError> {
Self::try_new($crate::INSTANT.now(), $crate::event::EventPropagationHandle::new(), $($arg),*)
}
$(#[$validate_outer])*
pub fn validate(&$self_v) -> Result<(), $ValidationError> {
$($validate)+
}
/// Panics if the arguments are invalid.
#[track_caller]
pub fn assert_valid(&self) {
if let Err(e) = self.validate() {
panic!("invalid `{}`, {e:?}", stringify!($Args));
}
}
}
};
// match no validate
(
$(#[$outer:meta])*
$vis:vis struct $Args:ident {
$($(#[$arg_outer:meta])* $arg_vis:vis $arg:ident : $arg_ty:ty,)*
..
$(#[$delivery_list_outer:meta])*
fn delivery_list(&$self:ident, $delivery_list_ident:ident: &mut UpdateDeliveryList) { $($delivery_list:tt)* }
}
) => {
$crate::__event_args! {common=>
$(#[$outer])*
$vis struct $Args {
$($(#[$arg_outer])* $arg_vis $arg: $arg_ty,)*
..
$(#[$delivery_list_outer])*
fn delivery_list(&$self, $delivery_list_ident: &mut UpdateDeliveryList) { $($delivery_list)* }
}
}
impl $Args {
/// New args from values that convert [into](Into) the argument types.
#[allow(clippy::too_many_arguments)]
pub fn new(
timestamp: impl Into<$crate::DInstant>,
propagation_handle: $crate::event::EventPropagationHandle,
$($arg : impl Into<$arg_ty>),*
) -> Self {
$Args {
timestamp: timestamp.into(),
$($arg: $arg.into(),)*
propagation_handle,
}
}
/// Arguments for event that happened now (`INSTANT.now`).
#[allow(clippy::too_many_arguments)]
pub fn now($($arg : impl Into<$arg_ty>),*) -> Self {
Self::new($crate::INSTANT.now(), $crate::event::EventPropagationHandle::new(), $($arg),*)
}
}
};
// common code between validating and not.
(common=>
$(#[$outer:meta])*
$vis:vis struct $Args:ident {
$($(#[$arg_outer:meta])* $arg_vis:vis $arg:ident : $arg_ty:ty,)*
..
$(#[$delivery_list_outer:meta])*
fn delivery_list(&$self:ident, $delivery_list_ident:ident: &mut UpdateDeliveryList) { $($delivery_list:tt)* }
}
) => {
$(#[$outer])*
#[derive(Debug, Clone)]
$vis struct $Args {
/// Instant the event happened.
pub timestamp: $crate::DInstant,
$($(#[$arg_outer])* $arg_vis $arg : $arg_ty,)*
propagation_handle: $crate::event::EventPropagationHandle,
}
impl $crate::event::EventArgs for $Args {
}
impl $crate::event::AnyEventArgs for $Args {
fn clone_any(&self) -> std::boxed::Box<dyn $crate::event::AnyEventArgs> {
Box::new(self.clone())
}
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn timestamp(&self) -> $crate::DInstant {
self.timestamp
}
$(#[$delivery_list_outer])*
fn delivery_list(&$self, $delivery_list_ident: &mut $crate::update::UpdateDeliveryList) {
#[allow(unused_imports)]
use $crate::update::UpdateDeliveryList;
$($delivery_list)*
}
fn propagation(&self) -> &$crate::event::EventPropagationHandle {
&self.propagation_handle
}
}
};
}
#[doc(inline)]
pub use crate::event_args;
use crate::update::UpdateDeliveryList;