From 2d29a887db7247a2443d2581f160de0d7071440b Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Fri, 15 Mar 2024 15:50:04 +0100
Subject: [PATCH 01/37] remove static-assertions from dev-dependencies.

There is no need to have the same dependency twice as `[dev-dependencies]` is
the sum of `[dependencies]` and what it adds.
---
 atspi-common/Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/atspi-common/Cargo.toml b/atspi-common/Cargo.toml
index de47cd0e..e40bba00 100644
--- a/atspi-common/Cargo.toml
+++ b/atspi-common/Cargo.toml
@@ -33,7 +33,6 @@ atspi-connection = { path = "../atspi-connection" }
 atspi-proxies = { path = "../atspi-proxies"  }
 rename-item = "0.1.0"
 serde_plain = "1.0.1"
-static_assertions = "1.1.0"
 tokio-stream = { version = "0.1", default-features = false, features = ["time"] }
 tokio = { version = "1", default-features = false, features = ["macros", "rt-multi-thread"] }
 tokio-test = "0.4.2"

From 701f880ed305b540b0f18d5e6cc15cae2d8de4fd Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Mon, 1 Apr 2024 15:21:31 +0200
Subject: [PATCH 02/37] Add strum as dependency

We are exploring deriving simple functionality on public enums using strum.
---
 atspi-common/Cargo.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/atspi-common/Cargo.toml b/atspi-common/Cargo.toml
index e40bba00..f33a16e3 100644
--- a/atspi-common/Cargo.toml
+++ b/atspi-common/Cargo.toml
@@ -22,6 +22,7 @@ tokio = ["zbus/tokio"]
 enumflags2 = "0.7.7"
 serde = "1.0"
 static_assertions = "1.1.0"
+strum = { version = "0.26", features = ["derive"] }
 zbus-lockstep = "0.4.4"
 zbus-lockstep-macros = "0.4.4"
 zbus_names = "3.0"
@@ -30,7 +31,7 @@ zbus = { workspace = true, optional = true, default-features = false }
 
 [dev-dependencies]
 atspi-connection = { path = "../atspi-connection" }
-atspi-proxies = { path = "../atspi-proxies"  }
+atspi-proxies = { path = "../atspi-proxies" }
 rename-item = "0.1.0"
 serde_plain = "1.0.1"
 tokio-stream = { version = "0.1", default-features = false, features = ["time"] }

From 3bcb82cbd7c02dd91dec18af15fef57cae2d1d5b Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Tue, 2 Apr 2024 10:02:10 +0200
Subject: [PATCH 03/37] atspi-proxies remove serde_plain as it is not in use in
 this crate.

---
 atspi-proxies/Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/atspi-proxies/Cargo.toml b/atspi-proxies/Cargo.toml
index 6485da98..64ea636a 100644
--- a/atspi-proxies/Cargo.toml
+++ b/atspi-proxies/Cargo.toml
@@ -35,7 +35,6 @@ byteorder = "1.4"
 futures-lite = { version = "2", default-features = false }
 rename-item = "0.1.0"
 serde_json = "1.0.96"
-serde_plain = "1.0.1"
 tokio = { version = "1", default_features = false, features = ["macros", "rt-multi-thread"] }
 tokio-stream = "0.1"
 tokio-test = "0.4.2"

From 7716ab3fb52a7a14b7cc2640e4732f0cb7b6694a Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Tue, 2 Apr 2024 12:42:02 +0200
Subject: [PATCH 04/37] Changes `Interface` to have IntoStaticStr and Display
 derived

- Remove consts as we cannot use these inside the attribute macros anyway.
  (likely because these are expanded after proc macros get run.)
- Make up for loss of consts by adding tests for each.

Note that this does not include strum::FromRepr because the representation
differs from what is used on the bus, this makes the internal representatation
meaningless to users. Instead I implemented FromStr, which makes more sense.

Because of internal representation and bus representations iffer,
we need custom Serialize and Deserialize implementations.

Note that the Deserializer received a small optimization. No longer is the
interface string required to be copied to stack before converting it to an
`Interface`, instead the `Deserialize` implementation now takes a reference to
the string and converts it.

This also expands tests to cover the changes.
---
 atspi-common/src/interface.rs | 410 +++++++++++++++++++++++++++++++++-
 1 file changed, 405 insertions(+), 5 deletions(-)

diff --git a/atspi-common/src/interface.rs b/atspi-common/src/interface.rs
index f9c7d3fd..ac86334b 100644
--- a/atspi-common/src/interface.rs
+++ b/atspi-common/src/interface.rs
@@ -9,76 +9,161 @@ use serde::{
 	ser::{self, Serializer},
 	Deserialize, Serialize,
 };
-use std::fmt;
+use std::{fmt, str::FromStr};
+use strum::{Display, IntoStaticStr};
 use zvariant::{Signature, Type};
 
+use crate::AtspiError;
+
 /// AT-SPI interfaces an accessible object can implement.
 #[bitflags]
 #[repr(u32)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Display, IntoStaticStr, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Interface {
-	/// Interface to indicate implementation of `AccessibleProxy`.
+	/// Interface to indicate implementation of `AccessibleProxy`.  
 	#[serde(rename = "org.a11y.atspi.Accessible")]
+	#[strum(serialize = "org.a11y.atspi.Accessible")]
 	Accessible,
+
 	/// Interface to indicate implementation of `ActionProxy`.
 	#[serde(rename = "org.a11y.atspi.Action")]
+	#[strum(serialize = "org.a11y.atspi.Action")]
 	Action,
+
 	/// Interface to indicate implementation of `ApplicationProxy`.
 	#[serde(rename = "org.a11y.atspi.Application")]
+	#[strum(serialize = "org.a11y.atspi.Application")]
 	Application,
+
 	/// Interface to indicate implementation of `CacheProxy`.
 	#[serde(rename = "org.a11y.atspi.Cache")]
+	#[strum(serialize = "org.a11y.atspi.Cache")]
 	Cache,
+
 	/// Interface to indicate implementation of `CollectionProxy`.
 	#[serde(rename = "org.a11y.atspi.Collection")]
+	#[strum(serialize = "org.a11y.atspi.Collection")]
 	Collection,
+
 	/// Interface to indicate implementation of `ComponentProxy`.
 	#[serde(rename = "org.a11y.atspi.Component")]
+	#[strum(serialize = "org.a11y.atspi.Component")]
 	Component,
+
 	/// Interface to indicate implementation of `DocumentProxy`.
 	#[serde(rename = "org.a11y.atspi.Document")]
+	#[strum(serialize = "org.a11y.atspi.Document")]
 	Document,
+
 	/// Interface to indicate implementation of `DeviceEventControllerProxy`.
 	#[serde(rename = "org.a11y.atspi.DeviceEventController")]
+	#[strum(serialize = "org.a11y.atspi.DeviceEventController")]
 	DeviceEventController,
+
 	/// Interface to indicate implementation of `DeviceEventListenerProxy`.
 	#[serde(rename = "org.a11y.atspi.DeviceEventListener")]
+	#[strum(serialize = "org.a11y.atspi.DeviceEventListener")]
 	DeviceEventListener,
+
 	/// Interface to indicate implementation of `EditableTextProxy`.
 	#[serde(rename = "org.a11y.atspi.EditableText")]
+	#[strum(serialize = "org.a11y.atspi.EditableText")]
 	EditableText,
+
 	/// Interface to indicate implementation of `HyperlinkProxy`.
 	#[serde(rename = "org.a11y.atspi.Hyperlink")]
+	#[strum(serialize = "org.a11y.atspi.Hyperlink")]
 	Hyperlink,
+
 	/// Interface to indicate implementation of `HypertextProxy`.
 	#[serde(rename = "org.a11y.atspi.Hypertext")]
+	#[strum(serialize = "org.a11y.atspi.Hypertext")]
 	Hypertext,
+
 	/// Interface to indicate implementation of `ImageProxy`.
 	#[serde(rename = "org.a11y.atspi.Image")]
+	#[strum(serialize = "org.a11y.atspi.Image")]
 	Image,
+
 	/// Interface to indicate implementation of `RegistryProxy`.
 	#[serde(rename = "org.a11y.atspi.Registry")]
+	#[strum(serialize = "org.a11y.atspi.Registry")]
 	Registry,
+
 	/// Interface to indicate implementation of `SelectionProxy`.
 	#[serde(rename = "org.a11y.atspi.Selection")]
+	#[strum(serialize = "org.a11y.atspi.Selection")]
 	Selection,
+
 	/// Interface to indicate implementation of `SocketProxy`.
 	#[serde(rename = "org.a11y.atspi.Socket")]
+	#[strum(serialize = "org.a11y.atspi.Socket")]
 	Socket,
+
 	/// Interface to indicate implementation of `TableProxy`.
 	#[serde(rename = "org.a11y.atspi.Table")]
+	#[strum(serialize = "org.a11y.atspi.Table")]
 	Table,
+
 	/// Interface to indicate implementation of `TableCellProxy`.
 	#[serde(rename = "org.a11y.atspi.TableCell")]
+	#[strum(serialize = "org.a11y.atspi.TableCell")]
 	TableCell,
+
 	/// Interface to indicate implementation of `TextProxy`.
 	#[serde(rename = "org.a11y.atspi.Text")]
+	#[strum(serialize = "org.a11y.atspi.Text")]
 	Text,
+
 	/// Interface to indicate implementation of `ValueProxy`.
 	#[serde(rename = "org.a11y.atspi.Value")]
+	#[strum(serialize = "org.a11y.atspi.Value")]
 	Value,
 }
 
+impl Type for Interface {
+	fn signature() -> Signature<'static> {
+		<String as Type>::signature()
+	}
+}
+
+impl FromStr for Interface {
+	type Err = AtspiError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let prefix = "org.a11y.atspi.";
+		if s.starts_with(prefix) {
+			match &s[prefix.len()..] {
+				"Accessible" => Ok(Interface::Accessible),
+				"Action" => Ok(Interface::Action),
+				"Application" => Ok(Interface::Application),
+				"Cache" => Ok(Interface::Cache),
+				"Collection" => Ok(Interface::Collection),
+				"Component" => Ok(Interface::Component),
+				"Document" => Ok(Interface::Document),
+				"DeviceEventController" => Ok(Interface::DeviceEventController),
+				"DeviceEventListener" => Ok(Interface::DeviceEventListener),
+				"EditableText" => Ok(Interface::EditableText),
+				"Hyperlink" => Ok(Interface::Hyperlink),
+				"Hypertext" => Ok(Interface::Hypertext),
+				"Image" => Ok(Interface::Image),
+				"Registry" => Ok(Interface::Registry),
+				"Selection" => Ok(Interface::Selection),
+				"Socket" => Ok(Interface::Socket),
+				"Table" => Ok(Interface::Table),
+				"TableCell" => Ok(Interface::TableCell),
+				"Text" => Ok(Interface::Text),
+				"Value" => Ok(Interface::Value),
+				_ => Err(AtspiError::InterfaceMatch(format!(
+					"No interface found for conversion: {s}"
+				))),
+			}
+		} else {
+			Err(AtspiError::InterfaceMatch(format!("No interface found for conversion: {s}")))
+		}
+	}
+}
+
 /// A collection type which encodes the AT-SPI interfaces an accessible object has implemented.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct InterfaceSet(BitFlags<Interface>);
@@ -191,11 +276,305 @@ impl std::ops::BitOr for InterfaceSet {
 	}
 }
 
+impl std::fmt::Display for InterfaceSet {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		let mut iter = self.0.iter();
+		if let Some(first) = iter.next() {
+			write!(f, "{first}")?;
+			for iface in iter {
+				write!(f, ", {iface}")?;
+			}
+		}
+		Ok(())
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use super::{Interface, InterfaceSet};
-	use zvariant::serialized::Data;
-	use zvariant::{serialized::Context, to_bytes, LE};
+	use std::str::FromStr;
+	use zvariant::{
+		serialized::{Context, Data},
+		to_bytes, Type, LE,
+	};
+
+	#[test]
+	fn interface_into_static_str_impl() {
+		let iface: Interface = Interface::Accessible;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Accessible");
+
+		let iface: Interface = Interface::Action;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Action");
+
+		let iface: Interface = Interface::Application;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Application");
+
+		let iface: Interface = Interface::Cache;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Cache");
+
+		let iface: Interface = Interface::Collection;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Collection");
+
+		let iface: Interface = Interface::Component;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Component");
+
+		let iface: Interface = Interface::Document;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Document");
+
+		let iface: Interface = Interface::DeviceEventController;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.DeviceEventController");
+
+		let iface: Interface = Interface::DeviceEventListener;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.DeviceEventListener");
+
+		let iface: Interface = Interface::EditableText;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.EditableText");
+
+		let iface: Interface = Interface::Hyperlink;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Hyperlink");
+
+		let iface: Interface = Interface::Hypertext;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Hypertext");
+
+		let iface: Interface = Interface::Image;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Image");
+
+		let iface: Interface = Interface::Registry;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Registry");
+
+		let iface: Interface = Interface::Selection;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Selection");
+
+		let iface: Interface = Interface::Socket;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Socket");
+
+		let iface: Interface = Interface::Table;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Table");
+
+		let iface: Interface = Interface::TableCell;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.TableCell");
+
+		let iface: Interface = Interface::Text;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Text");
+
+		let iface = Interface::Value;
+		let iface_str: &'static str = iface.into();
+		assert_eq!(iface_str, "org.a11y.atspi.Value");
+	}
+
+	#[test]
+	fn interface_from_str_impl() {
+		let iface = Interface::from_str("org.a11y.atspi.Accessible").unwrap();
+		assert_eq!(iface, Interface::Accessible);
+
+		let iface = Interface::from_str("org.a11y.atspi.Action").unwrap();
+		assert_eq!(iface, Interface::Action);
+
+		let iface = Interface::from_str("org.a11y.atspi.Application").unwrap();
+		assert_eq!(iface, Interface::Application);
+
+		let iface = Interface::from_str("org.a11y.atspi.Cache").unwrap();
+		assert_eq!(iface, Interface::Cache);
+
+		let iface = Interface::from_str("org.a11y.atspi.Collection").unwrap();
+		assert_eq!(iface, Interface::Collection);
+
+		let iface = Interface::from_str("org.a11y.atspi.Component").unwrap();
+		assert_eq!(iface, Interface::Component);
+
+		let iface = Interface::from_str("org.a11y.atspi.Document").unwrap();
+		assert_eq!(iface, Interface::Document);
+
+		let iface = Interface::from_str("org.a11y.atspi.DeviceEventController").unwrap();
+		assert_eq!(iface, Interface::DeviceEventController);
+
+		let iface = Interface::from_str("org.a11y.atspi.DeviceEventListener").unwrap();
+		assert_eq!(iface, Interface::DeviceEventListener);
+
+		let iface = Interface::from_str("org.a11y.atspi.EditableText").unwrap();
+		assert_eq!(iface, Interface::EditableText);
+
+		let iface = Interface::from_str("org.a11y.atspi.Hyperlink").unwrap();
+		assert_eq!(iface, Interface::Hyperlink);
+
+		let iface = Interface::from_str("org.a11y.atspi.Hypertext").unwrap();
+		assert_eq!(iface, Interface::Hypertext);
+
+		let iface = Interface::from_str("org.a11y.atspi.Image").unwrap();
+		assert_eq!(iface, Interface::Image);
+
+		let iface = Interface::from_str("org.a11y.atspi.Registry").unwrap();
+		assert_eq!(iface, Interface::Registry);
+
+		let iface = Interface::from_str("org.a11y.atspi.Selection").unwrap();
+		assert_eq!(iface, Interface::Selection);
+
+		let iface = Interface::from_str("org.a11y.atspi.Socket").unwrap();
+		assert_eq!(iface, Interface::Socket);
+
+		let iface = Interface::from_str("org.a11y.atspi.Table").unwrap();
+		assert_eq!(iface, Interface::Table);
+
+		let iface = Interface::from_str("org.a11y.atspi.TableCell").unwrap();
+		assert_eq!(iface, Interface::TableCell);
+
+		let iface = Interface::from_str("org.a11y.atspi.Text").unwrap();
+		assert_eq!(iface, Interface::Text);
+
+		let iface = Interface::from_str("org.a11y.atspi.Value").unwrap();
+		assert_eq!(iface, Interface::Value);
+	}
+
+	#[test]
+	fn interface_from_str_impl_no_match() {
+		let res = Interface::from_str("org.a11y.atspi.Foo");
+		assert!(res.is_err());
+
+		let res = Interface::from_str("com.a11y.atspi.Accessible");
+		assert!(res.is_err());
+	}
+
+	#[test]
+	fn interface_display_impl() {
+		assert_eq!(format!("{}", Interface::Accessible), "org.a11y.atspi.Accessible".to_owned());
+		assert_eq!(format!("{}", Interface::Action), "org.a11y.atspi.Action".to_owned());
+		assert_eq!(format!("{}", Interface::Application), "org.a11y.atspi.Application".to_owned());
+		assert_eq!(format!("{}", Interface::Cache), "org.a11y.atspi.Cache".to_owned());
+		assert_eq!(format!("{}", Interface::Collection), "org.a11y.atspi.Collection".to_owned());
+		assert_eq!(format!("{}", Interface::Component), "org.a11y.atspi.Component".to_owned());
+		assert_eq!(format!("{}", Interface::Document), "org.a11y.atspi.Document".to_owned());
+		assert_eq!(
+			format!("{}", Interface::DeviceEventController),
+			"org.a11y.atspi.DeviceEventController".to_owned()
+		);
+		assert_eq!(
+			format!("{}", Interface::DeviceEventListener),
+			"org.a11y.atspi.DeviceEventListener".to_owned()
+		);
+		assert_eq!(
+			format!("{}", Interface::EditableText),
+			"org.a11y.atspi.EditableText".to_owned()
+		);
+		assert_eq!(format!("{}", Interface::Hyperlink), "org.a11y.atspi.Hyperlink".to_owned());
+		assert_eq!(format!("{}", Interface::Hypertext), "org.a11y.atspi.Hypertext".to_owned());
+		assert_eq!(format!("{}", Interface::Image), "org.a11y.atspi.Image".to_owned());
+		assert_eq!(format!("{}", Interface::Registry), "org.a11y.atspi.Registry".to_owned());
+		assert_eq!(format!("{}", Interface::Selection), "org.a11y.atspi.Selection".to_owned());
+		assert_eq!(format!("{}", Interface::Socket), "org.a11y.atspi.Socket".to_owned());
+		assert_eq!(format!("{}", Interface::Table), "org.a11y.atspi.Table".to_owned());
+		assert_eq!(format!("{}", Interface::TableCell), "org.a11y.atspi.TableCell".to_owned());
+		assert_eq!(format!("{}", Interface::Text), "org.a11y.atspi.Text".to_owned());
+		assert_eq!(format!("{}", Interface::Value), "org.a11y.atspi.Value".to_owned());
+	}
+
+	#[test]
+	fn interface_set_display_impl() {
+		let ifaceset = InterfaceSet::new(Interface::Accessible);
+		assert_eq!(format!("{}", ifaceset), "org.a11y.atspi.Accessible");
+
+		let ifaceset = InterfaceSet::new(Interface::Accessible | Interface::Action);
+		assert_eq!(format!("{}", ifaceset), "org.a11y.atspi.Accessible, org.a11y.atspi.Action");
+
+		let ifaceset =
+			InterfaceSet::new(Interface::Accessible | Interface::Action | Interface::Component);
+		assert_eq!(
+			format!("{}", ifaceset),
+			"org.a11y.atspi.Accessible, org.a11y.atspi.Action, org.a11y.atspi.Component"
+		);
+	}
+
+	#[test]
+	fn interface_type_signature() {
+		assert_eq!(Interface::signature().as_str(), "s");
+	}
+
+	#[test]
+	fn interface_set_type_signature() {
+		assert_eq!(InterfaceSet::signature().as_str(), "as");
+	}
+
+	#[test]
+	fn serialize_and_deserialize_accessible_interface() {
+		let ctxt = Context::new_dbus(LE, 0);
+		let encoded = to_bytes(ctxt, &Interface::Accessible).unwrap();
+		assert_eq!(
+			encoded.bytes(),
+			&[
+				25, 0, 0, 0, 111, 114, 103, 46, 97, 49, 49, 121, 46, 97, 116, 115, 112, 105, 46,
+				65, 99, 99, 101, 115, 115, 105, 98, 108, 101, 0
+			]
+		);
+
+		let (decoded, _) = encoded.deserialize::<Interface>().unwrap();
+		assert_eq!(decoded, Interface::Accessible);
+	}
+
+	#[test]
+	fn serialize_and_deserialize_editable_text_interface() {
+		let ctxt = Context::new_dbus(LE, 0);
+		let encoded = to_bytes(ctxt, &Interface::EditableText).unwrap();
+		assert_eq!(
+			encoded.bytes(),
+			&[
+				27, 0, 0, 0, 111, 114, 103, 46, 97, 49, 49, 121, 46, 97, 116, 115, 112, 105, 46,
+				69, 100, 105, 116, 97, 98, 108, 101, 84, 101, 120, 116, 0
+			]
+		);
+
+		let (decoded, _) = encoded.deserialize::<Interface>().unwrap();
+		assert_eq!(decoded, Interface::EditableText);
+	}
+
+	#[test]
+	fn serialize_and_deserialize_hyperlink_interface() {
+		let ctxt = Context::new_dbus(LE, 0);
+		let encoded = to_bytes(ctxt, &Interface::Hyperlink).unwrap();
+		assert_eq!(
+			encoded.bytes(),
+			&[
+				24, 0, 0, 0, 111, 114, 103, 46, 97, 49, 49, 121, 46, 97, 116, 115, 112, 105, 46,
+				72, 121, 112, 101, 114, 108, 105, 110, 107, 0
+			]
+		);
+
+		let (decoded, _) = encoded.deserialize::<Interface>().unwrap();
+		assert_eq!(decoded, Interface::Hyperlink);
+	}
+
+	#[test]
+	fn serialize_and_deserialize_value_interface() {
+		let ctxt = Context::new_dbus(LE, 0);
+		let encoded = to_bytes(ctxt, &Interface::Value).unwrap();
+		assert_eq!(
+			encoded.bytes(),
+			&[
+				20, 0, 0, 0, 111, 114, 103, 46, 97, 49, 49, 121, 46, 97, 116, 115, 112, 105, 46,
+				86, 97, 108, 117, 101, 0
+			]
+		);
+
+		let (decoded, _) = encoded.deserialize::<Interface>().unwrap();
+		assert_eq!(decoded, Interface::Value);
+	}
 
 	#[test]
 	fn serialize_empty_interface_set() {
@@ -249,4 +628,25 @@ mod tests {
 		let (decoded, _) = encoded.deserialize::<InterfaceSet>().unwrap();
 		assert!(object == decoded);
 	}
+
+	#[test]
+	fn match_various_de_serialization_methods() {
+		for iface in InterfaceSet::all().iter() {
+			let displayed = format!("{iface}");
+			let serde_val = serde_plain::to_string(&iface)
+				.unwrap_or_else(|_| panic!("Unable to serialize {iface}"));
+
+			// Check that the Display trait and Serde's serialization match.
+			assert_eq!(
+				displayed, serde_val,
+				"Serde's serialization does not match the Display trait implementation."
+			);
+
+			// Check that the Display trait and TryFrom<&str> match.
+			let from_str = Interface::from_str(&displayed).unwrap();
+			assert_eq!(iface, from_str, "The display trait for {iface} became \"{displayed}\", but was re-serialized as {from_str} via TryFrom<&str>");
+			let serde_from_str: Interface = serde_plain::from_str(&serde_val).unwrap();
+			assert_eq!(serde_from_str, iface, "Serde's deserialization does not match its serialization. {iface} was serialized to \"{serde_val}\", but deserialized into {serde_from_str}");
+		}
+	}
 }

From 33d5a2639c6539e2812fdc000e63bcb1deccea8b Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Tue, 2 Apr 2024 12:55:59 +0200
Subject: [PATCH 05/37] trailing space policing

---
 atspi-proxies/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/atspi-proxies/Cargo.toml b/atspi-proxies/Cargo.toml
index 64ea636a..dafdc543 100644
--- a/atspi-proxies/Cargo.toml
+++ b/atspi-proxies/Cargo.toml
@@ -25,7 +25,7 @@ tokio = ["zbus/tokio", "atspi-common/tokio"]
 [dependencies]
 atspi-common = { path = "../atspi-common", version = "0.5.0", default-features = false }
 serde = { version = "^1.0", default-features = false, features = ["derive"] }
-zbus = { workspace = true } 
+zbus = { workspace = true }
 zvariant = { version = "4.0", default-features = false }
 
 [dev-dependencies]

From d13c4b3376917b35efca49ac60ed7d68396bf81e Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Thu, 4 Apr 2024 15:26:34 +0200
Subject: [PATCH 06/37] Apply strum traits that make sense to RelationType

RelationType is now also checked with zbus_lockstep.
As a consequence the type validation document is updated too.
---
 atspi-common/src/relation_type.rs | 32 +++++++++++++++++++++++++++++--
 type_validation.md                |  1 +
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/atspi-common/src/relation_type.rs b/atspi-common/src/relation_type.rs
index 93f04e61..2fbc794a 100644
--- a/atspi-common/src/relation_type.rs
+++ b/atspi-common/src/relation_type.rs
@@ -1,8 +1,24 @@
 use serde::{Deserialize, Serialize};
+use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
 /// Describes a relationship between one object and another.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type, Hash)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	PartialEq,
+	Eq,
+	FromRepr,
+	IntoStaticStr,
+	Serialize,
+	Deserialize,
+	Type,
+	Hash,
+)]
+#[strum(serialize_all = "snake_case")]
+#[repr(u32)]
 pub enum RelationType {
 	/// Not a meaningful relationship; clients should not normally encounter this value.
 	Null = 0,
@@ -59,7 +75,7 @@ pub enum RelationType {
 	/// that live in a separate process space from the embedding context.
 	EmbeddedBy,
 
-	///Denotes that the object is a transient window or frame associated with another
+	/// Denotes that the object is a transient window or frame associated with another
 	/// onscreen object. Similar to `TooltipFor`, but more general.
 	/// Useful for windows which are technically toplevels but which, for one or more reasons,
 	/// do not explicitly cause their associated window to lose 'window focus'.
@@ -118,3 +134,15 @@ pub enum RelationType {
 	/// Included in upstream [AT-SPI2-CORE](https://gitlab.gnome.org/GNOME/at-spi2-core) since 2.26.
 	ErrorFor,
 }
+
+#[cfg(test)]
+mod tests {
+	use super::RelationType;
+	use zvariant::Type;
+
+	#[test]
+	fn validate_relation_type_signature() {
+		let signature = zbus_lockstep::method_return_signature!("GetRelationSet");
+		assert_eq!(RelationType::signature(), signature.slice(2..3));
+	}
+}
diff --git a/type_validation.md b/type_validation.md
index 5edc8cea..40d7cecd 100644
--- a/type_validation.md
+++ b/type_validation.md
@@ -31,3 +31,4 @@ We leverage [zbus-lockstep](https://github.com/luukvanderduim/zbus-lockstep/) to
 | `Layer` | ✓ | `Component::GetLayer` return type.|
 | `ScrollType` | ✓ | `Component::ScrollTo` argument `type`|
 | `Live` | ✓ | `Event.Object::Announcement` argument `politeness`|
+| `RelationType` | ✓ | Part of `Accessible::GetRelationSet` return type |

From c3c47200477d33ac63c51fe9bc849a090f8324f7 Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Thu, 4 Apr 2024 15:30:03 +0200
Subject: [PATCH 07/37] Role received strum traits

`FromRepr`, `Display`, `IntoStaticStr` and `EnumIter`

I changed two variants that stood out odd:

`Role::Editbar` -> `Role::EditBar`
``Role::CHART` ->  `Role::Chart`

In the case of `EditBar`, this means it is now displayed as "edit bar" instead
of "editbar". If this raises concerns, please inform me why.

the `EnumIter` may be useful in tests.
That being said, this enum has a simple `u32` representation.
fSo checking whether each gets serialized and deserialized feels overly cautious
because `zvariant` is surely able to (de)serialize these.
In other words, it is not our concern to test that. We added no logic to
get this done.

Same goes for `&'static str` matching with the `Display` impl. It does not hurt
to test, but it is not our responsibility.
---
 atspi-common/src/role.rs | 586 ++++++++++++++++++---------------------
 1 file changed, 277 insertions(+), 309 deletions(-)

diff --git a/atspi-common/src/role.rs b/atspi-common/src/role.rs
index 417f67b1..37d209e7 100644
--- a/atspi-common/src/role.rs
+++ b/atspi-common/src/role.rs
@@ -1,289 +1,488 @@
 use serde::{Deserialize, Serialize};
+use strum::{Display, EnumIter, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
-use crate::AtspiError;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type, Hash)]
-/// An accessible object role.
+/// The accessible role that an object represents.
+///
+/// Roles make it possible for various UI toolkits to expose their controls to assistive
+/// technologies (ATs) with a standard interface, regardless of toolkit.
+///
+/// For example, a widget that acts like a conventional push button (appears unpressed; presses
+/// when acted upon; invokes a certain action when pressed) can expose a `Role::PushButton` role.
+///
 /// To think of it in terms of HTML, any semantic element likely has a corollary in this enum.
 /// For example: `<button>`, `<input>`, `<form>` or `<h4>`.
-/// Non-semantic elements like `<span>`, `<div>` and `<b>` will not be represented here, and this information is not passed through via the atspi library.
+/// Non-semantic elements like `<span>`, `<div>` and `<b>` will not be represented here, and this
+/// information is not passed through via the atspi library.
 /// TODO: add examples for GTK/Qt libraries in addition to HTML examples.
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	EnumIter,
+	FromRepr,
+	IntoStaticStr,
+	PartialEq,
+	Eq,
+	Serialize,
+	Deserialize,
+	Type,
+	Hash,
+)]
 #[repr(u32)]
