1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
use crate::Application;
use crate::File;
use glib::prelude::*;
use glib::signal::{connect_raw, SignalHandlerId};
use glib::translate::*;
use glib::GString;
use std::boxed::Box as Box_;
use std::mem::transmute;
pub trait ApplicationExtManual {
#[doc(alias = "g_application_run")]
fn run(&self) -> i32;
#[doc(alias = "g_application_run")]
fn run_with_args<S: AsRef<str>>(&self, args: &[S]) -> i32;
fn connect_open<F: Fn(&Self, &[File], &str) + 'static>(&self, f: F) -> SignalHandlerId;
#[doc(alias = "g_application_hold")]
fn hold(&self) -> ApplicationHoldGuard;
#[doc(alias = "g_application_mark_busy")]
fn mark_busy(&self) -> ApplicationBusyGuard;
}
impl<O: IsA<Application>> ApplicationExtManual for O {
fn run(&self) -> i32 {
self.run_with_args(&std::env::args().collect::<Vec<_>>())
}
fn run_with_args<S: AsRef<str>>(&self, args: &[S]) -> i32 {
let argv: Vec<&str> = args.iter().map(|a| a.as_ref()).collect();
let argc = argv.len() as i32;
unsafe {
ffi::g_application_run(self.as_ref().to_glib_none().0, argc, argv.to_glib_none().0)
}
}
fn connect_open<F: Fn(&Self, &[File], &str) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn open_trampoline<P, F: Fn(&P, &[File], &str) + 'static>(
this: *mut ffi::GApplication,
files: *const *mut ffi::GFile,
n_files: libc::c_int,
hint: *mut libc::c_char,
f: glib::ffi::gpointer,
) where
P: IsA<Application>,
{
let f: &F = &*(f as *const F);
let files: Vec<File> = FromGlibContainer::from_glib_none_num(files, n_files as usize);
f(
Application::from_glib_borrow(this).unsafe_cast_ref(),
&files,
&GString::from_glib_borrow(hint),
)
}
unsafe {
let f: Box_<F> = Box_::new(f);
connect_raw(
self.as_ptr() as *mut _,
b"open\0".as_ptr() as *const _,
Some(transmute::<_, unsafe extern "C" fn()>(
open_trampoline::<Self, F> as *const (),
)),
Box_::into_raw(f),
)
}
}
fn hold(&self) -> ApplicationHoldGuard {
unsafe {
ffi::g_application_hold(self.as_ref().to_glib_none().0);
}
ApplicationHoldGuard(self.as_ref().downgrade())
}
fn mark_busy(&self) -> ApplicationBusyGuard {
unsafe {
ffi::g_application_mark_busy(self.as_ref().to_glib_none().0);
}
ApplicationBusyGuard(self.as_ref().downgrade())
}
}
#[derive(Debug)]
#[must_use = "if unused the Application will immediately be released"]
pub struct ApplicationHoldGuard(glib::WeakRef<Application>);
impl Drop for ApplicationHoldGuard {
fn drop(&mut self) {
if let Some(application) = self.0.upgrade() {
unsafe {
ffi::g_application_release(application.to_glib_none().0);
}
}
}
}
#[derive(Debug)]
#[must_use = "if unused the Application will immediately be unmarked busy"]
pub struct ApplicationBusyGuard(glib::WeakRef<Application>);
impl Drop for ApplicationBusyGuard {
fn drop(&mut self) {
if let Some(application) = self.0.upgrade() {
unsafe {
ffi::g_application_unmark_busy(application.to_glib_none().0);
}
}
}
}