1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gio_sys as gio;
16use glib_sys as glib;
17use gobject_sys as gobject;
18
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22#[allow(unused_imports)]
23use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
24#[allow(unused_imports)]
25use std::ffi::{
26 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{gboolean, gconstpointer, gpointer, GType};
31
32pub type AstalIOAppError = c_int;
34pub const ASTAL_IO_APP_ERROR_NAME_OCCUPIED: AstalIOAppError = 0;
35pub const ASTAL_IO_APP_ERROR_TAKEOVER_FAILED: AstalIOAppError = 1;
36
37pub const ASTAL_IO_MAJOR_VERSION: c_int = 0;
39pub const ASTAL_IO_MINOR_VERSION: c_int = 1;
40pub const ASTAL_IO_MICRO_VERSION: c_int = 0;
41pub const ASTAL_IO_VERSION: &[u8] = b"0.1.0\0";
42
43#[derive(Copy, Clone)]
45#[repr(C)]
46pub struct AstalIOApplicationIface {
47 pub parent_iface: gobject::GTypeInterface,
48 pub quit: Option<unsafe extern "C" fn(*mut AstalIOApplication, *mut *mut glib::GError)>,
49 pub inspector: Option<unsafe extern "C" fn(*mut AstalIOApplication, *mut *mut glib::GError)>,
50 pub toggle_window: Option<
51 unsafe extern "C" fn(*mut AstalIOApplication, *const c_char, *mut *mut glib::GError),
52 >,
53 pub acquire_socket:
54 Option<unsafe extern "C" fn(*mut AstalIOApplication, *mut *mut glib::GError)>,
55 pub request: Option<
56 unsafe extern "C" fn(
57 *mut AstalIOApplication,
58 *const c_char,
59 *mut gio::GSocketConnection,
60 *mut *mut glib::GError,
61 ),
62 >,
63 pub get_instance_name: Option<unsafe extern "C" fn(*mut AstalIOApplication) -> *mut c_char>,
64 pub set_instance_name: Option<unsafe extern "C" fn(*mut AstalIOApplication, *const c_char)>,
65}
66
67impl ::std::fmt::Debug for AstalIOApplicationIface {
68 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
69 f.debug_struct(&format!("AstalIOApplicationIface @ {self:p}"))
70 .field("quit", &self.quit)
71 .field("inspector", &self.inspector)
72 .field("toggle_window", &self.toggle_window)
73 .field("acquire_socket", &self.acquire_socket)
74 .field("request", &self.request)
75 .field("get_instance_name", &self.get_instance_name)
76 .field("set_instance_name", &self.set_instance_name)
77 .finish()
78 }
79}
80
81#[derive(Copy, Clone)]
82#[repr(C)]
83pub struct AstalIODaemonClass {
84 pub parent_class: gio::GApplicationClass,
85 pub request: Option<
86 unsafe extern "C" fn(*mut AstalIODaemon, *const c_char, *mut gio::GSocketConnection),
87 >,
88}
89
90impl ::std::fmt::Debug for AstalIODaemonClass {
91 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
92 f.debug_struct(&format!("AstalIODaemonClass @ {self:p}"))
93 .field("request", &self.request)
94 .finish()
95 }
96}
97
98#[repr(C)]
99#[allow(dead_code)]
100pub struct _AstalIODaemonPrivate {
101 _data: [u8; 0],
102 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
103}
104
105pub type AstalIODaemonPrivate = _AstalIODaemonPrivate;
106
107#[derive(Copy, Clone)]
108#[repr(C)]
109pub struct AstalIOProcessClass {
110 pub parent_class: gobject::GObjectClass,
111}
112
113impl ::std::fmt::Debug for AstalIOProcessClass {
114 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
115 f.debug_struct(&format!("AstalIOProcessClass @ {self:p}"))
116 .finish()
117 }
118}
119
120#[repr(C)]
121#[allow(dead_code)]
122pub struct _AstalIOProcessPrivate {
123 _data: [u8; 0],
124 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
125}
126
127pub type AstalIOProcessPrivate = _AstalIOProcessPrivate;
128
129#[derive(Copy, Clone)]
130#[repr(C)]
131pub struct AstalIOTimeClass {
132 pub parent_class: gobject::GObjectClass,
133}
134
135impl ::std::fmt::Debug for AstalIOTimeClass {
136 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
137 f.debug_struct(&format!("AstalIOTimeClass @ {self:p}"))
138 .finish()
139 }
140}
141
142#[repr(C)]
143#[allow(dead_code)]
144pub struct _AstalIOTimePrivate {
145 _data: [u8; 0],
146 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
147}
148
149pub type AstalIOTimePrivate = _AstalIOTimePrivate;
150
151#[derive(Copy, Clone)]
152#[repr(C)]
153pub struct AstalIOVariableBaseClass {
154 pub parent_class: gobject::GObjectClass,
155}
156
157impl ::std::fmt::Debug for AstalIOVariableBaseClass {
158 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
159 f.debug_struct(&format!("AstalIOVariableBaseClass @ {self:p}"))
160 .finish()
161 }
162}
163
164#[repr(C)]
165#[allow(dead_code)]
166pub struct _AstalIOVariableBasePrivate {
167 _data: [u8; 0],
168 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
169}
170
171pub type AstalIOVariableBasePrivate = _AstalIOVariableBasePrivate;
172
173#[derive(Copy, Clone)]
174#[repr(C)]
175pub struct AstalIOVariableClass {
176 pub parent_class: AstalIOVariableBaseClass,
177}
178
179impl ::std::fmt::Debug for AstalIOVariableClass {
180 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
181 f.debug_struct(&format!("AstalIOVariableClass @ {self:p}"))
182 .finish()
183 }
184}
185
186#[repr(C)]
187#[allow(dead_code)]
188pub struct _AstalIOVariablePrivate {
189 _data: [u8; 0],
190 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
191}
192
193pub type AstalIOVariablePrivate = _AstalIOVariablePrivate;
194
195#[derive(Copy, Clone)]
197#[repr(C)]
198pub struct AstalIODaemon {
199 pub parent_instance: gio::GApplication,
200 pub priv_: *mut AstalIODaemonPrivate,
201}
202
203impl ::std::fmt::Debug for AstalIODaemon {
204 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
205 f.debug_struct(&format!("AstalIODaemon @ {self:p}"))
206 .finish()
207 }
208}
209
210#[derive(Copy, Clone)]
211#[repr(C)]
212pub struct AstalIOProcess {
213 pub parent_instance: gobject::GObject,
214 pub priv_: *mut AstalIOProcessPrivate,
215}
216
217impl ::std::fmt::Debug for AstalIOProcess {
218 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
219 f.debug_struct(&format!("AstalIOProcess @ {self:p}"))
220 .finish()
221 }
222}
223
224#[derive(Copy, Clone)]
225#[repr(C)]
226pub struct AstalIOTime {
227 pub parent_instance: gobject::GObject,
228 pub priv_: *mut AstalIOTimePrivate,
229}
230
231impl ::std::fmt::Debug for AstalIOTime {
232 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
233 f.debug_struct(&format!("AstalIOTime @ {self:p}")).finish()
234 }
235}
236
237#[derive(Copy, Clone)]
238#[repr(C)]
239pub struct AstalIOVariable {
240 pub parent_instance: AstalIOVariableBase,
241 pub priv_: *mut AstalIOVariablePrivate,
242}
243
244impl ::std::fmt::Debug for AstalIOVariable {
245 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
246 f.debug_struct(&format!("AstalIOVariable @ {self:p}"))
247 .finish()
248 }
249}
250
251#[derive(Copy, Clone)]
252#[repr(C)]
253pub struct AstalIOVariableBase {
254 pub parent_instance: gobject::GObject,
255 pub priv_: *mut AstalIOVariableBasePrivate,
256}
257
258impl ::std::fmt::Debug for AstalIOVariableBase {
259 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
260 f.debug_struct(&format!("AstalIOVariableBase @ {self:p}"))
261 .finish()
262 }
263}
264
265#[repr(C)]
267#[allow(dead_code)]
268pub struct AstalIOApplication {
269 _data: [u8; 0],
270 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
271}
272
273impl ::std::fmt::Debug for AstalIOApplication {
274 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
275 write!(f, "AstalIOApplication @ {self:p}")
276 }
277}
278
279extern "C" {
280
281 pub fn astal_io_app_error_get_type() -> GType;
285
286 pub fn astal_io_daemon_get_type() -> GType;
290 pub fn astal_io_daemon_request(
291 self_: *mut AstalIODaemon,
292 request: *const c_char,
293 conn: *mut gio::GSocketConnection,
294 );
295 pub fn astal_io_daemon_new() -> *mut AstalIODaemon;
296
297 pub fn astal_io_process_get_type() -> GType;
301 pub fn astal_io_process_kill(self_: *mut AstalIOProcess);
302 pub fn astal_io_process_signal(self_: *mut AstalIOProcess, signal_num: c_int);
303 pub fn astal_io_process_write(
304 self_: *mut AstalIOProcess,
305 in_: *const c_char,
306 error: *mut *mut glib::GError,
307 );
308 pub fn astal_io_process_write_async(
309 self_: *mut AstalIOProcess,
310 in_: *const c_char,
311 _callback_: gio::GAsyncReadyCallback,
312 _callback__target: *mut c_void,
313 );
314 pub fn astal_io_process_write_finish(self_: *mut AstalIOProcess, _res_: *mut gio::GAsyncResult);
315 pub fn astal_io_process_new(
316 cmd: *mut *mut c_char,
317 cmd_length1: c_int,
318 error: *mut *mut glib::GError,
319 ) -> *mut AstalIOProcess;
320 pub fn astal_io_process_subprocessv(
321 cmd: *mut *mut c_char,
322 cmd_length1: c_int,
323 error: *mut *mut glib::GError,
324 ) -> *mut AstalIOProcess;
325 pub fn astal_io_process_subprocess(
326 cmd: *const c_char,
327 error: *mut *mut glib::GError,
328 ) -> *mut AstalIOProcess;
329 pub fn astal_io_process_execv(
330 cmd: *mut *mut c_char,
331 cmd_length1: c_int,
332 error: *mut *mut glib::GError,
333 ) -> *mut c_char;
334 pub fn astal_io_process_exec(cmd: *const c_char, error: *mut *mut glib::GError) -> *mut c_char;
335 pub fn astal_io_process_exec_asyncv(
336 cmd: *mut *mut c_char,
337 cmd_length1: c_int,
338 _callback_: gio::GAsyncReadyCallback,
339 _callback__target: *mut c_void,
340 );
341 pub fn astal_io_process_exec_asyncv_finish(
342 _res_: *mut gio::GAsyncResult,
343 error: *mut *mut glib::GError,
344 ) -> *mut c_char;
345 pub fn astal_io_process_exec_async(
346 cmd: *const c_char,
347 _callback_: gio::GAsyncReadyCallback,
348 _callback__target: *mut c_void,
349 );
350 pub fn astal_io_process_exec_finish(
351 _res_: *mut gio::GAsyncResult,
352 error: *mut *mut glib::GError,
353 ) -> *mut c_char;
354 pub fn astal_io_process_get_argv(
355 self_: *mut AstalIOProcess,
356 result_length1: *mut c_int,
357 ) -> *mut *mut c_char;
358
359 pub fn astal_io_time_get_type() -> GType;
363 pub fn astal_io_time_new_interval_prio(
364 interval: c_uint,
365 prio: c_int,
366 fn_: *mut gobject::GClosure,
367 ) -> *mut AstalIOTime;
368 pub fn astal_io_time_new_timeout_prio(
369 timeout: c_uint,
370 prio: c_int,
371 fn_: *mut gobject::GClosure,
372 ) -> *mut AstalIOTime;
373 pub fn astal_io_time_new_idle_prio(
374 prio: c_int,
375 fn_: *mut gobject::GClosure,
376 ) -> *mut AstalIOTime;
377 pub fn astal_io_time_interval(
378 interval: c_uint,
379 fn_: *mut gobject::GClosure,
380 ) -> *mut AstalIOTime;
381 pub fn astal_io_time_timeout(timeout: c_uint, fn_: *mut gobject::GClosure) -> *mut AstalIOTime;
382 pub fn astal_io_time_idle(fn_: *mut gobject::GClosure) -> *mut AstalIOTime;
383 pub fn astal_io_time_cancel(self_: *mut AstalIOTime);
384 pub fn astal_io_time_new() -> *mut AstalIOTime;
385
386 pub fn astal_io_variable_get_type() -> GType;
390 pub fn astal_io_variable_new(init: *mut gobject::GValue) -> *mut AstalIOVariable;
391 pub fn astal_io_variable_poll(
392 self_: *mut AstalIOVariable,
393 interval: c_uint,
394 exec: *const c_char,
395 transform: *mut gobject::GClosure,
396 error: *mut *mut glib::GError,
397 ) -> *mut AstalIOVariable;
398 pub fn astal_io_variable_pollv(
399 self_: *mut AstalIOVariable,
400 interval: c_uint,
401 execv: *mut *mut c_char,
402 execv_length1: c_int,
403 transform: *mut gobject::GClosure,
404 error: *mut *mut glib::GError,
405 ) -> *mut AstalIOVariable;
406 pub fn astal_io_variable_pollfn(
407 self_: *mut AstalIOVariable,
408 interval: c_uint,
409 fn_: *mut gobject::GClosure,
410 error: *mut *mut glib::GError,
411 ) -> *mut AstalIOVariable;
412 pub fn astal_io_variable_watch(
413 self_: *mut AstalIOVariable,
414 exec: *const c_char,
415 transform: *mut gobject::GClosure,
416 error: *mut *mut glib::GError,
417 ) -> *mut AstalIOVariable;
418 pub fn astal_io_variable_watchv(
419 self_: *mut AstalIOVariable,
420 execv: *mut *mut c_char,
421 execv_length1: c_int,
422 transform: *mut gobject::GClosure,
423 error: *mut *mut glib::GError,
424 ) -> *mut AstalIOVariable;
425 pub fn astal_io_variable_start_poll(self_: *mut AstalIOVariable, error: *mut *mut glib::GError);
426 pub fn astal_io_variable_start_watch(
427 self_: *mut AstalIOVariable,
428 error: *mut *mut glib::GError,
429 );
430 pub fn astal_io_variable_stop_poll(self_: *mut AstalIOVariable);
431 pub fn astal_io_variable_stop_watch(self_: *mut AstalIOVariable);
432 pub fn astal_io_variable_is_polling(self_: *mut AstalIOVariable) -> gboolean;
433 pub fn astal_io_variable_is_watching(self_: *mut AstalIOVariable) -> gboolean;
434 pub fn astal_io_variable_get_value(self_: *mut AstalIOVariable, result: *mut gobject::GValue);
435 pub fn astal_io_variable_set_value(self_: *mut AstalIOVariable, value: *mut gobject::GValue);
436
437 pub fn astal_io_variable_base_get_type() -> GType;
441 pub fn astal_io_variable_base_emit_changed(self_: *mut AstalIOVariableBase);
442 pub fn astal_io_variable_base_emit_dropped(self_: *mut AstalIOVariableBase);
443 pub fn astal_io_variable_base_emit_error(self_: *mut AstalIOVariableBase, err: *const c_char);
444 pub fn astal_io_variable_base_new() -> *mut AstalIOVariableBase;
445
446 pub fn astal_io_application_get_type() -> GType;
450 pub fn astal_io_application_quit(self_: *mut AstalIOApplication, error: *mut *mut glib::GError);
451 pub fn astal_io_application_inspector(
452 self_: *mut AstalIOApplication,
453 error: *mut *mut glib::GError,
454 );
455 pub fn astal_io_application_toggle_window(
456 self_: *mut AstalIOApplication,
457 window: *const c_char,
458 error: *mut *mut glib::GError,
459 );
460 pub fn astal_io_application_acquire_socket(
461 self_: *mut AstalIOApplication,
462 error: *mut *mut glib::GError,
463 );
464 pub fn astal_io_application_request(
465 self_: *mut AstalIOApplication,
466 request: *const c_char,
467 conn: *mut gio::GSocketConnection,
468 error: *mut *mut glib::GError,
469 );
470 pub fn astal_io_application_get_instance_name(self_: *mut AstalIOApplication) -> *mut c_char;
471 pub fn astal_io_application_set_instance_name(
472 self_: *mut AstalIOApplication,
473 value: *const c_char,
474 );
475
476 pub fn astal_io_acquire_socket(
480 app: *mut AstalIOApplication,
481 sock: *mut *mut c_char,
482 error: *mut *mut glib::GError,
483 ) -> *mut gio::GSocketService;
484 pub fn astal_io_get_instances() -> *mut glib::GList;
485 pub fn astal_io_quit_instance(instance: *const c_char, error: *mut *mut glib::GError);
486 pub fn astal_io_open_inspector(instance: *const c_char, error: *mut *mut glib::GError);
487 pub fn astal_io_toggle_window_by_name(
488 instance: *const c_char,
489 window: *const c_char,
490 error: *mut *mut glib::GError,
491 );
492 pub fn astal_io_send_message(
493 instance: *const c_char,
494 request: *const c_char,
495 error: *mut *mut glib::GError,
496 ) -> *mut c_char;
497 pub fn astal_io_send_request(
498 instance: *const c_char,
499 request: *const c_char,
500 error: *mut *mut glib::GError,
501 ) -> *mut c_char;
502 pub fn astal_io_read_sock(
503 conn: *mut gio::GSocketConnection,
504 _callback_: gio::GAsyncReadyCallback,
505 _callback__target: *mut c_void,
506 );
507 pub fn astal_io_read_sock_finish(
508 _res_: *mut gio::GAsyncResult,
509 error: *mut *mut glib::GError,
510 ) -> *mut c_char;
511 pub fn astal_io_write_sock(
512 conn: *mut gio::GSocketConnection,
513 response: *const c_char,
514 _callback_: gio::GAsyncReadyCallback,
515 _callback__target: *mut c_void,
516 );
517 pub fn astal_io_write_sock_finish(_res_: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
518 pub fn astal_io_read_file(path: *const c_char) -> *mut c_char;
519 pub fn astal_io_read_file_async(
520 path: *const c_char,
521 _callback_: gio::GAsyncReadyCallback,
522 _callback__target: *mut c_void,
523 );
524 pub fn astal_io_read_file_finish(
525 _res_: *mut gio::GAsyncResult,
526 error: *mut *mut glib::GError,
527 ) -> *mut c_char;
528 pub fn astal_io_write_file(path: *const c_char, content: *const c_char);
529 pub fn astal_io_write_file_async(
530 path: *const c_char,
531 content: *const c_char,
532 _callback_: gio::GAsyncReadyCallback,
533 _callback__target: *mut c_void,
534 );
535 pub fn astal_io_write_file_finish(_res_: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
536 pub fn astal_io_monitor_file(
537 path: *const c_char,
538 callback: *mut gobject::GClosure,
539 ) -> *mut gio::GFileMonitor;
540
541}