1use crate::{
6 ActionGroup, ActionMap, ApplicationFlags, Cancellable, DBusConnection, File, Notification, ffi,
7};
8use glib::{
9 object::ObjectType as _,
10 prelude::*,
11 signal::{SignalHandlerId, connect_raw},
12 translate::*,
13};
14use std::boxed::Box as Box_;
15
16glib::wrapper! {
17 #[doc(alias = "GApplication")]
18 pub struct Application(Object<ffi::GApplication, ffi::GApplicationClass>) @implements ActionGroup, ActionMap;
19
20 match fn {
21 type_ => || ffi::g_application_get_type(),
22 }
23}
24
25impl Application {
26 pub const NONE: Option<&'static Application> = None;
27
28 #[doc(alias = "g_application_new")]
29 pub fn new(application_id: Option<&str>, flags: ApplicationFlags) -> Application {
30 unsafe {
31 from_glib_full(ffi::g_application_new(
32 application_id.to_glib_none().0,
33 flags.into_glib(),
34 ))
35 }
36 }
37
38 pub fn builder() -> ApplicationBuilder {
43 ApplicationBuilder::new()
44 }
45
46 #[doc(alias = "g_application_get_default")]
47 #[doc(alias = "get_default")]
48 #[allow(clippy::should_implement_trait)]
49 pub fn default() -> Option<Application> {
50 unsafe { from_glib_none(ffi::g_application_get_default()) }
51 }
52
53 #[doc(alias = "g_application_id_is_valid")]
54 pub fn id_is_valid(application_id: &str) -> bool {
55 unsafe {
56 from_glib(ffi::g_application_id_is_valid(
57 application_id.to_glib_none().0,
58 ))
59 }
60 }
61}
62
63impl Default for Application {
64 fn default() -> Self {
65 glib::object::Object::new::<Self>()
66 }
67}
68
69#[must_use = "The builder must be built to be used"]
74pub struct ApplicationBuilder {
75 builder: glib::object::ObjectBuilder<'static, Application>,
76}
77
78impl ApplicationBuilder {
79 fn new() -> Self {
80 Self {
81 builder: glib::object::Object::builder(),
82 }
83 }
84
85 pub fn application_id(self, application_id: impl Into<glib::GString>) -> Self {
86 Self {
87 builder: self
88 .builder
89 .property("application-id", application_id.into()),
90 }
91 }
92
93 pub fn flags(self, flags: ApplicationFlags) -> Self {
94 Self {
95 builder: self.builder.property("flags", flags),
96 }
97 }
98
99 pub fn inactivity_timeout(self, inactivity_timeout: u32) -> Self {
100 Self {
101 builder: self
102 .builder
103 .property("inactivity-timeout", inactivity_timeout),
104 }
105 }
106
107 pub fn resource_base_path(self, resource_base_path: impl Into<glib::GString>) -> Self {
108 Self {
109 builder: self
110 .builder
111 .property("resource-base-path", resource_base_path.into()),
112 }
113 }
114
115 #[cfg(feature = "v2_80")]
116 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
117 pub fn version(self, version: impl Into<glib::GString>) -> Self {
118 Self {
119 builder: self.builder.property("version", version.into()),
120 }
121 }
122
123 #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
126 pub fn build(self) -> Application {
127 self.builder.build()
128 }
129}
130
131pub trait ApplicationExt: IsA<Application> + 'static {
132 #[doc(alias = "g_application_activate")]
133 fn activate(&self) {
134 unsafe {
135 ffi::g_application_activate(self.as_ref().to_glib_none().0);
136 }
137 }
138
139 #[doc(alias = "g_application_add_main_option")]
140 fn add_main_option(
141 &self,
142 long_name: &str,
143 short_name: glib::Char,
144 flags: glib::OptionFlags,
145 arg: glib::OptionArg,
146 description: &str,
147 arg_description: Option<&str>,
148 ) {
149 unsafe {
150 ffi::g_application_add_main_option(
151 self.as_ref().to_glib_none().0,
152 long_name.to_glib_none().0,
153 short_name.into_glib(),
154 flags.into_glib(),
155 arg.into_glib(),
156 description.to_glib_none().0,
157 arg_description.to_glib_none().0,
158 );
159 }
160 }
161
162 #[doc(alias = "g_application_bind_busy_property")]
173 fn bind_busy_property(&self, object: &impl IsA<glib::Object>, property: &str) {
174 unsafe {
175 ffi::g_application_bind_busy_property(
176 self.as_ref().to_glib_none().0,
177 object.as_ref().to_glib_none().0,
178 property.to_glib_none().0,
179 );
180 }
181 }
182
183 #[doc(alias = "g_application_get_application_id")]
184 #[doc(alias = "get_application_id")]
185 #[doc(alias = "application-id")]
186 fn application_id(&self) -> Option<glib::GString> {
187 unsafe {
188 from_glib_none(ffi::g_application_get_application_id(
189 self.as_ref().to_glib_none().0,
190 ))
191 }
192 }
193
194 #[doc(alias = "g_application_get_dbus_connection")]
195 #[doc(alias = "get_dbus_connection")]
196 fn dbus_connection(&self) -> Option<DBusConnection> {
197 unsafe {
198 from_glib_none(ffi::g_application_get_dbus_connection(
199 self.as_ref().to_glib_none().0,
200 ))
201 }
202 }
203
204 #[doc(alias = "g_application_get_dbus_object_path")]
205 #[doc(alias = "get_dbus_object_path")]
206 fn dbus_object_path(&self) -> Option<glib::GString> {
207 unsafe {
208 from_glib_none(ffi::g_application_get_dbus_object_path(
209 self.as_ref().to_glib_none().0,
210 ))
211 }
212 }
213
214 #[doc(alias = "g_application_get_flags")]
215 #[doc(alias = "get_flags")]
216 fn flags(&self) -> ApplicationFlags {
217 unsafe { from_glib(ffi::g_application_get_flags(self.as_ref().to_glib_none().0)) }
218 }
219
220 #[doc(alias = "g_application_get_inactivity_timeout")]
221 #[doc(alias = "get_inactivity_timeout")]
222 #[doc(alias = "inactivity-timeout")]
223 fn inactivity_timeout(&self) -> u32 {
224 unsafe { ffi::g_application_get_inactivity_timeout(self.as_ref().to_glib_none().0) }
225 }
226
227 #[doc(alias = "g_application_get_is_busy")]
228 #[doc(alias = "get_is_busy")]
229 #[doc(alias = "is-busy")]
230 fn is_busy(&self) -> bool {
231 unsafe {
232 from_glib(ffi::g_application_get_is_busy(
233 self.as_ref().to_glib_none().0,
234 ))
235 }
236 }
237
238 #[doc(alias = "g_application_get_is_registered")]
239 #[doc(alias = "get_is_registered")]
240 #[doc(alias = "is-registered")]
241 fn is_registered(&self) -> bool {
242 unsafe {
243 from_glib(ffi::g_application_get_is_registered(
244 self.as_ref().to_glib_none().0,
245 ))
246 }
247 }
248
249 #[doc(alias = "g_application_get_is_remote")]
250 #[doc(alias = "get_is_remote")]
251 #[doc(alias = "is-remote")]
252 fn is_remote(&self) -> bool {
253 unsafe {
254 from_glib(ffi::g_application_get_is_remote(
255 self.as_ref().to_glib_none().0,
256 ))
257 }
258 }
259
260 #[doc(alias = "g_application_get_resource_base_path")]
261 #[doc(alias = "get_resource_base_path")]
262 #[doc(alias = "resource-base-path")]
263 fn resource_base_path(&self) -> Option<glib::GString> {
264 unsafe {
265 from_glib_none(ffi::g_application_get_resource_base_path(
266 self.as_ref().to_glib_none().0,
267 ))
268 }
269 }
270
271 #[cfg(feature = "v2_80")]
272 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
273 #[doc(alias = "g_application_get_version")]
274 #[doc(alias = "get_version")]
275 fn version(&self) -> Option<glib::GString> {
276 unsafe {
277 from_glib_none(ffi::g_application_get_version(
278 self.as_ref().to_glib_none().0,
279 ))
280 }
281 }
282
283 #[doc(alias = "g_application_open")]
284 fn open(&self, files: &[File], hint: &str) {
285 let n_files = files.len() as _;
286 unsafe {
287 ffi::g_application_open(
288 self.as_ref().to_glib_none().0,
289 files.to_glib_none().0,
290 n_files,
291 hint.to_glib_none().0,
292 );
293 }
294 }
295
296 #[doc(alias = "g_application_quit")]
297 fn quit(&self) {
298 unsafe {
299 ffi::g_application_quit(self.as_ref().to_glib_none().0);
300 }
301 }
302
303 #[doc(alias = "g_application_register")]
304 fn register(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
305 unsafe {
306 let mut error = std::ptr::null_mut();
307 let is_ok = ffi::g_application_register(
308 self.as_ref().to_glib_none().0,
309 cancellable.map(|p| p.as_ref()).to_glib_none().0,
310 &mut error,
311 );
312 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
313 if error.is_null() {
314 Ok(())
315 } else {
316 Err(from_glib_full(error))
317 }
318 }
319 }
320
321 #[doc(alias = "g_application_send_notification")]
322 fn send_notification(&self, id: Option<&str>, notification: &Notification) {
323 unsafe {
324 ffi::g_application_send_notification(
325 self.as_ref().to_glib_none().0,
326 id.to_glib_none().0,
327 notification.to_glib_none().0,
328 );
329 }
330 }
331
332 #[doc(alias = "g_application_set_application_id")]
333 #[doc(alias = "application-id")]
334 fn set_application_id(&self, application_id: Option<&str>) {
335 unsafe {
336 ffi::g_application_set_application_id(
337 self.as_ref().to_glib_none().0,
338 application_id.to_glib_none().0,
339 );
340 }
341 }
342
343 #[doc(alias = "g_application_set_default")]
344 fn set_default(&self) {
345 unsafe {
346 ffi::g_application_set_default(self.as_ref().to_glib_none().0);
347 }
348 }
349
350 #[doc(alias = "g_application_set_flags")]
351 #[doc(alias = "flags")]
352 fn set_flags(&self, flags: ApplicationFlags) {
353 unsafe {
354 ffi::g_application_set_flags(self.as_ref().to_glib_none().0, flags.into_glib());
355 }
356 }
357
358 #[doc(alias = "g_application_set_inactivity_timeout")]
359 #[doc(alias = "inactivity-timeout")]
360 fn set_inactivity_timeout(&self, inactivity_timeout: u32) {
361 unsafe {
362 ffi::g_application_set_inactivity_timeout(
363 self.as_ref().to_glib_none().0,
364 inactivity_timeout,
365 );
366 }
367 }
368
369 #[doc(alias = "g_application_set_option_context_description")]
370 fn set_option_context_description(&self, description: Option<&str>) {
371 unsafe {
372 ffi::g_application_set_option_context_description(
373 self.as_ref().to_glib_none().0,
374 description.to_glib_none().0,
375 );
376 }
377 }
378
379 #[doc(alias = "g_application_set_option_context_parameter_string")]
380 fn set_option_context_parameter_string(&self, parameter_string: Option<&str>) {
381 unsafe {
382 ffi::g_application_set_option_context_parameter_string(
383 self.as_ref().to_glib_none().0,
384 parameter_string.to_glib_none().0,
385 );
386 }
387 }
388
389 #[doc(alias = "g_application_set_option_context_summary")]
390 fn set_option_context_summary(&self, summary: Option<&str>) {
391 unsafe {
392 ffi::g_application_set_option_context_summary(
393 self.as_ref().to_glib_none().0,
394 summary.to_glib_none().0,
395 );
396 }
397 }
398
399 #[doc(alias = "g_application_set_resource_base_path")]
400 #[doc(alias = "resource-base-path")]
401 fn set_resource_base_path(&self, resource_path: Option<&str>) {
402 unsafe {
403 ffi::g_application_set_resource_base_path(
404 self.as_ref().to_glib_none().0,
405 resource_path.to_glib_none().0,
406 );
407 }
408 }
409
410 #[cfg(feature = "v2_80")]
411 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
412 #[doc(alias = "g_application_set_version")]
413 #[doc(alias = "version")]
414 fn set_version(&self, version: &str) {
415 unsafe {
416 ffi::g_application_set_version(
417 self.as_ref().to_glib_none().0,
418 version.to_glib_none().0,
419 );
420 }
421 }
422
423 #[doc(alias = "g_application_unbind_busy_property")]
424 fn unbind_busy_property(&self, object: &impl IsA<glib::Object>, property: &str) {
425 unsafe {
426 ffi::g_application_unbind_busy_property(
427 self.as_ref().to_glib_none().0,
428 object.as_ref().to_glib_none().0,
429 property.to_glib_none().0,
430 );
431 }
432 }
433
434 #[doc(alias = "g_application_withdraw_notification")]
435 fn withdraw_notification(&self, id: &str) {
436 unsafe {
437 ffi::g_application_withdraw_notification(
438 self.as_ref().to_glib_none().0,
439 id.to_glib_none().0,
440 );
441 }
442 }
443
444 #[doc(alias = "activate")]
445 fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
446 unsafe extern "C" fn activate_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
447 this: *mut ffi::GApplication,
448 f: glib::ffi::gpointer,
449 ) {
450 unsafe {
451 let f: &F = &*(f as *const F);
452 f(Application::from_glib_borrow(this).unsafe_cast_ref())
453 }
454 }
455 unsafe {
456 let f: Box_<F> = Box_::new(f);
457 connect_raw(
458 self.as_ptr() as *mut _,
459 c"activate".as_ptr(),
460 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
461 activate_trampoline::<Self, F> as *const (),
462 )),
463 Box_::into_raw(f),
464 )
465 }
466 }
467
468 #[cfg(feature = "v2_60")]
469 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
470 #[doc(alias = "name-lost")]
471 fn connect_name_lost<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
472 unsafe extern "C" fn name_lost_trampoline<
473 P: IsA<Application>,
474 F: Fn(&P) -> bool + 'static,
475 >(
476 this: *mut ffi::GApplication,
477 f: glib::ffi::gpointer,
478 ) -> glib::ffi::gboolean {
479 unsafe {
480 let f: &F = &*(f as *const F);
481 f(Application::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
482 }
483 }
484 unsafe {
485 let f: Box_<F> = Box_::new(f);
486 connect_raw(
487 self.as_ptr() as *mut _,
488 c"name-lost".as_ptr(),
489 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
490 name_lost_trampoline::<Self, F> as *const (),
491 )),
492 Box_::into_raw(f),
493 )
494 }
495 }
496
497 #[doc(alias = "shutdown")]
498 fn connect_shutdown<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
499 unsafe extern "C" fn shutdown_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
500 this: *mut ffi::GApplication,
501 f: glib::ffi::gpointer,
502 ) {
503 unsafe {
504 let f: &F = &*(f as *const F);
505 f(Application::from_glib_borrow(this).unsafe_cast_ref())
506 }
507 }
508 unsafe {
509 let f: Box_<F> = Box_::new(f);
510 connect_raw(
511 self.as_ptr() as *mut _,
512 c"shutdown".as_ptr(),
513 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
514 shutdown_trampoline::<Self, F> as *const (),
515 )),
516 Box_::into_raw(f),
517 )
518 }
519 }
520
521 #[doc(alias = "startup")]
522 fn connect_startup<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
523 unsafe extern "C" fn startup_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
524 this: *mut ffi::GApplication,
525 f: glib::ffi::gpointer,
526 ) {
527 unsafe {
528 let f: &F = &*(f as *const F);
529 f(Application::from_glib_borrow(this).unsafe_cast_ref())
530 }
531 }
532 unsafe {
533 let f: Box_<F> = Box_::new(f);
534 connect_raw(
535 self.as_ptr() as *mut _,
536 c"startup".as_ptr(),
537 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
538 startup_trampoline::<Self, F> as *const (),
539 )),
540 Box_::into_raw(f),
541 )
542 }
543 }
544
545 #[doc(alias = "application-id")]
546 fn connect_application_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
547 unsafe extern "C" fn notify_application_id_trampoline<
548 P: IsA<Application>,
549 F: Fn(&P) + 'static,
550 >(
551 this: *mut ffi::GApplication,
552 _param_spec: glib::ffi::gpointer,
553 f: glib::ffi::gpointer,
554 ) {
555 unsafe {
556 let f: &F = &*(f as *const F);
557 f(Application::from_glib_borrow(this).unsafe_cast_ref())
558 }
559 }
560 unsafe {
561 let f: Box_<F> = Box_::new(f);
562 connect_raw(
563 self.as_ptr() as *mut _,
564 c"notify::application-id".as_ptr(),
565 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
566 notify_application_id_trampoline::<Self, F> as *const (),
567 )),
568 Box_::into_raw(f),
569 )
570 }
571 }
572
573 #[doc(alias = "flags")]
574 fn connect_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
575 unsafe extern "C" fn notify_flags_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
576 this: *mut ffi::GApplication,
577 _param_spec: glib::ffi::gpointer,
578 f: glib::ffi::gpointer,
579 ) {
580 unsafe {
581 let f: &F = &*(f as *const F);
582 f(Application::from_glib_borrow(this).unsafe_cast_ref())
583 }
584 }
585 unsafe {
586 let f: Box_<F> = Box_::new(f);
587 connect_raw(
588 self.as_ptr() as *mut _,
589 c"notify::flags".as_ptr(),
590 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
591 notify_flags_trampoline::<Self, F> as *const (),
592 )),
593 Box_::into_raw(f),
594 )
595 }
596 }
597
598 #[doc(alias = "inactivity-timeout")]
599 fn connect_inactivity_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
600 unsafe extern "C" fn notify_inactivity_timeout_trampoline<
601 P: IsA<Application>,
602 F: Fn(&P) + 'static,
603 >(
604 this: *mut ffi::GApplication,
605 _param_spec: glib::ffi::gpointer,
606 f: glib::ffi::gpointer,
607 ) {
608 unsafe {
609 let f: &F = &*(f as *const F);
610 f(Application::from_glib_borrow(this).unsafe_cast_ref())
611 }
612 }
613 unsafe {
614 let f: Box_<F> = Box_::new(f);
615 connect_raw(
616 self.as_ptr() as *mut _,
617 c"notify::inactivity-timeout".as_ptr(),
618 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
619 notify_inactivity_timeout_trampoline::<Self, F> as *const (),
620 )),
621 Box_::into_raw(f),
622 )
623 }
624 }
625
626 #[doc(alias = "is-busy")]
627 fn connect_is_busy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
628 unsafe extern "C" fn notify_is_busy_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
629 this: *mut ffi::GApplication,
630 _param_spec: glib::ffi::gpointer,
631 f: glib::ffi::gpointer,
632 ) {
633 unsafe {
634 let f: &F = &*(f as *const F);
635 f(Application::from_glib_borrow(this).unsafe_cast_ref())
636 }
637 }
638 unsafe {
639 let f: Box_<F> = Box_::new(f);
640 connect_raw(
641 self.as_ptr() as *mut _,
642 c"notify::is-busy".as_ptr(),
643 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
644 notify_is_busy_trampoline::<Self, F> as *const (),
645 )),
646 Box_::into_raw(f),
647 )
648 }
649 }
650
651 #[doc(alias = "is-registered")]
652 fn connect_is_registered_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
653 unsafe extern "C" fn notify_is_registered_trampoline<
654 P: IsA<Application>,
655 F: Fn(&P) + 'static,
656 >(
657 this: *mut ffi::GApplication,
658 _param_spec: glib::ffi::gpointer,
659 f: glib::ffi::gpointer,
660 ) {
661 unsafe {
662 let f: &F = &*(f as *const F);
663 f(Application::from_glib_borrow(this).unsafe_cast_ref())
664 }
665 }
666 unsafe {
667 let f: Box_<F> = Box_::new(f);
668 connect_raw(
669 self.as_ptr() as *mut _,
670 c"notify::is-registered".as_ptr(),
671 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
672 notify_is_registered_trampoline::<Self, F> as *const (),
673 )),
674 Box_::into_raw(f),
675 )
676 }
677 }
678
679 #[doc(alias = "is-remote")]
680 fn connect_is_remote_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
681 unsafe extern "C" fn notify_is_remote_trampoline<
682 P: IsA<Application>,
683 F: Fn(&P) + 'static,
684 >(
685 this: *mut ffi::GApplication,
686 _param_spec: glib::ffi::gpointer,
687 f: glib::ffi::gpointer,
688 ) {
689 unsafe {
690 let f: &F = &*(f as *const F);
691 f(Application::from_glib_borrow(this).unsafe_cast_ref())
692 }
693 }
694 unsafe {
695 let f: Box_<F> = Box_::new(f);
696 connect_raw(
697 self.as_ptr() as *mut _,
698 c"notify::is-remote".as_ptr(),
699 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
700 notify_is_remote_trampoline::<Self, F> as *const (),
701 )),
702 Box_::into_raw(f),
703 )
704 }
705 }
706
707 #[doc(alias = "resource-base-path")]
708 fn connect_resource_base_path_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
709 unsafe extern "C" fn notify_resource_base_path_trampoline<
710 P: IsA<Application>,
711 F: Fn(&P) + 'static,
712 >(
713 this: *mut ffi::GApplication,
714 _param_spec: glib::ffi::gpointer,
715 f: glib::ffi::gpointer,
716 ) {
717 unsafe {
718 let f: &F = &*(f as *const F);
719 f(Application::from_glib_borrow(this).unsafe_cast_ref())
720 }
721 }
722 unsafe {
723 let f: Box_<F> = Box_::new(f);
724 connect_raw(
725 self.as_ptr() as *mut _,
726 c"notify::resource-base-path".as_ptr(),
727 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
728 notify_resource_base_path_trampoline::<Self, F> as *const (),
729 )),
730 Box_::into_raw(f),
731 )
732 }
733 }
734
735 #[cfg(feature = "v2_80")]
736 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
737 #[doc(alias = "version")]
738 fn connect_version_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
739 unsafe extern "C" fn notify_version_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
740 this: *mut ffi::GApplication,
741 _param_spec: glib::ffi::gpointer,
742 f: glib::ffi::gpointer,
743 ) {
744 unsafe {
745 let f: &F = &*(f as *const F);
746 f(Application::from_glib_borrow(this).unsafe_cast_ref())
747 }
748 }
749 unsafe {
750 let f: Box_<F> = Box_::new(f);
751 connect_raw(
752 self.as_ptr() as *mut _,
753 c"notify::version".as_ptr(),
754 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
755 notify_version_trampoline::<Self, F> as *const (),
756 )),
757 Box_::into_raw(f),
758 )
759 }
760 }
761}
762
763impl<O: IsA<Application>> ApplicationExt for O {}