+#[strum(serialize_all = "lowercase")]
 pub enum Role {
 	/// A role indicating an error condition, such as uninitialized Role data, or an error deserializing.
 	Invalid,
+
 	/// Object is a label indicating the keyboard accelerators for the parent.
+	#[strum(serialize = "accelerator label")]
 	AcceleratorLabel,
+
 	/// Object is used to alert the user about something.
 	Alert,
+
 	/// Object contains a dynamic or moving image of some kind.
 	Animation,
+
 	/// Object is a 2d directional indicator.
 	Arrow,
+
 	/// Object contains one or more dates, usually arranged into a 2d list.
 	Calendar,
+
 	/// Object that can be drawn into and is used to trap events.
 	Canvas,
+
 	/// A choice that can be checked or unchecked and provides a separate indicator for the current state.
+	#[strum(serialize = "check box")]
 	CheckBox,
+
 	/// A menu item that behaves like a check box. See [`Self::CheckBox`].
+	#[strum(serialize = "check menu item")]
 	CheckMenuItem,
+
 	/// A specialized dialog that lets the user choose a color.
+	#[strum(serialize = "color chooser")]
 	ColorChooser,
+
 	/// The header for a column of data.
+	#[strum(serialize = "column header")]
 	ColumnHeader,
+
 	/// A list of choices the user can select from.
+	#[strum(serialize = "combo box")]
 	ComboBox,
+
 	/// An object which allows entry of a date.
+	#[strum(serialize = "date editor")]
 	DateEditor,
+
 	/// An inconifed internal frame within a [`Role::DesktopFrame`].
+	#[strum(serialize = "desktop icon")]
 	DesktopIcon,
+
 	/// A pane that supports internal frames and iconified versions of those internal frames.
+	#[strum(serialize = "desktop frame")]
 	DesktopFrame,
+
 	/// An object that allows a value to be changed via rotating a visual element, or which displays a value via such a rotating element.
 	Dial,
+
 	/// A top level window with title bar and a border.
 	Dialog,
+
 	/// A pane that allows the user to navigate through and select the contents of a directory.
+	#[strum(serialize = "directory pane")]
 	DirectoryPane,
+
 	/// An object used for drawing custom user interface elements.
+	#[strum(serialize = "drawing area")]
 	DrawingArea,
+
 	/// A specialized dialog that displays the files in the directory and lets the user select a file, browse a different directory, or specify a filename.
+	#[strum(serialize = "file chooser")]
 	FileChooser,
+
 	/// A object that fills up space in a user interface.
 	Filler,
+
 	/// Don't use, reserved for future use.
+	#[strum(serialize = "focus traversable")]
 	FocusTraversable,
+
 	/// Allows selection of a display font.
+	#[strum(serialize = "font chooser")]
 	FontChooser,
+
 	/// A top level window with a title bar, border, menubar, etc.
 	Frame,
+
 	/// A pane that is guaranteed to be painted on top of all panes beneath it.
+	#[strum(serialize = "glass pane")]
 	GlassPane,
+
 	/// A document container for HTML, whose children represent the document content.
+	#[strum(serialize = "html container")]
 	HTMLContainer,
+
 	/// A small fixed size picture, typically used to decorate components.
 	Icon,
+
 	/// An image, typically static.
 	Image,
+
 	/// A frame-like object that is clipped by a desktop pane.
+	#[strum(serialize = "internal frame")]
 	InternalFrame,
+
 	/// An object used to present an icon or short string in an interface.
 	Label,
+
 	/// A specialized pane that allows its children to be drawn in layers, providing a form of stacking order.
+	#[strum(serialize = "layered pane")]
 	LayeredPane,
+
 	/// An object that presents a list of objects to the user and * allows the user to select one or more of them.
 	List,
+
 	/// An object that represents an element of a list.
+	#[strum(serialize = "list item")]
 	ListItem,
+
 	/// An object usually found inside a menu bar that contains a list of actions the user can choose from.
 	Menu,
+
 	/// An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from.
+	#[strum(serialize = "menu bar")]
 	MenuBar,
+
 	/// An object usually contained in a menu that presents an action the user can choose.
+	#[strum(serialize = "menu item")]
 	MenuItem,
+
 	/// A specialized pane whose primary use is inside a dialog.
+	#[strum(serialize = "option pane")]
 	OptionPane,
+
 	/// An object that is a child of a page tab list.
+	#[strum(serialize = "page tab")]
 	PageTab,
+
 	/// An object that presents a series of panels (or page tabs), one at a time,through some mechanism provided by the object.
+	#[strum(serialize = "page tab list")]
 	PageTabList,
+
 	/// A generic container that is often used to group objects.
 	Panel,
+
 	/// A text object uses for passwords, or other places where the text content is not shown visibly to the user.
+	#[strum(serialize = "password text")]
 	PasswordText,
+
 	/// A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices.
+	#[strum(serialize = "popup menu")]
 	PopupMenu,
+
 	/// An object used to indicate how much of a task has been completed.
+	#[strum(serialize = "progress bar")]
 	ProgressBar,
+
 	/// An object the user can manipulate to tell the application to do something.
+	#[strum(serialize = "push button")]
 	PushButton,
+
 	/// A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked.
+	#[strum(serialize = "radio button")]
 	RadioButton,
+
 	/// Object is both a menu item and a "radio button". See [`Self::RadioButton`].
+	#[strum(serialize = "radio menu item")]
 	RadioMenuItem,
+
 	/// A specialized pane that has a glass pane and a layered pane as its children.
+	#[strum(serialize = "root pane")]
 	RootPane,
+
 	/// The header for a row of data.
+	#[strum(serialize = "row header")]
 	RowHeader,
+
 	/// An object usually used to allow a user to incrementally view a large amount of data by moving the bounds of a viewport along a one-dimensional axis.
+	#[strum(serialize = "scroll bar")]
 	ScrollBar,
+
 	/// A scroll pane: the pane in which the scrollable content is contained within.
 	/// An object that allows a user to incrementally view a large amount of information.
 	/// [`Self::ScrollPane`] objects are usually accompanied by [`Self::ScrollBar`] controllers,
 	/// on which the [`crate::RelationType::ControllerFor`] and [`crate::RelationType::ControlledBy`] reciprocal relations are set.
+	#[strum(serialize = "scroll pane")]
 	ScrollPane,
+
 	/// An object usually contained in a menu to provide a visible and logical separation of the contents in a menu.
 	Separator,
+
 	/// An object that allows the user to select from a bounded range.
 	/// Unlike [`Self::ScrollBar`], [`Self::Slider`] objects need not control 'viewport'-like objects.
 	Slider,
 	/// An object which allows one of a set of choices to be selected, and which displays the current choice.
+	#[strum(serialize = "spin button")]
 	SpinButton,
+
 	/// A specialized panel that presents two other panels at the same time.
+	#[strum(serialize = "split pane")]
 	SplitPane,
+
 	/// Object displays non-quantitative status information (c.f. [`Self::ProgressBar`])
+	#[strum(serialize = "status bar")]
 	StatusBar,
+
 	/// An object used to represent information in terms of rows and columns.
 	Table,
+
 	/// A 'cell' or discrete child within a Table.
 	/// Note: Table cells need not have [`Self::TableCell`], other [`crate::Role`] values are valid as well.
+	#[strum(serialize = "table cell")]
 	TableCell,
+
 	/// An object which labels a particular column in an [`Self::Table`].
+	#[strum(serialize = "table column header")]
 	TableColumnHeader,
+
 	/// An object which labels a particular row in a [`Self::Table`].
 	/// `TableProxy` rows and columns may also be labelled via the
 	/// [`crate::RelationType::LabelFor`]/[`crate::RelationType::LabelledBy`] relationships.
 	/// See: `AccessibleProxy::get_relation_type`.
+	#[strum(serialize = "table row header")]
 	TableRowHeader,
+
 	/// Object allows menu to be removed from menubar and shown in its own window.
+	#[strum(serialize = "tearoff menu item")]
 	TearoffMenuItem,
+
 	/// An object that emulates a terminal.
 	Terminal,
+
 	/// An interactive widget that supports multiple lines of text and optionally accepts user input,
 	/// but whose purpose is not to solicit user input.
 	/// Thus [`Self::Text`] is appropriate for the text view in a plain text editor but inappropriate for an input field in a dialog box or web form.
 	/// For widgets whose purpose is to solicit input from the user, see [`Self::Entry`] and [`Self::PasswordText`].
 	/// For generic objects which display a brief amount of textual information, see [`Self::Static`].
 	Text,
+
 	/// A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state.
+	#[strum(serialize = "toggle button")]
 	ToggleButton,
+
 	/// A bar or palette usually composed of push buttons or toggle buttons.
+	#[strum(serialize = "tool bar")]
 	ToolBar,
+
 	/// An object that provides information about another object.
+	#[strum(serialize = "tool tip")]
 	ToolTip,
+
 	/// An object used to repsent hierarchical information to the user.
 	Tree,
+
 	/// An object that presents both tabular and hierarchical info to the user.
+	#[strum(serialize = "tree table")]
 	TreeTable,
+
 	/// When the role cannot be accurately reported, this role will be set.
 	Unknown,
+
 	/// An object usually used in a scroll pane, or to otherwise clip a larger object or content renderer to a specific onscreen viewport.
 	Viewport,
+
 	/// A top level window with no title or border.
 	Window,
+
 	/// means that the role for this item is known, but not included in the core enumeration.
 	Extended,
+
 	/// An object that serves as a document header.
 	Header,
+
 	/// An object that serves as a document footer.
 	Footer,
+
 	/// An object which is contains a single paragraph of text content. See also [`Self::Text`].
 	Paragraph,
+
 	/// An object which describes margins and tab stops, etc. for text objects which it controls (should have [`crate::RelationType::ControllerFor`] relation to such).
 	Ruler,
+
 	/// An object corresponding to the toplevel accessible of an application, which may contain [`Self::Frame`] objects or other accessible objects.
 	/// Children of objects with the [`Self::DesktopFrame`] role are generally [`Self::Application`] objects.
 	Application,
+
 	/// The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry.
 	Autocomplete,
+
 	/// The object is an editable text object in a toolbar.
-	Editbar,
+	#[strum(serialize = "edit bar")]
+	EditBar,
+
 	/// The object is an embedded component container.
 	/// This role is a "grouping" hint that the contained objects share a context which is different from the container in which this accessible is embedded.
 	/// In particular, it is used for some kinds of document embedding, and for embedding of out-of-process component, "panel applets", etc.
 	Embedded,
+
 	/// The object is a component whose textual content may be entered or modified by the user, provided [`crate::State::Editable`] is present.
 	/// A readonly [`Self::Entry`] object (i.e. where [`crate::State::Editable`] is not present) implies a read-only 'text field' in a form, as opposed to a title, label, or caption.
 	Entry,
+
 	/// The object is a graphical depiction of quantitative data.
 	/// It may contain multiple subelements whose attributes and/or description may be queried to obtain both the  quantitative data and information about how the data is being presented.
 	/// The [`crate::RelationType::LabelledBy`] relation is particularly important in interpreting objects of this type, as is the accessible description property.
 	/// See [`Self::Caption`].
-	CHART,
+	Chart,
+
 	/// The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image.
 	Caption,
+
 	/// The object is a visual frame or container which
 	/// contains a view of document content. [`Self::DocumentFrame`]s may occur within
 	/// another `DocumentProxy` instance, in which case the second  document may be
 	/// said to be embedded in the containing instance.
 	/// HTML frames are often [`Self::DocumentFrame`]:  Either this object, or a singleton descendant,
 	/// should implement the [`crate::Interface::Document`] interface.
+	#[strum(serialize = "document frame")]
 	DocumentFrame,
+
 	/// Heading: this is a heading with a level (usually 1-6). This is represented by `<h1>` through `<h6>` in HTML.
 	/// The object serves as a heading for content which follows it in a document.
 	/// The 'heading level' of the heading, if available, may be obtained by querying the object's attributes.
 	Heading,
+
 	/// The object is a containing instance which encapsulates a page of information.
 	/// [`Self::Page`] is used in documents and content which support a paginated navigation model.
 	Page,
+
 	/// The object is a containing instance of document content which constitutes a particular 'logical' section of the document.
 	/// The type of content within a section, and the nature of the section division itself, may be obtained by querying the object's attributes.
 	/// Sections may be nested.
 	Section,
+
 	/// The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.
 	/// Objects of this role should be ignored by clients, if they are encountered at all.
+	#[strum(serialize = "redundant object")]
 	RedundantObject,
+
 	/// The object is a containing instance of document content which has within it components with which the user can interact in order to input information;
 	/// i.e. the object is a container for pushbuttons, comboboxes, text input fields, and other 'GUI' components.
 	/// [`Self::Form`] should not, in general, be used for toplevel GUI containers or dialogs, but should be reserved for 'GUI' containers which occur within document content, for instance within Web documents, presentations, or text documents.
 	/// Unlike other GUI containers and dialogs which occur inside application instances, [`Self::Form`] containers' components are associated with the current document, rather than the current foreground application or viewer instance.
 	Form,
+
 	/// The object is a hypertext anchor, i.e. a "link" in a hypertext document.
 	/// Such objects are distinct from 'inline' content which may also use the [`crate::Interface::Hypertext`]/[`crate::Interface::Hyperlink`] interfaces to indicate the range/location within a text object where an inline or embedded object lies.
 	Link,
+
 	/// The object is a window or similar viewport which is used to allow composition or input of a 'complex character', in other words it is an "input method window".
+	#[strum(serialize = "input method window")]
 	InputMethodWindow,
+
 	/// A row in a table.
+	#[strum(serialize = "table row")]
 	TableRow,
+
 	/// An object that represents an element of a tree.
+	#[strum(serialize = "tree item")]
 	TreeItem,
+
 	/// A document frame which contains a spreadsheet.
+	#[strum(serialize = "document spreadsheet")]
 	DocumentSpreadsheet,
+
 	/// A document frame which contains a presentation or slide content.
+	#[strum(serialize = "document presentation")]
 	DocumentPresentation,
+
 	/// A document frame which contains textual content, such as found in a word processing application.
+	#[strum(serialize = "document text")]
 	DocumentText,
+
 	/// A document frame which contains HTML or other markup suitable for display in a web browser.
+	#[strum(serialize = "document web")]
 	DocumentWeb,
+
 	/// A document frame which contains email content to be displayed or composed either in plain text or HTML.
+	#[strum(serialize = "document email")]
 	DocumentEmail,
+
 	/// An object found within a document and designed to present a comment, note, or other annotation.
 	/// In some cases, this object might not be visible until activated.
 	Comment,
+
 	/// A non-collapsible list of choices the user can select from.
+	#[strum(serialize = "list box")]
 	ListBox,
+
 	/// A group of related widgets. This group typically has a label.
 	Grouping,
+
 	/// An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document.
+	#[strum(serialize = "image map")]
 	ImageMap,
+
 	/// A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.
 	Notification,
+
 	/// An object designed to present a message to the user within an existing window.
+	#[strum(serialize = "info bar")]
 	InfoBar,
+
 	/// A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.
+	#[strum(serialize = "level bar")]
 	LevelBar,
+
 	/// A bar that serves as the title of a window or a dialog.
+	#[strum(serialize = "title bar")]
 	TitleBar,
+
 	/// An object which contains a text section that is quoted from another source.
+	#[strum(serialize = "block quote")]
 	BlockQuote,
+
 	/// An object which represents an audio element.
 	Audio,
+
 	/// An object which represents a video element.
 	Video,
+
 	/// A definition of a term or concept.
 	Definition,
+
 	/// A section of a page that consists of a composition that forms an independent part of a document, page, or site.
 	/// Examples: A blog entry, a news story, a forum post.
 	Article,
+
 	/// A region of a web page intended as a navigational landmark. This is designed to allow Assistive Technologies to provide quick navigation among key regions within a document.
 	Landmark,
+
 	/// A text widget or container holding log content, such as chat history and error logs. In this role there is a relationship between the arrival of new items in the log and the reading order.
 	/// The log contains a meaningful sequence and new information is added only to the end of the log, not at arbitrary points.
 	Log,
+
 	/// A container where non-essential information changes frequently.
 	/// Common usages of marquee include stock tickers and ad banners.
 	/// The primary difference between a marquee and a log is that logs usually have a meaningful order or sequence of important content changes.
 	Marquee,
+
 	/// A text widget or container that holds a mathematical expression.
 	Math,
+
 	/// A rating system, generally out of five stars, but it does not need to be that way. There is no tag nor role for this in HTML, however.
 	/// A widget whose purpose is to display a rating, such as the number of stars associated with a song in a media player.
 	/// Objects of this role should also implement [`crate::Interface::Value`].
 	Rating,
+
 	/// An object containing a numerical counter which indicates an amount of elapsed time from a start point, or the time remaining until an end point.
 	Timer,
+
 	/// A generic non-container object whose purpose is to display a brief amount of information to the user and whose role is known by the implementor but lacks semantic value for the user.
 	/// Examples in which [`Self::Static`] is appropriate include the message displayed in a message box and an image used as an alternative means to display text.
 	/// [`Self::Static`] should not be applied to widgets which are traditionally interactive, objects which display a significant amount of content, or any object which has an accessible relation pointing to another object.
@@ -292,357 +491,126 @@ pub enum Role {
 	/// For text views, see [`Self::Text`].
 	/// For generic containers, see [`Self::Panel`]. For objects whose role is not known by the implementor, see [`Self::Unknown`].
 	Static,
+
 	/// An object that represents a mathematical fraction.
+	#[strum(serialize = "math fraction")]
 	MathFraction,
+
 	/// An object that represents a mathematical expression displayed with a radical.
+	#[strum(serialize = "math root")]
 	MathRoot,
+
 	/// An object that contains text that is displayed as a subscript.
 	Subscript,
+
 	/// An object that contains text that is displayed as a superscript.
 	Superscript,
+
 	/// An object that represents a list of term-value groups.
 	/// A term-value group represents an individual description and consist of one or more names ([`Self::DescriptionTerm`]) followed by one or more values ([`Self::DescriptionValue`]).
 	/// For each list, there should not be more than one group with the same term name.
+	#[strum(serialize = "description list")]
 	DescriptionList,
+
 	/// An object that represents a term or phrase with a corresponding definition.
+	#[strum(serialize = "description term")]
 	DescriptionTerm,
+
 	/// An object that represents the description, definition, or value of a term.
+	#[strum(serialize = "description value")]
 	DescriptionValue,
+
 	/// An object that contains the text of a footnote.
 	Footnote,
+
 	/// Content previously deleted or proposed to be deleted, e.g. in revision history or a content view providing suggestions from reviewers.
+	#[strum(serialize = "content deletion")]
 	ContentDeletion,
+
 	/// Content previously inserted or proposed to be inserted, e.g. in revision history or a content view providing suggestions from reviewers.
+	#[strum(serialize = "content insertion")]
 	ContentInsertion,
+
 	/// A run of content that is marked or highlighted, such as for reference purposes, or to call it out as having a special purpose.
 	/// If the marked content has an associated section in the document elaborating on the reason for the mark, then [`crate::RelationType::Details`] should be used on the mark to point to that associated section.
 	/// In addition, the reciprocal relation [`crate::RelationType::DetailsFor`] should be used on the associated content section to point back to the mark.
 	Mark,
+
 	/// A container for content that is called out as a proposed change from the current version of the document, such as by a reviewer of the content.
 	/// An object with this role should include children with [`Self::ContentDeletion`] and/or [`Self::ContentInsertion`], in any order, to indicate what the actual change is.
 	Suggestion,
+
 	/// A specialized push button to open a menu.
+	#[strum(serialize = "push button menu")]
 	PushButtonMenu,
 }
 
-impl TryFrom<u32> for Role {
-	type Error = AtspiError;
-
-	#[allow(clippy::too_many_lines)]
-	fn try_from(value: u32) -> Result<Self, Self::Error> {
-		#[allow(clippy::enum_glob_use)]
-		use Role::*;
-		let res = match value {
-			0 => Invalid,
-			1 => AcceleratorLabel,
-			2 => Alert,
-			3 => Animation,
-			4 => Arrow,
-			5 => Calendar,
-			6 => Canvas,
-			7 => CheckBox,
-			8 => CheckMenuItem,
-			9 => ColorChooser,
-			10 => ColumnHeader,
-			11 => ComboBox,
-			12 => DateEditor,
-			13 => DesktopIcon,
-			14 => DesktopFrame,
-			15 => Dial,
-			16 => Dialog,
-			17 => DirectoryPane,
-			18 => DrawingArea,
-			19 => FileChooser,
-			20 => Filler,
-			21 => FocusTraversable,
-			22 => FontChooser,
-			23 => Frame,
-			24 => GlassPane,
-			25 => HTMLContainer,
-			26 => Icon,
-			27 => Image,
-			28 => InternalFrame,
-			29 => Label,
-			30 => LayeredPane,
-			31 => List,
-			32 => ListItem,
-			33 => Menu,
-			34 => MenuBar,
-			35 => MenuItem,
-			36 => OptionPane,
-			37 => PageTab,
-			38 => PageTabList,
-			39 => Panel,
-			40 => PasswordText,
-			41 => PopupMenu,
-			42 => ProgressBar,
-			43 => PushButton,
-			44 => RadioButton,
-			45 => RadioMenuItem,
-			46 => RootPane,
-			47 => RowHeader,
-			48 => ScrollBar,
-			49 => ScrollPane,
-			50 => Separator,
-			51 => Slider,
-			52 => SpinButton,
-			53 => SplitPane,
-			54 => StatusBar,
-			55 => Table,
-			56 => TableCell,
-			57 => TableColumnHeader,
-			58 => TableRowHeader,
-			59 => TearoffMenuItem,
-			60 => Terminal,
-			61 => Text,
-			62 => ToggleButton,
-			63 => ToolBar,
-			64 => ToolTip,
-			65 => Tree,
-			66 => TreeTable,
-			67 => Unknown,
-			68 => Viewport,
-			69 => Window,
-			70 => Extended,
-			71 => Header,
-			72 => Footer,
-			73 => Paragraph,
-			74 => Ruler,
-			75 => Application,
-			76 => Autocomplete,
-			77 => Editbar,
-			78 => Embedded,
-			79 => Entry,
-			80 => CHART,
-			81 => Caption,
-			82 => DocumentFrame,
-			83 => Heading,
-			84 => Page,
-			85 => Section,
-			86 => RedundantObject,
-			87 => Form,
-			88 => Link,
-			89 => InputMethodWindow,
-			90 => TableRow,
-			91 => TreeItem,
-			92 => DocumentSpreadsheet,
-			93 => DocumentPresentation,
-			94 => DocumentText,
-			95 => DocumentWeb,
-			96 => DocumentEmail,
-			97 => Comment,
-			98 => ListBox,
-			99 => Grouping,
-			100 => ImageMap,
-			101 => Notification,
-			102 => InfoBar,
-			103 => LevelBar,
-			104 => TitleBar,
-			105 => BlockQuote,
-			106 => Audio,
-			107 => Video,
-			108 => Definition,
-			109 => Article,
-			110 => Landmark,
-			111 => Log,
-			112 => Marquee,
-			113 => Math,
-			114 => Rating,
-			115 => Timer,
-			116 => Static,
-			117 => MathFraction,
-			118 => MathRoot,
-			119 => Subscript,
-			120 => Superscript,
-			121 => DescriptionList,
-			122 => DescriptionTerm,
-			123 => DescriptionValue,
-			124 => Footnote,
-			125 => ContentDeletion,
-			126 => ContentInsertion,
-			127 => Mark,
-			128 => Suggestion,
-			129 => PushButtonMenu,
-			_ => return Err(AtspiError::UnknownRole(value)),
-		};
-		Ok(res)
-	}
-}
-
-const ROLE_NAMES: &[&str] = &[
-	"invalid",
-	"accelerator label",
-	"alert",
-	"animation",
-	"arrow",
-	"calendar",
-	"canvas",
-	"check box",
-	"check menu item",
-	"color chooser",
-	"column header",
-	"combo box",
-	"date editor",
-	"desktop icon",
-	"desktop frame",
-	"dial",
-	"dialog",
-	"directory pane",
-	"drawing area",
-	"file chooser",
-	"filler",
-	"focus traversable",
-	"font chooser",
-	"frame",
-	"glass pane",
-	"html container",
-	"icon",
-	"image",
-	"internal frame",
-	"label",
-	"layered pane",
-	"list",
-	"list item",
-	"menu",
-	"menu bar",
-	"menu item",
-	"option pane",
-	"page tab",
-	"page tab list",
-	"panel",
-	"password text",
-	"popup menu",
-	"progress bar",
-	"push button",
-	"radio button",
-	"radio menu item",
-	"root pane",
-	"row header",
-	"scroll bar",
-	"scroll pane",
-	"separator",
-	"slider",
-	"spin button",
-	"split pane",
-	"status bar",
-	"table",
-	"table cell",
-	"table column header",
-	"table row header",
-	"tearoff menu item",
-	"terminal",
-	"text",
-	"toggle button",
-	"tool bar",
-	"tool tip",
-	"tree",
-	"tree table",
-	"unknown",
-	"viewport",
-	"window",
-	"extended",
-	"header",
-	"footer",
-	"paragraph",
-	"ruler",
-	"application",
-	"autocomplete",
-	"editbar",
-	"embedded",
-	"entry",
-	"chart",
-	"caption",
-	"document frame",
-	"heading",
-	"page",
-	"section",
-	"redundant object",
-	"form",
-	"link",
-	"input method window",
-	"table row",
-	"tree item",
-	"document spreadsheet",
-	"document presentation",
-	"document text",
-	"document web",
-	"document email",
-	"comment",
-	"list box",
-	"grouping",
-	"image map",
-	"notification",
-	"info bar",
-	"level bar",
-	"title bar",
-	"block quote",
-	"audio",
-	"video",
-	"definition",
-	"article",
-	"landmark",
-	"log",
-	"marquee",
-	"math",
-	"rating",
-	"timer",
-	"static",
-	"math fraction",
-	"math root",
-	"subscript",
-	"superscript",
-	"description list",
-	"description term",
-	"description value",
-	"footnote",
-	"content deletion",
-	"content insertion",
-	"mark",
-	"suggestion",
-	"push button menu",
-];
-
 impl Role {
 	/// Get a readable, English name from the role.
 	#[must_use]
 	pub fn name(&self) -> &'static str {
-		ROLE_NAMES[*self as usize]
-	}
-}
-
-impl std::fmt::Display for Role {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f, "{}", self.name())
+		let s: &'static str = (*self).into();
+		s
 	}
 }
 
 #[cfg(test)]
 pub mod tests {
 	use super::Role;
+	use strum::IntoEnumIterator;
 	use zvariant::serialized::Context;
 	use zvariant::{to_bytes, LE};
 
-	const HIGHEST_ROLE_VALUE: u32 = 129;
-
 	#[test]
-	fn test_serialization_matches_from_impl() {
+	fn test_serialization_matches_fromreor_impl() {
 		let ctxt = Context::new_dbus(LE, 0);
 
-		for role_num in 1..=HIGHEST_ROLE_VALUE {
-			let from_role = Role::try_from(role_num)
-				.unwrap_or_else(|_| panic!("Unable to convert {role_num} into Role"));
-			let encoded = to_bytes(ctxt, &from_role)
-				.unwrap_or_else(|_| panic!("Unable to encode {from_role}"));
-			println!("ENCODED: {encoded:?}");
-
-			let (zbus_role, _) = encoded.deserialize().expect("Unable to decode {encoded:?}");
-
-			assert_eq!(from_role, zbus_role, "The serde `Data::deserialize` and `From<u32>` impls produced different results. The number used was {role_num}, it produced a Role of {from_role}, but the from_slice(...) implementation produced {zbus_role}");
-			assert_eq!(
-				from_role as u32, role_num,
-				"The role number {role_num} does not match the representation of the role {}",
-				from_role as u32
-			);
+		for role in Role::iter() {
+			let encoded = to_bytes(ctxt, &role)
+				.expect("A valid Role with well known representation should serialize.");
+
+			let (zbus_role, _) = encoded.deserialize().expect("Unable to decode encoded");
+
+			assert_eq!(role, zbus_role, "The serde `Data::deserialize`d Role and Role appear to be unequal. role: \"{role}\", deserialized role: \"{zbus_role}\"");
+		}
+	}
+
+	#[test]
+	fn test_role_name() {
+		assert_eq!(Role::Invalid.name(), "invalid");
+		assert_eq!(Role::AcceleratorLabel.name(), "accelerator label");
+		assert_eq!(Role::Alert.name(), "alert");
+		assert_eq!(Role::Animation.name(), "animation");
+		assert_eq!(Role::Calendar.name(), "calendar");
+		assert_eq!(Role::CheckBox.name(), "check box");
+		assert_eq!(Role::CheckMenuItem.name(), "check menu item");
+		assert_eq!(Role::ComboBox.name(), "combo box");
+		assert_eq!(Role::DateEditor.name(), "date editor");
+		assert_eq!(Role::DrawingArea.name(), "drawing area");
+
+		//
+		assert_eq!(Role::EditBar.name(), "edit bar");
+		assert_eq!(Role::Chart.name(), "chart");
+
+		assert_eq!(Role::Superscript.name(), "superscript");
+		assert_eq!(Role::DescriptionList.name(), "description list");
+		assert_eq!(Role::DescriptionTerm.name(), "description term");
+		assert_eq!(Role::DescriptionValue.name(), "description value");
+		assert_eq!(Role::Footnote.name(), "footnote");
+		assert_eq!(Role::ContentDeletion.name(), "content deletion");
+		assert_eq!(Role::ContentInsertion.name(), "content insertion");
+		assert_eq!(Role::Mark.name(), "mark");
+		assert_eq!(Role::Suggestion.name(), "suggestion");
+		assert_eq!(Role::PushButtonMenu.name(), "push button menu");
+	}
+
+	// Testing Display impl is more a strum responsibility, but it's good to have a test here.
+	#[test]
+	fn test_role_display() {
+		for role in Role::iter() {
+			let role_str = role.to_string();
+			let role_static_str = role.name();
+			assert_eq!(role_str, role_static_str, "Role display impl \"{role_str}\" should match the static name: \"{role_static_str}\"");
 		}
 	}
 }

From a7a92efb3057df51591cddaf2d0169f966b77c9b Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Thu, 4 Apr 2024 15:43:31 +0200
Subject: [PATCH 08/37] Clippy suggestion / optimization

Clipyp suggests not to index in the match argument.
Using `strip_prefix` exits early or hands the match string to `match`.

The indexing pattern ``` &match_me[prefix.len()..] {} ```
May be more expensive becaus it requires a bounds check and requires panic code
to go alongside. (TIL)
---
 atspi-common/src/interface.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/atspi-common/src/interface.rs b/atspi-common/src/interface.rs
index ac86334b..95cce7e7 100644
--- a/atspi-common/src/interface.rs
+++ b/atspi-common/src/interface.rs
@@ -130,10 +130,9 @@ impl Type for Interface {
 impl FromStr for Interface {
 	type Err = AtspiError;
 
-	fn from_str(s: &str) -> Result<Self, Self::Err> {
-		let prefix = "org.a11y.atspi.";
-		if s.starts_with(prefix) {
-			match &s[prefix.len()..] {
+	fn from_str(iface_str: &str) -> Result<Self, Self::Err> {
+		if let Some(iface_id) = iface_str.strip_prefix("org.a11y.atspi.") {
+			match iface_id {
 				"Accessible" => Ok(Interface::Accessible),
 				"Action" => Ok(Interface::Action),
 				"Application" => Ok(Interface::Application),
@@ -155,11 +154,11 @@ impl FromStr for Interface {
 				"Text" => Ok(Interface::Text),
 				"Value" => Ok(Interface::Value),
 				_ => Err(AtspiError::InterfaceMatch(format!(
-					"No interface found for conversion: {s}"
+					"No interface which matches id: \"{iface_id}\""
 				))),
 			}
 		} else {
-			Err(AtspiError::InterfaceMatch(format!("No interface found for conversion: {s}")))
+			Err(AtspiError::InterfaceMatch(format!("No interface matches: \"{iface_str}\"")))
 		}
 	}
 }

From 84507aa69b62f053026d0afc62c97d979a53eccd Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Fri, 5 Apr 2024 11:48:52 +0200
Subject: [PATCH 09/37] Various types gain derived strum traits

`FromRepr`, `Display`, `IntoStaticStr` now implemented for

- `Live`
- `ScrollType`
- `Layer`
- `Granularity`
- `ClipType`
- `CoordType`
- `MatchType`
- `TreeTraversalType`
- `SortOrder`

These _currently use 'snake_case' character translations, but we can
pick some other scheme. I would really like some feedback and thoughts here.

The derive macros are now found just above the type instead of above the comments.
This makes it easier to see which implementations a type has derived, especially
if the docs on the type are more than just a few lines.
---
 atspi-common/src/lib.rs | 181 +++++++++++++++++++++++++++++++++-------
 1 file changed, 149 insertions(+), 32 deletions(-)

diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index 69619795..bce1a7ca 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -32,6 +32,7 @@ mod relation_type;
 pub use relation_type::RelationType;
 
 use serde::{Deserialize, Serialize};
+use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
 pub type Result<T> = std::result::Result<T, AtspiError>;
@@ -48,12 +49,26 @@ pub type MatchArgs<'a> = (
 	bool,
 );
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[repr(u32)]
 /// Enumeration used by interface `CollectionProxy` to specify the way [`ObjectRef`]
 /// objects should be sorted.
 ///
 /// [`ObjectRef`]: crate::object_ref::ObjectRef
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum SortOrder {
 	/// Invalid sort order
 	Invalid,
@@ -72,8 +87,22 @@ pub enum SortOrder {
 }
 
 /// Method of traversing a tree in the `CollectionProxy`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
 #[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum TreeTraversalType {
 	/// Restrict children tree traversal
 	RestrictChildren,
@@ -83,11 +112,25 @@ pub enum TreeTraversalType {
 	Inorder,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[repr(i32)]
 /// Enumeration used by [`MatchArgs`] to specify how to interpret [`ObjectRef`] objects.
 ///
 /// [`ObjectRef`]: crate::object_ref::ObjectRef
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	IntoStaticStr,
+	Hash,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(i32)]
+#[strum(serialize_all = "snake_case")]
 pub enum MatchType {
 	/// Invalid match type
 	Invalid,
@@ -102,9 +145,23 @@ pub enum MatchType {
 	Empty,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[repr(u32)]
 /// The coordinate type encodes the frame of reference.
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum CoordType {
 	/// In relation to the entire screen.
 	Screen,
@@ -114,9 +171,23 @@ pub enum CoordType {
 	Parent,
 }
 
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[repr(u32)]
 /// Enumeration used by `TextProxy` to indicate how to treat characters intersecting bounding boxes.
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum ClipType {
 	/// No characters/glyphs are omitted.
 	Neither,
@@ -128,9 +199,23 @@ pub enum ClipType {
 	Both,
 }
 
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[repr(u32)]
 /// Level of granularity to get text of, in relation to a cursor position.
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum Granularity {
 	/// Gives the character at the index of the cursor. With a line-style cursor (which is standard) this will get the character that appears after the cursor.
 	Char,
@@ -158,7 +243,22 @@ pub enum Granularity {
 /// the recommended heuristic is first child paints first. In other words,
 /// assume that the first siblings in the child list are subject to being
 /// overpainted by later siblings if their bounds intersect.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum Layer {
 	/// Indicates an error condition or uninitialized value.
 	Invalid,
@@ -184,7 +284,22 @@ pub enum Layer {
 }
 
 /// Enumeration used by interface the [`crate::interface::Interface::Accessible`] to specify where an object should be placed on the screen when using `scroll_to`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
+#[repr(u32)]
+#[strum(serialize_all = "snake_case")]
 pub enum ScrollType {
 	/// Scroll the object to the top left corner of the window.
 	TopLeft,
@@ -207,8 +322,23 @@ pub enum ScrollType {
 /// for `Announcement` events, but it may be used for additional purposes
 /// in the future.
 /// The argument in the `Announcement` event is named `politeness`.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize, Type)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Default,
+	Display,
+	Eq,
+	FromRepr,
+	Hash,
+	IntoStaticStr,
+	PartialEq,
+	Serialize,
+	Deserialize,
+	Type,
+)]
 #[repr(i32)]
+#[strum(serialize_all = "snake_case")]
 pub enum Live {
 	/// No live region.
 	#[default]
@@ -219,19 +349,6 @@ pub enum Live {
 	Assertive,
 }
 
-impl TryFrom<i32> for Live {
-	type Error = AtspiError;
-
-	fn try_from(value: i32) -> std::result::Result<Self, Self::Error> {
-		match value {
-			0 => Ok(Live::None),
-			1 => Ok(Live::Polite),
-			2 => Ok(Live::Assertive),
-			_ => Err(AtspiError::Conversion("Unknown Live variant")),
-		}
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -241,11 +358,11 @@ mod tests {
 
 	#[test]
 	fn convert_i32_to_live() {
-		assert_eq!(Live::None, Live::try_from(0).unwrap());
-		assert_eq!(Live::Polite, Live::try_from(1).unwrap());
-		assert_eq!(Live::Assertive, Live::try_from(2).unwrap());
-		assert!(Live::try_from(3).is_err());
-		assert!(Live::try_from(-1).is_err());
+		assert_eq!(Live::None, Live::from_repr(0).unwrap());
+		assert_eq!(Live::Polite, Live::from_repr(1).unwrap());
+		assert_eq!(Live::Assertive, Live::from_repr(2).unwrap());
+		assert!(Live::from_repr(3).is_none());
+		assert!(Live::from_repr(-1).is_none());
 	}
 
 	#[test]

From ce4b10a9b9b0b75320a038afd4711e12ef376b0e Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Fri, 5 Apr 2024 13:10:59 +0200
Subject: [PATCH 10/37] Adjust to `Role` changes

Use `from_repr() -> Role` instead of `From<i32> for Role`.
Remove import for a single use of `Hash`.
---
 atspi-common/src/events/object.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 189f2744..90160a7c 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -1,9 +1,7 @@
-use std::hash::Hash;
-
 use crate::{
 	error::AtspiError,
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, State,
+	Event, Live, State,
 };
 use zvariant::{ObjectPath, OwnedValue, Value};
 
@@ -73,7 +71,7 @@ pub struct PropertyChangeEvent {
 	pub value: Property,
 }
 
-impl Hash for PropertyChangeEvent {
+impl core::hash::Hash for PropertyChangeEvent {
 	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 		self.item.hash(state);
 		self.property.hash(state);
@@ -166,9 +164,7 @@ impl TryFrom<EventBodyOwned> for Property {
 					.any_data
 					.try_into()
 					.map_err(|_| AtspiError::ParseError("accessible-role"))?;
-				let role: crate::Role = crate::Role::try_from(role_int)
-					.map_err(|_| AtspiError::ParseError("accessible-role"))?;
-				role
+				crate::Role::from_repr(role_int).ok_or(AtspiError::ParseError("accessible-role"))?
 			})),
 			"accessible-parent" => Ok(Self::Parent(
 				body.any_data
@@ -651,7 +647,8 @@ impl GenericEvent<'_> for AnnouncementEvent {
 		Ok(Self {
 			item,
 			text: body.any_data.try_into().map_err(|_| AtspiError::Conversion("text"))?,
-			live: body.detail1.try_into()?,
+			live: Live::from_repr(body.detail1)
+				.ok_or(AtspiError::Conversion("\"detail1\" not convertable to \"Live\""))?,
 		})
 	}
 	fn sender(&self) -> String {

From 68196c1f9d931343e600bc224a4a1f2397ffe5aa Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Sun, 7 Apr 2024 16:45:32 +0200
Subject: [PATCH 11/37] Adds strum derivation on `State` enum

- Adds notes tp clarify peculiarities found when revisiting this module.
- Adds strum derives `IntoStaticStr`, `Display` and `FromRepr`
---
 atspi-common/src/state.rs | 199 +++++++++++++++++++-------------------
 1 file changed, 99 insertions(+), 100 deletions(-)

diff --git a/atspi-common/src/state.rs b/atspi-common/src/state.rs
index 92661174..b1661997 100644
--- a/atspi-common/src/state.rs
+++ b/atspi-common/src/state.rs
@@ -4,16 +4,48 @@ use serde::{
 	ser::{SerializeSeq, Serializer},
 	Deserialize, Serialize,
 };
-use std::fmt;
+use std::{fmt, str::FromStr};
+use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::{Signature, Type};
 
+use crate::AtspiError;
+
+// Notes on peculiarities of the AT-SPI2 API and how they are handled in this module:
+//
+// `State` is counterpart to the `AtspiStateType` enum in the C AT-SPI2 library.
+// The `StateChanged` signal (see: `Event.xml`) uses 'string' to encode the state,
+// (NOT by a `u32` representing the enum variant!)
+// `State`'s Rust representation is a `u64` bitfield, which is then serialized /
+// deserialized to / from a string.
+// The bitfield representation comes in handy when in use with the `StateSet` struct.
+//
+// The `GetState` method (see: `Accessible.xml`) encodes any combination of states using a bitfield.
+// This is currently achieved by sending an array of two `u32`s, which is then interpreted as a `u64`.
+// (NOT by sending a `u64` directly! )
+// so we need to serialize / deserialize `StateSet` to and from a bitfield.
+// `StateSet` is counterpart to the `AtspiStateSet` struct in the C AT-SPI2 library.
+
 /// Used by various interfaces indicating every possible state
 /// of an accessibility object.
 #[bitflags]
 #[non_exhaustive]
 #[repr(u64)]
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Default)]
+#[derive(
+	Clone,
+	Copy,
+	Debug,
+	Display,
+	FromRepr,
+	IntoStaticStr,
+	Serialize,
+	Deserialize,
+	PartialEq,
+	Eq,
+	Hash,
+	Default,
+)]
 #[serde(rename_all = "kebab-case")]
+#[strum(serialize_all = "kebab-case")]
 pub enum State {
 	/// Indicates an invalid state - probably an error condition.
 	#[default]
@@ -221,112 +253,79 @@ pub enum State {
 	ReadOnly,
 }
 
-impl From<State> for String {
-	fn from(state: State) -> String {
-		match state {
-			State::Invalid => "invalid",
-			State::Active => "active",
-			State::Armed => "armed",
-			State::Busy => "busy",
-			State::Checked => "checked",
-			State::Collapsed => "collapsed",
-			State::Defunct => "defunct",
-			State::Editable => "editable",
-			State::Enabled => "enabled",
-			State::Expandable => "expandable",
-			State::Expanded => "expanded",
-			State::Focusable => "focusable",
-			State::Focused => "focused",
-			State::HasTooltip => "has-tooltip",
-			State::Horizontal => "horizontal",
-			State::Iconified => "iconified",
-			State::Modal => "modal",
-			State::MultiLine => "multi-line",
-			State::Multiselectable => "multiselectable",
-			State::Opaque => "opaque",
-			State::Pressed => "pressed",
-			State::Resizable => "resizable",
-			State::Selectable => "selectable",
-			State::Selected => "selected",
-			State::Sensitive => "sensitive",
-			State::Showing => "showing",
-			State::SingleLine => "single-line",
-			State::Stale => "stale",
-			State::Transient => "transient",
-			State::Vertical => "vertical",
-			State::Visible => "visible",
-			State::ManagesDescendants => "manages-descendants",
-			State::Indeterminate => "indeterminate",
-			State::Required => "required",
-			State::Truncated => "truncated",
-			State::Animated => "animated",
-			State::InvalidEntry => "invalid-entry",
-			State::SupportsAutocompletion => "supports-autocompletion",
-			State::SelectableText => "selectable-text",
-			State::IsDefault => "is-default",
-			State::Visited => "visited",
-			State::Checkable => "checkable",
-			State::HasPopup => "has-popup",
-			State::ReadOnly => "read-only",
+// Fallible conversion from &str to State
+impl FromStr for State {
+	type Err = AtspiError;
+
+	fn from_str(s: &str) -> Result<State, Self::Err> {
+		match s {
+			"invalid" => Ok(State::Invalid),
+			"active" => Ok(State::Active),
+			"armed" => Ok(State::Armed),
+			"busy" => Ok(State::Busy),
+			"checked" => Ok(State::Checked),
+			"collapsed" => Ok(State::Collapsed),
+			"defunct" => Ok(State::Defunct),
+			"editable" => Ok(State::Editable),
+			"enabled" => Ok(State::Enabled),
+			"expandable" => Ok(State::Expandable),
+			"expanded" => Ok(State::Expanded),
+			"focusable" => Ok(State::Focusable),
+			"focused" => Ok(State::Focused),
+			"has-tooltip" => Ok(State::HasTooltip),
+			"horizontal" => Ok(State::Horizontal),
+			"iconified" => Ok(State::Iconified),
+			"modal" => Ok(State::Modal),
+			"multi-line" => Ok(State::MultiLine),
+			"multiselectable" => Ok(State::Multiselectable),
+			"opaque" => Ok(State::Opaque),
+			"pressed" => Ok(State::Pressed),
+			"resizable" => Ok(State::Resizable),
+			"selectable" => Ok(State::Selectable),
+			"selected" => Ok(State::Selected),
+			"sensitive" => Ok(State::Sensitive),
+			"showing" => Ok(State::Showing),
+			"single-line" => Ok(State::SingleLine),
+			"stale" => Ok(State::Stale),
+			"transient" => Ok(State::Transient),
+			"vertical" => Ok(State::Vertical),
+			"visible" => Ok(State::Visible),
+			"manages-descendants" => Ok(State::ManagesDescendants),
+			"indeterminate" => Ok(State::Indeterminate),
+			"required" => Ok(State::Required),
+			"truncated" => Ok(State::Truncated),
+			"animated" => Ok(State::Animated),
+			"invalid-entry" => Ok(State::InvalidEntry),
+			"supports-autocompletion" => Ok(State::SupportsAutocompletion),
+			"selectable-text" => Ok(State::SelectableText),
+			"is-default" => Ok(State::IsDefault),
+			"visited" => Ok(State::Visited),
+			"checkable" => Ok(State::Checkable),
+			"has-popup" => Ok(State::HasPopup),
+			"read-only" => Ok(State::ReadOnly),
+			_ => Err(AtspiError::Conversion("Unknown state")),
 		}
-		.to_string()
 	}
 }
 
+// Infalible conversion from &str to State
+impl From<&str> for State {
+	fn from(string: &str) -> State {
+		string.parse().unwrap_or(State::Invalid)
+	}
+}
+
+// `EventBodyOwned` has owned data that we can convert to `State` in object.rs
 impl From<String> for State {
 	fn from(string: String) -> State {
-		(&*string).into()
+		string.as_str().into()
 	}
 }
 
-impl From<&str> for State {
-	fn from(string: &str) -> State {
-		match string {
-			"active" => State::Active,
-			"armed" => State::Armed,
-			"busy" => State::Busy,
-			"checked" => State::Checked,
-			"collapsed" => State::Collapsed,
-			"defunct" => State::Defunct,
-			"editable" => State::Editable,
-			"enabled" => State::Enabled,
-			"expandable" => State::Expandable,
-			"expanded" => State::Expanded,
-			"focusable" => State::Focusable,
-			"focused" => State::Focused,
-			"has-tooltip" => State::HasTooltip,
-			"horizontal" => State::Horizontal,
-			"iconified" => State::Iconified,
-			"modal" => State::Modal,
-			"multi-line" => State::MultiLine,
-			"multiselectable" => State::Multiselectable,
-			"opaque" => State::Opaque,
-			"pressed" => State::Pressed,
-			"resizable" => State::Resizable,
-			"selectable" => State::Selectable,
-			"selected" => State::Selected,
-			"sensitive" => State::Sensitive,
-			"showing" => State::Showing,
-			"single-line" => State::SingleLine,
-			"stale" => State::Stale,
-			"transient" => State::Transient,
-			"vertical" => State::Vertical,
-			"visible" => State::Visible,
-			"manages-descendants" => State::ManagesDescendants,
-			"indeterminate" => State::Indeterminate,
-			"required" => State::Required,
-			"truncated" => State::Truncated,
-			"animated" => State::Animated,
-			"invalid-entry" => State::InvalidEntry,
-			"supports-autocompletion" => State::SupportsAutocompletion,
-			"selectable-text" => State::SelectableText,
-			"is-default" => State::IsDefault,
-			"visited" => State::Visited,
-			"checkable" => State::Checkable,
-			"has-popup" => State::HasPopup,
-			"read-only" => State::ReadOnly,
-			_ => State::Invalid,
-		}
+impl From<State> for String {
+	fn from(state: State) -> String {
+		// Using the derived `Display`
+		state.to_string()
 	}
 }
 
@@ -351,7 +350,7 @@ impl StateSet {
 	}
 
 	/// Returns the `StateSet` that corresponds to the provided `u64`s bit pattern.
-	///# Errors
+	/// # Errors
 	/// When the argument encodes an undefined [`State`].
 	pub fn from_bits(bits: u64) -> Result<StateSet, FromBitsError<State>> {
 		Ok(StateSet(BitFlags::from_bits(bits)?))

From 1a452b41860a33fb9a28c41091e2c88089aa87ae Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Sun, 14 Apr 2024 17:24:17 +0200
Subject: [PATCH 12/37] Fixup Clippy CI errors

---
 atspi-common/src/interface.rs | 57 +++++++++++++++--------------------
 1 file changed, 25 insertions(+), 32 deletions(-)

diff --git a/atspi-common/src/interface.rs b/atspi-common/src/interface.rs
index 95cce7e7..f39d827f 100644
--- a/atspi-common/src/interface.rs
+++ b/atspi-common/src/interface.rs
@@ -454,49 +454,42 @@ mod tests {
 
 	#[test]
 	fn interface_display_impl() {
-		assert_eq!(format!("{}", Interface::Accessible), "org.a11y.atspi.Accessible".to_owned());
-		assert_eq!(format!("{}", Interface::Action), "org.a11y.atspi.Action".to_owned());
-		assert_eq!(format!("{}", Interface::Application), "org.a11y.atspi.Application".to_owned());
-		assert_eq!(format!("{}", Interface::Cache), "org.a11y.atspi.Cache".to_owned());
-		assert_eq!(format!("{}", Interface::Collection), "org.a11y.atspi.Collection".to_owned());
-		assert_eq!(format!("{}", Interface::Component), "org.a11y.atspi.Component".to_owned());
-		assert_eq!(format!("{}", Interface::Document), "org.a11y.atspi.Document".to_owned());
-		assert_eq!(
-			format!("{}", Interface::DeviceEventController),
-			"org.a11y.atspi.DeviceEventController".to_owned()
-		);
-		assert_eq!(
-			format!("{}", Interface::DeviceEventListener),
-			"org.a11y.atspi.DeviceEventListener".to_owned()
-		);
-		assert_eq!(
-			format!("{}", Interface::EditableText),
-			"org.a11y.atspi.EditableText".to_owned()
-		);
-		assert_eq!(format!("{}", Interface::Hyperlink), "org.a11y.atspi.Hyperlink".to_owned());
-		assert_eq!(format!("{}", Interface::Hypertext), "org.a11y.atspi.Hypertext".to_owned());
-		assert_eq!(format!("{}", Interface::Image), "org.a11y.atspi.Image".to_owned());
-		assert_eq!(format!("{}", Interface::Registry), "org.a11y.atspi.Registry".to_owned());
-		assert_eq!(format!("{}", Interface::Selection), "org.a11y.atspi.Selection".to_owned());
-		assert_eq!(format!("{}", Interface::Socket), "org.a11y.atspi.Socket".to_owned());
-		assert_eq!(format!("{}", Interface::Table), "org.a11y.atspi.Table".to_owned());
-		assert_eq!(format!("{}", Interface::TableCell), "org.a11y.atspi.TableCell".to_owned());
-		assert_eq!(format!("{}", Interface::Text), "org.a11y.atspi.Text".to_owned());
-		assert_eq!(format!("{}", Interface::Value), "org.a11y.atspi.Value".to_owned());
+		use Interface::*;
+		// `ToSting` impl is derived from Display trait.
+		assert_eq!(Accessible.to_string(), "org.a11y.atspi.Accessible");
+		assert_eq!(Action.to_string(), "org.a11y.atspi.Action");
+		assert_eq!(Application.to_string(), "org.a11y.atspi.Application");
+		assert_eq!(Cache.to_string(), "org.a11y.atspi.Cache");
+		assert_eq!(Collection.to_string(), "org.a11y.atspi.Collection");
+		assert_eq!(Component.to_string(), "org.a11y.atspi.Component");
+		assert_eq!(Document.to_string(), "org.a11y.atspi.Document");
+		assert_eq!(DeviceEventController.to_string(), "org.a11y.atspi.DeviceEventController");
+		assert_eq!(DeviceEventListener.to_string(), "org.a11y.atspi.DeviceEventListener");
+		assert_eq!(EditableText.to_string(), "org.a11y.atspi.EditableText");
+		assert_eq!(Hyperlink.to_string(), "org.a11y.atspi.Hyperlink");
+		assert_eq!(Hypertext.to_string(), "org.a11y.atspi.Hypertext");
+		assert_eq!(Image.to_string(), "org.a11y.atspi.Image");
+		assert_eq!(Registry.to_string(), "org.a11y.atspi.Registry");
+		assert_eq!(Selection.to_string(), "org.a11y.atspi.Selection");
+		assert_eq!(Socket.to_string(), "org.a11y.atspi.Socket");
+		assert_eq!(Table.to_string(), "org.a11y.atspi.Table");
+		assert_eq!(TableCell.to_string(), "org.a11y.atspi.TableCell");
+		assert_eq!(Text.to_string(), "org.a11y.atspi.Text");
+		assert_eq!(Value.to_string(), "org.a11y.atspi.Value");
 	}
 
 	#[test]
 	fn interface_set_display_impl() {
 		let ifaceset = InterfaceSet::new(Interface::Accessible);
-		assert_eq!(format!("{}", ifaceset), "org.a11y.atspi.Accessible");
+		assert_eq!(ifaceset.to_string(), "org.a11y.atspi.Accessible");
 
 		let ifaceset = InterfaceSet::new(Interface::Accessible | Interface::Action);
-		assert_eq!(format!("{}", ifaceset), "org.a11y.atspi.Accessible, org.a11y.atspi.Action");
+		assert_eq!(ifaceset.to_string(), "org.a11y.atspi.Accessible, org.a11y.atspi.Action");
 
 		let ifaceset =
 			InterfaceSet::new(Interface::Accessible | Interface::Action | Interface::Component);
 		assert_eq!(
-			format!("{}", ifaceset),
+			ifaceset.to_string(),
 			"org.a11y.atspi.Accessible, org.a11y.atspi.Action, org.a11y.atspi.Component"
 		);
 	}

From cbb3ca8a58af9a66c3582b4677cf6d183b3b4ec4 Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Sun, 14 Apr 2024 17:28:20 +0200
Subject: [PATCH 13/37] Fixup occurence of `Accessible` where `ObjectRef` is
 more appropriate

---
 atspi-common/src/events/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 3b6e0913..32f4f94b 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -9,7 +9,7 @@ pub mod window;
 // Unmarshalled event body signatures: These outline the event specific deserialized event types.
 // Safety: These are evaluated at compile time.
 // ----
-// The signal signature "(so)" (an Accessible) is ambiguous, because it is used in:
+// The signal signature "(so)" (`ObjectRef`) is ambiguous, because it is used in:
 // -  Cache : RemoveAccessible
 // -  Socket: Available  *( signals the availability of the `Registry` daemon.)
 //

From d7c2ac0a15ab4cf2c37ffd28b9444caddc696c43 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 15:42:46 -0600
Subject: [PATCH 14/37] Feature gate strum

---
 atspi-common/Cargo.toml           |   3 +-
 atspi-common/src/interface.rs     |  47 +++++-----
 atspi-common/src/lib.rs           |  55 ++++-------
 atspi-common/src/relation_type.rs |   7 +-
 atspi-common/src/role.rs          | 148 +++++++++++++++---------------
 atspi-common/src/state.rs         |   8 +-
 6 files changed, 127 insertions(+), 141 deletions(-)

diff --git a/atspi-common/Cargo.toml b/atspi-common/Cargo.toml
index f33a16e3..96e24b2f 100644
--- a/atspi-common/Cargo.toml
+++ b/atspi-common/Cargo.toml
@@ -14,6 +14,7 @@ rust-version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
+strum = ["dep:strum"]
 default = ["async-std"]
 async-std = ["zbus/async-io"]
 tokio = ["zbus/tokio"]
@@ -22,7 +23,7 @@ tokio = ["zbus/tokio"]
 enumflags2 = "0.7.7"
 serde = "1.0"
 static_assertions = "1.1.0"
-strum = { version = "0.26", features = ["derive"] }
+strum = { version = "0.26", features = ["derive"], optional = true }
 zbus-lockstep = "0.4.4"
 zbus-lockstep-macros = "0.4.4"
 zbus_names = "3.0"
diff --git a/atspi-common/src/interface.rs b/atspi-common/src/interface.rs
index f39d827f..c514c19e 100644
--- a/atspi-common/src/interface.rs
+++ b/atspi-common/src/interface.rs
@@ -10,6 +10,7 @@ use serde::{
 	Deserialize, Serialize,
 };
 use std::{fmt, str::FromStr};
+#[cfg(feature = "strum")]
 use strum::{Display, IntoStaticStr};
 use zvariant::{Signature, Type};
 
@@ -18,106 +19,107 @@ use crate::AtspiError;
 /// AT-SPI interfaces an accessible object can implement.
 #[bitflags]
 #[repr(u32)]
-#[derive(Clone, Copy, Debug, Display, IntoStaticStr, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "strum", derive(Display, IntoStaticStr))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Interface {
 	/// Interface to indicate implementation of `AccessibleProxy`.  
 	#[serde(rename = "org.a11y.atspi.Accessible")]
-	#[strum(serialize = "org.a11y.atspi.Accessible")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Accessible"))]
 	Accessible,
 
 	/// Interface to indicate implementation of `ActionProxy`.
 	#[serde(rename = "org.a11y.atspi.Action")]
-	#[strum(serialize = "org.a11y.atspi.Action")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Action"))]
 	Action,
 
 	/// Interface to indicate implementation of `ApplicationProxy`.
 	#[serde(rename = "org.a11y.atspi.Application")]
-	#[strum(serialize = "org.a11y.atspi.Application")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Application"))]
 	Application,
 
 	/// Interface to indicate implementation of `CacheProxy`.
 	#[serde(rename = "org.a11y.atspi.Cache")]
-	#[strum(serialize = "org.a11y.atspi.Cache")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Cache"))]
 	Cache,
 
 	/// Interface to indicate implementation of `CollectionProxy`.
 	#[serde(rename = "org.a11y.atspi.Collection")]
-	#[strum(serialize = "org.a11y.atspi.Collection")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Collection"))]
 	Collection,
 
 	/// Interface to indicate implementation of `ComponentProxy`.
 	#[serde(rename = "org.a11y.atspi.Component")]
-	#[strum(serialize = "org.a11y.atspi.Component")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Component"))]
 	Component,
 
 	/// Interface to indicate implementation of `DocumentProxy`.
 	#[serde(rename = "org.a11y.atspi.Document")]
-	#[strum(serialize = "org.a11y.atspi.Document")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Document"))]
 	Document,
 
 	/// Interface to indicate implementation of `DeviceEventControllerProxy`.
 	#[serde(rename = "org.a11y.atspi.DeviceEventController")]
-	#[strum(serialize = "org.a11y.atspi.DeviceEventController")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.DeviceEventController"))]
 	DeviceEventController,
 
 	/// Interface to indicate implementation of `DeviceEventListenerProxy`.
 	#[serde(rename = "org.a11y.atspi.DeviceEventListener")]
-	#[strum(serialize = "org.a11y.atspi.DeviceEventListener")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.DeviceEventListener"))]
 	DeviceEventListener,
 
 	/// Interface to indicate implementation of `EditableTextProxy`.
 	#[serde(rename = "org.a11y.atspi.EditableText")]
-	#[strum(serialize = "org.a11y.atspi.EditableText")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.EditableText"))]
 	EditableText,
 
 	/// Interface to indicate implementation of `HyperlinkProxy`.
 	#[serde(rename = "org.a11y.atspi.Hyperlink")]
-	#[strum(serialize = "org.a11y.atspi.Hyperlink")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Hyperlink"))]
 	Hyperlink,
 
 	/// Interface to indicate implementation of `HypertextProxy`.
 	#[serde(rename = "org.a11y.atspi.Hypertext")]
-	#[strum(serialize = "org.a11y.atspi.Hypertext")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Hypertext"))]
 	Hypertext,
 
 	/// Interface to indicate implementation of `ImageProxy`.
 	#[serde(rename = "org.a11y.atspi.Image")]
-	#[strum(serialize = "org.a11y.atspi.Image")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Image"))]
 	Image,
 
 	/// Interface to indicate implementation of `RegistryProxy`.
 	#[serde(rename = "org.a11y.atspi.Registry")]
-	#[strum(serialize = "org.a11y.atspi.Registry")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Registry"))]
 	Registry,
 
 	/// Interface to indicate implementation of `SelectionProxy`.
 	#[serde(rename = "org.a11y.atspi.Selection")]
-	#[strum(serialize = "org.a11y.atspi.Selection")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Selection"))]
 	Selection,
 
 	/// Interface to indicate implementation of `SocketProxy`.
 	#[serde(rename = "org.a11y.atspi.Socket")]
-	#[strum(serialize = "org.a11y.atspi.Socket")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Socket"))]
 	Socket,
 
 	/// Interface to indicate implementation of `TableProxy`.
 	#[serde(rename = "org.a11y.atspi.Table")]
-	#[strum(serialize = "org.a11y.atspi.Table")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Table"))]
 	Table,
 
 	/// Interface to indicate implementation of `TableCellProxy`.
 	#[serde(rename = "org.a11y.atspi.TableCell")]
-	#[strum(serialize = "org.a11y.atspi.TableCell")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.TableCell"))]
 	TableCell,
 
 	/// Interface to indicate implementation of `TextProxy`.
 	#[serde(rename = "org.a11y.atspi.Text")]
-	#[strum(serialize = "org.a11y.atspi.Text")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Text"))]
 	Text,
 
 	/// Interface to indicate implementation of `ValueProxy`.
 	#[serde(rename = "org.a11y.atspi.Value")]
-	#[strum(serialize = "org.a11y.atspi.Value")]
+	#[cfg_attr(feature = "strum", strum(serialize = "org.a11y.atspi.Value"))]
 	Value,
 }
 
@@ -275,6 +277,7 @@ impl std::ops::BitOr for InterfaceSet {
 	}
 }
 
+#[cfg(feature = "strum")]
 impl std::fmt::Display for InterfaceSet {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		let mut iter = self.0.iter();
@@ -452,6 +455,7 @@ mod tests {
 		assert!(res.is_err());
 	}
 
+	#[cfg(feature = "strum")]
 	#[test]
 	fn interface_display_impl() {
 		use Interface::*;
@@ -478,6 +482,7 @@ mod tests {
 		assert_eq!(Value.to_string(), "org.a11y.atspi.Value");
 	}
 
+	#[cfg(feature = "strum")]
 	#[test]
 	fn interface_set_display_impl() {
 		let ifaceset = InterfaceSet::new(Interface::Accessible);
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index bce1a7ca..6e47e015 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -32,6 +32,7 @@ mod relation_type;
 pub use relation_type::RelationType;
 
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "strum")]
 use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
@@ -57,18 +58,16 @@ pub type MatchArgs<'a> = (
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum SortOrder {
 	/// Invalid sort order
 	Invalid,
@@ -91,18 +90,16 @@ pub enum SortOrder {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum TreeTraversalType {
 	/// Restrict children tree traversal
 	RestrictChildren,
@@ -119,10 +116,7 @@ pub enum TreeTraversalType {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
-	IntoStaticStr,
 	Hash,
 	PartialEq,
 	Serialize,
@@ -130,7 +124,8 @@ pub enum TreeTraversalType {
 	Type,
 )]
 #[repr(i32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum MatchType {
 	/// Invalid match type
 	Invalid,
@@ -150,18 +145,16 @@ pub enum MatchType {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum CoordType {
 	/// In relation to the entire screen.
 	Screen,
@@ -176,18 +169,16 @@ pub enum CoordType {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum ClipType {
 	/// No characters/glyphs are omitted.
 	Neither,
@@ -204,18 +195,16 @@ pub enum ClipType {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Granularity {
 	/// Gives the character at the index of the cursor. With a line-style cursor (which is standard) this will get the character that appears after the cursor.
 	Char,
@@ -247,18 +236,16 @@ pub enum Granularity {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Layer {
 	/// Indicates an error condition or uninitialized value.
 	Invalid,
@@ -288,18 +275,16 @@ pub enum Layer {
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(u32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum ScrollType {
 	/// Scroll the object to the top left corner of the window.
 	TopLeft,
@@ -327,18 +312,16 @@ pub enum ScrollType {
 	Copy,
 	Debug,
 	Default,
-	Display,
 	Eq,
-	FromRepr,
 	Hash,
-	IntoStaticStr,
 	PartialEq,
 	Serialize,
 	Deserialize,
 	Type,
 )]
 #[repr(i32)]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Live {
 	/// No live region.
 	#[default]
diff --git a/atspi-common/src/relation_type.rs b/atspi-common/src/relation_type.rs
index 2fbc794a..39a0cc1e 100644
--- a/atspi-common/src/relation_type.rs
+++ b/atspi-common/src/relation_type.rs
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "strum")]
 use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
@@ -7,17 +8,15 @@ use zvariant::Type;
 	Clone,
 	Copy,
 	Debug,
-	Display,
 	PartialEq,
 	Eq,
-	FromRepr,
-	IntoStaticStr,
 	Serialize,
 	Deserialize,
 	Type,
 	Hash,
 )]
-#[strum(serialize_all = "snake_case")]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 #[repr(u32)]
 pub enum RelationType {
 	/// Not a meaningful relationship; clients should not normally encounter this value.
diff --git a/atspi-common/src/role.rs b/atspi-common/src/role.rs
index 37d209e7..9469dc3a 100644
--- a/atspi-common/src/role.rs
+++ b/atspi-common/src/role.rs
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "strum")]
 use strum::{Display, EnumIter, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
@@ -19,10 +20,6 @@ use zvariant::Type;
 	Clone,
 	Copy,
 	Debug,
-	Display,
-	EnumIter,
-	FromRepr,
-	IntoStaticStr,
 	PartialEq,
 	Eq,
 	Serialize,
@@ -30,14 +27,15 @@ use zvariant::Type;
 	Type,
 	Hash,
 )]
+#[cfg_attr(feature = "strum", derive(Display, EnumIter, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "lowercase"))]
 #[repr(u32)]
-#[strum(serialize_all = "lowercase")]
 pub enum Role {
 	/// A role indicating an error condition, such as uninitialized Role data, or an error deserializing.
 	Invalid,
 
 	/// Object is a label indicating the keyboard accelerators for the parent.
-	#[strum(serialize = "accelerator label")]
+	#[cfg_attr(feature = "strum", strum(serialize = "accelerator label"))]
 	AcceleratorLabel,
 
 	/// Object is used to alert the user about something.
@@ -56,35 +54,35 @@ pub enum Role {
 	Canvas,
 
 	/// A choice that can be checked or unchecked and provides a separate indicator for the current state.
-	#[strum(serialize = "check box")]
+	#[cfg_attr(feature = "strum", strum(serialize = "check box"))]
 	CheckBox,
 
 	/// A menu item that behaves like a check box. See [`Self::CheckBox`].
-	#[strum(serialize = "check menu item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "check menu item"))]
 	CheckMenuItem,
 
 	/// A specialized dialog that lets the user choose a color.
-	#[strum(serialize = "color chooser")]
+	#[cfg_attr(feature = "strum", strum(serialize = "color chooser"))]
 	ColorChooser,
 
 	/// The header for a column of data.
-	#[strum(serialize = "column header")]
+	#[cfg_attr(feature = "strum", strum(serialize = "column header"))]
 	ColumnHeader,
 
 	/// A list of choices the user can select from.
-	#[strum(serialize = "combo box")]
+	#[cfg_attr(feature = "strum", strum(serialize = "combo box"))]
 	ComboBox,
 
 	/// An object which allows entry of a date.
-	#[strum(serialize = "date editor")]
+	#[cfg_attr(feature = "strum", strum(serialize = "date editor"))]
 	DateEditor,
 
 	/// An inconifed internal frame within a [`Role::DesktopFrame`].
-	#[strum(serialize = "desktop icon")]
+	#[cfg_attr(feature = "strum", strum(serialize = "desktop icon"))]
 	DesktopIcon,
 
 	/// A pane that supports internal frames and iconified versions of those internal frames.
-	#[strum(serialize = "desktop frame")]
+	#[cfg_attr(feature = "strum", strum(serialize = "desktop frame"))]
 	DesktopFrame,
 
 	/// An object that allows a value to be changed via rotating a visual element, or which displays a value via such a rotating element.
@@ -94,37 +92,37 @@ pub enum Role {
 	Dialog,
 
 	/// A pane that allows the user to navigate through and select the contents of a directory.
-	#[strum(serialize = "directory pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "directory pane"))]
 	DirectoryPane,
 
 	/// An object used for drawing custom user interface elements.
-	#[strum(serialize = "drawing area")]
+	#[cfg_attr(feature = "strum", strum(serialize = "drawing area"))]
 	DrawingArea,
 
 	/// A specialized dialog that displays the files in the directory and lets the user select a file, browse a different directory, or specify a filename.
-	#[strum(serialize = "file chooser")]
+	#[cfg_attr(feature = "strum", strum(serialize = "file chooser"))]
 	FileChooser,
 
 	/// A object that fills up space in a user interface.
 	Filler,
 
 	/// Don't use, reserved for future use.
-	#[strum(serialize = "focus traversable")]
+	#[cfg_attr(feature = "strum", strum(serialize = "focus traversable"))]
 	FocusTraversable,
 
 	/// Allows selection of a display font.
-	#[strum(serialize = "font chooser")]
+	#[cfg_attr(feature = "strum", strum(serialize = "font chooser"))]
 	FontChooser,
 
 	/// A top level window with a title bar, border, menubar, etc.
 	Frame,
 
 	/// A pane that is guaranteed to be painted on top of all panes beneath it.
-	#[strum(serialize = "glass pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "glass pane"))]
 	GlassPane,
 
 	/// A document container for HTML, whose children represent the document content.
-	#[strum(serialize = "html container")]
+	#[cfg_attr(feature = "strum", strum(serialize = "html container"))]
 	HTMLContainer,
 
 	/// A small fixed size picture, typically used to decorate components.
@@ -134,90 +132,90 @@ pub enum Role {
 	Image,
 
 	/// A frame-like object that is clipped by a desktop pane.
-	#[strum(serialize = "internal frame")]
+	#[cfg_attr(feature = "strum", strum(serialize = "internal frame"))]
 	InternalFrame,
 
 	/// An object used to present an icon or short string in an interface.
 	Label,
 
 	/// A specialized pane that allows its children to be drawn in layers, providing a form of stacking order.
-	#[strum(serialize = "layered pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "layered pane"))]
 	LayeredPane,
 
 	/// An object that presents a list of objects to the user and * allows the user to select one or more of them.
 	List,
 
 	/// An object that represents an element of a list.
-	#[strum(serialize = "list item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "list item"))]
 	ListItem,
 
 	/// An object usually found inside a menu bar that contains a list of actions the user can choose from.
 	Menu,
 
 	/// An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from.
-	#[strum(serialize = "menu bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "menu bar"))]
 	MenuBar,
 
 	/// An object usually contained in a menu that presents an action the user can choose.
-	#[strum(serialize = "menu item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "menu item"))]
 	MenuItem,
 
 	/// A specialized pane whose primary use is inside a dialog.
-	#[strum(serialize = "option pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "option pane"))]
 	OptionPane,
 
 	/// An object that is a child of a page tab list.
-	#[strum(serialize = "page tab")]
+	#[cfg_attr(feature = "strum", strum(serialize = "page tab"))]
 	PageTab,
 
 	/// An object that presents a series of panels (or page tabs), one at a time,through some mechanism provided by the object.
-	#[strum(serialize = "page tab list")]
+	#[cfg_attr(feature = "strum", strum(serialize = "page tab list"))]
 	PageTabList,
 
 	/// A generic container that is often used to group objects.
 	Panel,
 
 	/// A text object uses for passwords, or other places where the text content is not shown visibly to the user.
-	#[strum(serialize = "password text")]
+	#[cfg_attr(feature = "strum", strum(serialize = "password text"))]
 	PasswordText,
 
 	/// A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices.
-	#[strum(serialize = "popup menu")]
+	#[cfg_attr(feature = "strum", strum(serialize = "popup menu"))]
 	PopupMenu,
 
 	/// An object used to indicate how much of a task has been completed.
-	#[strum(serialize = "progress bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "progress bar"))]
 	ProgressBar,
 
 	/// An object the user can manipulate to tell the application to do something.
-	#[strum(serialize = "push button")]
+	#[cfg_attr(feature = "strum", strum(serialize = "push button"))]
 	PushButton,
 
 	/// A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked.
-	#[strum(serialize = "radio button")]
+	#[cfg_attr(feature = "strum", strum(serialize = "radio button"))]
 	RadioButton,
 
 	/// Object is both a menu item and a "radio button". See [`Self::RadioButton`].
-	#[strum(serialize = "radio menu item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "radio menu item"))]
 	RadioMenuItem,
 
 	/// A specialized pane that has a glass pane and a layered pane as its children.
-	#[strum(serialize = "root pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "root pane"))]
 	RootPane,
 
 	/// The header for a row of data.
-	#[strum(serialize = "row header")]
+	#[cfg_attr(feature = "strum", strum(serialize = "row header"))]
 	RowHeader,
 
 	/// An object usually used to allow a user to incrementally view a large amount of data by moving the bounds of a viewport along a one-dimensional axis.
-	#[strum(serialize = "scroll bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "scroll bar"))]
 	ScrollBar,
 
 	/// A scroll pane: the pane in which the scrollable content is contained within.
 	/// An object that allows a user to incrementally view a large amount of information.
 	/// [`Self::ScrollPane`] objects are usually accompanied by [`Self::ScrollBar`] controllers,
 	/// on which the [`crate::RelationType::ControllerFor`] and [`crate::RelationType::ControlledBy`] reciprocal relations are set.
-	#[strum(serialize = "scroll pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "scroll pane"))]
 	ScrollPane,
 
 	/// An object usually contained in a menu to provide a visible and logical separation of the contents in a menu.
@@ -227,15 +225,15 @@ pub enum Role {
 	/// Unlike [`Self::ScrollBar`], [`Self::Slider`] objects need not control 'viewport'-like objects.
 	Slider,
 	/// An object which allows one of a set of choices to be selected, and which displays the current choice.
-	#[strum(serialize = "spin button")]
+	#[cfg_attr(feature = "strum", strum(serialize = "spin button"))]
 	SpinButton,
 
 	/// A specialized panel that presents two other panels at the same time.
-	#[strum(serialize = "split pane")]
+	#[cfg_attr(feature = "strum", strum(serialize = "split pane"))]
 	SplitPane,
 
 	/// Object displays non-quantitative status information (c.f. [`Self::ProgressBar`])
-	#[strum(serialize = "status bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "status bar"))]
 	StatusBar,
 
 	/// An object used to represent information in terms of rows and columns.
@@ -243,22 +241,22 @@ pub enum Role {
 
 	/// A 'cell' or discrete child within a Table.
 	/// Note: Table cells need not have [`Self::TableCell`], other [`crate::Role`] values are valid as well.
-	#[strum(serialize = "table cell")]
+	#[cfg_attr(feature = "strum", strum(serialize = "table cell"))]
 	TableCell,
 
 	/// An object which labels a particular column in an [`Self::Table`].
-	#[strum(serialize = "table column header")]
+	#[cfg_attr(feature = "strum", strum(serialize = "table column header"))]
 	TableColumnHeader,
 
 	/// An object which labels a particular row in a [`Self::Table`].
 	/// `TableProxy` rows and columns may also be labelled via the
 	/// [`crate::RelationType::LabelFor`]/[`crate::RelationType::LabelledBy`] relationships.
 	/// See: `AccessibleProxy::get_relation_type`.
-	#[strum(serialize = "table row header")]
+	#[cfg_attr(feature = "strum", strum(serialize = "table row header"))]
 	TableRowHeader,
 
 	/// Object allows menu to be removed from menubar and shown in its own window.
-	#[strum(serialize = "tearoff menu item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "tearoff menu item"))]
 	TearoffMenuItem,
 
 	/// An object that emulates a terminal.
@@ -272,22 +270,22 @@ pub enum Role {
 	Text,
 
 	/// A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state.
-	#[strum(serialize = "toggle button")]
+	#[cfg_attr(feature = "strum", strum(serialize = "toggle button"))]
 	ToggleButton,
 
 	/// A bar or palette usually composed of push buttons or toggle buttons.
-	#[strum(serialize = "tool bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "tool bar"))]
 	ToolBar,
 
 	/// An object that provides information about another object.
-	#[strum(serialize = "tool tip")]
+	#[cfg_attr(feature = "strum", strum(serialize = "tool tip"))]
 	ToolTip,
 
 	/// An object used to repsent hierarchical information to the user.
 	Tree,
 
 	/// An object that presents both tabular and hierarchical info to the user.
-	#[strum(serialize = "tree table")]
+	#[cfg_attr(feature = "strum", strum(serialize = "tree table"))]
 	TreeTable,
 
 	/// When the role cannot be accurately reported, this role will be set.
@@ -322,7 +320,7 @@ pub enum Role {
 	Autocomplete,
 
 	/// The object is an editable text object in a toolbar.
-	#[strum(serialize = "edit bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "edit bar"))]
 	EditBar,
 
 	/// The object is an embedded component container.
@@ -349,7 +347,7 @@ pub enum Role {
 	/// said to be embedded in the containing instance.
 	/// HTML frames are often [`Self::DocumentFrame`]:  Either this object, or a singleton descendant,
 	/// should implement the [`crate::Interface::Document`] interface.
-	#[strum(serialize = "document frame")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document frame"))]
 	DocumentFrame,
 
 	/// Heading: this is a heading with a level (usually 1-6). This is represented by `<h1>` through `<h6>` in HTML.
@@ -368,7 +366,7 @@ pub enum Role {
 
 	/// The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.
 	/// Objects of this role should be ignored by clients, if they are encountered at all.
-	#[strum(serialize = "redundant object")]
+	#[cfg_attr(feature = "strum", strum(serialize = "redundant object"))]
 	RedundantObject,
 
 	/// The object is a containing instance of document content which has within it components with which the user can interact in order to input information;
@@ -382,35 +380,35 @@ pub enum Role {
 	Link,
 
 	/// The object is a window or similar viewport which is used to allow composition or input of a 'complex character', in other words it is an "input method window".
-	#[strum(serialize = "input method window")]
+	#[cfg_attr(feature = "strum", strum(serialize = "input method window"))]
 	InputMethodWindow,
 
 	/// A row in a table.
-	#[strum(serialize = "table row")]
+	#[cfg_attr(feature = "strum", strum(serialize = "table row"))]
 	TableRow,
 
 	/// An object that represents an element of a tree.
-	#[strum(serialize = "tree item")]
+	#[cfg_attr(feature = "strum", strum(serialize = "tree item"))]
 	TreeItem,
 
 	/// A document frame which contains a spreadsheet.
-	#[strum(serialize = "document spreadsheet")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document spreadsheet"))]
 	DocumentSpreadsheet,
 
 	/// A document frame which contains a presentation or slide content.
-	#[strum(serialize = "document presentation")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document presentation"))]
 	DocumentPresentation,
 
 	/// A document frame which contains textual content, such as found in a word processing application.
-	#[strum(serialize = "document text")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document text"))]
 	DocumentText,
 
 	/// A document frame which contains HTML or other markup suitable for display in a web browser.
-	#[strum(serialize = "document web")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document web"))]
 	DocumentWeb,
 
 	/// A document frame which contains email content to be displayed or composed either in plain text or HTML.
-	#[strum(serialize = "document email")]
+	#[cfg_attr(feature = "strum", strum(serialize = "document email"))]
 	DocumentEmail,
 
 	/// An object found within a document and designed to present a comment, note, or other annotation.
@@ -418,33 +416,33 @@ pub enum Role {
 	Comment,
 
 	/// A non-collapsible list of choices the user can select from.
-	#[strum(serialize = "list box")]
+	#[cfg_attr(feature = "strum", strum(serialize = "list box"))]
 	ListBox,
 
 	/// A group of related widgets. This group typically has a label.
 	Grouping,
 
 	/// An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document.
-	#[strum(serialize = "image map")]
+	#[cfg_attr(feature = "strum", strum(serialize = "image map"))]
 	ImageMap,
 
 	/// A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.
 	Notification,
 
 	/// An object designed to present a message to the user within an existing window.
-	#[strum(serialize = "info bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "info bar"))]
 	InfoBar,
 
 	/// A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.
-	#[strum(serialize = "level bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "level bar"))]
 	LevelBar,
 
 	/// A bar that serves as the title of a window or a dialog.
-	#[strum(serialize = "title bar")]
+	#[cfg_attr(feature = "strum", strum(serialize = "title bar"))]
 	TitleBar,
 
 	/// An object which contains a text section that is quoted from another source.
-	#[strum(serialize = "block quote")]
+	#[cfg_attr(feature = "strum", strum(serialize = "block quote"))]
 	BlockQuote,
 
 	/// An object which represents an audio element.
@@ -493,11 +491,11 @@ pub enum Role {
 	Static,
 
 	/// An object that represents a mathematical fraction.
-	#[strum(serialize = "math fraction")]
+	#[cfg_attr(feature = "strum", strum(serialize = "math fraction"))]
 	MathFraction,
 
 	/// An object that represents a mathematical expression displayed with a radical.
-	#[strum(serialize = "math root")]
+	#[cfg_attr(feature = "strum", strum(serialize = "math root"))]
 	MathRoot,
 
 	/// An object that contains text that is displayed as a subscript.
@@ -509,26 +507,26 @@ pub enum Role {
 	/// An object that represents a list of term-value groups.
 	/// A term-value group represents an individual description and consist of one or more names ([`Self::DescriptionTerm`]) followed by one or more values ([`Self::DescriptionValue`]).
 	/// For each list, there should not be more than one group with the same term name.
-	#[strum(serialize = "description list")]
+	#[cfg_attr(feature = "strum", strum(serialize = "description list"))]
 	DescriptionList,
 
 	/// An object that represents a term or phrase with a corresponding definition.
-	#[strum(serialize = "description term")]
+	#[cfg_attr(feature = "strum", strum(serialize = "description term"))]
 	DescriptionTerm,
 
 	/// An object that represents the description, definition, or value of a term.
-	#[strum(serialize = "description value")]
+	#[cfg_attr(feature = "strum", strum(serialize = "description value"))]
 	DescriptionValue,
 
 	/// An object that contains the text of a footnote.
 	Footnote,
 
 	/// Content previously deleted or proposed to be deleted, e.g. in revision history or a content view providing suggestions from reviewers.
-	#[strum(serialize = "content deletion")]
+	#[cfg_attr(feature = "strum", strum(serialize = "content deletion"))]
 	ContentDeletion,
 
 	/// Content previously inserted or proposed to be inserted, e.g. in revision history or a content view providing suggestions from reviewers.
-	#[strum(serialize = "content insertion")]
+	#[cfg_attr(feature = "strum", strum(serialize = "content insertion"))]
 	ContentInsertion,
 
 	/// A run of content that is marked or highlighted, such as for reference purposes, or to call it out as having a special purpose.
@@ -541,7 +539,7 @@ pub enum Role {
 	Suggestion,
 
 	/// A specialized push button to open a menu.
-	#[strum(serialize = "push button menu")]
+	#[cfg_attr(feature = "strum", strum(serialize = "push button menu"))]
 	PushButtonMenu,
 }
 
diff --git a/atspi-common/src/state.rs b/atspi-common/src/state.rs
index b1661997..7b6cfe65 100644
--- a/atspi-common/src/state.rs
+++ b/atspi-common/src/state.rs
@@ -5,6 +5,7 @@ use serde::{
 	Deserialize, Serialize,
 };
 use std::{fmt, str::FromStr};
+#[cfg(feature = "strum")]
 use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::{Signature, Type};
 
@@ -34,9 +35,6 @@ use crate::AtspiError;
 	Clone,
 	Copy,
 	Debug,
-	Display,
-	FromRepr,
-	IntoStaticStr,
 	Serialize,
 	Deserialize,
 	PartialEq,
@@ -45,7 +43,8 @@ use crate::AtspiError;
 	Default,
 )]
 #[serde(rename_all = "kebab-case")]
-#[strum(serialize_all = "kebab-case")]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", strum(serialize_all = "kebab-case"))]
 pub enum State {
 	/// Indicates an invalid state - probably an error condition.
 	#[default]
@@ -322,6 +321,7 @@ impl From<String> for State {
 	}
 }
 
+#[cfg(feature = "strum")]
 impl From<State> for String {
 	fn from(state: State) -> String {
 		// Using the derived `Display`

From beb0a30147afb9d423173b072519c2ff5adace18 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Tue, 21 May 2024 13:08:46 -0600
Subject: [PATCH 15/37] Fully feature gate the strum additions

---
 atspi-common/Cargo.toml           | 4 ++--
 atspi-common/src/events/object.rs | 9 ++++++++-
 atspi-common/src/role.rs          | 1 +
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/atspi-common/Cargo.toml b/atspi-common/Cargo.toml
index 96e24b2f..f66d5fcf 100644
--- a/atspi-common/Cargo.toml
+++ b/atspi-common/Cargo.toml
@@ -16,8 +16,8 @@ rust-version.workspace = true
 [features]
 strum = ["dep:strum"]
 default = ["async-std"]
-async-std = ["zbus/async-io"]
-tokio = ["zbus/tokio"]
+async-std = ["zbus/async-io", "strum"]
+tokio = ["zbus/tokio", "strum"]
 
 [dependencies]
 enumflags2 = "0.7.7"
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 90160a7c..3efc6e22 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -1,9 +1,11 @@
 use crate::{
 	error::AtspiError,
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, Live, State,
+	Event, State,
 };
 use zvariant::{ObjectPath, OwnedValue, Value};
+#[cfg(feature = "strum")]
+use crate::Live;
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
 pub enum ObjectEvents {
@@ -142,6 +144,7 @@ impl Default for Property {
 	}
 }
 
+#[cfg(feature = "strum")]
 impl TryFrom<EventBodyOwned> for Property {
 	type Error = AtspiError;
 
@@ -411,6 +414,7 @@ pub struct TextCaretMovedEvent {
 	pub position: i32,
 }
 
+#[cfg(feature = "strum")]
 impl GenericEvent<'_> for PropertyChangeEvent {
 	const DBUS_MEMBER: &'static str = "PropertyChange";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
@@ -485,6 +489,7 @@ impl GenericEvent<'_> for LinkSelectedEvent {
 	}
 }
 
+#[cfg(feature = "strum")]
 impl GenericEvent<'_> for StateChangedEvent {
 	const DBUS_MEMBER: &'static str = "StateChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
@@ -634,6 +639,7 @@ impl GenericEvent<'_> for ActiveDescendantChangedEvent {
 	}
 }
 
+#[cfg(feature = "strum")]
 impl GenericEvent<'_> for AnnouncementEvent {
 	const DBUS_MEMBER: &'static str = "Announcement";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
@@ -1087,6 +1093,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(StateChangedEvent);
 impl_to_dbus_message!(StateChangedEvent);
 impl_from_dbus_message!(StateChangedEvent);
+#[cfg(feature = "strum")]
 impl From<StateChangedEvent> for EventBodyOwned {
 	fn from(event: StateChangedEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/role.rs b/atspi-common/src/role.rs
index 9469dc3a..678519dd 100644
--- a/atspi-common/src/role.rs
+++ b/atspi-common/src/role.rs
@@ -543,6 +543,7 @@ pub enum Role {
 	PushButtonMenu,
 }
 
+#[cfg(feature = "strum")]
 impl Role {
 	/// Get a readable, English name from the role.
 	#[must_use]

From fa92a7a7031f6170096590742baf85c9c88c84a5 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Tue, 21 May 2024 13:09:15 -0600
Subject: [PATCH 16/37] fmt

---
 atspi-common/src/events/object.rs |   4 +-
 atspi-common/src/lib.rs           | 127 +++++-------------------------
 atspi-common/src/relation_type.rs |  12 +--
 atspi-common/src/role.rs          |  12 +--
 atspi-common/src/state.rs         |  12 +--
 5 files changed, 23 insertions(+), 144 deletions(-)

diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 3efc6e22..30c3f441 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -1,11 +1,11 @@
+#[cfg(feature = "strum")]
+use crate::Live;
 use crate::{
 	error::AtspiError,
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event, State,
 };
 use zvariant::{ObjectPath, OwnedValue, Value};
-#[cfg(feature = "strum")]
-use crate::Live;
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
 pub enum ObjectEvents {
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index 6e47e015..610d571c 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -54,19 +54,9 @@ pub type MatchArgs<'a> = (
 /// objects should be sorted.
 ///
 /// [`ObjectRef`]: crate::object_ref::ObjectRef
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum SortOrder {
 	/// Invalid sort order
@@ -86,19 +76,9 @@ pub enum SortOrder {
 }
 
 /// Method of traversing a tree in the `CollectionProxy`.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum TreeTraversalType {
 	/// Restrict children tree traversal
@@ -112,19 +92,9 @@ pub enum TreeTraversalType {
 /// Enumeration used by [`MatchArgs`] to specify how to interpret [`ObjectRef`] objects.
 ///
 /// [`ObjectRef`]: crate::object_ref::ObjectRef
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(i32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum MatchType {
 	/// Invalid match type
@@ -141,19 +111,9 @@ pub enum MatchType {
 }
 
 /// The coordinate type encodes the frame of reference.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum CoordType {
 	/// In relation to the entire screen.
@@ -165,19 +125,9 @@ pub enum CoordType {
 }
 
 /// Enumeration used by `TextProxy` to indicate how to treat characters intersecting bounding boxes.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum ClipType {
 	/// No characters/glyphs are omitted.
@@ -191,19 +141,9 @@ pub enum ClipType {
 }
 
 /// Level of granularity to get text of, in relation to a cursor position.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Granularity {
 	/// Gives the character at the index of the cursor. With a line-style cursor (which is standard) this will get the character that appears after the cursor.
@@ -232,19 +172,9 @@ pub enum Granularity {
 /// the recommended heuristic is first child paints first. In other words,
 /// assume that the first siblings in the child list are subject to being
 /// overpainted by later siblings if their bounds intersect.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Layer {
 	/// Indicates an error condition or uninitialized value.
@@ -271,19 +201,9 @@ pub enum Layer {
 }
 
 /// Enumeration used by interface the [`crate::interface::Interface::Accessible`] to specify where an object should be placed on the screen when using `scroll_to`.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(u32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum ScrollType {
 	/// Scroll the object to the top left corner of the window.
@@ -307,20 +227,9 @@ pub enum ScrollType {
 /// for `Announcement` events, but it may be used for additional purposes
 /// in the future.
 /// The argument in the `Announcement` event is named `politeness`.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Default,
-	Eq,
-	Hash,
-	PartialEq,
-	Serialize,
-	Deserialize,
-	Type,
-)]
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq, Serialize, Deserialize, Type)]
 #[repr(i32)]
-#[cfg_attr(feature = "strum", derive(	Display, FromRepr, IntoStaticStr))]
+#[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 pub enum Live {
 	/// No live region.
diff --git a/atspi-common/src/relation_type.rs b/atspi-common/src/relation_type.rs
index 39a0cc1e..c634ce9a 100644
--- a/atspi-common/src/relation_type.rs
+++ b/atspi-common/src/relation_type.rs
@@ -4,17 +4,7 @@ use strum::{Display, FromRepr, IntoStaticStr};
 use zvariant::Type;
 
 /// Describes a relationship between one object and another.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	PartialEq,
-	Eq,
-	Serialize,
-	Deserialize,
-	Type,
-	Hash,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type, Hash)]
 #[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "snake_case"))]
 #[repr(u32)]
diff --git a/atspi-common/src/role.rs b/atspi-common/src/role.rs
index 678519dd..5b9ff604 100644
--- a/atspi-common/src/role.rs
+++ b/atspi-common/src/role.rs
@@ -16,17 +16,7 @@ use zvariant::Type;
 /// Non-semantic elements like `<span>`, `<div>` and `<b>` will not be represented here, and this
 /// information is not passed through via the atspi library.
 /// TODO: add examples for GTK/Qt libraries in addition to HTML examples.
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	PartialEq,
-	Eq,
-	Serialize,
-	Deserialize,
-	Type,
-	Hash,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type, Hash)]
 #[cfg_attr(feature = "strum", derive(Display, EnumIter, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "lowercase"))]
 #[repr(u32)]
diff --git a/atspi-common/src/state.rs b/atspi-common/src/state.rs
index 7b6cfe65..97b19e6b 100644
--- a/atspi-common/src/state.rs
+++ b/atspi-common/src/state.rs
@@ -31,17 +31,7 @@ use crate::AtspiError;
 #[bitflags]
 #[non_exhaustive]
 #[repr(u64)]
-#[derive(
-	Clone,
-	Copy,
-	Debug,
-	Serialize,
-	Deserialize,
-	PartialEq,
-	Eq,
-	Hash,
-	Default,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Default)]
 #[serde(rename_all = "kebab-case")]
 #[cfg_attr(feature = "strum", derive(Display, FromRepr, IntoStaticStr))]
 #[cfg_attr(feature = "strum", strum(serialize_all = "kebab-case"))]

From 490fef2441ba2a49e57f9ac7c364d5b6c06c2236 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 22:37:05 -0600
Subject: [PATCH 17/37] Upgrade codecov to v4

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ea96040a..0cf4accf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -243,6 +243,6 @@ jobs:
       - name: cargo llvm-cov
         run: cargo llvm-cov --workspace --locked --lcov --output-path lcov.info
       - name: Upload to codecov.io
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true

From 58eae4586e97d5ce016d0023596e88a59dcb511c Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 22:42:44 -0600
Subject: [PATCH 18/37] Explicitly pass codecov token as required by v4

---
 .github/workflows/ci.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0cf4accf..599b5f69 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -246,3 +246,4 @@ jobs:
         uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}

From 37e6a3d448414376204d05ef2111d48cf3c15350 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 20:22:30 -0600
Subject: [PATCH 19/37] Make ObjectRef more explicit in type

---
 atspi-common/src/cache.rs           | 12 ++--
 atspi-common/src/events/document.rs | 25 ++++----
 atspi-common/src/events/focus.rs    |  5 +-
 atspi-common/src/events/keyboard.rs |  5 +-
 atspi-common/src/events/mod.rs      | 39 +++++++------
 atspi-common/src/events/mouse.rs    | 13 +++--
 atspi-common/src/events/object.rs   | 89 +++++++++++++++--------------
 atspi-common/src/events/terminal.rs | 21 +++----
 atspi-common/src/events/window.rs   | 77 +++++++++++++------------
 atspi-common/src/macros.rs          |  2 +-
 atspi-common/src/object_ref.rs      | 10 +++-
 atspi-common/tests/tests.rs         |  3 +-
 atspi-proxies/src/accessible.rs     |  4 +-
 13 files changed, 159 insertions(+), 146 deletions(-)

diff --git a/atspi-common/src/cache.rs b/atspi-common/src/cache.rs
index d54fb8c4..3a5a82b9 100644
--- a/atspi-common/src/cache.rs
+++ b/atspi-common/src/cache.rs
@@ -37,15 +37,15 @@ impl Default for CacheItem {
 	fn default() -> Self {
 		Self {
 			object: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/object".try_into().unwrap(),
 			},
 			app: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/application".try_into().unwrap(),
 			},
 			parent: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/parent".try_into().unwrap(),
 			},
 			index: 0,
@@ -86,15 +86,15 @@ impl Default for LegacyCacheItem {
 	fn default() -> Self {
 		Self {
 			object: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/object".try_into().unwrap(),
 			},
 			app: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/application".try_into().unwrap(),
 			},
 			parent: ObjectRef {
-				name: ":0.0".into(),
+				name: ":0.0".try_into().unwrap(),
 				path: "/org/a11y/atspi/accessible/parent".try_into().unwrap(),
 			},
 			children: Vec::new(),
diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index e320b6c5..dd79d5ca 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
@@ -84,8 +85,8 @@ impl GenericEvent<'_> for LoadCompleteEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -108,8 +109,8 @@ impl GenericEvent<'_> for ReloadEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -132,8 +133,8 @@ impl GenericEvent<'_> for LoadStoppedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -156,8 +157,8 @@ impl GenericEvent<'_> for ContentChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -180,8 +181,8 @@ impl GenericEvent<'_> for AttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -204,8 +205,8 @@ impl GenericEvent<'_> for PageChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 8958f874..866b7683 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
@@ -38,8 +39,8 @@ impl GenericEvent<'_> for FocusEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 3e4f331d..02a53139 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
@@ -41,8 +42,8 @@ impl GenericEvent<'_> for ModifiersEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, previous_modifiers: body.detail1, current_modifiers: body.detail2 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 32f4f94b..6ec9d776 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -28,7 +28,7 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 use zbus_lockstep_macros::validate;
-use zbus_names::{OwnedUniqueName, UniqueName};
+use zbus_names::{BusName, OwnedBusName, OwnedUniqueName, UniqueName};
 #[cfg(feature = "zbus")]
 use zvariant::OwnedObjectPath;
 use zvariant::{ObjectPath, OwnedValue, Signature, Type, Value};
@@ -60,7 +60,7 @@ pub struct EventBody<'a, T> {
 	/// Map of string to an any type.
 	/// This is not used for anything, but it is defined by AT-SPI.
 	#[serde(borrow)]
-	pub properties: HashMap<&'a str, Value<'a>>,
+	pub properties: HashMap<BusName<'a>, Value<'a>>,
 }
 
 impl<T> Type for EventBody<'_, T> {
@@ -120,7 +120,7 @@ pub struct EventBodyOwned {
 	pub any_data: OwnedValue,
 	/// A map of properties.
 	/// Not in use.
-	pub properties: HashMap<String, OwnedValue>,
+	pub properties: HashMap<OwnedBusName, OwnedValue>,
 }
 
 impl From<EventBodyQT> for EventBodyOwned {
@@ -296,8 +296,8 @@ impl GenericEvent<'_> for LegacyAddAccessibleEvent {
 		Ok(Self { item, node_added: body })
 	}
 
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -339,8 +339,8 @@ impl GenericEvent<'_> for AddAccessibleEvent {
 		Ok(Self { item, node_added: body })
 	}
 
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -388,8 +388,8 @@ impl GenericEvent<'_> for RemoveAccessibleEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, node_removed: body })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -448,10 +448,11 @@ impl TryFrom<&zbus::Message> for ObjectRef {
 		let path = header.path().expect("returned path is either `Some` or panics");
 		let owned_path: OwnedObjectPath = path.clone().into();
 
-		let sender = header.sender().expect("No sender in header");
-		let name_string = sender.as_str().to_owned();
+		let sender: UniqueName<'_> = header.sender().expect("No sender in header").into();
+		let bus_name: BusName<'_> = sender.into();
+		let name: OwnedBusName = bus_name.to_owned().into();
 
-		Ok(ObjectRef { name: name_string, path: owned_path })
+		Ok(ObjectRef { name, path: owned_path })
 	}
 }
 
@@ -547,8 +548,8 @@ impl GenericEvent<'_> for EventListenerDeregisteredEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, deregistered_event: body })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -594,8 +595,8 @@ impl GenericEvent<'_> for EventListenerRegisteredEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, registered_event: body })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -642,8 +643,8 @@ impl GenericEvent<'_> for AvailableEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, socket: body })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -762,7 +763,7 @@ pub trait GenericEvent<'a> {
 	/// ### Errors
 	/// - when deserializing the header failed, or
 	/// - When `zbus::get_field!` finds that 'sender' is an invalid field.
-	fn sender(&self) -> String;
+	fn sender(&self) -> BusName<'_>;
 
 	/// The body of the object.
 	fn body(&self) -> Self::Body;
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index bd9f03f9..f5b1073c 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::ObjectPath;
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
@@ -61,8 +62,8 @@ impl GenericEvent<'_> for AbsEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -85,8 +86,8 @@ impl GenericEvent<'_> for RelEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -109,8 +110,8 @@ impl GenericEvent<'_> for ButtonEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, detail: body.kind, mouse_x: body.detail1, mouse_y: body.detail2 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 30c3f441..b78777a8 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -5,6 +5,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event, State,
 };
+use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue, Value};
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Hash)]
@@ -429,8 +430,8 @@ impl GenericEvent<'_> for PropertyChangeEvent {
 		let value: Property = body.try_into()?;
 		Ok(Self { item, property, value })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -453,8 +454,8 @@ impl GenericEvent<'_> for BoundsChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -477,8 +478,8 @@ impl GenericEvent<'_> for LinkSelectedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -502,8 +503,8 @@ impl GenericEvent<'_> for StateChangedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, state: body.kind.into(), enabled: body.detail1 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -531,8 +532,8 @@ impl GenericEvent<'_> for ChildrenChangedEvent {
 			child: body.any_data.try_into()?,
 		})
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -555,8 +556,8 @@ impl GenericEvent<'_> for VisibleDataChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -579,8 +580,8 @@ impl GenericEvent<'_> for SelectionChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -603,8 +604,8 @@ impl GenericEvent<'_> for ModelChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -627,8 +628,8 @@ impl GenericEvent<'_> for ActiveDescendantChangedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, child: body.any_data.try_into()? })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -657,8 +658,8 @@ impl GenericEvent<'_> for AnnouncementEvent {
 				.ok_or(AtspiError::Conversion("\"detail1\" not convertable to \"Live\""))?,
 		})
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -681,8 +682,8 @@ impl GenericEvent<'_> for AttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -705,8 +706,8 @@ impl GenericEvent<'_> for RowInsertedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -729,8 +730,8 @@ impl GenericEvent<'_> for RowReorderedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -753,8 +754,8 @@ impl GenericEvent<'_> for RowDeletedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -777,8 +778,8 @@ impl GenericEvent<'_> for ColumnInsertedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -801,8 +802,8 @@ impl GenericEvent<'_> for ColumnReorderedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -825,8 +826,8 @@ impl GenericEvent<'_> for ColumnDeletedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -849,8 +850,8 @@ impl GenericEvent<'_> for TextBoundsChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -873,8 +874,8 @@ impl GenericEvent<'_> for TextSelectionChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -903,8 +904,8 @@ impl GenericEvent<'_> for TextChangedEvent {
 			text: body.any_data.try_into()?,
 		})
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -927,8 +928,8 @@ impl GenericEvent<'_> for TextAttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -951,8 +952,8 @@ impl GenericEvent<'_> for TextCaretMovedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, position: body.detail1 })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index d8c4fbe6..983762ca 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::ObjectPath;
 
 /// All events related to the `org.a11y.atspi.Event.Terminal` interface.
@@ -79,8 +80,8 @@ impl GenericEvent<'_> for LineChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -103,8 +104,8 @@ impl GenericEvent<'_> for ColumnCountChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -127,8 +128,8 @@ impl GenericEvent<'_> for LineCountChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -151,8 +152,8 @@ impl GenericEvent<'_> for ApplicationChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -175,8 +176,8 @@ impl GenericEvent<'_> for CharWidthChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index 10fcee6b..ca6853cb 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -3,6 +3,7 @@ use crate::{
 	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
+use zbus_names::BusName;
 use zvariant::ObjectPath;
 
 /// All events on the `org.a11y.atspi.Event.Window` interface.
@@ -191,8 +192,8 @@ impl GenericEvent<'_> for PropertyChangeEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, property: body.kind })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -215,8 +216,8 @@ impl GenericEvent<'_> for MinimizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -239,8 +240,8 @@ impl GenericEvent<'_> for MaximizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -263,8 +264,8 @@ impl GenericEvent<'_> for RestoreEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -287,8 +288,8 @@ impl GenericEvent<'_> for CloseEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -311,8 +312,8 @@ impl GenericEvent<'_> for CreateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -335,8 +336,8 @@ impl GenericEvent<'_> for ReparentEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -359,8 +360,8 @@ impl GenericEvent<'_> for DesktopCreateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -383,8 +384,8 @@ impl GenericEvent<'_> for DesktopDestroyEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -407,8 +408,8 @@ impl GenericEvent<'_> for DestroyEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -431,8 +432,8 @@ impl GenericEvent<'_> for ActivateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -455,8 +456,8 @@ impl GenericEvent<'_> for DeactivateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -479,8 +480,8 @@ impl GenericEvent<'_> for RaiseEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -503,8 +504,8 @@ impl GenericEvent<'_> for LowerEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -527,8 +528,8 @@ impl GenericEvent<'_> for MoveEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -551,8 +552,8 @@ impl GenericEvent<'_> for ResizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -575,8 +576,8 @@ impl GenericEvent<'_> for ShadeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -599,8 +600,8 @@ impl GenericEvent<'_> for UUshadeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
@@ -623,8 +624,8 @@ impl GenericEvent<'_> for RestyleEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> String {
-		self.item.name.clone()
+	fn sender(&self) -> BusName<'_> {
+		self.item.name.clone().into()
 	}
 	fn path<'a>(&self) -> ObjectPath<'_> {
 		self.item.path.clone().into()
diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index 71dfacbf..9628b793 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -184,7 +184,7 @@ macro_rules! impl_to_dbus_message {
 					<$type as GenericEvent>::DBUS_INTERFACE,
 					<$type as GenericEvent>::DBUS_MEMBER,
 				)?
-				.sender(event.sender())?
+				.sender(event.sender().to_string())?
 				.build(&event.body())?)
 			}
 		}
diff --git a/atspi-common/src/object_ref.rs b/atspi-common/src/object_ref.rs
index 400a815a..8ef4b496 100644
--- a/atspi-common/src/object_ref.rs
+++ b/atspi-common/src/object_ref.rs
@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use zbus_lockstep_macros::validate;
+use zbus_names::OwnedBusName;
 use zvariant::{ObjectPath, OwnedObjectPath, Signature, Type};
 
 pub const OBJECT_REF_SIGNATURE: Signature<'_> = Signature::from_static_str_unchecked("(so)");
@@ -15,14 +16,14 @@ pub const OBJECT_REF_SIGNATURE: Signature<'_> = Signature::from_static_str_unche
 #[validate(signal: "Available")]
 #[derive(Debug, Clone, Serialize, Deserialize, Type, PartialEq, Eq, Hash)]
 pub struct ObjectRef {
-	pub name: String,
+	pub name: OwnedBusName,
 	pub path: OwnedObjectPath,
 }
 
 impl Default for ObjectRef {
 	fn default() -> Self {
 		ObjectRef {
-			name: ":0.0".into(),
+			name: ":0.0".try_into().unwrap(),
 			path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/null")
 				.unwrap()
 				.into(),
@@ -84,7 +85,10 @@ impl TryFrom<zvariant::OwnedValue> for ObjectRef {
 					fields.first().ok_or(zvariant::Error::IncorrectType)?.try_into()?;
 				let path_value: ObjectPath<'_> =
 					fields.last().ok_or(zvariant::Error::IncorrectType)?.try_into()?;
-				Ok(ObjectRef { name, path: path_value.into() })
+				Ok(ObjectRef {
+					name: name.try_into().map_err(|_| zvariant::Error::IncorrectType)?,
+					path: path_value.into(),
+				})
 			}
 			_ => Err(zvariant::Error::IncorrectType),
 		}
diff --git a/atspi-common/tests/tests.rs b/atspi-common/tests/tests.rs
index 0e059c3d..de9a9cfe 100644
--- a/atspi-common/tests/tests.rs
+++ b/atspi-common/tests/tests.rs
@@ -5,6 +5,7 @@ use atspi_connection::AccessibilityConnection;
 use std::time::Duration;
 use tokio_stream::StreamExt;
 use zbus::Message;
+use zbus_names::OwnedBusName;
 use zvariant::OwnedObjectPath;
 
 #[tokio::test]
@@ -18,7 +19,7 @@ async fn test_recv_remove_accessible() {
 
 	let msg = {
 		let remove_body = ObjectRef {
-			name: ":69.420".into(),
+			name: OwnedBusName::try_from(":69.420").unwrap(),
 			path: OwnedObjectPath::try_from("/org/a11y/atspi/accessible/remove").unwrap(),
 		};
 
diff --git a/atspi-proxies/src/accessible.rs b/atspi-proxies/src/accessible.rs
index 49998810..a78b398f 100644
--- a/atspi-proxies/src/accessible.rs
+++ b/atspi-proxies/src/accessible.rs
@@ -233,7 +233,7 @@ impl TryFrom<AccessibleProxy<'_>> for ObjectRef {
 	type Error = AtspiError;
 	fn try_from(proxy: AccessibleProxy<'_>) -> Result<ObjectRef, Self::Error> {
 		Ok(ObjectRef {
-			name: proxy.inner().destination().to_string(),
+			name: proxy.inner().destination().to_owned().into(),
 			path: proxy.inner().path().to_string().try_into()?,
 		})
 	}
@@ -242,7 +242,7 @@ impl TryFrom<&AccessibleProxy<'_>> for ObjectRef {
 	type Error = AtspiError;
 	fn try_from(proxy: &AccessibleProxy<'_>) -> Result<ObjectRef, Self::Error> {
 		Ok(ObjectRef {
-			name: proxy.inner().destination().to_string(),
+			name: proxy.inner().destination().to_owned().into(),
 			path: proxy.inner().path().to_string().try_into()?,
 		})
 	}

From 5d96bd307b4072ea69c5f32c26e66b4f928257ef Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 15:12:14 -0600
Subject: [PATCH 20/37] Use from_static_str for Default implementaiton

clippy
---
 atspi-common/src/cache.rs      | 39 ++++++++++++++++++++++------------
 atspi-common/src/object_ref.rs |  4 ++--
 2 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/atspi-common/src/cache.rs b/atspi-common/src/cache.rs
index 3a5a82b9..8cc00321 100644
--- a/atspi-common/src/cache.rs
+++ b/atspi-common/src/cache.rs
@@ -4,7 +4,8 @@
 use crate::{InterfaceSet, ObjectRef, Role, StateSet};
 use serde::{Deserialize, Serialize};
 use zbus_lockstep_macros::validate;
-use zvariant::Type;
+use zbus_names::BusName;
+use zvariant::{ObjectPath, Type};
 
 /// The item type provided by `Cache:Add` signals
 #[allow(clippy::module_name_repetitions)]
@@ -37,16 +38,22 @@ impl Default for CacheItem {
 	fn default() -> Self {
 		Self {
 			object: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/object".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/object")
+					.unwrap()
+					.into(),
 			},
 			app: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/application".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/application")
+					.unwrap()
+					.into(),
 			},
 			parent: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/parent".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/parent")
+					.unwrap()
+					.into(),
 			},
 			index: 0,
 			children: 0,
@@ -86,16 +93,22 @@ impl Default for LegacyCacheItem {
 	fn default() -> Self {
 		Self {
 			object: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/object".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/object")
+					.unwrap()
+					.into(),
 			},
 			app: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/application".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/application")
+					.unwrap()
+					.into(),
 			},
 			parent: ObjectRef {
-				name: ":0.0".try_into().unwrap(),
-				path: "/org/a11y/atspi/accessible/parent".try_into().unwrap(),
+				name: BusName::from_static_str(":0.0").unwrap().into(),
+				path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/parent")
+					.unwrap()
+					.into(),
 			},
 			children: Vec::new(),
 			ifaces: InterfaceSet::empty(),
diff --git a/atspi-common/src/object_ref.rs b/atspi-common/src/object_ref.rs
index 8ef4b496..95f51244 100644
--- a/atspi-common/src/object_ref.rs
+++ b/atspi-common/src/object_ref.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use zbus_lockstep_macros::validate;
-use zbus_names::OwnedBusName;
+use zbus_names::{BusName, OwnedBusName};
 use zvariant::{ObjectPath, OwnedObjectPath, Signature, Type};
 
 pub const OBJECT_REF_SIGNATURE: Signature<'_> = Signature::from_static_str_unchecked("(so)");
@@ -23,7 +23,7 @@ pub struct ObjectRef {
 impl Default for ObjectRef {
 	fn default() -> Self {
 		ObjectRef {
-			name: ":0.0".try_into().unwrap(),
+			name: BusName::from_static_str(":0.0").unwrap().into(),
 			path: ObjectPath::from_static_str("/org/a11y/atspi/accessible/null")
 				.unwrap()
 				.into(),

From 6253a90ee5afd5182ae6b909f19d869758bc704c Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 23:20:52 -0600
Subject: [PATCH 21/37] GenericEvent -> BusProperties, GenericEvent is now an
 object-safe auto-impl for BusProperties

---
 atspi-common/new_events.diff        | 169 ++++++++++++++++++++++++++++
 atspi-common/src/events/document.rs |  14 +--
 atspi-common/src/events/focus.rs    |   4 +-
 atspi-common/src/events/keyboard.rs |   4 +-
 atspi-common/src/events/mod.rs      |  74 +++++++++---
 atspi-common/src/events/mouse.rs    |   8 +-
 atspi-common/src/events/object.rs   |  46 ++++----
 atspi-common/src/events/terminal.rs |  12 +-
 atspi-common/src/events/window.rs   |  40 +++----
 atspi-common/src/lib.rs             |   2 +-
 atspi-common/src/macros.rs          |  36 +++---
 11 files changed, 312 insertions(+), 97 deletions(-)
 create mode 100644 atspi-common/new_events.diff

diff --git a/atspi-common/new_events.diff b/atspi-common/new_events.diff
new file mode 100644
index 00000000..e8c3d1b7
--- /dev/null
+++ b/atspi-common/new_events.diff
@@ -0,0 +1,169 @@
+diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
+index 3b6e091..1abeb33 100644
+--- a/atspi-common/src/events/mod.rs
++++ b/atspi-common/src/events/mod.rs
+@@ -31,6 +31,7 @@ use zbus_lockstep_macros::validate;
+ use zbus_names::{OwnedUniqueName, UniqueName};
+ #[cfg(feature = "zbus")]
+ use zvariant::OwnedObjectPath;
++use zbus_names::BusName;
+ use zvariant::{ObjectPath, OwnedValue, Signature, Type, Value};
+ 
+ use crate::{
+@@ -283,7 +284,7 @@ event_test_cases!(LegacyAddAccessibleEvent);
+ impl_from_dbus_message!(LegacyAddAccessibleEvent);
+ impl_to_dbus_message!(LegacyAddAccessibleEvent);
+ 
+-impl GenericEvent<'_> for LegacyAddAccessibleEvent {
++impl BusProperties<'_> for LegacyAddAccessibleEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
+@@ -326,7 +327,7 @@ impl_from_user_facing_type_for_event_enum!(AddAccessibleEvent, Event::Cache);
+ impl_try_from_event_for_user_facing_type!(AddAccessibleEvent, CacheEvents::Add, Event::Cache);
+ event_test_cases!(AddAccessibleEvent);
+ 
+-impl GenericEvent<'_> for AddAccessibleEvent {
++impl BusProperties<'_> for AddAccessibleEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
+@@ -349,11 +350,11 @@ impl GenericEvent<'_> for AddAccessibleEvent {
+ 		self.node_added.clone()
+ 	}
+ }
+-impl<'a, T: GenericEvent<'a>> HasMatchRule for T {
+-	const MATCH_RULE_STRING: &'static str = <T as GenericEvent>::MATCH_RULE_STRING;
++impl<'a, T: BusProperties<'a>> HasMatchRule for T {
++	const MATCH_RULE_STRING: &'static str = <T as BusProperties>::MATCH_RULE_STRING;
+ }
+-impl<'a, T: GenericEvent<'a>> HasRegistryEventString for T {
+-	const REGISTRY_EVENT_STRING: &'static str = <T as GenericEvent>::REGISTRY_EVENT_STRING;
++impl<'a, T: BusProperties<'a>> HasRegistryEventString for T {
++	const REGISTRY_EVENT_STRING: &'static str = <T as BusProperties>::REGISTRY_EVENT_STRING;
+ }
+ impl_from_dbus_message!(AddAccessibleEvent);
+ impl_to_dbus_message!(AddAccessibleEvent);
+@@ -376,7 +377,7 @@ impl_from_user_facing_event_for_interface_event_enum!(
+ impl_from_user_facing_type_for_event_enum!(RemoveAccessibleEvent, Event::Cache);
+ impl_try_from_event_for_user_facing_type!(RemoveAccessibleEvent, CacheEvents::Remove, Event::Cache);
+ event_test_cases!(RemoveAccessibleEvent);
+-impl GenericEvent<'_> for RemoveAccessibleEvent {
++impl BusProperties<'_> for RemoveAccessibleEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Remove";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Cache',member='RemoveAccessible'";
+@@ -535,7 +536,7 @@ impl_try_from_event_for_user_facing_type!(
+ 	Event::Listener
+ );
+ event_test_cases!(EventListenerDeregisteredEvent);
+-impl GenericEvent<'_> for EventListenerDeregisteredEvent {
++impl BusProperties<'_> for EventListenerDeregisteredEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerDeregistered";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerDeregistered'";
+@@ -582,7 +583,7 @@ impl_try_from_event_for_user_facing_type!(
+ 	Event::Listener
+ );
+ event_test_cases!(EventListenerRegisteredEvent);
+-impl GenericEvent<'_> for EventListenerRegisteredEvent {
++impl BusProperties<'_> for EventListenerRegisteredEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerRegistered";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerRegistered'";
+@@ -630,7 +631,7 @@ impl TryFrom<Event> for AvailableEvent {
+ 	}
+ }
+ event_test_cases!(AvailableEvent);
+-impl GenericEvent<'_> for AvailableEvent {
++impl BusProperties<'_> for AvailableEvent {
+ 	const REGISTRY_EVENT_STRING: &'static str = "Socket:Available";
+ 	const MATCH_RULE_STRING: &'static str =
+ 		"type='signal',interface='org.a11y.atspi.Socket',member='Available'";
+@@ -725,8 +726,37 @@ impl TryFrom<&zbus::Message> for Event {
+ 	}
+ }
+ 
++/// Get generic information abbout an event, like its:
++/// 
++/// - dbus member name
++/// - dbus interface name
++/// - dbus path
++/// - dbus sender (bus id)
++///
++/// Member name and interface name combined are unique to individual event types;
++/// dbus path and sender are unique to a specific accessible item available on the accessibility bus (also know as an [`ObjectRef`]).
++/// 
++/// This trait *is* object-safe.
++pub trait GenericEvent {
++	fn member(&self) -> &'static str;
++	fn interface(&self) -> &'static str;
++	fn path(&self) -> ObjectPath<'_>;
++	fn sender(&self) -> BusName<'_>;
++}
++
++assert_obj_safe!(GenericEvent);
++
++impl<T: GenericEvent> From<&T> for ObjectRef {
++	fn from(ev: &T) -> ObjectRef {
++		ObjectRef {
++			name: ev.sender().to_string(),
++			path: ev.path().into(),
++		}
++	}
++}
++
+ /// Shared behavior of bus `Signal` events.
+-pub trait GenericEvent<'a> {
++pub trait BusProperties {
+ 	/// The `DBus` member for the event.
+ 	/// For example, for an [`object::TextChangedEvent`] this should be `"TextChanged"`
+ 	const DBUS_MEMBER: &'static str;
+@@ -742,44 +772,21 @@ pub trait GenericEvent<'a> {
+ 	const REGISTRY_EVENT_STRING: &'static str;
+ 
+ 	/// What is the body type of this event.
+-	type Body: Type + Serialize + Deserialize<'a>;
+-
+-	/// Build the event from the object pair (`ObjectRef` and the Body).
+-	///
+-	/// # Errors
+-	///
+-	/// When the body type, which is what the raw message looks like over `DBus`, does not match the type that is expected for the given event.
+-	/// It is not possible for this to error on most events, but on events whose raw message [`Self::Body`] type contains a [`enum@zvariant::Value`], you may get errors when constructing the structure.
+-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError>
+-	where
+-		Self: Sized;
+-
+-	/// Path of the signalling object.
+-	fn path(&self) -> ObjectPath<'_>;
+-
+-	/// Sender of the signal.
+-	///
+-	/// ### Errors
+-	/// - when deserializing the header failed, or
+-	/// - When `zbus::get_field!` finds that 'sender' is an invalid field.
+-	fn sender(&self) -> String;
+-
+-	/// The body of the object.
+-	fn body(&self) -> Self::Body;
++	type Body: Type + Serialize + for<'b> Deserialize<'b>;
+ }
+ 
+ /// A specific trait *only* to define match rules.
+ pub trait HasMatchRule {
+ 	/// A static match rule string for `DBus`.
+ 	/// This should usually be a string that looks like this: `"type='signal',interface='org.a11y.atspi.Event.Object',member='PropertyChange'"`;
+-	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
++	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
+ 	const MATCH_RULE_STRING: &'static str;
+ }
+ 
+ /// A specific trait *only* to define registry event matches.
+ pub trait HasRegistryEventString {
+ 	/// A registry event string for registering for event receiving via the `RegistryProxy`.
+-	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
++	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
+ 	const REGISTRY_EVENT_STRING: &'static str;
+ }
+ 
diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index dd79d5ca..6d9ebfb8 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -73,7 +73,7 @@ pub struct PageChangedEvent {
 	pub item: crate::events::ObjectRef,
 }
 
-impl GenericEvent<'_> for LoadCompleteEvent {
+impl BusProperties for LoadCompleteEvent {
 	const DBUS_MEMBER: &'static str = "LoadComplete";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
@@ -97,7 +97,7 @@ impl GenericEvent<'_> for LoadCompleteEvent {
 	}
 }
 
-impl GenericEvent<'_> for ReloadEvent {
+impl BusProperties for ReloadEvent {
 	const DBUS_MEMBER: &'static str = "Reload";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
@@ -121,7 +121,7 @@ impl GenericEvent<'_> for ReloadEvent {
 	}
 }
 
-impl GenericEvent<'_> for LoadStoppedEvent {
+impl BusProperties for LoadStoppedEvent {
 	const DBUS_MEMBER: &'static str = "LoadStopped";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
@@ -145,7 +145,7 @@ impl GenericEvent<'_> for LoadStoppedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ContentChangedEvent {
+impl BusProperties for ContentChangedEvent {
 	const DBUS_MEMBER: &'static str = "ContentChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
@@ -169,7 +169,7 @@ impl GenericEvent<'_> for ContentChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for AttributesChangedEvent {
+impl BusProperties for AttributesChangedEvent {
 	const DBUS_MEMBER: &'static str = "AttributesChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
@@ -193,7 +193,7 @@ impl GenericEvent<'_> for AttributesChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for PageChangedEvent {
+impl BusProperties for PageChangedEvent {
 	const DBUS_MEMBER: &'static str = "PageChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Document";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 866b7683..28d2592e 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -27,7 +27,7 @@ pub struct FocusEvent {
 	pub item: crate::events::ObjectRef,
 }
 
-impl GenericEvent<'_> for FocusEvent {
+impl BusProperties for FocusEvent {
 	const DBUS_MEMBER: &'static str = "Focus";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Focus";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 02a53139..ea86957a 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -30,7 +30,7 @@ pub struct ModifiersEvent {
 	pub current_modifiers: i32,
 }
 
-impl GenericEvent<'_> for ModifiersEvent {
+impl BusProperties for ModifiersEvent {
 	const DBUS_MEMBER: &'static str = "Modifiers";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Keyboard";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 6ec9d776..cfa8c080 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -283,7 +283,7 @@ event_test_cases!(LegacyAddAccessibleEvent);
 impl_from_dbus_message!(LegacyAddAccessibleEvent);
 impl_to_dbus_message!(LegacyAddAccessibleEvent);
 
-impl GenericEvent<'_> for LegacyAddAccessibleEvent {
+impl BusProperties for LegacyAddAccessibleEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
@@ -326,7 +326,7 @@ impl_from_user_facing_type_for_event_enum!(AddAccessibleEvent, Event::Cache);
 impl_try_from_event_for_user_facing_type!(AddAccessibleEvent, CacheEvents::Add, Event::Cache);
 event_test_cases!(AddAccessibleEvent);
 
-impl GenericEvent<'_> for AddAccessibleEvent {
+impl BusProperties for AddAccessibleEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
@@ -349,11 +349,11 @@ impl GenericEvent<'_> for AddAccessibleEvent {
 		self.node_added.clone()
 	}
 }
-impl<'a, T: GenericEvent<'a>> HasMatchRule for T {
-	const MATCH_RULE_STRING: &'static str = <T as GenericEvent>::MATCH_RULE_STRING;
+impl<'a, T: BusProperties> HasMatchRule for T {
+	const MATCH_RULE_STRING: &'static str = <T as BusProperties>::MATCH_RULE_STRING;
 }
-impl<'a, T: GenericEvent<'a>> HasRegistryEventString for T {
-	const REGISTRY_EVENT_STRING: &'static str = <T as GenericEvent>::REGISTRY_EVENT_STRING;
+impl<'a, T: BusProperties> HasRegistryEventString for T {
+	const REGISTRY_EVENT_STRING: &'static str = <T as BusProperties>::REGISTRY_EVENT_STRING;
 }
 impl_from_dbus_message!(AddAccessibleEvent);
 impl_to_dbus_message!(AddAccessibleEvent);
@@ -376,7 +376,7 @@ impl_from_user_facing_event_for_interface_event_enum!(
 impl_from_user_facing_type_for_event_enum!(RemoveAccessibleEvent, Event::Cache);
 impl_try_from_event_for_user_facing_type!(RemoveAccessibleEvent, CacheEvents::Remove, Event::Cache);
 event_test_cases!(RemoveAccessibleEvent);
-impl GenericEvent<'_> for RemoveAccessibleEvent {
+impl BusProperties for RemoveAccessibleEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Remove";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Cache',member='RemoveAccessible'";
@@ -536,7 +536,7 @@ impl_try_from_event_for_user_facing_type!(
 	Event::Listener
 );
 event_test_cases!(EventListenerDeregisteredEvent);
-impl GenericEvent<'_> for EventListenerDeregisteredEvent {
+impl BusProperties for EventListenerDeregisteredEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerDeregistered";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerDeregistered'";
@@ -583,7 +583,7 @@ impl_try_from_event_for_user_facing_type!(
 	Event::Listener
 );
 event_test_cases!(EventListenerRegisteredEvent);
-impl GenericEvent<'_> for EventListenerRegisteredEvent {
+impl BusProperties for EventListenerRegisteredEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerRegistered";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerRegistered'";
@@ -631,7 +631,7 @@ impl TryFrom<Event> for AvailableEvent {
 	}
 }
 event_test_cases!(AvailableEvent);
-impl GenericEvent<'_> for AvailableEvent {
+impl BusProperties for AvailableEvent {
 	const REGISTRY_EVENT_STRING: &'static str = "Socket:Available";
 	const MATCH_RULE_STRING: &'static str =
 		"type='signal',interface='org.a11y.atspi.Socket',member='Available'";
@@ -726,8 +726,54 @@ impl TryFrom<&zbus::Message> for Event {
 	}
 }
 
+/// Describes the DBus-related information about a given struct.
+///
+/// - DBus member name
+/// - DBus interface name
+/// - DBus path
+/// - DBus bus name
+///
+/// Together, the member and interface name can describe a specific event _type_.
+/// Likewise, the path and bus collectively create a unique ID for an _object on the accessibility bus_, this can also be referred to as an [`ObjectRef`].
+///
+/// This can also be generalized, for example this is implemented for [`Event`] by dispatching to the matching variants.
+///
+/// This trait *is* object-safe.
+pub trait GenericEvent {
+	fn member(&self) -> &'static str;
+	fn interface(&self) -> &'static str;
+	fn path2<'a>(&self) -> ObjectPath<'a>;
+	fn name2<'a>(&self) -> BusName<'a>;
+}
+
+impl<'a, T: BusProperties> GenericEvent for T {
+	fn member(&self) -> &'static str {
+		<T as BusProperties>::DBUS_MEMBER
+	}
+	fn interface(&self) -> &'static str {
+		<T as BusProperties>::DBUS_INTERFACE
+	}
+	fn path2<'b>(&self) -> ObjectPath<'b> {
+		todo!()
+	}
+	fn name2<'b>(&self) -> BusName<'b> {
+		todo!()
+	}
+}
+
+impl<T: GenericEvent> From<&T> for ObjectRef {
+	fn from(ev: &T) -> ObjectRef {
+		ObjectRef {
+			path: ev.path2().to_owned().into(),
+			name: ev.name2().to_owned().into(),
+		}
+	}
+}
+
+assert_obj_safe!(GenericEvent);
+
 /// Shared behavior of bus `Signal` events.
-pub trait GenericEvent<'a> {
+pub trait BusProperties {
 	/// The `DBus` member for the event.
 	/// For example, for an [`object::TextChangedEvent`] this should be `"TextChanged"`
 	const DBUS_MEMBER: &'static str;
@@ -743,7 +789,7 @@ pub trait GenericEvent<'a> {
 	const REGISTRY_EVENT_STRING: &'static str;
 
 	/// What is the body type of this event.
-	type Body: Type + Serialize + Deserialize<'a>;
+	type Body: Type + Serialize + for<'a> Deserialize<'a>;
 
 	/// Build the event from the object pair (`ObjectRef` and the Body).
 	///
@@ -773,14 +819,14 @@ pub trait GenericEvent<'a> {
 pub trait HasMatchRule {
 	/// A static match rule string for `DBus`.
 	/// This should usually be a string that looks like this: `"type='signal',interface='org.a11y.atspi.Event.Object',member='PropertyChange'"`;
-	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
+	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
 	const MATCH_RULE_STRING: &'static str;
 }
 
 /// A specific trait *only* to define registry event matches.
 pub trait HasRegistryEventString {
 	/// A registry event string for registering for event receiving via the `RegistryProxy`.
-	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
+	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
 	const REGISTRY_EVENT_STRING: &'static str;
 }
 
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index f5b1073c..51cc8a58 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -50,7 +50,7 @@ pub struct ButtonEvent {
 	pub mouse_y: i32,
 }
 
-impl GenericEvent<'_> for AbsEvent {
+impl BusProperties for AbsEvent {
 	const DBUS_MEMBER: &'static str = "Abs";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Mouse";
 	const MATCH_RULE_STRING: &'static str =
@@ -74,7 +74,7 @@ impl GenericEvent<'_> for AbsEvent {
 	}
 }
 
-impl GenericEvent<'_> for RelEvent {
+impl BusProperties for RelEvent {
 	const DBUS_MEMBER: &'static str = "Rel";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Mouse";
 	const MATCH_RULE_STRING: &'static str =
@@ -98,7 +98,7 @@ impl GenericEvent<'_> for RelEvent {
 	}
 }
 
-impl GenericEvent<'_> for ButtonEvent {
+impl BusProperties for ButtonEvent {
 	const DBUS_MEMBER: &'static str = "Button";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Mouse";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index b78777a8..70132c9c 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -2,7 +2,7 @@
 use crate::Live;
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event, State,
 };
 use zbus_names::BusName;
@@ -416,7 +416,7 @@ pub struct TextCaretMovedEvent {
 }
 
 #[cfg(feature = "strum")]
-impl GenericEvent<'_> for PropertyChangeEvent {
+impl BusProperties for PropertyChangeEvent {
 	const DBUS_MEMBER: &'static str = "PropertyChange";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -442,7 +442,7 @@ impl GenericEvent<'_> for PropertyChangeEvent {
 	}
 }
 
-impl GenericEvent<'_> for BoundsChangedEvent {
+impl BusProperties for BoundsChangedEvent {
 	const DBUS_MEMBER: &'static str = "BoundsChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -466,7 +466,7 @@ impl GenericEvent<'_> for BoundsChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for LinkSelectedEvent {
+impl BusProperties for LinkSelectedEvent {
 	const DBUS_MEMBER: &'static str = "LinkSelected";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -491,7 +491,7 @@ impl GenericEvent<'_> for LinkSelectedEvent {
 }
 
 #[cfg(feature = "strum")]
-impl GenericEvent<'_> for StateChangedEvent {
+impl BusProperties for StateChangedEvent {
 	const DBUS_MEMBER: &'static str = "StateChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -515,7 +515,7 @@ impl GenericEvent<'_> for StateChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ChildrenChangedEvent {
+impl BusProperties for ChildrenChangedEvent {
 	const DBUS_MEMBER: &'static str = "ChildrenChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -544,7 +544,7 @@ impl GenericEvent<'_> for ChildrenChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for VisibleDataChangedEvent {
+impl BusProperties for VisibleDataChangedEvent {
 	const DBUS_MEMBER: &'static str = "VisibleDataChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -568,7 +568,7 @@ impl GenericEvent<'_> for VisibleDataChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for SelectionChangedEvent {
+impl BusProperties for SelectionChangedEvent {
 	const DBUS_MEMBER: &'static str = "SelectionChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -592,7 +592,7 @@ impl GenericEvent<'_> for SelectionChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ModelChangedEvent {
+impl BusProperties for ModelChangedEvent {
 	const DBUS_MEMBER: &'static str = "ModelChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -616,7 +616,7 @@ impl GenericEvent<'_> for ModelChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ActiveDescendantChangedEvent {
+impl BusProperties for ActiveDescendantChangedEvent {
 	const DBUS_MEMBER: &'static str = "ActiveDescendantChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -641,7 +641,7 @@ impl GenericEvent<'_> for ActiveDescendantChangedEvent {
 }
 
 #[cfg(feature = "strum")]
-impl GenericEvent<'_> for AnnouncementEvent {
+impl BusProperties for AnnouncementEvent {
 	const DBUS_MEMBER: &'static str = "Announcement";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -670,7 +670,7 @@ impl GenericEvent<'_> for AnnouncementEvent {
 	}
 }
 
-impl GenericEvent<'_> for AttributesChangedEvent {
+impl BusProperties for AttributesChangedEvent {
 	const DBUS_MEMBER: &'static str = "AttributesChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -694,7 +694,7 @@ impl GenericEvent<'_> for AttributesChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for RowInsertedEvent {
+impl BusProperties for RowInsertedEvent {
 	const DBUS_MEMBER: &'static str = "RowInserted";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -718,7 +718,7 @@ impl GenericEvent<'_> for RowInsertedEvent {
 	}
 }
 
-impl GenericEvent<'_> for RowReorderedEvent {
+impl BusProperties for RowReorderedEvent {
 	const DBUS_MEMBER: &'static str = "RowReordered";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -742,7 +742,7 @@ impl GenericEvent<'_> for RowReorderedEvent {
 	}
 }
 
-impl GenericEvent<'_> for RowDeletedEvent {
+impl BusProperties for RowDeletedEvent {
 	const DBUS_MEMBER: &'static str = "RowDeleted";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -766,7 +766,7 @@ impl GenericEvent<'_> for RowDeletedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ColumnInsertedEvent {
+impl BusProperties for ColumnInsertedEvent {
 	const DBUS_MEMBER: &'static str = "ColumnInserted";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -790,7 +790,7 @@ impl GenericEvent<'_> for ColumnInsertedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ColumnReorderedEvent {
+impl BusProperties for ColumnReorderedEvent {
 	const DBUS_MEMBER: &'static str = "ColumnReordered";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -814,7 +814,7 @@ impl GenericEvent<'_> for ColumnReorderedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ColumnDeletedEvent {
+impl BusProperties for ColumnDeletedEvent {
 	const DBUS_MEMBER: &'static str = "ColumnDeleted";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -838,7 +838,7 @@ impl GenericEvent<'_> for ColumnDeletedEvent {
 	}
 }
 
-impl GenericEvent<'_> for TextBoundsChangedEvent {
+impl BusProperties for TextBoundsChangedEvent {
 	const DBUS_MEMBER: &'static str = "TextBoundsChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -862,7 +862,7 @@ impl GenericEvent<'_> for TextBoundsChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for TextSelectionChangedEvent {
+impl BusProperties for TextSelectionChangedEvent {
 	const DBUS_MEMBER: &'static str = "TextSelectionChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -886,7 +886,7 @@ impl GenericEvent<'_> for TextSelectionChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for TextChangedEvent {
+impl BusProperties for TextChangedEvent {
 	const DBUS_MEMBER: &'static str = "TextChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -916,7 +916,7 @@ impl GenericEvent<'_> for TextChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for TextAttributesChangedEvent {
+impl BusProperties for TextAttributesChangedEvent {
 	const DBUS_MEMBER: &'static str = "TextAttributesChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
@@ -940,7 +940,7 @@ impl GenericEvent<'_> for TextAttributesChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for TextCaretMovedEvent {
+impl BusProperties for TextCaretMovedEvent {
 	const DBUS_MEMBER: &'static str = "TextCaretMoved";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Object";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index 983762ca..800dfe14 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -68,7 +68,7 @@ pub struct CharWidthChangedEvent {
 	pub item: crate::events::ObjectRef,
 }
 
-impl GenericEvent<'_> for LineChangedEvent {
+impl BusProperties for LineChangedEvent {
 	const DBUS_MEMBER: &'static str = "LineChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Terminal";
 	const MATCH_RULE_STRING: &'static str =
@@ -92,7 +92,7 @@ impl GenericEvent<'_> for LineChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ColumnCountChangedEvent {
+impl BusProperties for ColumnCountChangedEvent {
 	const DBUS_MEMBER: &'static str = "ColumncountChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Terminal";
 	const MATCH_RULE_STRING: &'static str =
@@ -116,7 +116,7 @@ impl GenericEvent<'_> for ColumnCountChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for LineCountChangedEvent {
+impl BusProperties for LineCountChangedEvent {
 	const DBUS_MEMBER: &'static str = "LinecountChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Terminal";
 	const MATCH_RULE_STRING: &'static str =
@@ -140,7 +140,7 @@ impl GenericEvent<'_> for LineCountChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for ApplicationChangedEvent {
+impl BusProperties for ApplicationChangedEvent {
 	const DBUS_MEMBER: &'static str = "ApplicationChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Terminal";
 	const MATCH_RULE_STRING: &'static str =
@@ -164,7 +164,7 @@ impl GenericEvent<'_> for ApplicationChangedEvent {
 	}
 }
 
-impl GenericEvent<'_> for CharWidthChangedEvent {
+impl BusProperties for CharWidthChangedEvent {
 	const DBUS_MEMBER: &'static str = "CharwidthChanged";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Terminal";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index ca6853cb..fc802b86 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, GenericEvent, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
@@ -180,7 +180,7 @@ pub struct RestyleEvent {
 	pub item: crate::events::ObjectRef,
 }
 
-impl GenericEvent<'_> for PropertyChangeEvent {
+impl BusProperties for PropertyChangeEvent {
 	const DBUS_MEMBER: &'static str = "PropertyChange";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -204,7 +204,7 @@ impl GenericEvent<'_> for PropertyChangeEvent {
 	}
 }
 
-impl GenericEvent<'_> for MinimizeEvent {
+impl BusProperties for MinimizeEvent {
 	const DBUS_MEMBER: &'static str = "Minimize";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -228,7 +228,7 @@ impl GenericEvent<'_> for MinimizeEvent {
 	}
 }
 
-impl GenericEvent<'_> for MaximizeEvent {
+impl BusProperties for MaximizeEvent {
 	const DBUS_MEMBER: &'static str = "Maximize";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -252,7 +252,7 @@ impl GenericEvent<'_> for MaximizeEvent {
 	}
 }
 
-impl GenericEvent<'_> for RestoreEvent {
+impl BusProperties for RestoreEvent {
 	const DBUS_MEMBER: &'static str = "Restore";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -276,7 +276,7 @@ impl GenericEvent<'_> for RestoreEvent {
 	}
 }
 
-impl GenericEvent<'_> for CloseEvent {
+impl BusProperties for CloseEvent {
 	const DBUS_MEMBER: &'static str = "Close";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -300,7 +300,7 @@ impl GenericEvent<'_> for CloseEvent {
 	}
 }
 
-impl GenericEvent<'_> for CreateEvent {
+impl BusProperties for CreateEvent {
 	const DBUS_MEMBER: &'static str = "Create";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -324,7 +324,7 @@ impl GenericEvent<'_> for CreateEvent {
 	}
 }
 
-impl GenericEvent<'_> for ReparentEvent {
+impl BusProperties for ReparentEvent {
 	const DBUS_MEMBER: &'static str = "Reparent";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -348,7 +348,7 @@ impl GenericEvent<'_> for ReparentEvent {
 	}
 }
 
-impl GenericEvent<'_> for DesktopCreateEvent {
+impl BusProperties for DesktopCreateEvent {
 	const DBUS_MEMBER: &'static str = "DesktopCreate";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -372,7 +372,7 @@ impl GenericEvent<'_> for DesktopCreateEvent {
 	}
 }
 
-impl GenericEvent<'_> for DesktopDestroyEvent {
+impl BusProperties for DesktopDestroyEvent {
 	const DBUS_MEMBER: &'static str = "DesktopDestroy";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -396,7 +396,7 @@ impl GenericEvent<'_> for DesktopDestroyEvent {
 	}
 }
 
-impl GenericEvent<'_> for DestroyEvent {
+impl BusProperties for DestroyEvent {
 	const DBUS_MEMBER: &'static str = "Destroy";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -420,7 +420,7 @@ impl GenericEvent<'_> for DestroyEvent {
 	}
 }
 
-impl GenericEvent<'_> for ActivateEvent {
+impl BusProperties for ActivateEvent {
 	const DBUS_MEMBER: &'static str = "Activate";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -444,7 +444,7 @@ impl GenericEvent<'_> for ActivateEvent {
 	}
 }
 
-impl GenericEvent<'_> for DeactivateEvent {
+impl BusProperties for DeactivateEvent {
 	const DBUS_MEMBER: &'static str = "Deactivate";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -468,7 +468,7 @@ impl GenericEvent<'_> for DeactivateEvent {
 	}
 }
 
-impl GenericEvent<'_> for RaiseEvent {
+impl BusProperties for RaiseEvent {
 	const DBUS_MEMBER: &'static str = "Raise";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -492,7 +492,7 @@ impl GenericEvent<'_> for RaiseEvent {
 	}
 }
 
-impl GenericEvent<'_> for LowerEvent {
+impl BusProperties for LowerEvent {
 	const DBUS_MEMBER: &'static str = "Lower";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -516,7 +516,7 @@ impl GenericEvent<'_> for LowerEvent {
 	}
 }
 
-impl GenericEvent<'_> for MoveEvent {
+impl BusProperties for MoveEvent {
 	const DBUS_MEMBER: &'static str = "Move";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -540,7 +540,7 @@ impl GenericEvent<'_> for MoveEvent {
 	}
 }
 
-impl GenericEvent<'_> for ResizeEvent {
+impl BusProperties for ResizeEvent {
 	const DBUS_MEMBER: &'static str = "Resize";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -564,7 +564,7 @@ impl GenericEvent<'_> for ResizeEvent {
 	}
 }
 
-impl GenericEvent<'_> for ShadeEvent {
+impl BusProperties for ShadeEvent {
 	const DBUS_MEMBER: &'static str = "Shade";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -588,7 +588,7 @@ impl GenericEvent<'_> for ShadeEvent {
 	}
 }
 
-impl GenericEvent<'_> for UUshadeEvent {
+impl BusProperties for UUshadeEvent {
 	const DBUS_MEMBER: &'static str = "uUshade";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
@@ -612,7 +612,7 @@ impl GenericEvent<'_> for UUshadeEvent {
 	}
 }
 
-impl GenericEvent<'_> for RestyleEvent {
+impl BusProperties for RestyleEvent {
 	const DBUS_MEMBER: &'static str = "Restyle";
 	const DBUS_INTERFACE: &'static str = "org.a11y.atspi.Event.Window";
 	const MATCH_RULE_STRING: &'static str =
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index 610d571c..76dcf8ce 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -25,7 +25,7 @@ pub use cache::{CacheItem, LegacyCacheItem};
 pub mod error;
 pub use error::AtspiError;
 pub mod events;
-pub use events::{Event, GenericEvent};
+pub use events::{Event, GenericEvent, BusProperties};
 mod role;
 pub use role::Role;
 mod relation_type;
diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index 9628b793..a65403a5 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -181,8 +181,8 @@ macro_rules! impl_to_dbus_message {
 			fn try_from(event: $type) -> Result<Self, Self::Error> {
 				Ok(zbus::Message::signal(
 					event.path(),
-					<$type as GenericEvent>::DBUS_INTERFACE,
-					<$type as GenericEvent>::DBUS_MEMBER,
+					<$type as BusProperties>::DBUS_INTERFACE,
+					<$type as BusProperties>::DBUS_MEMBER,
 				)?
 				.sender(event.sender().to_string())?
 				.build(&event.body())?)
@@ -226,12 +226,12 @@ macro_rules! impl_from_dbus_message {
 			fn try_from(msg: &zbus::Message) -> Result<Self, Self::Error> {
 				let header = msg.header();
 				if header.interface().ok_or(AtspiError::MissingInterface)?
-					!= <$type as GenericEvent>::DBUS_INTERFACE
+					!= <$type as BusProperties>::DBUS_INTERFACE
 				{
 					return Err(AtspiError::InterfaceMatch(format!(
 						"The interface {} does not match the signal's interface: {}",
 						header.interface().unwrap(),
-						<$type as GenericEvent>::DBUS_INTERFACE
+						<$type as BusProperties>::DBUS_INTERFACE
 					)));
 				}
 				if header.member().ok_or(AtspiError::MissingMember)? != <$type>::DBUS_MEMBER {
@@ -239,12 +239,12 @@ macro_rules! impl_from_dbus_message {
 						"The member {} does not match the signal's member: {}",
 						// unwrap is safe here because of guard above
 						header.member().unwrap(),
-						<$type as GenericEvent>::DBUS_MEMBER
+						<$type as BusProperties>::DBUS_MEMBER
 					)));
 				}
 				<$type>::build(
 					msg.try_into()?,
-					msg.body().deserialize::<<$type as GenericEvent>::Body>()?,
+					msg.body().deserialize::<<$type as BusProperties>::Body>()?,
 				)
 			}
 		}
@@ -255,13 +255,13 @@ macro_rules! impl_from_dbus_message {
 // This prevents Clippy from complaining about the macro not being used.
 // It is being used, but only in test mode.
 //
-/// Tests `Default` and `GenericEvent::build` for a given event struct.
+/// Tests `Default` and `BusProperties::build` for a given event struct.
 ///
 /// Obtains a default for the given event struct.
 /// Asserts that the path and sender are the default.
 ///
 /// Breaks the struct down into item (the associated object) and body.
-/// Then tests `GenericEvent::build` with the item and body.
+/// Then tests `BusProperties::build` with the item and body.
 #[cfg(test)]
 macro_rules! generic_event_test_case {
 	($type:ty) => {
@@ -358,7 +358,7 @@ macro_rules! zbus_message_test_case {
 		fn zbus_msg_conversion_failure_correct_interface() -> () {
 			let fake_msg = zbus::Message::signal(
 				"/org/a11y/sixtynine/fourtwenty",
-				<$type as GenericEvent>::DBUS_INTERFACE,
+				<$type as BusProperties>::DBUS_INTERFACE,
 				"MadeUpMember",
 			)
 			.unwrap()
@@ -376,8 +376,8 @@ macro_rules! zbus_message_test_case {
 		fn zbus_msg_conversion_failure_correct_interface_and_member() -> () {
 			let fake_msg = zbus::Message::signal(
 				"/org/a11y/sixtynine/fourtwenty",
-				<$type as GenericEvent>::DBUS_INTERFACE,
-				<$type as GenericEvent>::DBUS_MEMBER,
+				<$type as BusProperties>::DBUS_INTERFACE,
+				<$type as BusProperties>::DBUS_MEMBER,
 			)
 			.unwrap()
 			.sender(":0.0")
@@ -413,7 +413,7 @@ macro_rules! zbus_message_test_case {
 			let fake_msg = zbus::Message::signal(
 				"/org/a11y/sixtynine/fourtwenty",
 				"org.a11y.atspi.accessible.technically.valid",
-				<$type as GenericEvent>::DBUS_MEMBER,
+				<$type as BusProperties>::DBUS_MEMBER,
 			)
 			.unwrap()
 			.sender(":0.0")
@@ -449,7 +449,7 @@ macro_rules! event_wrapper_test_cases {
 		#[cfg(test)]
 		#[rename_item::rename(name($type), prefix = "events_tests_", case = "snake")]
 		mod foo {
-			use super::{$any_subtype, $type, Event, GenericEvent};
+			use super::{$any_subtype, $type, Event, BusProperties};
 			#[test]
 			fn into_and_try_from_event() {
 				// Create a default event struct from its type's `Default::default()` impl.
@@ -473,7 +473,7 @@ macro_rules! event_wrapper_test_cases {
 				let fake_msg = zbus::Message::signal(
 					"/org/a11y/sixtynine/fourtwenty",
 					"org.a11y.atspi.technically.valid.lol",
-					<$any_subtype as GenericEvent>::DBUS_MEMBER,
+					<$any_subtype as BusProperties>::DBUS_MEMBER,
 				)
 				.unwrap()
 				.sender(":0.0")
@@ -498,7 +498,7 @@ macro_rules! event_wrapper_test_cases {
 			fn zbus_msg_invalid_member() {
 				let fake_msg = zbus::Message::signal(
 					"/org/a11y/sixtynine/fourtwenty",
-					<$any_subtype as GenericEvent>::DBUS_INTERFACE,
+					<$any_subtype as BusProperties>::DBUS_INTERFACE,
 					"FakeFunctionLol",
 				)
 				.unwrap()
@@ -535,8 +535,8 @@ macro_rules! event_wrapper_test_cases {
 			fn zbus_msg_conversion() {
 				let valid_msg = zbus::Message::signal(
 					"/org/a11y/sixtynine/fourtwenty",
-					<$any_subtype as GenericEvent>::DBUS_INTERFACE,
-					<$any_subtype as GenericEvent>::DBUS_MEMBER,
+					<$any_subtype as BusProperties>::DBUS_INTERFACE,
+					<$any_subtype as BusProperties>::DBUS_MEMBER,
 				)
 				.unwrap()
 				.sender(":0.0")
@@ -556,7 +556,7 @@ macro_rules! event_test_cases {
 		#[cfg(test)]
 		#[rename_item::rename(name($type), prefix = "event_tests_", case = "snake")]
 		mod foo {
-			use super::{$type, Event, GenericEvent};
+			use super::{$type, Event, BusProperties};
 
 			generic_event_test_case!($type);
 			event_enum_test_case!($type);

From 97a9706052ae29b93fd0c4362d8b5dc43fcb46c0 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 23:21:18 -0600
Subject: [PATCH 22/37] Update atspi-connection to include changes to trait
 names

---
 atspi-connection/src/lib.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/atspi-connection/src/lib.rs b/atspi-connection/src/lib.rs
index df9a21c1..03c4a603 100644
--- a/atspi-connection/src/lib.rs
+++ b/atspi-connection/src/lib.rs
@@ -14,7 +14,7 @@ use atspi_proxies::{
 	registry::RegistryProxy,
 };
 use common::error::AtspiError;
-use common::events::{Event, GenericEvent, HasMatchRule, HasRegistryEventString};
+use common::events::{Event, BusProperties, HasMatchRule, HasRegistryEventString};
 use futures_lite::stream::{Stream, StreamExt};
 use std::ops::Deref;
 use zbus::{fdo::DBusProxy, Address, MatchRule, MessageStream, MessageType};
@@ -283,7 +283,7 @@ impl AccessibilityConnection {
 	}
 
 	/// Send an event over the accessibility bus.
-	/// This converts the event into a [`zbus::Message`] using the [`GenericEvent`] trait.
+	/// This converts the event into a [`zbus::Message`] using the [`BusProperties`] trait.
 	///
 	/// # Errors
 	///
@@ -294,13 +294,13 @@ impl AccessibilityConnection {
 	/// Both of these conditions should never happen as long as you have a valid event.
 	pub async fn send_event<T>(&self, event: T) -> Result<(), AtspiError>
 	where
-		T: for<'a> GenericEvent<'a>,
+		T: BusProperties,
 	{
 		let conn = self.connection();
 		let new_message = zbus::Message::signal(
 			event.path(),
-			<T as GenericEvent>::DBUS_INTERFACE,
-			<T as GenericEvent>::DBUS_MEMBER,
+			<T as BusProperties>::DBUS_INTERFACE,
+			<T as BusProperties>::DBUS_MEMBER,
 		)?
 		.sender(conn.unique_name().ok_or(AtspiError::MissingName)?)?
 		// this re-encodes the entire body; it's not great..., but you can't replace a sender once a message a created.

From d686c3af72972f1a35fdc9fff682013282811050 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Wed, 17 Apr 2024 23:26:23 -0600
Subject: [PATCH 23/37] Update docs

Cargo format

Clippy
---
 atspi-common/src/events/document.rs |  2 +-
 atspi-common/src/events/focus.rs    |  2 +-
 atspi-common/src/events/keyboard.rs |  2 +-
 atspi-common/src/events/mod.rs      | 29 +++++++++++++++++------------
 atspi-common/src/events/mouse.rs    |  2 +-
 atspi-common/src/events/object.rs   |  2 +-
 atspi-common/src/events/terminal.rs |  2 +-
 atspi-common/src/events/window.rs   |  2 +-
 atspi-common/src/lib.rs             |  2 +-
 atspi-connection/src/lib.rs         |  2 +-
 10 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index 6d9ebfb8..2d112907 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 28d2592e..d454bd58 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index ea86957a..5aea5f7f 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index cfa8c080..7c0444fb 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -349,10 +349,10 @@ impl BusProperties for AddAccessibleEvent {
 		self.node_added.clone()
 	}
 }
-impl<'a, T: BusProperties> HasMatchRule for T {
+impl<T: BusProperties> HasMatchRule for T {
 	const MATCH_RULE_STRING: &'static str = <T as BusProperties>::MATCH_RULE_STRING;
 }
-impl<'a, T: BusProperties> HasRegistryEventString for T {
+impl<T: BusProperties> HasRegistryEventString for T {
 	const REGISTRY_EVENT_STRING: &'static str = <T as BusProperties>::REGISTRY_EVENT_STRING;
 }
 impl_from_dbus_message!(AddAccessibleEvent);
@@ -728,10 +728,10 @@ impl TryFrom<&zbus::Message> for Event {
 
 /// Describes the DBus-related information about a given struct.
 ///
-/// - DBus member name
-/// - DBus interface name
-/// - DBus path
-/// - DBus bus name
+/// - `DBus` member name
+/// - `DBus` interface name
+/// - `DBus` path
+/// - `DBus` bus name
 ///
 /// Together, the member and interface name can describe a specific event _type_.
 /// Likewise, the path and bus collectively create a unique ID for an _object on the accessibility bus_, this can also be referred to as an [`ObjectRef`].
@@ -746,7 +746,7 @@ pub trait GenericEvent {
 	fn name2<'a>(&self) -> BusName<'a>;
 }
 
-impl<'a, T: BusProperties> GenericEvent for T {
+impl<T: BusProperties> GenericEvent for T {
 	fn member(&self) -> &'static str {
 		<T as BusProperties>::DBUS_MEMBER
 	}
@@ -763,16 +763,21 @@ impl<'a, T: BusProperties> GenericEvent for T {
 
 impl<T: GenericEvent> From<&T> for ObjectRef {
 	fn from(ev: &T) -> ObjectRef {
-		ObjectRef {
-			path: ev.path2().to_owned().into(),
-			name: ev.name2().to_owned().into(),
-		}
+		ObjectRef { path: ev.path2().to_owned().into(), name: ev.name2().to_owned().into() }
 	}
 }
 
 assert_obj_safe!(GenericEvent);
 
-/// Shared behavior of bus `Signal` events.
+/// Describes the `DBus`-related information about a given struct.
+///
+/// - `DBus` member name
+/// - `DBus` interface name
+/// - `DBus` match string: used to tell `DBus` you are interested in a particular signal
+/// - accessibility registry event string: used to tell the accessibility registry that you are interested in a particular event
+///
+/// This trait *is not* object-safe.
+/// For a similar, but object-safe trait, see [`GenericEvent`].
 pub trait BusProperties {
 	/// The `DBus` member for the event.
 	/// For example, for an [`object::TextChangedEvent`] this should be `"TextChanged"`
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index 51cc8a58..f8aafefe 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 70132c9c..c85b3c3b 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -2,7 +2,7 @@
 use crate::Live;
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event, State,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index 800dfe14..4d641bd8 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index fc802b86..2b8d8fb8 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -1,6 +1,6 @@
 use crate::{
 	error::AtspiError,
-	events::{EventBodyOwned, BusProperties, HasMatchRule, HasRegistryEventString, ObjectRef},
+	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
 	Event,
 };
 use zbus_names::BusName;
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index 76dcf8ce..ee0f8afc 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -25,7 +25,7 @@ pub use cache::{CacheItem, LegacyCacheItem};
 pub mod error;
 pub use error::AtspiError;
 pub mod events;
-pub use events::{Event, GenericEvent, BusProperties};
+pub use events::{BusProperties, Event, GenericEvent};
 mod role;
 pub use role::Role;
 mod relation_type;
diff --git a/atspi-connection/src/lib.rs b/atspi-connection/src/lib.rs
index 03c4a603..1e45883c 100644
--- a/atspi-connection/src/lib.rs
+++ b/atspi-connection/src/lib.rs
@@ -14,7 +14,7 @@ use atspi_proxies::{
 	registry::RegistryProxy,
 };
 use common::error::AtspiError;
-use common::events::{Event, BusProperties, HasMatchRule, HasRegistryEventString};
+use common::events::{BusProperties, Event, HasMatchRule, HasRegistryEventString};
 use futures_lite::stream::{Stream, StreamExt};
 use std::ops::Deref;
 use zbus::{fdo::DBusProxy, Address, MatchRule, MessageStream, MessageType};

From e8fc22ba5a744a47b763679a470ea6f99d892914 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 12:48:46 -0600
Subject: [PATCH 24/37] Split GenericEvent into 3 traits

1. BusProperties. This contains static information about the DBus properties of a particular event type. This is implemented for indivudal event types only and is NOT object safe; it is similar to GenericEvent, but without path() and sender() functions.
	- DBUS_MEMBER
	- DBUS_INTERFACE
	- MATCH_RULE_STRING
	- REGISTRY_EVENT_STRING
	- type Body
	- build() function
2. EventTypeProperties. This is an object-safe trait that specifies similar data as BusProperties, but as runtime functions instead of constants. This will be implemented on individual event types, and wrapper types like `Event`.
	- member() -> &'static str
	- interface() -> &'static str
	- match_rule() -> &'static str
	- registry_string() -> &'static str
	- EventProperties is blanket implemented for any type that implenents BusPropeties.
3. EventProperties. This is an object-safe trait specifying qualities of a particular event, not its type.
	- name() -> BusName<'_>
	- path() -> ObjectPath<'_>
	- object_ref() -> ObjectRef (auto-impl)

This fixes #176, addresses, at least in part #148.
---
 atspi-common/src/events/document.rs |  44 ++------
 atspi-common/src/events/focus.rs    |   9 +-
 atspi-common/src/events/keyboard.rs |   9 +-
 atspi-common/src/events/mod.rs      | 101 +++++++-----------
 atspi-common/src/events/mouse.rs    |  23 +---
 atspi-common/src/events/object.rs   | 156 ++++------------------------
 atspi-common/src/events/terminal.rs |  37 ++-----
 atspi-common/src/events/window.rs   | 135 ++++--------------------
 atspi-common/src/lib.rs             |   2 +-
 atspi-common/src/macros.rs          |  15 ++-
 atspi-connection/src/lib.rs         |   4 +-
 11 files changed, 117 insertions(+), 418 deletions(-)

diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index 2d112907..b69fecf0 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -85,12 +85,6 @@ impl BusProperties for LoadCompleteEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -109,12 +103,6 @@ impl BusProperties for ReloadEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -133,12 +121,6 @@ impl BusProperties for LoadStoppedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -157,12 +139,6 @@ impl BusProperties for ContentChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -181,12 +157,6 @@ impl BusProperties for AttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -205,12 +175,6 @@ impl BusProperties for PageChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -252,6 +216,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(LoadCompleteEvent);
 impl_to_dbus_message!(LoadCompleteEvent);
 impl_from_dbus_message!(LoadCompleteEvent);
+impl_event_properties!(LoadCompleteEvent);
 impl From<LoadCompleteEvent> for EventBodyOwned {
 	fn from(_event: LoadCompleteEvent) -> Self {
 		EventBodyOwned {
@@ -275,6 +240,7 @@ impl_try_from_event_for_user_facing_type!(ReloadEvent, DocumentEvents::Reload, E
 event_test_cases!(ReloadEvent);
 impl_to_dbus_message!(ReloadEvent);
 impl_from_dbus_message!(ReloadEvent);
+impl_event_properties!(ReloadEvent);
 impl From<ReloadEvent> for EventBodyOwned {
 	fn from(_event: ReloadEvent) -> Self {
 		EventBodyOwned {
@@ -302,6 +268,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(LoadStoppedEvent);
 impl_to_dbus_message!(LoadStoppedEvent);
 impl_from_dbus_message!(LoadStoppedEvent);
+impl_event_properties!(LoadStoppedEvent);
 impl From<LoadStoppedEvent> for EventBodyOwned {
 	fn from(_event: LoadStoppedEvent) -> Self {
 		EventBodyOwned {
@@ -329,6 +296,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ContentChangedEvent);
 impl_to_dbus_message!(ContentChangedEvent);
 impl_from_dbus_message!(ContentChangedEvent);
+impl_event_properties!(ContentChangedEvent);
 impl From<ContentChangedEvent> for EventBodyOwned {
 	fn from(_event: ContentChangedEvent) -> Self {
 		EventBodyOwned {
@@ -356,6 +324,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(AttributesChangedEvent);
 impl_to_dbus_message!(AttributesChangedEvent);
 impl_from_dbus_message!(AttributesChangedEvent);
+impl_event_properties!(AttributesChangedEvent);
 impl From<AttributesChangedEvent> for EventBodyOwned {
 	fn from(_event: AttributesChangedEvent) -> Self {
 		EventBodyOwned {
@@ -383,6 +352,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(PageChangedEvent);
 impl_to_dbus_message!(PageChangedEvent);
 impl_from_dbus_message!(PageChangedEvent);
+impl_event_properties!(PageChangedEvent);
 impl From<PageChangedEvent> for EventBodyOwned {
 	fn from(_event: PageChangedEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index d454bd58..8d850e45 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -39,12 +39,6 @@ impl BusProperties for FocusEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -73,6 +67,7 @@ impl_try_from_event_for_user_facing_type!(FocusEvent, FocusEvents::Focus, Event:
 event_test_cases!(FocusEvent);
 impl_to_dbus_message!(FocusEvent);
 impl_from_dbus_message!(FocusEvent);
+impl_event_properties!(FocusEvent);
 impl From<FocusEvent> for EventBodyOwned {
 	fn from(_event: FocusEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 5aea5f7f..3dab03b2 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -42,12 +42,6 @@ impl BusProperties for ModifiersEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, previous_modifiers: body.detail1, current_modifiers: body.detail2 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -84,6 +78,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ModifiersEvent);
 impl_to_dbus_message!(ModifiersEvent);
 impl_from_dbus_message!(ModifiersEvent);
+impl_event_properties!(ModifiersEvent);
 impl From<ModifiersEvent> for EventBodyOwned {
 	fn from(event: ModifiersEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 7c0444fb..83ece49c 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -281,6 +281,7 @@ impl_try_from_event_for_user_facing_type!(
 );
 event_test_cases!(LegacyAddAccessibleEvent);
 impl_from_dbus_message!(LegacyAddAccessibleEvent);
+impl_event_properties!(LegacyAddAccessibleEvent);
 impl_to_dbus_message!(LegacyAddAccessibleEvent);
 
 impl BusProperties for LegacyAddAccessibleEvent {
@@ -296,12 +297,6 @@ impl BusProperties for LegacyAddAccessibleEvent {
 		Ok(Self { item, node_added: body })
 	}
 
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.node_added.clone()
 	}
@@ -339,12 +334,6 @@ impl BusProperties for AddAccessibleEvent {
 		Ok(Self { item, node_added: body })
 	}
 
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.node_added.clone()
 	}
@@ -356,6 +345,7 @@ impl<T: BusProperties> HasRegistryEventString for T {
 	const REGISTRY_EVENT_STRING: &'static str = <T as BusProperties>::REGISTRY_EVENT_STRING;
 }
 impl_from_dbus_message!(AddAccessibleEvent);
+impl_event_properties!(AddAccessibleEvent);
 impl_to_dbus_message!(AddAccessibleEvent);
 
 /// `Cache::RemoveAccessible` signal event type.
@@ -388,18 +378,13 @@ impl BusProperties for RemoveAccessibleEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, node_removed: body })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.node_removed.clone()
 	}
 }
 
 impl_from_dbus_message!(RemoveAccessibleEvent);
+impl_event_properties!(RemoveAccessibleEvent);
 impl_to_dbus_message!(RemoveAccessibleEvent);
 
 #[cfg(test)]
@@ -548,17 +533,12 @@ impl BusProperties for EventListenerDeregisteredEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, deregistered_event: body })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.deregistered_event.clone()
 	}
 }
 impl_from_dbus_message!(EventListenerDeregisteredEvent);
+impl_event_properties!(EventListenerDeregisteredEvent);
 impl_to_dbus_message!(EventListenerDeregisteredEvent);
 
 /// An event that is emitted by the regostry daemon to signal that an event has been registered to listen for.
@@ -595,17 +575,12 @@ impl BusProperties for EventListenerRegisteredEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, registered_event: body })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.registered_event.clone()
 	}
 }
 impl_from_dbus_message!(EventListenerRegisteredEvent);
+impl_event_properties!(EventListenerRegisteredEvent);
 impl_to_dbus_message!(EventListenerRegisteredEvent);
 
 /// An event that is emitted when the registry daemon has started.
@@ -643,17 +618,12 @@ impl BusProperties for AvailableEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, socket: body })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		self.socket.clone()
 	}
 }
 impl_from_dbus_message!(AvailableEvent);
+impl_event_properties!(AvailableEvent);
 impl_to_dbus_message!(AvailableEvent);
 
 #[cfg(feature = "zbus")]
@@ -726,48 +696,59 @@ impl TryFrom<&zbus::Message> for Event {
 	}
 }
 
-/// Describes the DBus-related information about a given struct.
+/// Describes properties of a specific event _type_.
 ///
 /// - `DBus` member name
 /// - `DBus` interface name
-/// - `DBus` path
-/// - `DBus` bus name
 ///
 /// Together, the member and interface name can describe a specific event _type_.
-/// Likewise, the path and bus collectively create a unique ID for an _object on the accessibility bus_, this can also be referred to as an [`ObjectRef`].
+/// Likewise, the path and sender bus name collectively make up an [`ObjectRef`], which is a way to uniquely identify an individual accessible item available to `atspi`.
+/// The latter is available via the [`EventProperties`] trait.
 ///
 /// This can also be generalized, for example this is implemented for [`Event`] by dispatching to the matching variants.
+/// NOTE: to use `EventProperties` on wrapper types, like `Event`, you must enable the "enum-dispatch" feature.
 ///
 /// This trait *is* object-safe.
-pub trait GenericEvent {
+pub trait EventTypeProperties {
 	fn member(&self) -> &'static str;
 	fn interface(&self) -> &'static str;
-	fn path2<'a>(&self) -> ObjectPath<'a>;
-	fn name2<'a>(&self) -> BusName<'a>;
+	fn match_rule(&self) -> &'static str;
+	fn registry_string(&self) -> &'static str;
 }
 
-impl<T: BusProperties> GenericEvent for T {
+impl<T: BusProperties> EventTypeProperties for T {
 	fn member(&self) -> &'static str {
-		<T as BusProperties>::DBUS_MEMBER
+		<T>::DBUS_MEMBER
 	}
 	fn interface(&self) -> &'static str {
-		<T as BusProperties>::DBUS_INTERFACE
+		<T>::DBUS_INTERFACE
 	}
-	fn path2<'b>(&self) -> ObjectPath<'b> {
-		todo!()
+	fn match_rule(&self) -> &'static str {
+		<T>::MATCH_RULE_STRING
 	}
-	fn name2<'b>(&self) -> BusName<'b> {
-		todo!()
+	fn registry_string(&self) -> &'static str {
+		<T>::REGISTRY_EVENT_STRING
 	}
 }
 
-impl<T: GenericEvent> From<&T> for ObjectRef {
-	fn from(ev: &T) -> ObjectRef {
-		ObjectRef { path: ev.path2().to_owned().into(), name: ev.name2().to_owned().into() }
+assert_obj_safe!(EventTypeProperties);
+
+/// `EventProperties` allows access to the internals of an event, specifically:
+///
+/// - The `DBUs` name which sent the event.
+/// - The `ObjectPath`, a unique id for a given application.
+/// - Collectively, this is called an [`ObjectRef`].
+///
+/// This trait *is* object-safe.
+pub trait EventProperties {
+	fn sender(&self) -> BusName<'_>;
+	fn path(&self) -> ObjectPath<'_>;
+	fn object_ref(&self) -> ObjectRef {
+		ObjectRef { name: self.sender().into(), path: self.path().into() }
 	}
 }
 
-assert_obj_safe!(GenericEvent);
+assert_obj_safe!(EventProperties);
 
 /// Describes the `DBus`-related information about a given struct.
 ///
@@ -777,7 +758,7 @@ assert_obj_safe!(GenericEvent);
 /// - accessibility registry event string: used to tell the accessibility registry that you are interested in a particular event
 ///
 /// This trait *is not* object-safe.
-/// For a similar, but object-safe trait, see [`GenericEvent`].
+/// For a similar, but object-safe trait, see [`EventProperties`].
 pub trait BusProperties {
 	/// The `DBus` member for the event.
 	/// For example, for an [`object::TextChangedEvent`] this should be `"TextChanged"`
@@ -806,16 +787,6 @@ pub trait BusProperties {
 	where
 		Self: Sized;
 
-	/// Path of the signalling object.
-	fn path(&self) -> ObjectPath<'_>;
-
-	/// Sender of the signal.
-	///
-	/// ### Errors
-	/// - when deserializing the header failed, or
-	/// - When `zbus::get_field!` finds that 'sender' is an invalid field.
-	fn sender(&self) -> BusName<'_>;
-
 	/// The body of the object.
 	fn body(&self) -> Self::Body;
 }
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index f8aafefe..741b1689 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -62,12 +62,6 @@ impl BusProperties for AbsEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -86,12 +80,6 @@ impl BusProperties for RelEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -110,12 +98,6 @@ impl BusProperties for ButtonEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, detail: body.kind, mouse_x: body.detail1, mouse_y: body.detail2 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -146,6 +128,7 @@ impl_try_from_event_for_user_facing_type!(AbsEvent, MouseEvents::Abs, Event::Mou
 event_test_cases!(AbsEvent);
 impl_to_dbus_message!(AbsEvent);
 impl_from_dbus_message!(AbsEvent);
+impl_event_properties!(AbsEvent);
 impl From<AbsEvent> for EventBodyOwned {
 	fn from(event: AbsEvent) -> Self {
 		EventBodyOwned {
@@ -164,6 +147,7 @@ impl_try_from_event_for_user_facing_type!(RelEvent, MouseEvents::Rel, Event::Mou
 event_test_cases!(RelEvent);
 impl_to_dbus_message!(RelEvent);
 impl_from_dbus_message!(RelEvent);
+impl_event_properties!(RelEvent);
 impl From<RelEvent> for EventBodyOwned {
 	fn from(event: RelEvent) -> Self {
 		EventBodyOwned {
@@ -186,6 +170,7 @@ impl_try_from_event_for_user_facing_type!(ButtonEvent, MouseEvents::Button, Even
 event_test_cases!(ButtonEvent);
 impl_to_dbus_message!(ButtonEvent);
 impl_from_dbus_message!(ButtonEvent);
+impl_event_properties!(ButtonEvent);
 impl From<ButtonEvent> for EventBodyOwned {
 	fn from(event: ButtonEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index c85b3c3b..0bed0ec0 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -3,7 +3,7 @@ use crate::Live;
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, State,
+	Event, EventProperties, State,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue, Value};
@@ -430,12 +430,6 @@ impl BusProperties for PropertyChangeEvent {
 		let value: Property = body.try_into()?;
 		Ok(Self { item, property, value })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -454,12 +448,6 @@ impl BusProperties for BoundsChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -478,12 +466,6 @@ impl BusProperties for LinkSelectedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -503,12 +485,6 @@ impl BusProperties for StateChangedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, state: body.kind.into(), enabled: body.detail1 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -532,12 +508,6 @@ impl BusProperties for ChildrenChangedEvent {
 			child: body.any_data.try_into()?,
 		})
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -556,12 +526,6 @@ impl BusProperties for VisibleDataChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -580,12 +544,6 @@ impl BusProperties for SelectionChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -604,12 +562,6 @@ impl BusProperties for ModelChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -628,12 +580,6 @@ impl BusProperties for ActiveDescendantChangedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, child: body.any_data.try_into()? })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -658,12 +604,6 @@ impl BusProperties for AnnouncementEvent {
 				.ok_or(AtspiError::Conversion("\"detail1\" not convertable to \"Live\""))?,
 		})
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -682,12 +622,6 @@ impl BusProperties for AttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -706,12 +640,6 @@ impl BusProperties for RowInsertedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -730,12 +658,6 @@ impl BusProperties for RowReorderedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -754,12 +676,6 @@ impl BusProperties for RowDeletedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -778,12 +694,6 @@ impl BusProperties for ColumnInsertedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -802,12 +712,6 @@ impl BusProperties for ColumnReorderedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -826,12 +730,6 @@ impl BusProperties for ColumnDeletedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -850,12 +748,6 @@ impl BusProperties for TextBoundsChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -874,12 +766,6 @@ impl BusProperties for TextSelectionChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -904,12 +790,6 @@ impl BusProperties for TextChangedEvent {
 			text: body.any_data.try_into()?,
 		})
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -928,12 +808,6 @@ impl BusProperties for TextAttributesChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -952,12 +826,6 @@ impl BusProperties for TextCaretMovedEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, position: body.detail1 })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -1015,6 +883,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(PropertyChangeEvent);
 impl_to_dbus_message!(PropertyChangeEvent);
 impl_from_dbus_message!(PropertyChangeEvent);
+impl_event_properties!(PropertyChangeEvent);
 
 impl From<PropertyChangeEvent> for EventBodyOwned {
 	fn from(event: PropertyChangeEvent) -> Self {
@@ -1042,6 +911,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(BoundsChangedEvent);
 impl_to_dbus_message!(BoundsChangedEvent);
 impl_from_dbus_message!(BoundsChangedEvent);
+impl_event_properties!(BoundsChangedEvent);
 impl From<BoundsChangedEvent> for EventBodyOwned {
 	fn from(_event: BoundsChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1068,6 +938,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(LinkSelectedEvent);
 impl_to_dbus_message!(LinkSelectedEvent);
 impl_from_dbus_message!(LinkSelectedEvent);
+impl_event_properties!(LinkSelectedEvent);
 impl From<LinkSelectedEvent> for EventBodyOwned {
 	fn from(_event: LinkSelectedEvent) -> Self {
 		EventBodyOwned {
@@ -1094,6 +965,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(StateChangedEvent);
 impl_to_dbus_message!(StateChangedEvent);
 impl_from_dbus_message!(StateChangedEvent);
+impl_event_properties!(StateChangedEvent);
 #[cfg(feature = "strum")]
 impl From<StateChangedEvent> for EventBodyOwned {
 	fn from(event: StateChangedEvent) -> Self {
@@ -1121,6 +993,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ChildrenChangedEvent);
 impl_to_dbus_message!(ChildrenChangedEvent);
 impl_from_dbus_message!(ChildrenChangedEvent);
+impl_event_properties!(ChildrenChangedEvent);
 impl From<ChildrenChangedEvent> for EventBodyOwned {
 	fn from(event: ChildrenChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1152,6 +1025,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(VisibleDataChangedEvent);
 impl_to_dbus_message!(VisibleDataChangedEvent);
 impl_from_dbus_message!(VisibleDataChangedEvent);
+impl_event_properties!(VisibleDataChangedEvent);
 impl From<VisibleDataChangedEvent> for EventBodyOwned {
 	fn from(_event: VisibleDataChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1178,6 +1052,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(SelectionChangedEvent);
 impl_to_dbus_message!(SelectionChangedEvent);
 impl_from_dbus_message!(SelectionChangedEvent);
+impl_event_properties!(SelectionChangedEvent);
 impl From<SelectionChangedEvent> for EventBodyOwned {
 	fn from(_event: SelectionChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1204,6 +1079,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ModelChangedEvent);
 impl_to_dbus_message!(ModelChangedEvent);
 impl_from_dbus_message!(ModelChangedEvent);
+impl_event_properties!(ModelChangedEvent);
 impl From<ModelChangedEvent> for EventBodyOwned {
 	fn from(_event: ModelChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1230,6 +1106,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ActiveDescendantChangedEvent);
 impl_to_dbus_message!(ActiveDescendantChangedEvent);
 impl_from_dbus_message!(ActiveDescendantChangedEvent);
+impl_event_properties!(ActiveDescendantChangedEvent);
 impl From<ActiveDescendantChangedEvent> for EventBodyOwned {
 	fn from(event: ActiveDescendantChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1261,6 +1138,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(AnnouncementEvent);
 impl_to_dbus_message!(AnnouncementEvent);
 impl_from_dbus_message!(AnnouncementEvent);
+impl_event_properties!(AnnouncementEvent);
 impl From<AnnouncementEvent> for EventBodyOwned {
 	fn from(event: AnnouncementEvent) -> Self {
 		EventBodyOwned {
@@ -1289,6 +1167,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(AttributesChangedEvent);
 impl_to_dbus_message!(AttributesChangedEvent);
 impl_from_dbus_message!(AttributesChangedEvent);
+impl_event_properties!(AttributesChangedEvent);
 impl From<AttributesChangedEvent> for EventBodyOwned {
 	fn from(_event: AttributesChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1315,6 +1194,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(RowInsertedEvent);
 impl_to_dbus_message!(RowInsertedEvent);
 impl_from_dbus_message!(RowInsertedEvent);
+impl_event_properties!(RowInsertedEvent);
 impl From<RowInsertedEvent> for EventBodyOwned {
 	fn from(_event: RowInsertedEvent) -> Self {
 		EventBodyOwned {
@@ -1341,6 +1221,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(RowReorderedEvent);
 impl_to_dbus_message!(RowReorderedEvent);
 impl_from_dbus_message!(RowReorderedEvent);
+impl_event_properties!(RowReorderedEvent);
 impl From<RowReorderedEvent> for EventBodyOwned {
 	fn from(_event: RowReorderedEvent) -> Self {
 		EventBodyOwned {
@@ -1363,6 +1244,7 @@ impl_try_from_event_for_user_facing_type!(RowDeletedEvent, ObjectEvents::RowDele
 event_test_cases!(RowDeletedEvent);
 impl_to_dbus_message!(RowDeletedEvent);
 impl_from_dbus_message!(RowDeletedEvent);
+impl_event_properties!(RowDeletedEvent);
 impl From<RowDeletedEvent> for EventBodyOwned {
 	fn from(_event: RowDeletedEvent) -> Self {
 		EventBodyOwned {
@@ -1389,6 +1271,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ColumnInsertedEvent);
 impl_to_dbus_message!(ColumnInsertedEvent);
 impl_from_dbus_message!(ColumnInsertedEvent);
+impl_event_properties!(ColumnInsertedEvent);
 impl From<ColumnInsertedEvent> for EventBodyOwned {
 	fn from(_event: ColumnInsertedEvent) -> Self {
 		EventBodyOwned {
@@ -1415,6 +1298,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ColumnReorderedEvent);
 impl_to_dbus_message!(ColumnReorderedEvent);
 impl_from_dbus_message!(ColumnReorderedEvent);
+impl_event_properties!(ColumnReorderedEvent);
 impl From<ColumnReorderedEvent> for EventBodyOwned {
 	fn from(_event: ColumnReorderedEvent) -> Self {
 		EventBodyOwned {
@@ -1441,6 +1325,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ColumnDeletedEvent);
 impl_to_dbus_message!(ColumnDeletedEvent);
 impl_from_dbus_message!(ColumnDeletedEvent);
+impl_event_properties!(ColumnDeletedEvent);
 impl From<ColumnDeletedEvent> for EventBodyOwned {
 	fn from(_event: ColumnDeletedEvent) -> Self {
 		EventBodyOwned {
@@ -1467,6 +1352,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(TextBoundsChangedEvent);
 impl_to_dbus_message!(TextBoundsChangedEvent);
 impl_from_dbus_message!(TextBoundsChangedEvent);
+impl_event_properties!(TextBoundsChangedEvent);
 impl From<TextBoundsChangedEvent> for EventBodyOwned {
 	fn from(_event: TextBoundsChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1493,6 +1379,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(TextSelectionChangedEvent);
 impl_to_dbus_message!(TextSelectionChangedEvent);
 impl_from_dbus_message!(TextSelectionChangedEvent);
+impl_event_properties!(TextSelectionChangedEvent);
 impl From<TextSelectionChangedEvent> for EventBodyOwned {
 	fn from(_event: TextSelectionChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1519,6 +1406,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(TextChangedEvent);
 impl_to_dbus_message!(TextChangedEvent);
 impl_from_dbus_message!(TextChangedEvent);
+impl_event_properties!(TextChangedEvent);
 impl From<TextChangedEvent> for EventBodyOwned {
 	fn from(event: TextChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1550,6 +1438,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(TextAttributesChangedEvent);
 impl_to_dbus_message!(TextAttributesChangedEvent);
 impl_from_dbus_message!(TextAttributesChangedEvent);
+impl_event_properties!(TextAttributesChangedEvent);
 impl From<TextAttributesChangedEvent> for EventBodyOwned {
 	fn from(_event: TextAttributesChangedEvent) -> Self {
 		EventBodyOwned {
@@ -1576,6 +1465,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(TextCaretMovedEvent);
 impl_to_dbus_message!(TextCaretMovedEvent);
 impl_from_dbus_message!(TextCaretMovedEvent);
+impl_event_properties!(TextCaretMovedEvent);
 impl From<TextCaretMovedEvent> for EventBodyOwned {
 	fn from(event: TextCaretMovedEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index 4d641bd8..23175e04 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -80,12 +80,6 @@ impl BusProperties for LineChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -104,12 +98,6 @@ impl BusProperties for ColumnCountChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -128,12 +116,6 @@ impl BusProperties for LineCountChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -152,12 +134,6 @@ impl BusProperties for ApplicationChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -176,12 +152,6 @@ impl BusProperties for CharWidthChangedEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -221,6 +191,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(LineChangedEvent);
 impl_to_dbus_message!(LineChangedEvent);
 impl_from_dbus_message!(LineChangedEvent);
+impl_event_properties!(LineChangedEvent);
 impl From<LineChangedEvent> for EventBodyOwned {
 	fn from(_event: LineChangedEvent) -> Self {
 		EventBodyOwned {
@@ -247,6 +218,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ColumnCountChangedEvent);
 impl_to_dbus_message!(ColumnCountChangedEvent);
 impl_from_dbus_message!(ColumnCountChangedEvent);
+impl_event_properties!(ColumnCountChangedEvent);
 impl From<ColumnCountChangedEvent> for EventBodyOwned {
 	fn from(_event: ColumnCountChangedEvent) -> Self {
 		EventBodyOwned {
@@ -273,6 +245,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(LineCountChangedEvent);
 impl_to_dbus_message!(LineCountChangedEvent);
 impl_from_dbus_message!(LineCountChangedEvent);
+impl_event_properties!(LineCountChangedEvent);
 impl From<LineCountChangedEvent> for EventBodyOwned {
 	fn from(_event: LineCountChangedEvent) -> Self {
 		EventBodyOwned {
@@ -299,6 +272,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(ApplicationChangedEvent);
 impl_to_dbus_message!(ApplicationChangedEvent);
 impl_from_dbus_message!(ApplicationChangedEvent);
+impl_event_properties!(ApplicationChangedEvent);
 impl From<ApplicationChangedEvent> for EventBodyOwned {
 	fn from(_event: ApplicationChangedEvent) -> Self {
 		EventBodyOwned {
@@ -325,6 +299,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(CharWidthChangedEvent);
 impl_to_dbus_message!(CharWidthChangedEvent);
 impl_from_dbus_message!(CharWidthChangedEvent);
+impl_event_properties!(CharWidthChangedEvent);
 impl From<CharWidthChangedEvent> for EventBodyOwned {
 	fn from(_event: CharWidthChangedEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index 2b8d8fb8..66ce09ea 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event,
+	Event, EventProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -192,12 +192,6 @@ impl BusProperties for PropertyChangeEvent {
 	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, property: body.kind })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -216,12 +210,6 @@ impl BusProperties for MinimizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -240,12 +228,6 @@ impl BusProperties for MaximizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -264,12 +246,6 @@ impl BusProperties for RestoreEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -288,12 +264,6 @@ impl BusProperties for CloseEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -312,12 +282,6 @@ impl BusProperties for CreateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -336,12 +300,6 @@ impl BusProperties for ReparentEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -360,12 +318,6 @@ impl BusProperties for DesktopCreateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -384,12 +336,6 @@ impl BusProperties for DesktopDestroyEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -408,12 +354,6 @@ impl BusProperties for DestroyEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -432,12 +372,6 @@ impl BusProperties for ActivateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -456,12 +390,6 @@ impl BusProperties for DeactivateEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -480,12 +408,6 @@ impl BusProperties for RaiseEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -504,12 +426,6 @@ impl BusProperties for LowerEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -528,12 +444,6 @@ impl BusProperties for MoveEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -552,12 +462,6 @@ impl BusProperties for ResizeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -576,12 +480,6 @@ impl BusProperties for ShadeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -600,12 +498,6 @@ impl BusProperties for UUshadeEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -624,12 +516,6 @@ impl BusProperties for RestyleEvent {
 	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
-	fn sender(&self) -> BusName<'_> {
-		self.item.name.clone().into()
-	}
-	fn path<'a>(&self) -> ObjectPath<'_> {
-		self.item.path.clone().into()
-	}
 	fn body(&self) -> Self::Body {
 		let copy = self.clone();
 		copy.into()
@@ -683,6 +569,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(PropertyChangeEvent);
 impl_to_dbus_message!(PropertyChangeEvent);
 impl_from_dbus_message!(PropertyChangeEvent);
+impl_event_properties!(PropertyChangeEvent);
 impl From<PropertyChangeEvent> for EventBodyOwned {
 	fn from(event: PropertyChangeEvent) -> Self {
 		EventBodyOwned {
@@ -705,6 +592,7 @@ impl_try_from_event_for_user_facing_type!(MinimizeEvent, WindowEvents::Minimize,
 event_test_cases!(MinimizeEvent);
 impl_to_dbus_message!(MinimizeEvent);
 impl_from_dbus_message!(MinimizeEvent);
+impl_event_properties!(MinimizeEvent);
 impl From<MinimizeEvent> for EventBodyOwned {
 	fn from(_event: MinimizeEvent) -> Self {
 		EventBodyOwned {
@@ -727,6 +615,7 @@ impl_try_from_event_for_user_facing_type!(MaximizeEvent, WindowEvents::Maximize,
 event_test_cases!(MaximizeEvent);
 impl_to_dbus_message!(MaximizeEvent);
 impl_from_dbus_message!(MaximizeEvent);
+impl_event_properties!(MaximizeEvent);
 impl From<MaximizeEvent> for EventBodyOwned {
 	fn from(_event: MaximizeEvent) -> Self {
 		EventBodyOwned {
@@ -749,6 +638,7 @@ impl_try_from_event_for_user_facing_type!(RestoreEvent, WindowEvents::Restore, E
 event_test_cases!(RestoreEvent);
 impl_to_dbus_message!(RestoreEvent);
 impl_from_dbus_message!(RestoreEvent);
+impl_event_properties!(RestoreEvent);
 impl From<RestoreEvent> for EventBodyOwned {
 	fn from(_event: RestoreEvent) -> Self {
 		EventBodyOwned {
@@ -771,6 +661,7 @@ impl_try_from_event_for_user_facing_type!(CloseEvent, WindowEvents::Close, Event
 event_test_cases!(CloseEvent);
 impl_to_dbus_message!(CloseEvent);
 impl_from_dbus_message!(CloseEvent);
+impl_event_properties!(CloseEvent);
 impl From<CloseEvent> for EventBodyOwned {
 	fn from(_event: CloseEvent) -> Self {
 		EventBodyOwned {
@@ -793,6 +684,7 @@ impl_try_from_event_for_user_facing_type!(CreateEvent, WindowEvents::Create, Eve
 event_test_cases!(CreateEvent);
 impl_to_dbus_message!(CreateEvent);
 impl_from_dbus_message!(CreateEvent);
+impl_event_properties!(CreateEvent);
 impl From<CreateEvent> for EventBodyOwned {
 	fn from(_event: CreateEvent) -> Self {
 		EventBodyOwned {
@@ -815,6 +707,7 @@ impl_try_from_event_for_user_facing_type!(ReparentEvent, WindowEvents::Reparent,
 event_test_cases!(ReparentEvent);
 impl_to_dbus_message!(ReparentEvent);
 impl_from_dbus_message!(ReparentEvent);
+impl_event_properties!(ReparentEvent);
 impl From<ReparentEvent> for EventBodyOwned {
 	fn from(_event: ReparentEvent) -> Self {
 		EventBodyOwned {
@@ -841,6 +734,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(DesktopCreateEvent);
 impl_to_dbus_message!(DesktopCreateEvent);
 impl_from_dbus_message!(DesktopCreateEvent);
+impl_event_properties!(DesktopCreateEvent);
 impl From<DesktopCreateEvent> for EventBodyOwned {
 	fn from(_event: DesktopCreateEvent) -> Self {
 		EventBodyOwned {
@@ -867,6 +761,7 @@ impl_try_from_event_for_user_facing_type!(
 event_test_cases!(DesktopDestroyEvent);
 impl_to_dbus_message!(DesktopDestroyEvent);
 impl_from_dbus_message!(DesktopDestroyEvent);
+impl_event_properties!(DesktopDestroyEvent);
 impl From<DesktopDestroyEvent> for EventBodyOwned {
 	fn from(_event: DesktopDestroyEvent) -> Self {
 		EventBodyOwned {
@@ -889,6 +784,7 @@ impl_try_from_event_for_user_facing_type!(DestroyEvent, WindowEvents::Destroy, E
 event_test_cases!(DestroyEvent);
 impl_to_dbus_message!(DestroyEvent);
 impl_from_dbus_message!(DestroyEvent);
+impl_event_properties!(DestroyEvent);
 impl From<DestroyEvent> for EventBodyOwned {
 	fn from(_event: DestroyEvent) -> Self {
 		EventBodyOwned {
@@ -911,6 +807,7 @@ impl_try_from_event_for_user_facing_type!(ActivateEvent, WindowEvents::Activate,
 event_test_cases!(ActivateEvent);
 impl_to_dbus_message!(ActivateEvent);
 impl_from_dbus_message!(ActivateEvent);
+impl_event_properties!(ActivateEvent);
 impl From<ActivateEvent> for EventBodyOwned {
 	fn from(_event: ActivateEvent) -> Self {
 		EventBodyOwned {
@@ -933,6 +830,7 @@ impl_try_from_event_for_user_facing_type!(DeactivateEvent, WindowEvents::Deactiv
 event_test_cases!(DeactivateEvent);
 impl_to_dbus_message!(DeactivateEvent);
 impl_from_dbus_message!(DeactivateEvent);
+impl_event_properties!(DeactivateEvent);
 impl From<DeactivateEvent> for EventBodyOwned {
 	fn from(_event: DeactivateEvent) -> Self {
 		EventBodyOwned {
@@ -955,6 +853,7 @@ impl_try_from_event_for_user_facing_type!(RaiseEvent, WindowEvents::Raise, Event
 event_test_cases!(RaiseEvent);
 impl_to_dbus_message!(RaiseEvent);
 impl_from_dbus_message!(RaiseEvent);
+impl_event_properties!(RaiseEvent);
 impl From<RaiseEvent> for EventBodyOwned {
 	fn from(_event: RaiseEvent) -> Self {
 		EventBodyOwned {
@@ -977,6 +876,7 @@ impl_try_from_event_for_user_facing_type!(LowerEvent, WindowEvents::Lower, Event
 event_test_cases!(LowerEvent);
 impl_to_dbus_message!(LowerEvent);
 impl_from_dbus_message!(LowerEvent);
+impl_event_properties!(LowerEvent);
 impl From<LowerEvent> for EventBodyOwned {
 	fn from(_event: LowerEvent) -> Self {
 		EventBodyOwned {
@@ -995,6 +895,7 @@ impl_try_from_event_for_user_facing_type!(MoveEvent, WindowEvents::Move, Event::
 event_test_cases!(MoveEvent);
 impl_to_dbus_message!(MoveEvent);
 impl_from_dbus_message!(MoveEvent);
+impl_event_properties!(MoveEvent);
 impl From<MoveEvent> for EventBodyOwned {
 	fn from(_event: MoveEvent) -> Self {
 		EventBodyOwned {
@@ -1017,6 +918,7 @@ impl_try_from_event_for_user_facing_type!(ResizeEvent, WindowEvents::Resize, Eve
 event_test_cases!(ResizeEvent);
 impl_to_dbus_message!(ResizeEvent);
 impl_from_dbus_message!(ResizeEvent);
+impl_event_properties!(ResizeEvent);
 impl From<ResizeEvent> for EventBodyOwned {
 	fn from(_event: ResizeEvent) -> Self {
 		EventBodyOwned {
@@ -1039,6 +941,7 @@ impl_try_from_event_for_user_facing_type!(ShadeEvent, WindowEvents::Shade, Event
 event_test_cases!(ShadeEvent);
 impl_to_dbus_message!(ShadeEvent);
 impl_from_dbus_message!(ShadeEvent);
+impl_event_properties!(ShadeEvent);
 impl From<ShadeEvent> for EventBodyOwned {
 	fn from(_event: ShadeEvent) -> Self {
 		EventBodyOwned {
@@ -1061,6 +964,7 @@ impl_try_from_event_for_user_facing_type!(UUshadeEvent, WindowEvents::UUshade, E
 event_test_cases!(UUshadeEvent);
 impl_to_dbus_message!(UUshadeEvent);
 impl_from_dbus_message!(UUshadeEvent);
+impl_event_properties!(UUshadeEvent);
 impl From<UUshadeEvent> for EventBodyOwned {
 	fn from(_event: UUshadeEvent) -> Self {
 		EventBodyOwned {
@@ -1083,6 +987,7 @@ impl_try_from_event_for_user_facing_type!(RestyleEvent, WindowEvents::Restyle, E
 event_test_cases!(RestyleEvent);
 impl_to_dbus_message!(RestyleEvent);
 impl_from_dbus_message!(RestyleEvent);
+impl_event_properties!(RestyleEvent);
 impl From<RestyleEvent> for EventBodyOwned {
 	fn from(_event: RestyleEvent) -> Self {
 		EventBodyOwned {
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index ee0f8afc..626d3bb0 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -25,7 +25,7 @@ pub use cache::{CacheItem, LegacyCacheItem};
 pub mod error;
 pub use error::AtspiError;
 pub mod events;
-pub use events::{BusProperties, Event, GenericEvent};
+pub use events::{BusProperties, Event, EventProperties};
 mod role;
 pub use role::Role;
 mod relation_type;
diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index a65403a5..189b9bad 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -1,3 +1,16 @@
+macro_rules! impl_event_properties {
+	($type:ty) => {
+		impl EventProperties for $type {
+			fn sender(&self) -> BusName<'_> {
+				self.item.name.as_ref()
+			}
+			fn path(&self) -> ObjectPath<'_> {
+				self.item.path.as_ref()
+			}
+		}
+	};
+}
+
 /// Expands to a conversion given the enclosed event type and outer `Event` variant.
 ///
 /// eg
@@ -556,7 +569,7 @@ macro_rules! event_test_cases {
 		#[cfg(test)]
 		#[rename_item::rename(name($type), prefix = "event_tests_", case = "snake")]
 		mod foo {
-			use super::{$type, Event, BusProperties};
+			use super::{$type, Event, BusProperties, EventProperties};
 
 			generic_event_test_case!($type);
 			event_enum_test_case!($type);
diff --git a/atspi-connection/src/lib.rs b/atspi-connection/src/lib.rs
index 1e45883c..3c84727b 100644
--- a/atspi-connection/src/lib.rs
+++ b/atspi-connection/src/lib.rs
@@ -14,7 +14,7 @@ use atspi_proxies::{
 	registry::RegistryProxy,
 };
 use common::error::AtspiError;
-use common::events::{BusProperties, Event, HasMatchRule, HasRegistryEventString};
+use common::events::{BusProperties, Event, EventProperties, HasMatchRule, HasRegistryEventString};
 use futures_lite::stream::{Stream, StreamExt};
 use std::ops::Deref;
 use zbus::{fdo::DBusProxy, Address, MatchRule, MessageStream, MessageType};
@@ -294,7 +294,7 @@ impl AccessibilityConnection {
 	/// Both of these conditions should never happen as long as you have a valid event.
 	pub async fn send_event<T>(&self, event: T) -> Result<(), AtspiError>
 	where
-		T: BusProperties,
+		T: BusProperties + EventProperties,
 	{
 		let conn = self.connection();
 		let new_message = zbus::Message::signal(

From 54e95dfa88d38d5f1ba5de10c554536b408ffb85 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 13:55:45 -0600
Subject: [PATCH 25/37] Implement EventTypeProperties and EventProperties for
 wrapper types

---
 atspi-common/src/events/document.rs |  69 +++++++++++-
 atspi-common/src/events/focus.rs    |  14 ++-
 atspi-common/src/events/keyboard.rs |  14 ++-
 atspi-common/src/events/mod.rs      | 150 +++++++++++++++++++++++++
 atspi-common/src/events/mouse.rs    |  50 ++++++++-
 atspi-common/src/events/object.rs   | 164 +++++++++++++++++++++++++++-
 atspi-common/src/events/terminal.rs |  62 ++++++++++-
 atspi-common/src/events/window.rs   | 146 ++++++++++++++++++++++++-
 atspi-common/src/lib.rs             |   2 +-
 9 files changed, 663 insertions(+), 8 deletions(-)

diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index b69fecf0..b27b9e1c 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -21,6 +21,73 @@ pub enum DocumentEvents {
 	/// See: [`PageChangedEvent`].
 	PageChanged(PageChangedEvent),
 }
+
+impl EventTypeProperties for DocumentEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::LoadComplete(inner) => inner.member(),
+			Self::Reload(inner) => inner.member(),
+			Self::LoadStopped(inner) => inner.member(),
+			Self::ContentChanged(inner) => inner.member(),
+			Self::AttributesChanged(inner) => inner.member(),
+			Self::PageChanged(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::LoadComplete(inner) => inner.interface(),
+			Self::Reload(inner) => inner.interface(),
+			Self::LoadStopped(inner) => inner.interface(),
+			Self::ContentChanged(inner) => inner.interface(),
+			Self::AttributesChanged(inner) => inner.interface(),
+			Self::PageChanged(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::LoadComplete(inner) => inner.match_rule(),
+			Self::Reload(inner) => inner.match_rule(),
+			Self::LoadStopped(inner) => inner.match_rule(),
+			Self::ContentChanged(inner) => inner.match_rule(),
+			Self::AttributesChanged(inner) => inner.match_rule(),
+			Self::PageChanged(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::LoadComplete(inner) => inner.registry_string(),
+			Self::Reload(inner) => inner.registry_string(),
+			Self::LoadStopped(inner) => inner.registry_string(),
+			Self::ContentChanged(inner) => inner.registry_string(),
+			Self::AttributesChanged(inner) => inner.registry_string(),
+			Self::PageChanged(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for DocumentEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::LoadComplete(inner) => inner.path(),
+			Self::Reload(inner) => inner.path(),
+			Self::LoadStopped(inner) => inner.path(),
+			Self::ContentChanged(inner) => inner.path(),
+			Self::AttributesChanged(inner) => inner.path(),
+			Self::PageChanged(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::LoadComplete(inner) => inner.sender(),
+			Self::Reload(inner) => inner.sender(),
+			Self::LoadStopped(inner) => inner.sender(),
+			Self::ContentChanged(inner) => inner.sender(),
+			Self::AttributesChanged(inner) => inner.sender(),
+			Self::PageChanged(inner) => inner.sender(),
+		}
+	}
+}
+
 impl_from_interface_event_enum_for_event!(DocumentEvents, Event::Document);
 impl_try_from_event_for_user_facing_event_type!(DocumentEvents, Event::Document);
 event_wrapper_test_cases!(DocumentEvents, LoadCompleteEvent);
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 8d850e45..78441d4b 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -12,6 +12,18 @@ pub enum FocusEvents {
 	Focus(FocusEvent),
 }
 
+impl EventTypeProperties for FocusEvents {
+	fn member(&self) -> &'static str { match self { Self::Focus(inner) => inner.member() } }
+	fn match_rule(&self) -> &'static str { match self { Self::Focus(inner) => inner.match_rule() } }
+	fn interface(&self) -> &'static str { match self { Self::Focus(inner) => inner.interface() } }
+	fn registry_string(&self) -> &'static str { match self { Self::Focus(inner) => inner.registry_string() } }
+}
+
+impl EventProperties for FocusEvents {
+	fn path(&self) -> ObjectPath<'_> { match self { Self::Focus(inner) => inner.path() } }
+	fn sender(&self) -> BusName<'_> { match self { Self::Focus(inner) => inner.sender() } }
+}
+
 impl_from_interface_event_enum_for_event!(FocusEvents, Event::Focus);
 impl_try_from_event_for_user_facing_event_type!(FocusEvents, Event::Focus);
 
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 3dab03b2..3db1e8b1 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue};
@@ -12,6 +12,18 @@ pub enum KeyboardEvents {
 	Modifiers(ModifiersEvent),
 }
 
+impl EventTypeProperties for KeyboardEvents {
+	fn member(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.member() } }
+	fn match_rule(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.match_rule() } }
+	fn interface(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.interface() } }
+	fn registry_string(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.registry_string() } }
+}
+
+impl EventProperties for KeyboardEvents {
+	fn path(&self) -> ObjectPath<'_> { match self { Self::Modifiers(inner) => inner.path() } }
+	fn sender(&self) -> BusName<'_> { match self { Self::Modifiers(inner) => inner.sender() } }
+}
+
 impl_from_interface_event_enum_for_event!(KeyboardEvents, Event::Keyboard);
 impl_try_from_event_for_user_facing_event_type!(KeyboardEvents, Event::Keyboard);
 
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 83ece49c..41f262ad 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -227,6 +227,96 @@ pub enum Event {
 	Listener(EventListenerEvents),
 }
 
+impl EventTypeProperties for Event {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Document(inner) => inner.member(),
+			Self::Focus(inner) => inner.member(),
+			Self::Keyboard(inner) => inner.member(),
+			Self::Mouse(inner) => inner.member(),
+			Self::Object(inner) => inner.member(),
+			Self::Terminal(inner) => inner.member(),
+			Self::Window(inner) => inner.member(),
+			Self::Available(inner) => inner.member(),
+			Self::Cache(inner) => inner.member(),
+			Self::Listener(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Document(inner) => inner.interface(),
+			Self::Focus(inner) => inner.interface(),
+			Self::Keyboard(inner) => inner.interface(),
+			Self::Mouse(inner) => inner.interface(),
+			Self::Object(inner) => inner.interface(),
+			Self::Terminal(inner) => inner.interface(),
+			Self::Window(inner) => inner.interface(),
+			Self::Available(inner) => inner.interface(),
+			Self::Cache(inner) => inner.interface(),
+			Self::Listener(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Document(inner) => inner.match_rule(),
+			Self::Focus(inner) => inner.match_rule(),
+			Self::Keyboard(inner) => inner.match_rule(),
+			Self::Mouse(inner) => inner.match_rule(),
+			Self::Object(inner) => inner.match_rule(),
+			Self::Terminal(inner) => inner.match_rule(),
+			Self::Window(inner) => inner.match_rule(),
+			Self::Available(inner) => inner.match_rule(),
+			Self::Cache(inner) => inner.match_rule(),
+			Self::Listener(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Document(inner) => inner.registry_string(),
+			Self::Focus(inner) => inner.registry_string(),
+			Self::Keyboard(inner) => inner.registry_string(),
+			Self::Mouse(inner) => inner.registry_string(),
+			Self::Object(inner) => inner.registry_string(),
+			Self::Terminal(inner) => inner.registry_string(),
+			Self::Window(inner) => inner.registry_string(),
+			Self::Available(inner) => inner.registry_string(),
+			Self::Cache(inner) => inner.registry_string(),
+			Self::Listener(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for Event {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Document(inner) => inner.path(),
+			Self::Focus(inner) => inner.path(),
+			Self::Keyboard(inner) => inner.path(),
+			Self::Mouse(inner) => inner.path(),
+			Self::Object(inner) => inner.path(),
+			Self::Terminal(inner) => inner.path(),
+			Self::Window(inner) => inner.path(),
+			Self::Available(inner) => inner.path(),
+			Self::Cache(inner) => inner.path(),
+			Self::Listener(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Document(inner) => inner.sender(),
+			Self::Focus(inner) => inner.sender(),
+			Self::Keyboard(inner) => inner.sender(),
+			Self::Mouse(inner) => inner.sender(),
+			Self::Object(inner) => inner.sender(),
+			Self::Terminal(inner) => inner.sender(),
+			Self::Window(inner) => inner.sender(),
+			Self::Available(inner) => inner.sender(),
+			Self::Cache(inner) => inner.sender(),
+			Self::Listener(inner) => inner.sender(),
+		}
+	}
+}
+
 impl HasMatchRule for CacheEvents {
 	const MATCH_RULE_STRING: &'static str = "type='signal',interface='org.a11y.atspi.Event.Cache'";
 }
@@ -258,6 +348,54 @@ pub enum CacheEvents {
 	Remove(RemoveAccessibleEvent),
 }
 
+impl EventTypeProperties for CacheEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Add(inner) => inner.member(),
+			Self::LegacyAdd(inner) => inner.member(),
+			Self::Remove(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Add(inner) => inner.interface(),
+			Self::LegacyAdd(inner) => inner.interface(),
+			Self::Remove(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Add(inner) => inner.match_rule(),
+			Self::LegacyAdd(inner) => inner.match_rule(),
+			Self::Remove(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Add(inner) => inner.registry_string(),
+			Self::LegacyAdd(inner) => inner.registry_string(),
+			Self::Remove(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for CacheEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Add(inner) => inner.path(),
+			Self::LegacyAdd(inner) => inner.path(),
+			Self::Remove(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Add(inner) => inner.sender(),
+			Self::LegacyAdd(inner) => inner.sender(),
+			Self::Remove(inner) => inner.sender(),
+		}
+	}
+}
+
 /// Type that contains the `zbus::Message` for meta information and
 /// the [`crate::cache::LegacyCacheItem`]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, Eq, Hash)]
@@ -498,6 +636,18 @@ pub enum EventListenerEvents {
 	Deregistered(EventListenerDeregisteredEvent),
 }
 
+impl EventTypeProperties for EventListenerEvents {
+	fn member(&self) -> &'static str { match self { Self::Registered(inner) => inner.member(), Self::Deregistered(inner) => inner.member() } }
+	fn match_rule(&self) -> &'static str { match self { Self::Registered(inner) => inner.match_rule(), Self::Deregistered(inner) => inner.match_rule() } }
+	fn interface(&self) -> &'static str { match self { Self::Registered(inner) => inner.interface(), Self::Deregistered(inner) => inner.interface() } }
+	fn registry_string(&self) -> &'static str { match self { Self::Registered(inner) => inner.registry_string(), Self::Deregistered(inner) => inner.registry_string() } }
+}
+
+impl EventProperties for EventListenerEvents {
+	fn path(&self) -> ObjectPath<'_> { match self { Self::Registered(inner) => inner.path(), Self::Deregistered(inner) => inner.path() } }
+	fn sender(&self) -> BusName<'_> { match self { Self::Registered(inner) => inner.sender(), Self::Deregistered(inner) => inner.sender() } }
+}
+
 /// An event that is emitted by the registry daemon, to inform that an event has been deregistered
 /// to no longer listen for.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, Eq, Hash)]
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index 741b1689..f8ab059d 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -16,6 +16,54 @@ pub enum MouseEvents {
 	Button(ButtonEvent),
 }
 
+impl EventTypeProperties for MouseEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Abs(inner) => inner.member(),
+			Self::Rel(inner) => inner.member(),
+			Self::Button(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Abs(inner) => inner.interface(),
+			Self::Rel(inner) => inner.interface(),
+			Self::Button(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Abs(inner) => inner.match_rule(),
+			Self::Rel(inner) => inner.match_rule(),
+			Self::Button(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Abs(inner) => inner.registry_string(),
+			Self::Rel(inner) => inner.registry_string(),
+			Self::Button(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for MouseEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Abs(inner) => inner.path(),
+			Self::Rel(inner) => inner.path(),
+			Self::Button(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Abs(inner) => inner.sender(),
+			Self::Rel(inner) => inner.sender(),
+			Self::Button(inner) => inner.sender(),
+		}
+	}
+}
+
 impl_from_interface_event_enum_for_event!(MouseEvents, Event::Mouse);
 impl_try_from_event_for_user_facing_event_type!(MouseEvents, Event::Mouse);
 
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 0bed0ec0..29868b70 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -3,7 +3,7 @@ use crate::Live;
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties, State,
+	Event, EventProperties, State, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue, Value};
@@ -56,6 +56,168 @@ pub enum ObjectEvents {
 	TextCaretMoved(TextCaretMovedEvent),
 }
 
+impl EventTypeProperties for ObjectEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.member(),
+			Self::BoundsChanged(inner) => inner.member(),
+			Self::LinkSelected(inner) => inner.member(),
+			Self::StateChanged(inner) => inner.member(),
+			Self::ChildrenChanged(inner) => inner.member(),
+			Self::VisibleDataChanged(inner) => inner.member(),
+			Self::SelectionChanged(inner) => inner.member(),
+			Self::ModelChanged(inner) => inner.member(),
+			Self::ActiveDescendantChanged(inner) => inner.member(),
+			Self::Announcement(inner) => inner.member(),
+			Self::AttributesChanged(inner) => inner.member(),
+			Self::RowInserted(inner) => inner.member(),
+			Self::RowReordered(inner) => inner.member(),
+			Self::RowDeleted(inner) => inner.member(),
+			Self::ColumnInserted(inner) => inner.member(),
+			Self::ColumnReordered(inner) => inner.member(),
+			Self::ColumnDeleted(inner) => inner.member(),
+			Self::TextBoundsChanged(inner) => inner.member(),
+			Self::TextSelectionChanged(inner) => inner.member(),
+			Self::TextChanged(inner) => inner.member(),
+			Self::TextAttributesChanged(inner) => inner.member(),
+			Self::TextCaretMoved(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.interface(),
+			Self::BoundsChanged(inner) => inner.interface(),
+			Self::LinkSelected(inner) => inner.interface(),
+			Self::StateChanged(inner) => inner.interface(),
+			Self::ChildrenChanged(inner) => inner.interface(),
+			Self::VisibleDataChanged(inner) => inner.interface(),
+			Self::SelectionChanged(inner) => inner.interface(),
+			Self::ModelChanged(inner) => inner.interface(),
+			Self::ActiveDescendantChanged(inner) => inner.interface(),
+			Self::Announcement(inner) => inner.interface(),
+			Self::AttributesChanged(inner) => inner.interface(),
+			Self::RowInserted(inner) => inner.interface(),
+			Self::RowReordered(inner) => inner.interface(),
+			Self::RowDeleted(inner) => inner.interface(),
+			Self::ColumnInserted(inner) => inner.interface(),
+			Self::ColumnReordered(inner) => inner.interface(),
+			Self::ColumnDeleted(inner) => inner.interface(),
+			Self::TextBoundsChanged(inner) => inner.interface(),
+			Self::TextSelectionChanged(inner) => inner.interface(),
+			Self::TextChanged(inner) => inner.interface(),
+			Self::TextAttributesChanged(inner) => inner.interface(),
+			Self::TextCaretMoved(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.match_rule(),
+			Self::BoundsChanged(inner) => inner.match_rule(),
+			Self::LinkSelected(inner) => inner.match_rule(),
+			Self::StateChanged(inner) => inner.match_rule(),
+			Self::ChildrenChanged(inner) => inner.match_rule(),
+			Self::VisibleDataChanged(inner) => inner.match_rule(),
+			Self::SelectionChanged(inner) => inner.match_rule(),
+			Self::ModelChanged(inner) => inner.match_rule(),
+			Self::ActiveDescendantChanged(inner) => inner.match_rule(),
+			Self::Announcement(inner) => inner.match_rule(),
+			Self::AttributesChanged(inner) => inner.match_rule(),
+			Self::RowInserted(inner) => inner.match_rule(),
+			Self::RowReordered(inner) => inner.match_rule(),
+			Self::RowDeleted(inner) => inner.match_rule(),
+			Self::ColumnInserted(inner) => inner.match_rule(),
+			Self::ColumnReordered(inner) => inner.match_rule(),
+			Self::ColumnDeleted(inner) => inner.match_rule(),
+			Self::TextBoundsChanged(inner) => inner.match_rule(),
+			Self::TextSelectionChanged(inner) => inner.match_rule(),
+			Self::TextChanged(inner) => inner.match_rule(),
+			Self::TextAttributesChanged(inner) => inner.match_rule(),
+			Self::TextCaretMoved(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.registry_string(),
+			Self::BoundsChanged(inner) => inner.registry_string(),
+			Self::LinkSelected(inner) => inner.registry_string(),
+			Self::StateChanged(inner) => inner.registry_string(),
+			Self::ChildrenChanged(inner) => inner.registry_string(),
+			Self::VisibleDataChanged(inner) => inner.registry_string(),
+			Self::SelectionChanged(inner) => inner.registry_string(),
+			Self::ModelChanged(inner) => inner.registry_string(),
+			Self::ActiveDescendantChanged(inner) => inner.registry_string(),
+			Self::Announcement(inner) => inner.registry_string(),
+			Self::AttributesChanged(inner) => inner.registry_string(),
+			Self::RowInserted(inner) => inner.registry_string(),
+			Self::RowReordered(inner) => inner.registry_string(),
+			Self::RowDeleted(inner) => inner.registry_string(),
+			Self::ColumnInserted(inner) => inner.registry_string(),
+			Self::ColumnReordered(inner) => inner.registry_string(),
+			Self::ColumnDeleted(inner) => inner.registry_string(),
+			Self::TextBoundsChanged(inner) => inner.registry_string(),
+			Self::TextSelectionChanged(inner) => inner.registry_string(),
+			Self::TextChanged(inner) => inner.registry_string(),
+			Self::TextAttributesChanged(inner) => inner.registry_string(),
+			Self::TextCaretMoved(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for ObjectEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::PropertyChange(inner) => inner.path(),
+			Self::BoundsChanged(inner) => inner.path(),
+			Self::LinkSelected(inner) => inner.path(),
+			Self::StateChanged(inner) => inner.path(),
+			Self::ChildrenChanged(inner) => inner.path(),
+			Self::VisibleDataChanged(inner) => inner.path(),
+			Self::SelectionChanged(inner) => inner.path(),
+			Self::ModelChanged(inner) => inner.path(),
+			Self::ActiveDescendantChanged(inner) => inner.path(),
+			Self::Announcement(inner) => inner.path(),
+			Self::AttributesChanged(inner) => inner.path(),
+			Self::RowInserted(inner) => inner.path(),
+			Self::RowReordered(inner) => inner.path(),
+			Self::RowDeleted(inner) => inner.path(),
+			Self::ColumnInserted(inner) => inner.path(),
+			Self::ColumnReordered(inner) => inner.path(),
+			Self::ColumnDeleted(inner) => inner.path(),
+			Self::TextBoundsChanged(inner) => inner.path(),
+			Self::TextSelectionChanged(inner) => inner.path(),
+			Self::TextChanged(inner) => inner.path(),
+			Self::TextAttributesChanged(inner) => inner.path(),
+			Self::TextCaretMoved(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::PropertyChange(inner) => inner.sender(),
+			Self::BoundsChanged(inner) => inner.sender(),
+			Self::LinkSelected(inner) => inner.sender(),
+			Self::StateChanged(inner) => inner.sender(),
+			Self::ChildrenChanged(inner) => inner.sender(),
+			Self::VisibleDataChanged(inner) => inner.sender(),
+			Self::SelectionChanged(inner) => inner.sender(),
+			Self::ModelChanged(inner) => inner.sender(),
+			Self::ActiveDescendantChanged(inner) => inner.sender(),
+			Self::Announcement(inner) => inner.sender(),
+			Self::AttributesChanged(inner) => inner.sender(),
+			Self::RowInserted(inner) => inner.sender(),
+			Self::RowReordered(inner) => inner.sender(),
+			Self::RowDeleted(inner) => inner.sender(),
+			Self::ColumnInserted(inner) => inner.sender(),
+			Self::ColumnReordered(inner) => inner.sender(),
+			Self::ColumnDeleted(inner) => inner.sender(),
+			Self::TextBoundsChanged(inner) => inner.sender(),
+			Self::TextSelectionChanged(inner) => inner.sender(),
+			Self::TextChanged(inner) => inner.sender(),
+			Self::TextAttributesChanged(inner) => inner.sender(),
+			Self::TextCaretMoved(inner) => inner.sender(),
+		}
+	}
+}
+
 impl_from_interface_event_enum_for_event!(ObjectEvents, Event::Object);
 impl_try_from_event_for_user_facing_event_type!(ObjectEvents, Event::Object);
 
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index 23175e04..582401b7 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -21,6 +21,66 @@ pub enum TerminalEvents {
 	CharWidthChanged(CharWidthChangedEvent),
 }
 
+impl EventTypeProperties for TerminalEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::LineChanged(inner) => inner.member(),
+			Self::ColumnCountChanged(inner) => inner.member(),
+			Self::LineCountChanged(inner) => inner.member(),
+			Self::ApplicationChanged(inner) => inner.member(),
+			Self::CharWidthChanged(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::LineChanged(inner) => inner.interface(),
+			Self::ColumnCountChanged(inner) => inner.interface(),
+			Self::LineCountChanged(inner) => inner.interface(),
+			Self::ApplicationChanged(inner) => inner.interface(),
+			Self::CharWidthChanged(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::LineChanged(inner) => inner.match_rule(),
+			Self::ColumnCountChanged(inner) => inner.match_rule(),
+			Self::LineCountChanged(inner) => inner.match_rule(),
+			Self::ApplicationChanged(inner) => inner.match_rule(),
+			Self::CharWidthChanged(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::LineChanged(inner) => inner.registry_string(),
+			Self::ColumnCountChanged(inner) => inner.registry_string(),
+			Self::LineCountChanged(inner) => inner.registry_string(),
+			Self::ApplicationChanged(inner) => inner.registry_string(),
+			Self::CharWidthChanged(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for TerminalEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::LineChanged(inner) => inner.path(),
+			Self::ColumnCountChanged(inner) => inner.path(),
+			Self::LineCountChanged(inner) => inner.path(),
+			Self::ApplicationChanged(inner) => inner.path(),
+			Self::CharWidthChanged(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::LineChanged(inner) => inner.sender(),
+			Self::ColumnCountChanged(inner) => inner.sender(),
+			Self::LineCountChanged(inner) => inner.sender(),
+			Self::ApplicationChanged(inner) => inner.sender(),
+			Self::CharWidthChanged(inner) => inner.sender(),
+		}
+	}
+}
+
 impl_from_interface_event_enum_for_event!(TerminalEvents, Event::Terminal);
 impl_try_from_event_for_user_facing_event_type!(TerminalEvents, Event::Terminal);
 
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index 66ce09ea..c51daaf5 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -1,7 +1,7 @@
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties,
+	Event, EventProperties, EventTypeProperties,
 };
 use zbus_names::BusName;
 use zvariant::ObjectPath;
@@ -49,6 +49,150 @@ pub enum WindowEvents {
 	Restyle(RestyleEvent),
 }
 
+impl EventTypeProperties for WindowEvents {
+	fn member(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.member(),
+			Self::Minimize(inner) => inner.member(),
+			Self::Maximize(inner) => inner.member(),
+			Self::Restore(inner) => inner.member(),
+			Self::Close(inner) => inner.member(),
+			Self::Create(inner) => inner.member(),
+			Self::Reparent(inner) => inner.member(),
+			Self::DesktopCreate(inner) => inner.member(),
+			Self::DesktopDestroy(inner) => inner.member(),
+			Self::Destroy(inner) => inner.member(),
+			Self::Activate(inner) => inner.member(),
+			Self::Deactivate(inner) => inner.member(),
+			Self::Raise(inner) => inner.member(),
+			Self::Lower(inner) => inner.member(),
+			Self::Move(inner) => inner.member(),
+			Self::Resize(inner) => inner.member(),
+			Self::Shade(inner) => inner.member(),
+			Self::UUshade(inner) => inner.member(),
+			Self::Restyle(inner) => inner.member(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.interface(),
+			Self::Minimize(inner) => inner.interface(),
+			Self::Maximize(inner) => inner.interface(),
+			Self::Restore(inner) => inner.interface(),
+			Self::Close(inner) => inner.interface(),
+			Self::Create(inner) => inner.interface(),
+			Self::Reparent(inner) => inner.interface(),
+			Self::DesktopCreate(inner) => inner.interface(),
+			Self::DesktopDestroy(inner) => inner.interface(),
+			Self::Destroy(inner) => inner.interface(),
+			Self::Activate(inner) => inner.interface(),
+			Self::Deactivate(inner) => inner.interface(),
+			Self::Raise(inner) => inner.interface(),
+			Self::Lower(inner) => inner.interface(),
+			Self::Move(inner) => inner.interface(),
+			Self::Resize(inner) => inner.interface(),
+			Self::Shade(inner) => inner.interface(),
+			Self::UUshade(inner) => inner.interface(),
+			Self::Restyle(inner) => inner.interface(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.match_rule(),
+			Self::Minimize(inner) => inner.match_rule(),
+			Self::Maximize(inner) => inner.match_rule(),
+			Self::Restore(inner) => inner.match_rule(),
+			Self::Close(inner) => inner.match_rule(),
+			Self::Create(inner) => inner.match_rule(),
+			Self::Reparent(inner) => inner.match_rule(),
+			Self::DesktopCreate(inner) => inner.match_rule(),
+			Self::DesktopDestroy(inner) => inner.match_rule(),
+			Self::Destroy(inner) => inner.match_rule(),
+			Self::Activate(inner) => inner.match_rule(),
+			Self::Deactivate(inner) => inner.match_rule(),
+			Self::Raise(inner) => inner.match_rule(),
+			Self::Lower(inner) => inner.match_rule(),
+			Self::Move(inner) => inner.match_rule(),
+			Self::Resize(inner) => inner.match_rule(),
+			Self::Shade(inner) => inner.match_rule(),
+			Self::UUshade(inner) => inner.match_rule(),
+			Self::Restyle(inner) => inner.match_rule(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::PropertyChange(inner) => inner.registry_string(),
+			Self::Minimize(inner) => inner.registry_string(),
+			Self::Maximize(inner) => inner.registry_string(),
+			Self::Restore(inner) => inner.registry_string(),
+			Self::Close(inner) => inner.registry_string(),
+			Self::Create(inner) => inner.registry_string(),
+			Self::Reparent(inner) => inner.registry_string(),
+			Self::DesktopCreate(inner) => inner.registry_string(),
+			Self::DesktopDestroy(inner) => inner.registry_string(),
+			Self::Destroy(inner) => inner.registry_string(),
+			Self::Activate(inner) => inner.registry_string(),
+			Self::Deactivate(inner) => inner.registry_string(),
+			Self::Raise(inner) => inner.registry_string(),
+			Self::Lower(inner) => inner.registry_string(),
+			Self::Move(inner) => inner.registry_string(),
+			Self::Resize(inner) => inner.registry_string(),
+			Self::Shade(inner) => inner.registry_string(),
+			Self::UUshade(inner) => inner.registry_string(),
+			Self::Restyle(inner) => inner.registry_string(),
+		}
+	}
+}
+
+impl EventProperties for WindowEvents {
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::PropertyChange(inner) => inner.path(),
+			Self::Minimize(inner) => inner.path(),
+			Self::Maximize(inner) => inner.path(),
+			Self::Restore(inner) => inner.path(),
+			Self::Close(inner) => inner.path(),
+			Self::Create(inner) => inner.path(),
+			Self::Reparent(inner) => inner.path(),
+			Self::DesktopCreate(inner) => inner.path(),
+			Self::DesktopDestroy(inner) => inner.path(),
+			Self::Destroy(inner) => inner.path(),
+			Self::Activate(inner) => inner.path(),
+			Self::Deactivate(inner) => inner.path(),
+			Self::Raise(inner) => inner.path(),
+			Self::Lower(inner) => inner.path(),
+			Self::Move(inner) => inner.path(),
+			Self::Resize(inner) => inner.path(),
+			Self::Shade(inner) => inner.path(),
+			Self::UUshade(inner) => inner.path(),
+			Self::Restyle(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::PropertyChange(inner) => inner.sender(),
+			Self::Minimize(inner) => inner.sender(),
+			Self::Maximize(inner) => inner.sender(),
+			Self::Restore(inner) => inner.sender(),
+			Self::Close(inner) => inner.sender(),
+			Self::Create(inner) => inner.sender(),
+			Self::Reparent(inner) => inner.sender(),
+			Self::DesktopCreate(inner) => inner.sender(),
+			Self::DesktopDestroy(inner) => inner.sender(),
+			Self::Destroy(inner) => inner.sender(),
+			Self::Activate(inner) => inner.sender(),
+			Self::Deactivate(inner) => inner.sender(),
+			Self::Raise(inner) => inner.sender(),
+			Self::Lower(inner) => inner.sender(),
+			Self::Move(inner) => inner.sender(),
+			Self::Resize(inner) => inner.sender(),
+			Self::Shade(inner) => inner.sender(),
+			Self::UUshade(inner) => inner.sender(),
+			Self::Restyle(inner) => inner.sender(),
+		}
+	}
+}
+
 impl_from_interface_event_enum_for_event!(WindowEvents, Event::Window);
 impl_try_from_event_for_user_facing_event_type!(WindowEvents, Event::Window);
 
diff --git a/atspi-common/src/lib.rs b/atspi-common/src/lib.rs
index 626d3bb0..0f9dbc58 100644
--- a/atspi-common/src/lib.rs
+++ b/atspi-common/src/lib.rs
@@ -25,7 +25,7 @@ pub use cache::{CacheItem, LegacyCacheItem};
 pub mod error;
 pub use error::AtspiError;
 pub mod events;
-pub use events::{BusProperties, Event, EventProperties};
+pub use events::{BusProperties, Event, EventProperties, EventTypeProperties};
 mod role;
 pub use role::Role;
 mod relation_type;

From b2145b3899b44967010ffae8898ce458bc34a1f0 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 13:56:15 -0600
Subject: [PATCH 26/37] Add tests to check for inner transparency on the Event
 type

Cargo fmt
---
 atspi-common/src/events/focus.rs    | 36 ++++++++++++++++----
 atspi-common/src/events/keyboard.rs | 36 ++++++++++++++++----
 atspi-common/src/events/mod.rs      | 42 ++++++++++++++++++++----
 atspi-common/src/events/object.rs   |  2 +-
 atspi-common/src/macros.rs          | 51 ++++++++++++++++++++++++++++-
 5 files changed, 147 insertions(+), 20 deletions(-)

diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 78441d4b..76bfb469 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -13,15 +13,39 @@ pub enum FocusEvents {
 }
 
 impl EventTypeProperties for FocusEvents {
-	fn member(&self) -> &'static str { match self { Self::Focus(inner) => inner.member() } }
-	fn match_rule(&self) -> &'static str { match self { Self::Focus(inner) => inner.match_rule() } }
-	fn interface(&self) -> &'static str { match self { Self::Focus(inner) => inner.interface() } }
-	fn registry_string(&self) -> &'static str { match self { Self::Focus(inner) => inner.registry_string() } }
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Focus(inner) => inner.member(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Focus(inner) => inner.match_rule(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Focus(inner) => inner.interface(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Focus(inner) => inner.registry_string(),
+		}
+	}
 }
 
 impl EventProperties for FocusEvents {
-	fn path(&self) -> ObjectPath<'_> { match self { Self::Focus(inner) => inner.path() } }
-	fn sender(&self) -> BusName<'_> { match self { Self::Focus(inner) => inner.sender() } }
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Focus(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Focus(inner) => inner.sender(),
+		}
+	}
 }
 
 impl_from_interface_event_enum_for_event!(FocusEvents, Event::Focus);
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 3db1e8b1..5c89df6a 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -13,15 +13,39 @@ pub enum KeyboardEvents {
 }
 
 impl EventTypeProperties for KeyboardEvents {
-	fn member(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.member() } }
-	fn match_rule(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.match_rule() } }
-	fn interface(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.interface() } }
-	fn registry_string(&self) -> &'static str { match self { Self::Modifiers(inner) => inner.registry_string() } }
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Modifiers(inner) => inner.member(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Modifiers(inner) => inner.match_rule(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Modifiers(inner) => inner.interface(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Modifiers(inner) => inner.registry_string(),
+		}
+	}
 }
 
 impl EventProperties for KeyboardEvents {
-	fn path(&self) -> ObjectPath<'_> { match self { Self::Modifiers(inner) => inner.path() } }
-	fn sender(&self) -> BusName<'_> { match self { Self::Modifiers(inner) => inner.sender() } }
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Modifiers(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Modifiers(inner) => inner.sender(),
+		}
+	}
 }
 
 impl_from_interface_event_enum_for_event!(KeyboardEvents, Event::Keyboard);
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 41f262ad..d3eb2876 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -637,15 +637,45 @@ pub enum EventListenerEvents {
 }
 
 impl EventTypeProperties for EventListenerEvents {
-	fn member(&self) -> &'static str { match self { Self::Registered(inner) => inner.member(), Self::Deregistered(inner) => inner.member() } }
-	fn match_rule(&self) -> &'static str { match self { Self::Registered(inner) => inner.match_rule(), Self::Deregistered(inner) => inner.match_rule() } }
-	fn interface(&self) -> &'static str { match self { Self::Registered(inner) => inner.interface(), Self::Deregistered(inner) => inner.interface() } }
-	fn registry_string(&self) -> &'static str { match self { Self::Registered(inner) => inner.registry_string(), Self::Deregistered(inner) => inner.registry_string() } }
+	fn member(&self) -> &'static str {
+		match self {
+			Self::Registered(inner) => inner.member(),
+			Self::Deregistered(inner) => inner.member(),
+		}
+	}
+	fn match_rule(&self) -> &'static str {
+		match self {
+			Self::Registered(inner) => inner.match_rule(),
+			Self::Deregistered(inner) => inner.match_rule(),
+		}
+	}
+	fn interface(&self) -> &'static str {
+		match self {
+			Self::Registered(inner) => inner.interface(),
+			Self::Deregistered(inner) => inner.interface(),
+		}
+	}
+	fn registry_string(&self) -> &'static str {
+		match self {
+			Self::Registered(inner) => inner.registry_string(),
+			Self::Deregistered(inner) => inner.registry_string(),
+		}
+	}
 }
 
 impl EventProperties for EventListenerEvents {
-	fn path(&self) -> ObjectPath<'_> { match self { Self::Registered(inner) => inner.path(), Self::Deregistered(inner) => inner.path() } }
-	fn sender(&self) -> BusName<'_> { match self { Self::Registered(inner) => inner.sender(), Self::Deregistered(inner) => inner.sender() } }
+	fn path(&self) -> ObjectPath<'_> {
+		match self {
+			Self::Registered(inner) => inner.path(),
+			Self::Deregistered(inner) => inner.path(),
+		}
+	}
+	fn sender(&self) -> BusName<'_> {
+		match self {
+			Self::Registered(inner) => inner.sender(),
+			Self::Deregistered(inner) => inner.sender(),
+		}
+	}
 }
 
 /// An event that is emitted by the registry daemon, to inform that an event has been deregistered
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 29868b70..c310d1d0 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -3,7 +3,7 @@ use crate::Live;
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties, State, EventTypeProperties,
+	Event, EventProperties, EventTypeProperties, State,
 };
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue, Value};
diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index 189b9bad..d60622f3 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -316,6 +316,54 @@ macro_rules! event_enum_test_case {
 	};
 }
 
+/// Tests transparency of the `EventTypeProperties` and `EventProperties` trait on the `Event` wrapper type.
+///
+/// Obtains a default for the given event struct.
+/// Converts the struct into the `Event` enum, wrapping the struct.
+/// Checks the equality of all four functions defined in the `EventTypeProiperties` and `EventProperties` traits:
+///
+/// - member
+/// - interface
+/// - registry_string
+/// - match_rule
+/// - path
+/// - sender
+///
+/// It is imperitive that these items come through with no modifications from the wrappers.
+///
+#[cfg(test)]
+macro_rules! event_enum_transparency_test_case {
+	($type:ty) => {
+		#[test]
+		fn event_enum_transparency_test_case() {
+			let specific_event = <$type>::default();
+			let generic_event = Event::from(specific_event.clone());
+			assert_eq!(
+				specific_event.member(),
+				generic_event.member(),
+				"DBus member strings do not match."
+			);
+			assert_eq!(
+				specific_event.interface(),
+				generic_event.interface(),
+				"Registry interfaces do not match."
+			);
+			assert_eq!(
+				specific_event.registry_string(),
+				generic_event.registry_string(),
+				"Registry strings do not match."
+			);
+			assert_eq!(
+				specific_event.match_rule(),
+				generic_event.match_rule(),
+				"Match rule strings do not match."
+			);
+			assert_eq!(specific_event.path(), generic_event.path(), "Pathsdo not match.");
+			assert_eq!(specific_event.sender(), generic_event.sender(), "Senders do not match.");
+		}
+	};
+}
+
 // We decorate the macro with a `#[cfg(test)]` attribute.
 // This prevents Clippy from complaining about the macro not being used.
 // It is being used, but only in test mode.
@@ -569,11 +617,12 @@ macro_rules! event_test_cases {
 		#[cfg(test)]
 		#[rename_item::rename(name($type), prefix = "event_tests_", case = "snake")]
 		mod foo {
-			use super::{$type, Event, BusProperties, EventProperties};
+			use super::{$type, Event, BusProperties, EventProperties, EventTypeProperties};
 
 			generic_event_test_case!($type);
 			event_enum_test_case!($type);
 			zbus_message_test_case!($type);
+			event_enum_transparency_test_case!($type);
 		}
 		assert_impl_all!(
 			$type: Clone,

From 4d5ba897d0c8866f1e62a89d8267b0c3527292bc Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 15:22:18 -0600
Subject: [PATCH 27/37] Fix, add to docs

Whoopsie
---
 atspi-common/src/macros.rs | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index d60622f3..03ab64bb 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -1,3 +1,22 @@
+/// Expands to implement the required methods for the [`crate::EventProperties`] trait.
+/// This depends on the struct to have an `item` field of type `ObjectRef`.
+///
+/// ```ignore
+/// impl_from_interface_event_enum_for_event!(TextCaretMovedEvent);
+/// ```
+///
+/// Expands to:
+///
+/// ```ignore
+/// impl EventProperties for TextCaretMovedEvent {
+///   fn sender(&self) -> BusName<'_> {
+///     self.item.name.as_ref()
+///   }
+///   fn path(&self) -> ObjectPath<'_> {
+///     self.item.path.as_ref()
+///   }
+/// }
+/// ```
 macro_rules! impl_event_properties {
 	($type:ty) => {
 		impl EventProperties for $type {
@@ -322,12 +341,12 @@ macro_rules! event_enum_test_case {
 /// Converts the struct into the `Event` enum, wrapping the struct.
 /// Checks the equality of all four functions defined in the `EventTypeProiperties` and `EventProperties` traits:
 ///
-/// - member
-/// - interface
-/// - registry_string
-/// - match_rule
-/// - path
-/// - sender
+/// - `member`
+/// - `interface`
+/// - `registry_string`
+/// - `match_rule`
+/// - `path`
+/// - `sender`
 ///
 /// It is imperitive that these items come through with no modifications from the wrappers.
 ///

From 284652df0da6e02af2026abcf2db474f3385480f Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 18 Apr 2024 15:29:13 -0600
Subject: [PATCH 28/37] Add additional required traits for each individual
 event type

---
 atspi-common/src/macros.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index 03ab64bb..1f2599e5 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -652,6 +652,9 @@ macro_rules! event_test_cases {
 			PartialEq,
 			Eq,
 			std::hash::Hash,
+			crate::EventProperties,
+			crate::EventTypeProperties,
+			crate::BusProperties,
 		);
 		#[cfg(feature = "zbus")]
 		assert_impl_all!(zbus::Message: TryFrom<$type>);

From a9e3007e550d8bc93d6a0c7321a4d77594af2c4d Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Tue, 23 Apr 2024 15:25:47 +0200
Subject: [PATCH 29/37] Remove stray new_events.diff file.

---
 atspi-common/new_events.diff | 169 -----------------------------------
 1 file changed, 169 deletions(-)
 delete mode 100644 atspi-common/new_events.diff

diff --git a/atspi-common/new_events.diff b/atspi-common/new_events.diff
deleted file mode 100644
index e8c3d1b7..00000000
--- a/atspi-common/new_events.diff
+++ /dev/null
@@ -1,169 +0,0 @@
-diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
-index 3b6e091..1abeb33 100644
---- a/atspi-common/src/events/mod.rs
-+++ b/atspi-common/src/events/mod.rs
-@@ -31,6 +31,7 @@ use zbus_lockstep_macros::validate;
- use zbus_names::{OwnedUniqueName, UniqueName};
- #[cfg(feature = "zbus")]
- use zvariant::OwnedObjectPath;
-+use zbus_names::BusName;
- use zvariant::{ObjectPath, OwnedValue, Signature, Type, Value};
- 
- use crate::{
-@@ -283,7 +284,7 @@ event_test_cases!(LegacyAddAccessibleEvent);
- impl_from_dbus_message!(LegacyAddAccessibleEvent);
- impl_to_dbus_message!(LegacyAddAccessibleEvent);
- 
--impl GenericEvent<'_> for LegacyAddAccessibleEvent {
-+impl BusProperties<'_> for LegacyAddAccessibleEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
-@@ -326,7 +327,7 @@ impl_from_user_facing_type_for_event_enum!(AddAccessibleEvent, Event::Cache);
- impl_try_from_event_for_user_facing_type!(AddAccessibleEvent, CacheEvents::Add, Event::Cache);
- event_test_cases!(AddAccessibleEvent);
- 
--impl GenericEvent<'_> for AddAccessibleEvent {
-+impl BusProperties<'_> for AddAccessibleEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Add";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Cache',member='AddAccessible'";
-@@ -349,11 +350,11 @@ impl GenericEvent<'_> for AddAccessibleEvent {
- 		self.node_added.clone()
- 	}
- }
--impl<'a, T: GenericEvent<'a>> HasMatchRule for T {
--	const MATCH_RULE_STRING: &'static str = <T as GenericEvent>::MATCH_RULE_STRING;
-+impl<'a, T: BusProperties<'a>> HasMatchRule for T {
-+	const MATCH_RULE_STRING: &'static str = <T as BusProperties>::MATCH_RULE_STRING;
- }
--impl<'a, T: GenericEvent<'a>> HasRegistryEventString for T {
--	const REGISTRY_EVENT_STRING: &'static str = <T as GenericEvent>::REGISTRY_EVENT_STRING;
-+impl<'a, T: BusProperties<'a>> HasRegistryEventString for T {
-+	const REGISTRY_EVENT_STRING: &'static str = <T as BusProperties>::REGISTRY_EVENT_STRING;
- }
- impl_from_dbus_message!(AddAccessibleEvent);
- impl_to_dbus_message!(AddAccessibleEvent);
-@@ -376,7 +377,7 @@ impl_from_user_facing_event_for_interface_event_enum!(
- impl_from_user_facing_type_for_event_enum!(RemoveAccessibleEvent, Event::Cache);
- impl_try_from_event_for_user_facing_type!(RemoveAccessibleEvent, CacheEvents::Remove, Event::Cache);
- event_test_cases!(RemoveAccessibleEvent);
--impl GenericEvent<'_> for RemoveAccessibleEvent {
-+impl BusProperties<'_> for RemoveAccessibleEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Cache:Remove";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Cache',member='RemoveAccessible'";
-@@ -535,7 +536,7 @@ impl_try_from_event_for_user_facing_type!(
- 	Event::Listener
- );
- event_test_cases!(EventListenerDeregisteredEvent);
--impl GenericEvent<'_> for EventListenerDeregisteredEvent {
-+impl BusProperties<'_> for EventListenerDeregisteredEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerDeregistered";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerDeregistered'";
-@@ -582,7 +583,7 @@ impl_try_from_event_for_user_facing_type!(
- 	Event::Listener
- );
- event_test_cases!(EventListenerRegisteredEvent);
--impl GenericEvent<'_> for EventListenerRegisteredEvent {
-+impl BusProperties<'_> for EventListenerRegisteredEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Registry:EventListenerRegistered";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Registry',member='EventListenerRegistered'";
-@@ -630,7 +631,7 @@ impl TryFrom<Event> for AvailableEvent {
- 	}
- }
- event_test_cases!(AvailableEvent);
--impl GenericEvent<'_> for AvailableEvent {
-+impl BusProperties<'_> for AvailableEvent {
- 	const REGISTRY_EVENT_STRING: &'static str = "Socket:Available";
- 	const MATCH_RULE_STRING: &'static str =
- 		"type='signal',interface='org.a11y.atspi.Socket',member='Available'";
-@@ -725,8 +726,37 @@ impl TryFrom<&zbus::Message> for Event {
- 	}
- }
- 
-+/// Get generic information abbout an event, like its:
-+/// 
-+/// - dbus member name
-+/// - dbus interface name
-+/// - dbus path
-+/// - dbus sender (bus id)
-+///
-+/// Member name and interface name combined are unique to individual event types;
-+/// dbus path and sender are unique to a specific accessible item available on the accessibility bus (also know as an [`ObjectRef`]).
-+/// 
-+/// This trait *is* object-safe.
-+pub trait GenericEvent {
-+	fn member(&self) -> &'static str;
-+	fn interface(&self) -> &'static str;
-+	fn path(&self) -> ObjectPath<'_>;
-+	fn sender(&self) -> BusName<'_>;
-+}
-+
-+assert_obj_safe!(GenericEvent);
-+
-+impl<T: GenericEvent> From<&T> for ObjectRef {
-+	fn from(ev: &T) -> ObjectRef {
-+		ObjectRef {
-+			name: ev.sender().to_string(),
-+			path: ev.path().into(),
-+		}
-+	}
-+}
-+
- /// Shared behavior of bus `Signal` events.
--pub trait GenericEvent<'a> {
-+pub trait BusProperties {
- 	/// The `DBus` member for the event.
- 	/// For example, for an [`object::TextChangedEvent`] this should be `"TextChanged"`
- 	const DBUS_MEMBER: &'static str;
-@@ -742,44 +772,21 @@ pub trait GenericEvent<'a> {
- 	const REGISTRY_EVENT_STRING: &'static str;
- 
- 	/// What is the body type of this event.
--	type Body: Type + Serialize + Deserialize<'a>;
--
--	/// Build the event from the object pair (`ObjectRef` and the Body).
--	///
--	/// # Errors
--	///
--	/// When the body type, which is what the raw message looks like over `DBus`, does not match the type that is expected for the given event.
--	/// It is not possible for this to error on most events, but on events whose raw message [`Self::Body`] type contains a [`enum@zvariant::Value`], you may get errors when constructing the structure.
--	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError>
--	where
--		Self: Sized;
--
--	/// Path of the signalling object.
--	fn path(&self) -> ObjectPath<'_>;
--
--	/// Sender of the signal.
--	///
--	/// ### Errors
--	/// - when deserializing the header failed, or
--	/// - When `zbus::get_field!` finds that 'sender' is an invalid field.
--	fn sender(&self) -> String;
--
--	/// The body of the object.
--	fn body(&self) -> Self::Body;
-+	type Body: Type + Serialize + for<'b> Deserialize<'b>;
- }
- 
- /// A specific trait *only* to define match rules.
- pub trait HasMatchRule {
- 	/// A static match rule string for `DBus`.
- 	/// This should usually be a string that looks like this: `"type='signal',interface='org.a11y.atspi.Event.Object',member='PropertyChange'"`;
--	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
-+	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
- 	const MATCH_RULE_STRING: &'static str;
- }
- 
- /// A specific trait *only* to define registry event matches.
- pub trait HasRegistryEventString {
- 	/// A registry event string for registering for event receiving via the `RegistryProxy`.
--	/// This should be deprecated in favour of composing the string from [`GenericEvent::DBUS_MEMBER`] and [`GenericEvent::DBUS_INTERFACE`].
-+	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].
- 	const REGISTRY_EVENT_STRING: &'static str;
- }
- 

From 2c7728a304a9fafd0ba22eb73e4d95559f7a0f93 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 25 Apr 2024 16:47:08 -0600
Subject: [PATCH 30/37] Add object-safety comments

---
 atspi-common/src/events/mod.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index d3eb2876..9c316625 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -972,6 +972,11 @@ pub trait BusProperties {
 }
 
 /// A specific trait *only* to define match rules.
+/// This is useful for event wrappers like [`ObjectEvents`], which, while it does not have other
+/// information required to implement the [`BusProperties`] trait, you can indeed add a match rule
+/// to the `DBus` connection to capture all sub events of [`ObjectEvents`].
+/// 
+/// This trait *is not* object-safe.
 pub trait HasMatchRule {
 	/// A static match rule string for `DBus`.
 	/// This should usually be a string that looks like this: `"type='signal',interface='org.a11y.atspi.Event.Object',member='PropertyChange'"`;
@@ -980,6 +985,11 @@ pub trait HasMatchRule {
 }
 
 /// A specific trait *only* to define registry event matches.
+/// This is useful for event wrappers like [`ObjectEvents`], which, while it does not have other
+/// information required to implement the [`BusProperties`] trait, you can indeed add a match rule
+/// to the AT-SPI connection to subscribe to all sub events of [`ObjectEvents`].
+///
+/// This trait *is not* object-safe.
 pub trait HasRegistryEventString {
 	/// A registry event string for registering for event receiving via the `RegistryProxy`.
 	/// This should be deprecated in favour of composing the string from [`BusProperties::DBUS_MEMBER`] and [`BusProperties::DBUS_INTERFACE`].

From 70af88a989b5618a0aef5d9b3d18ed570066c6fd Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Thu, 25 Apr 2024 17:12:27 -0600
Subject: [PATCH 31/37] BusProperties::build -> from_message_parts

fmt

Fix tests
---
 atspi-common/src/events/document.rs | 12 ++++----
 atspi-common/src/events/focus.rs    |  2 +-
 atspi-common/src/events/keyboard.rs |  2 +-
 atspi-common/src/events/mod.rs      | 16 +++++------
 atspi-common/src/events/mouse.rs    |  6 ++--
 atspi-common/src/events/object.rs   | 44 ++++++++++++++---------------
 atspi-common/src/events/terminal.rs | 10 +++----
 atspi-common/src/events/window.rs   | 38 ++++++++++++-------------
 atspi-common/src/macros.rs          | 10 +++----
 9 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/atspi-common/src/events/document.rs b/atspi-common/src/events/document.rs
index b27b9e1c..7d13aaaf 100644
--- a/atspi-common/src/events/document.rs
+++ b/atspi-common/src/events/document.rs
@@ -149,7 +149,7 @@ impl BusProperties for LoadCompleteEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -167,7 +167,7 @@ impl BusProperties for ReloadEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -185,7 +185,7 @@ impl BusProperties for LoadStoppedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -203,7 +203,7 @@ impl BusProperties for ContentChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -221,7 +221,7 @@ impl BusProperties for AttributesChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -239,7 +239,7 @@ impl BusProperties for PageChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/focus.rs b/atspi-common/src/events/focus.rs
index 76bfb469..25831bd0 100644
--- a/atspi-common/src/events/focus.rs
+++ b/atspi-common/src/events/focus.rs
@@ -72,7 +72,7 @@ impl BusProperties for FocusEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/keyboard.rs b/atspi-common/src/events/keyboard.rs
index 5c89df6a..4b2d5b3c 100644
--- a/atspi-common/src/events/keyboard.rs
+++ b/atspi-common/src/events/keyboard.rs
@@ -75,7 +75,7 @@ impl BusProperties for ModifiersEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, previous_modifiers: body.detail1, current_modifiers: body.detail2 })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index 9c316625..ccb28312 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -431,7 +431,7 @@ impl BusProperties for LegacyAddAccessibleEvent {
 
 	type Body = LegacyCacheItem;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, node_added: body })
 	}
 
@@ -468,7 +468,7 @@ impl BusProperties for AddAccessibleEvent {
 
 	type Body = CacheItem;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, node_added: body })
 	}
 
@@ -513,7 +513,7 @@ impl BusProperties for RemoveAccessibleEvent {
 
 	type Body = ObjectRef;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, node_removed: body })
 	}
 	fn body(&self) -> Self::Body {
@@ -710,7 +710,7 @@ impl BusProperties for EventListenerDeregisteredEvent {
 
 	type Body = EventListeners;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, deregistered_event: body })
 	}
 	fn body(&self) -> Self::Body {
@@ -752,7 +752,7 @@ impl BusProperties for EventListenerRegisteredEvent {
 
 	type Body = EventListeners;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, registered_event: body })
 	}
 	fn body(&self) -> Self::Body {
@@ -795,7 +795,7 @@ impl BusProperties for AvailableEvent {
 
 	type Body = ObjectRef;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, socket: body })
 	}
 	fn body(&self) -> Self::Body {
@@ -963,7 +963,7 @@ pub trait BusProperties {
 	///
 	/// When the body type, which is what the raw message looks like over `DBus`, does not match the type that is expected for the given event.
 	/// It is not possible for this to error on most events, but on events whose raw message [`Self::Body`] type contains a [`enum@zvariant::Value`], you may get errors when constructing the structure.
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError>
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError>
 	where
 		Self: Sized;
 
@@ -975,7 +975,7 @@ pub trait BusProperties {
 /// This is useful for event wrappers like [`ObjectEvents`], which, while it does not have other
 /// information required to implement the [`BusProperties`] trait, you can indeed add a match rule
 /// to the `DBus` connection to capture all sub events of [`ObjectEvents`].
-/// 
+///
 /// This trait *is not* object-safe.
 pub trait HasMatchRule {
 	/// A static match rule string for `DBus`.
diff --git a/atspi-common/src/events/mouse.rs b/atspi-common/src/events/mouse.rs
index f8ab059d..b5de3f0e 100644
--- a/atspi-common/src/events/mouse.rs
+++ b/atspi-common/src/events/mouse.rs
@@ -107,7 +107,7 @@ impl BusProperties for AbsEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
 	fn body(&self) -> Self::Body {
@@ -125,7 +125,7 @@ impl BusProperties for RelEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, x: body.detail1, y: body.detail2 })
 	}
 	fn body(&self) -> Self::Body {
@@ -143,7 +143,7 @@ impl BusProperties for ButtonEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, detail: body.kind, mouse_x: body.detail1, mouse_y: body.detail2 })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index c310d1d0..484b8727 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -587,7 +587,7 @@ impl BusProperties for PropertyChangeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		let property = body.kind.clone();
 		let value: Property = body.try_into()?;
 		Ok(Self { item, property, value })
@@ -607,7 +607,7 @@ impl BusProperties for BoundsChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -625,7 +625,7 @@ impl BusProperties for LinkSelectedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -644,7 +644,7 @@ impl BusProperties for StateChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, state: body.kind.into(), enabled: body.detail1 })
 	}
 	fn body(&self) -> Self::Body {
@@ -662,7 +662,7 @@ impl BusProperties for ChildrenChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self {
 			item,
 			operation: body.kind,
@@ -685,7 +685,7 @@ impl BusProperties for VisibleDataChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -703,7 +703,7 @@ impl BusProperties for SelectionChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -721,7 +721,7 @@ impl BusProperties for ModelChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -739,7 +739,7 @@ impl BusProperties for ActiveDescendantChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, child: body.any_data.try_into()? })
 	}
 	fn body(&self) -> Self::Body {
@@ -758,7 +758,7 @@ impl BusProperties for AnnouncementEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self {
 			item,
 			text: body.any_data.try_into().map_err(|_| AtspiError::Conversion("text"))?,
@@ -781,7 +781,7 @@ impl BusProperties for AttributesChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -799,7 +799,7 @@ impl BusProperties for RowInsertedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -817,7 +817,7 @@ impl BusProperties for RowReorderedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -835,7 +835,7 @@ impl BusProperties for RowDeletedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -853,7 +853,7 @@ impl BusProperties for ColumnInsertedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -871,7 +871,7 @@ impl BusProperties for ColumnReorderedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -889,7 +889,7 @@ impl BusProperties for ColumnDeletedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -907,7 +907,7 @@ impl BusProperties for TextBoundsChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -925,7 +925,7 @@ impl BusProperties for TextSelectionChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -943,7 +943,7 @@ impl BusProperties for TextChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self {
 			item,
 			operation: body.kind,
@@ -967,7 +967,7 @@ impl BusProperties for TextAttributesChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -985,7 +985,7 @@ impl BusProperties for TextCaretMovedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, position: body.detail1 })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/terminal.rs b/atspi-common/src/events/terminal.rs
index 582401b7..2a5749a9 100644
--- a/atspi-common/src/events/terminal.rs
+++ b/atspi-common/src/events/terminal.rs
@@ -137,7 +137,7 @@ impl BusProperties for LineChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -155,7 +155,7 @@ impl BusProperties for ColumnCountChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -173,7 +173,7 @@ impl BusProperties for LineCountChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -191,7 +191,7 @@ impl BusProperties for ApplicationChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -209,7 +209,7 @@ impl BusProperties for CharWidthChangedEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/events/window.rs b/atspi-common/src/events/window.rs
index c51daaf5..30f64df4 100644
--- a/atspi-common/src/events/window.rs
+++ b/atspi-common/src/events/window.rs
@@ -333,7 +333,7 @@ impl BusProperties for PropertyChangeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item, property: body.kind })
 	}
 	fn body(&self) -> Self::Body {
@@ -351,7 +351,7 @@ impl BusProperties for MinimizeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -369,7 +369,7 @@ impl BusProperties for MaximizeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -387,7 +387,7 @@ impl BusProperties for RestoreEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -405,7 +405,7 @@ impl BusProperties for CloseEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -423,7 +423,7 @@ impl BusProperties for CreateEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -441,7 +441,7 @@ impl BusProperties for ReparentEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -459,7 +459,7 @@ impl BusProperties for DesktopCreateEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -477,7 +477,7 @@ impl BusProperties for DesktopDestroyEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -495,7 +495,7 @@ impl BusProperties for DestroyEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -513,7 +513,7 @@ impl BusProperties for ActivateEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -531,7 +531,7 @@ impl BusProperties for DeactivateEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -549,7 +549,7 @@ impl BusProperties for RaiseEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -567,7 +567,7 @@ impl BusProperties for LowerEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -585,7 +585,7 @@ impl BusProperties for MoveEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -603,7 +603,7 @@ impl BusProperties for ResizeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -621,7 +621,7 @@ impl BusProperties for ShadeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -639,7 +639,7 @@ impl BusProperties for UUshadeEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
@@ -657,7 +657,7 @@ impl BusProperties for RestyleEvent {
 
 	type Body = EventBodyOwned;
 
-	fn build(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
+	fn from_message_parts(item: ObjectRef, _body: Self::Body) -> Result<Self, AtspiError> {
 		Ok(Self { item })
 	}
 	fn body(&self) -> Self::Body {
diff --git a/atspi-common/src/macros.rs b/atspi-common/src/macros.rs
index 1f2599e5..2d693649 100644
--- a/atspi-common/src/macros.rs
+++ b/atspi-common/src/macros.rs
@@ -246,7 +246,7 @@ macro_rules! impl_to_dbus_message {
 ///         msg.header().member().unwrap(),
 ///         StateChangedEvent::DBUS_MEMBER)));
 ///     }
-///     StateChangedEvent::build(msg.try_into()?, msg.body().deserialize::<StateChangedEvent::Body>()?)
+///     StateChangedEvent::from_message_parts(msg.try_into()?, msg.body().deserialize::<StateChangedEvent::Body>()?)
 ///  }
 /// }
 /// ```
@@ -274,7 +274,7 @@ macro_rules! impl_from_dbus_message {
 						<$type as BusProperties>::DBUS_MEMBER
 					)));
 				}
-				<$type>::build(
+				<$type>::from_message_parts(
 					msg.try_into()?,
 					msg.body().deserialize::<<$type as BusProperties>::Body>()?,
 				)
@@ -287,13 +287,13 @@ macro_rules! impl_from_dbus_message {
 // This prevents Clippy from complaining about the macro not being used.
 // It is being used, but only in test mode.
 //
-/// Tests `Default` and `BusProperties::build` for a given event struct.
+/// Tests `Default` and `BusProperties::from_message_parts` for a given event struct.
 ///
 /// Obtains a default for the given event struct.
 /// Asserts that the path and sender are the default.
 ///
 /// Breaks the struct down into item (the associated object) and body.
-/// Then tests `BusProperties::build` with the item and body.
+/// Then tests `BusProperties::from_message_parts` with the item and body.
 #[cfg(test)]
 macro_rules! generic_event_test_case {
 	($type:ty) => {
@@ -304,7 +304,7 @@ macro_rules! generic_event_test_case {
 			assert_eq!(struct_event.sender().as_str(), ":0.0");
 			let item = struct_event.item.clone();
 			let body = struct_event.body();
-			let build_struct = <$type>::build(item, body)
+			let build_struct = <$type>::from_message_parts(item, body)
 				.expect("<$type as Default>'s parts should build a valid ObjectRef");
 			assert_eq!(struct_event, build_struct);
 		}

From a648d1511c5501342708e7eaa063af8852fafd71 Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Sun, 28 Apr 2024 18:41:53 +0200
Subject: [PATCH 32/37] Obtain an `AccessibleProxy` from any `ObjectRef` with
 `ObjectRefExt`

All objects in any server's tree implements the `Accessible` interface.

Bringing `ObjectRefExt` into scope allows users to call `as_accessible_proxy`
on any `ObjectRef` to obtain an `AccessibleProxy` from the `ObjectRef`.
---
 atspi-proxies/src/accessible.rs | 34 +++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/atspi-proxies/src/accessible.rs b/atspi-proxies/src/accessible.rs
index a78b398f..1e7eee99 100644
--- a/atspi-proxies/src/accessible.rs
+++ b/atspi-proxies/src/accessible.rs
@@ -238,6 +238,7 @@ impl TryFrom<AccessibleProxy<'_>> for ObjectRef {
 		})
 	}
 }
+
 impl TryFrom<&AccessibleProxy<'_>> for ObjectRef {
 	type Error = AtspiError;
 	fn try_from(proxy: &AccessibleProxy<'_>) -> Result<ObjectRef, Self::Error> {
@@ -248,6 +249,39 @@ impl TryFrom<&AccessibleProxy<'_>> for ObjectRef {
 	}
 }
 
+pub trait ObjectRefExt {
+	type Error;
+
+	/// Returns an [`AccessibleProxy`], the handle to the object's  `Accessible` interface.
+	///
+	/// # Errors  
+	///
+	/// `BusName` or `ObjectPath` are assumed to be valid because they are obtained from a valid `ObjectRef`.
+	/// If the builder is lacking the necessary parameters to build a proxy. See [`zbus::ProxyBuilder::build`].
+	/// If this method fails, you may want to check the `AccessibleProxy` default values for missing / invalid parameters.
+	fn as_accessible_proxy(
+		&self,
+		conn: &zbus::Connection,
+	) -> Result<AccessibleProxy<'_>, Self::Error>;
+}
+
+impl ObjectRefExt for ObjectRef {
+	type Error = AtspiError;
+
+	fn as_accessible_proxy(
+		&self,
+		conn: &zbus::Connection,
+	) -> Result<AccessibleProxy<'_>, Self::Error> {
+		Ok(zbus::block_on(async {
+			AccessibleProxy::builder(conn)
+				.destination(self.name.as_str())?
+				.path(self.path.as_str())?
+				.build()
+				.await
+		})?)
+	}
+}
+
 impl PartialEq for AccessibleProxy<'_> {
 	fn eq<'a>(&self, other: &Self) -> bool {
 		self.inner().path() == other.inner().path()

From d8a2698662ad8ac201b666efe109f3c24f3205d3 Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Mon, 29 Apr 2024 13:07:14 +0200
Subject: [PATCH 33/37] Changes implementation to an async trait

---
 atspi-proxies/src/accessible.rs | 36 +++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/atspi-proxies/src/accessible.rs b/atspi-proxies/src/accessible.rs
index 1e7eee99..1fa1a38c 100644
--- a/atspi-proxies/src/accessible.rs
+++ b/atspi-proxies/src/accessible.rs
@@ -249,9 +249,8 @@ impl TryFrom<&AccessibleProxy<'_>> for ObjectRef {
 	}
 }
 
-pub trait ObjectRefExt {
-	type Error;
-
+#[allow(dead_code)]
+trait ObjectRefExt {
 	/// Returns an [`AccessibleProxy`], the handle to the object's  `Accessible` interface.
 	///
 	/// # Errors  
@@ -259,26 +258,33 @@ pub trait ObjectRefExt {
 	/// `BusName` or `ObjectPath` are assumed to be valid because they are obtained from a valid `ObjectRef`.
 	/// If the builder is lacking the necessary parameters to build a proxy. See [`zbus::ProxyBuilder::build`].
 	/// If this method fails, you may want to check the `AccessibleProxy` default values for missing / invalid parameters.
-	fn as_accessible_proxy(
+	async fn as_accessible_proxy(
 		&self,
 		conn: &zbus::Connection,
-	) -> Result<AccessibleProxy<'_>, Self::Error>;
+	) -> impl std::future::Future<Output = Result<AccessibleProxy<'_>, zbus::Error>>;
 }
 
 impl ObjectRefExt for ObjectRef {
-	type Error = AtspiError;
-
-	fn as_accessible_proxy(
+	async fn as_accessible_proxy(
 		&self,
 		conn: &zbus::Connection,
-	) -> Result<AccessibleProxy<'_>, Self::Error> {
-		Ok(zbus::block_on(async {
-			AccessibleProxy::builder(conn)
-				.destination(self.name.as_str())?
-				.path(self.path.as_str())?
+	) -> impl std::future::Future<Output = Result<AccessibleProxy<'_>, zbus::Error>> {
+		let builder = AccessibleProxy::builder(conn).destination(self.name.as_str());
+		let Ok(builder) = builder else {
+			return std::future::ready(Err(builder.unwrap_err()));
+		};
+
+		let builder = builder.path(self.path.as_str());
+		let Ok(builder) = builder else {
+			return std::future::ready(Err(builder.unwrap_err()));
+		};
+
+		std::future::ready(
+			builder
+				.cache_properties(zbus::proxy::CacheProperties::No)
 				.build()
-				.await
-		})?)
+				.await,
+		)
 	}
 }
 

From 4b839403123ec976553c03c6d7c6bf0e90c58655 Mon Sep 17 00:00:00 2001
From: Luuk van der Duim <luukvanderduim@gmail.com>
Date: Mon, 29 Apr 2024 14:16:54 +0200
Subject: [PATCH 34/37] Making the trait public

Makes the trait public
In the trait definition, adds the send bound
in the impl, resuggars the impl
---
 atspi-proxies/src/accessible.rs | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/atspi-proxies/src/accessible.rs b/atspi-proxies/src/accessible.rs
index 1fa1a38c..7d58e16e 100644
--- a/atspi-proxies/src/accessible.rs
+++ b/atspi-proxies/src/accessible.rs
@@ -249,8 +249,7 @@ impl TryFrom<&AccessibleProxy<'_>> for ObjectRef {
 	}
 }
 
-#[allow(dead_code)]
-trait ObjectRefExt {
+pub trait ObjectRefExt {
 	/// Returns an [`AccessibleProxy`], the handle to the object's  `Accessible` interface.
 	///
 	/// # Errors  
@@ -258,33 +257,31 @@ trait ObjectRefExt {
 	/// `BusName` or `ObjectPath` are assumed to be valid because they are obtained from a valid `ObjectRef`.
 	/// If the builder is lacking the necessary parameters to build a proxy. See [`zbus::ProxyBuilder::build`].
 	/// If this method fails, you may want to check the `AccessibleProxy` default values for missing / invalid parameters.
-	async fn as_accessible_proxy(
+	fn as_accessible_proxy(
 		&self,
 		conn: &zbus::Connection,
-	) -> impl std::future::Future<Output = Result<AccessibleProxy<'_>, zbus::Error>>;
+	) -> impl std::future::Future<Output = Result<AccessibleProxy<'_>, zbus::Error>> + Send;
 }
 
 impl ObjectRefExt for ObjectRef {
 	async fn as_accessible_proxy(
 		&self,
 		conn: &zbus::Connection,
-	) -> impl std::future::Future<Output = Result<AccessibleProxy<'_>, zbus::Error>> {
+	) -> Result<AccessibleProxy<'_>, zbus::Error> {
 		let builder = AccessibleProxy::builder(conn).destination(self.name.as_str());
 		let Ok(builder) = builder else {
-			return std::future::ready(Err(builder.unwrap_err()));
+			return Err(builder.unwrap_err());
 		};
 
 		let builder = builder.path(self.path.as_str());
 		let Ok(builder) = builder else {
-			return std::future::ready(Err(builder.unwrap_err()));
+			return Err(builder.unwrap_err());
 		};
 
-		std::future::ready(
-			builder
-				.cache_properties(zbus::proxy::CacheProperties::No)
-				.build()
-				.await,
-		)
+		builder
+			.cache_properties(zbus::proxy::CacheProperties::No)
+			.build()
+			.await
 	}
 }
 

From ac8ece0c9c4f7b8990b922054d9779fac2a611d4 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Tue, 21 May 2024 13:52:55 -0600
Subject: [PATCH 35/37] default_features -> default-features

---
 atspi-proxies/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/atspi-proxies/Cargo.toml b/atspi-proxies/Cargo.toml
index dafdc543..dcf0dc7d 100644
--- a/atspi-proxies/Cargo.toml
+++ b/atspi-proxies/Cargo.toml
@@ -35,7 +35,7 @@ byteorder = "1.4"
 futures-lite = { version = "2", default-features = false }
 rename-item = "0.1.0"
 serde_json = "1.0.96"
-tokio = { version = "1", default_features = false, features = ["macros", "rt-multi-thread"] }
+tokio = { version = "1", default-features = false, features = ["macros", "rt-multi-thread"] }
 tokio-stream = "0.1"
 tokio-test = "0.4.2"
 tracing = "0.1.37"

From 6c5ace0eae9a0867b6b6b9f1b339aff36f03269b Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Tue, 21 May 2024 13:56:32 -0600
Subject: [PATCH 36/37] Feature gate additional impls behind the 'strum' flag;
 make strum a dev-dep

fmt
---
 atspi-common/Cargo.toml           |  1 +
 atspi-common/src/events/mod.rs    |  1 +
 atspi-common/src/events/object.rs | 10 +++++++---
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/atspi-common/Cargo.toml b/atspi-common/Cargo.toml
index f66d5fcf..f1a05ed3 100644
--- a/atspi-common/Cargo.toml
+++ b/atspi-common/Cargo.toml
@@ -35,6 +35,7 @@ atspi-connection = { path = "../atspi-connection" }
 atspi-proxies = { path = "../atspi-proxies" }
 rename-item = "0.1.0"
 serde_plain = "1.0.1"
+strum = { version = "0.26", features = ["derive"] }
 tokio-stream = { version = "0.1", default-features = false, features = ["time"] }
 tokio = { version = "1", default-features = false, features = ["macros", "rt-multi-thread"] }
 tokio-test = "0.4.2"
diff --git a/atspi-common/src/events/mod.rs b/atspi-common/src/events/mod.rs
index ccb28312..0a1d2d07 100644
--- a/atspi-common/src/events/mod.rs
+++ b/atspi-common/src/events/mod.rs
@@ -227,6 +227,7 @@ pub enum Event {
 	Listener(EventListenerEvents),
 }
 
+#[cfg(feature = "strum")]
 impl EventTypeProperties for Event {
 	fn member(&self) -> &'static str {
 		match self {
diff --git a/atspi-common/src/events/object.rs b/atspi-common/src/events/object.rs
index 484b8727..89e5ae47 100644
--- a/atspi-common/src/events/object.rs
+++ b/atspi-common/src/events/object.rs
@@ -1,10 +1,10 @@
-#[cfg(feature = "strum")]
-use crate::Live;
 use crate::{
 	error::AtspiError,
 	events::{BusProperties, EventBodyOwned, HasMatchRule, HasRegistryEventString, ObjectRef},
-	Event, EventProperties, EventTypeProperties, State,
+	Event, EventProperties, State,
 };
+#[cfg(feature = "strum")]
+use crate::{EventTypeProperties, Live};
 use zbus_names::BusName;
 use zvariant::{ObjectPath, OwnedValue, Value};
 
@@ -56,6 +56,7 @@ pub enum ObjectEvents {
 	TextCaretMoved(TextCaretMovedEvent),
 }
 
+#[cfg(feature = "strum")]
 impl EventTypeProperties for ObjectEvents {
 	fn member(&self) -> &'static str {
 		match self {
@@ -1042,6 +1043,7 @@ impl_try_from_event_for_user_facing_type!(
 	Event::Object
 );
 
+#[cfg(feature = "strum")]
 event_test_cases!(PropertyChangeEvent);
 impl_to_dbus_message!(PropertyChangeEvent);
 impl_from_dbus_message!(PropertyChangeEvent);
@@ -1124,6 +1126,7 @@ impl_try_from_event_for_user_facing_type!(
 	ObjectEvents::StateChanged,
 	Event::Object
 );
+#[cfg(feature = "strum")]
 event_test_cases!(StateChangedEvent);
 impl_to_dbus_message!(StateChangedEvent);
 impl_from_dbus_message!(StateChangedEvent);
@@ -1297,6 +1300,7 @@ impl_try_from_event_for_user_facing_type!(
 	ObjectEvents::Announcement,
 	Event::Object
 );
+#[cfg(feature = "strum")]
 event_test_cases!(AnnouncementEvent);
 impl_to_dbus_message!(AnnouncementEvent);
 impl_from_dbus_message!(AnnouncementEvent);

From 682afee0d354ed5b0ec6267c05e036b6d2d9f4b7 Mon Sep 17 00:00:00 2001
From: Tait Hoyem <tait@tait.tech>
Date: Tue, 21 May 2024 14:01:06 -0600
Subject: [PATCH 37/37] Remove zbus flag in favour of re-exporting zbus if
 either runtime is specified

d
---
 atspi/Cargo.toml | 5 +++--
 atspi/src/lib.rs | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/atspi/Cargo.toml b/atspi/Cargo.toml
index 061f78d4..e84e6991 100644
--- a/atspi/Cargo.toml
+++ b/atspi/Cargo.toml
@@ -17,8 +17,8 @@ include = ["src/**/*", "LICENSE-*", "README.md"]
 
 [features]
 default = ["async-std"]
-async-std = ["proxies-async-std", "connection-async-std"]
-tokio = ["proxies-tokio", "connection-tokio"]
+async-std = ["proxies-async-std", "connection-async-std", "dep:zbus"]
+tokio = ["proxies-tokio", "connection-tokio", "dep:zbus"]
 
 proxies = []
 proxies-async-std = ["atspi-proxies/async-std", "proxies"]
@@ -32,6 +32,7 @@ tracing = ["atspi-connection/tracing"]
 atspi-common = { path = "../atspi-common", version = "0.5.0", default-features = false }
 atspi-connection = { path = "../atspi-connection", version = "0.5.0", default-features = false, optional = true }
 atspi-proxies = { path = "../atspi-proxies", version = "0.5.0", default-features = false, optional = true }
+zbus = { workspace = true, optional = true }
 
 [[bench]]
 name = "event_parsing"
diff --git a/atspi/src/lib.rs b/atspi/src/lib.rs
index 25aa674b..aff50bda 100644
--- a/atspi/src/lib.rs
+++ b/atspi/src/lib.rs
@@ -20,5 +20,5 @@ pub use atspi_connection as connection;
 #[cfg(feature = "connection")]
 pub use connection::AccessibilityConnection;
 
-#[cfg(feature = "zbus")]
+#[cfg(any(feature = "async-std", feature = "tokio"))]
 pub use zbus;