1use crate::{
6 ffi, AsyncInitable, AsyncResult, BusType, Cancellable, DBusConnection, DBusObjectManager,
7 DBusObjectManagerClientFlags, DBusObjectProxy, DBusProxy, Initable,
8};
9use glib::{
10 object::ObjectType as _,
11 prelude::*,
12 signal::{connect_raw, SignalHandlerId},
13 translate::*,
14};
15use std::boxed::Box as Box_;
16
17glib::wrapper! {
18 #[doc(alias = "GDBusObjectManagerClient")]
19 pub struct DBusObjectManagerClient(Object<ffi::GDBusObjectManagerClient, ffi::GDBusObjectManagerClientClass>) @implements AsyncInitable, DBusObjectManager, Initable;
20
21 match fn {
22 type_ => || ffi::g_dbus_object_manager_client_get_type(),
23 }
24}
25
26impl DBusObjectManagerClient {
27 pub const NONE: Option<&'static DBusObjectManagerClient> = None;
28
29 #[doc(alias = "g_dbus_object_manager_client_new_for_bus_sync")]
30 #[doc(alias = "new_for_bus_sync")]
31 #[allow(dead_code)]
32 pub(crate) fn for_bus_sync_impl(
33 bus_type: BusType,
34 flags: DBusObjectManagerClientFlags,
35 name: &str,
36 object_path: &str,
37 get_proxy_type_func: Option<
38 Box_<
39 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type + 'static,
40 >,
41 >,
42 cancellable: Option<&impl IsA<Cancellable>>,
43 ) -> Result<DBusObjectManagerClient, glib::Error> {
44 let get_proxy_type_func_data: Box_<
45 Option<
46 Box_<
47 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
48 + 'static,
49 >,
50 >,
51 > = Box_::new(get_proxy_type_func);
52 unsafe extern "C" fn get_proxy_type_func_func(
53 manager: *mut ffi::GDBusObjectManagerClient,
54 object_path: *const std::ffi::c_char,
55 interface_name: *const std::ffi::c_char,
56 data: glib::ffi::gpointer,
57 ) -> glib::ffi::GType {
58 let manager = from_glib_borrow(manager);
59 let object_path: Borrowed<glib::GString> = from_glib_borrow(object_path);
60 let interface_name: Borrowed<Option<glib::GString>> = from_glib_borrow(interface_name);
61 let callback = &*(data as *mut Option<
62 Box_<
63 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
64 + 'static,
65 >,
66 >);
67 if let Some(ref callback) = *callback {
68 callback(
69 &manager,
70 object_path.as_str(),
71 (*interface_name).as_ref().map(|s| s.as_str()),
72 )
73 } else {
74 panic!("cannot get closure...")
75 }
76 .into_glib()
77 }
78 let get_proxy_type_func = if get_proxy_type_func_data.is_some() {
79 Some(get_proxy_type_func_func as _)
80 } else {
81 None
82 };
83 unsafe extern "C" fn get_proxy_type_destroy_notify_func(data: glib::ffi::gpointer) {
84 let _callback = Box_::from_raw(
85 data as *mut Option<
86 Box_<
87 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
88 + 'static,
89 >,
90 >,
91 );
92 }
93 let destroy_call6 = Some(get_proxy_type_destroy_notify_func as _);
94 let super_callback0: Box_<
95 Option<
96 Box_<
97 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
98 + 'static,
99 >,
100 >,
101 > = get_proxy_type_func_data;
102 unsafe {
103 let mut error = std::ptr::null_mut();
104 let ret = ffi::g_dbus_object_manager_client_new_for_bus_sync(
105 bus_type.into_glib(),
106 flags.into_glib(),
107 name.to_glib_none().0,
108 object_path.to_glib_none().0,
109 get_proxy_type_func,
110 Box_::into_raw(super_callback0) as *mut _,
111 destroy_call6,
112 cancellable.map(|p| p.as_ref()).to_glib_none().0,
113 &mut error,
114 );
115 if error.is_null() {
116 Ok(from_glib_full(ret))
117 } else {
118 Err(from_glib_full(error))
119 }
120 }
121 }
122
123 #[doc(alias = "g_dbus_object_manager_client_new_sync")]
124 #[doc(alias = "new_sync")]
125 #[allow(dead_code)]
126 pub(crate) fn new_sync_impl(
127 connection: &DBusConnection,
128 flags: DBusObjectManagerClientFlags,
129 name: Option<&str>,
130 object_path: &str,
131 get_proxy_type_func: Option<
132 Box_<
133 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type + 'static,
134 >,
135 >,
136 cancellable: Option<&impl IsA<Cancellable>>,
137 ) -> Result<DBusObjectManagerClient, glib::Error> {
138 let get_proxy_type_func_data: Box_<
139 Option<
140 Box_<
141 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
142 + 'static,
143 >,
144 >,
145 > = Box_::new(get_proxy_type_func);
146 unsafe extern "C" fn get_proxy_type_func_func(
147 manager: *mut ffi::GDBusObjectManagerClient,
148 object_path: *const std::ffi::c_char,
149 interface_name: *const std::ffi::c_char,
150 data: glib::ffi::gpointer,
151 ) -> glib::ffi::GType {
152 let manager = from_glib_borrow(manager);
153 let object_path: Borrowed<glib::GString> = from_glib_borrow(object_path);
154 let interface_name: Borrowed<Option<glib::GString>> = from_glib_borrow(interface_name);
155 let callback = &*(data as *mut Option<
156 Box_<
157 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
158 + 'static,
159 >,
160 >);
161 if let Some(ref callback) = *callback {
162 callback(
163 &manager,
164 object_path.as_str(),
165 (*interface_name).as_ref().map(|s| s.as_str()),
166 )
167 } else {
168 panic!("cannot get closure...")
169 }
170 .into_glib()
171 }
172 let get_proxy_type_func = if get_proxy_type_func_data.is_some() {
173 Some(get_proxy_type_func_func as _)
174 } else {
175 None
176 };
177 unsafe extern "C" fn get_proxy_type_destroy_notify_func(data: glib::ffi::gpointer) {
178 let _callback = Box_::from_raw(
179 data as *mut Option<
180 Box_<
181 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
182 + 'static,
183 >,
184 >,
185 );
186 }
187 let destroy_call6 = Some(get_proxy_type_destroy_notify_func as _);
188 let super_callback0: Box_<
189 Option<
190 Box_<
191 dyn Fn(&DBusObjectManagerClient, &str, Option<&str>) -> glib::types::Type
192 + 'static,
193 >,
194 >,
195 > = get_proxy_type_func_data;
196 unsafe {
197 let mut error = std::ptr::null_mut();
198 let ret = ffi::g_dbus_object_manager_client_new_sync(
199 connection.to_glib_none().0,
200 flags.into_glib(),
201 name.to_glib_none().0,
202 object_path.to_glib_none().0,
203 get_proxy_type_func,
204 Box_::into_raw(super_callback0) as *mut _,
205 destroy_call6,
206 cancellable.map(|p| p.as_ref()).to_glib_none().0,
207 &mut error,
208 );
209 if error.is_null() {
210 Ok(from_glib_full(ret))
211 } else {
212 Err(from_glib_full(error))
213 }
214 }
215 }
216}
217
218impl std::fmt::Display for DBusObjectManagerClient {
219 #[inline]
220 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
221 f.write_str(&DBusObjectManagerClientExt::name(self))
222 }
223}
224
225unsafe impl Send for DBusObjectManagerClient {}
226unsafe impl Sync for DBusObjectManagerClient {}
227
228pub trait DBusObjectManagerClientExt: IsA<DBusObjectManagerClient> + 'static {
229 #[doc(alias = "g_dbus_object_manager_client_get_connection")]
230 #[doc(alias = "get_connection")]
231 fn connection(&self) -> DBusConnection {
232 unsafe {
233 from_glib_none(ffi::g_dbus_object_manager_client_get_connection(
234 self.as_ref().to_glib_none().0,
235 ))
236 }
237 }
238
239 #[doc(alias = "g_dbus_object_manager_client_get_flags")]
240 #[doc(alias = "get_flags")]
241 fn flags(&self) -> DBusObjectManagerClientFlags {
242 unsafe {
243 from_glib(ffi::g_dbus_object_manager_client_get_flags(
244 self.as_ref().to_glib_none().0,
245 ))
246 }
247 }
248
249 #[doc(alias = "g_dbus_object_manager_client_get_name")]
250 #[doc(alias = "get_name")]
251 fn name(&self) -> glib::GString {
252 unsafe {
253 from_glib_none(ffi::g_dbus_object_manager_client_get_name(
254 self.as_ref().to_glib_none().0,
255 ))
256 }
257 }
258
259 #[doc(alias = "g_dbus_object_manager_client_get_name_owner")]
260 #[doc(alias = "get_name_owner")]
261 #[doc(alias = "name-owner")]
262 fn name_owner(&self) -> Option<glib::GString> {
263 unsafe {
264 from_glib_full(ffi::g_dbus_object_manager_client_get_name_owner(
265 self.as_ref().to_glib_none().0,
266 ))
267 }
268 }
269
270 #[doc(alias = "interface-proxy-signal")]
271 fn connect_interface_proxy_signal<
272 F: Fn(&Self, &DBusObjectProxy, &DBusProxy, &str, &str, &glib::Variant) + Send + Sync + 'static,
273 >(
274 &self,
275 f: F,
276 ) -> SignalHandlerId {
277 unsafe extern "C" fn interface_proxy_signal_trampoline<
278 P: IsA<DBusObjectManagerClient>,
279 F: Fn(&P, &DBusObjectProxy, &DBusProxy, &str, &str, &glib::Variant)
280 + Send
281 + Sync
282 + 'static,
283 >(
284 this: *mut ffi::GDBusObjectManagerClient,
285 object_proxy: *mut ffi::GDBusObjectProxy,
286 interface_proxy: *mut ffi::GDBusProxy,
287 sender_name: *mut std::ffi::c_char,
288 signal_name: *mut std::ffi::c_char,
289 parameters: *mut glib::ffi::GVariant,
290 f: glib::ffi::gpointer,
291 ) {
292 let f: &F = &*(f as *const F);
293 f(
294 DBusObjectManagerClient::from_glib_borrow(this).unsafe_cast_ref(),
295 &from_glib_borrow(object_proxy),
296 &from_glib_borrow(interface_proxy),
297 &glib::GString::from_glib_borrow(sender_name),
298 &glib::GString::from_glib_borrow(signal_name),
299 &from_glib_borrow(parameters),
300 )
301 }
302 unsafe {
303 let f: Box_<F> = Box_::new(f);
304 connect_raw(
305 self.as_ptr() as *mut _,
306 c"interface-proxy-signal".as_ptr() as *const _,
307 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
308 interface_proxy_signal_trampoline::<Self, F> as *const (),
309 )),
310 Box_::into_raw(f),
311 )
312 }
313 }
314
315 #[doc(alias = "name-owner")]
316 fn connect_name_owner_notify<F: Fn(&Self) + Send + Sync + 'static>(
317 &self,
318 f: F,
319 ) -> SignalHandlerId {
320 unsafe extern "C" fn notify_name_owner_trampoline<
321 P: IsA<DBusObjectManagerClient>,
322 F: Fn(&P) + Send + Sync + 'static,
323 >(
324 this: *mut ffi::GDBusObjectManagerClient,
325 _param_spec: glib::ffi::gpointer,
326 f: glib::ffi::gpointer,
327 ) {
328 let f: &F = &*(f as *const F);
329 f(DBusObjectManagerClient::from_glib_borrow(this).unsafe_cast_ref())
330 }
331 unsafe {
332 let f: Box_<F> = Box_::new(f);
333 connect_raw(
334 self.as_ptr() as *mut _,
335 c"notify::name-owner".as_ptr() as *const _,
336 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
337 notify_name_owner_trampoline::<Self, F> as *const (),
338 )),
339 Box_::into_raw(f),
340 )
341 }
342 }
343}
344
345impl<O: IsA<DBusObjectManagerClient>> DBusObjectManagerClientExt for O {}