1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal,
10 clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14#[allow(unused_imports)]
15use libc::{
16 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
17 intptr_t, size_t, ssize_t, uintptr_t, FILE,
18};
19
20#[allow(unused_imports)]
21use glib::{gboolean, gconstpointer, gpointer, GType};
22
23pub type GnomeDesktopThumbnailSize = c_int;
25pub const GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL: GnomeDesktopThumbnailSize = 0;
26pub const GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE: GnomeDesktopThumbnailSize = 1;
27pub const GNOME_DESKTOP_THUMBNAIL_SIZE_XLARGE: GnomeDesktopThumbnailSize = 2;
28pub const GNOME_DESKTOP_THUMBNAIL_SIZE_XXLARGE: GnomeDesktopThumbnailSize = 3;
29
30pub const GNOME_DESKTOP_PLATFORM_VERSION: c_int = 44;
32
33pub type GnomeIdleMonitorWatchFunc =
35 Option<unsafe extern "C" fn(*mut GnomeIdleMonitor, c_uint, gpointer)>;
36
37#[derive(Copy, Clone)]
39#[repr(C)]
40pub struct GnomeDesktopThumbnailFactoryClass {
41 pub parent: gobject::GObjectClass,
42}
43
44impl ::std::fmt::Debug for GnomeDesktopThumbnailFactoryClass {
45 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
46 f.debug_struct(&format!("GnomeDesktopThumbnailFactoryClass @ {self:p}"))
47 .field("parent", &self.parent)
48 .finish()
49 }
50}
51
52#[repr(C)]
53pub struct _GnomeDesktopThumbnailFactoryPrivate {
54 _data: [u8; 0],
55 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
56}
57
58pub type GnomeDesktopThumbnailFactoryPrivate = *mut _GnomeDesktopThumbnailFactoryPrivate;
59
60#[derive(Copy, Clone)]
61#[repr(C)]
62pub struct GnomeIdleMonitorClass {
63 pub parent_class: gobject::GObjectClass,
64}
65
66impl ::std::fmt::Debug for GnomeIdleMonitorClass {
67 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
68 f.debug_struct(&format!("GnomeIdleMonitorClass @ {self:p}"))
69 .field("parent_class", &self.parent_class)
70 .finish()
71 }
72}
73
74#[repr(C)]
75pub struct _GnomeIdleMonitorPrivate {
76 _data: [u8; 0],
77 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
78}
79
80pub type GnomeIdleMonitorPrivate = *mut _GnomeIdleMonitorPrivate;
81
82#[derive(Copy, Clone)]
83#[repr(C)]
84pub struct GnomePnpIdsClass {
85 pub parent_class: gobject::GObjectClass,
86}
87
88impl ::std::fmt::Debug for GnomePnpIdsClass {
89 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
90 f.debug_struct(&format!("GnomePnpIdsClass @ {self:p}"))
91 .field("parent_class", &self.parent_class)
92 .finish()
93 }
94}
95
96#[repr(C)]
97pub struct _GnomePnpIdsPrivate {
98 _data: [u8; 0],
99 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
100}
101
102pub type GnomePnpIdsPrivate = *mut _GnomePnpIdsPrivate;
103
104#[derive(Copy, Clone)]
105#[repr(C)]
106pub struct GnomeWallClockClass {
107 pub parent_class: gobject::GObjectClass,
108}
109
110impl ::std::fmt::Debug for GnomeWallClockClass {
111 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
112 f.debug_struct(&format!("GnomeWallClockClass @ {self:p}"))
113 .field("parent_class", &self.parent_class)
114 .finish()
115 }
116}
117
118#[repr(C)]
119pub struct _GnomeWallClockPrivate {
120 _data: [u8; 0],
121 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
122}
123
124pub type GnomeWallClockPrivate = *mut _GnomeWallClockPrivate;
125
126#[derive(Copy, Clone)]
127#[repr(C)]
128pub struct GnomeXkbInfoClass {
129 pub parent_class: gobject::GObjectClass,
130}
131
132impl ::std::fmt::Debug for GnomeXkbInfoClass {
133 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
134 f.debug_struct(&format!("GnomeXkbInfoClass @ {self:p}"))
135 .field("parent_class", &self.parent_class)
136 .finish()
137 }
138}
139
140#[repr(C)]
141pub struct _GnomeXkbInfoPrivate {
142 _data: [u8; 0],
143 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
144}
145
146pub type GnomeXkbInfoPrivate = *mut _GnomeXkbInfoPrivate;
147
148#[derive(Copy, Clone)]
150#[repr(C)]
151pub struct GnomeDesktopThumbnailFactory {
152 pub parent: gobject::GObject,
153 pub priv_: *mut GnomeDesktopThumbnailFactoryPrivate,
154}
155
156impl ::std::fmt::Debug for GnomeDesktopThumbnailFactory {
157 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
158 f.debug_struct(&format!("GnomeDesktopThumbnailFactory @ {self:p}"))
159 .field("parent", &self.parent)
160 .field("priv_", &self.priv_)
161 .finish()
162 }
163}
164
165#[derive(Copy, Clone)]
166#[repr(C)]
167pub struct GnomeIdleMonitor {
168 pub parent: gobject::GObject,
169 pub priv_: *mut GnomeIdleMonitorPrivate,
170}
171
172impl ::std::fmt::Debug for GnomeIdleMonitor {
173 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
174 f.debug_struct(&format!("GnomeIdleMonitor @ {self:p}"))
175 .field("parent", &self.parent)
176 .field("priv_", &self.priv_)
177 .finish()
178 }
179}
180
181#[derive(Copy, Clone)]
182#[repr(C)]
183pub struct GnomePnpIds {
184 pub parent: gobject::GObject,
185 pub priv_: *mut GnomePnpIdsPrivate,
186}
187
188impl ::std::fmt::Debug for GnomePnpIds {
189 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
190 f.debug_struct(&format!("GnomePnpIds @ {self:p}"))
191 .field("parent", &self.parent)
192 .field("priv_", &self.priv_)
193 .finish()
194 }
195}
196
197#[derive(Copy, Clone)]
198#[repr(C)]
199pub struct GnomeWallClock {
200 pub parent_object: gobject::GObject,
201 pub priv_: *mut GnomeWallClockPrivate,
202}
203
204impl ::std::fmt::Debug for GnomeWallClock {
205 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
206 f.debug_struct(&format!("GnomeWallClock @ {self:p}"))
207 .field("parent_object", &self.parent_object)
208 .field("priv_", &self.priv_)
209 .finish()
210 }
211}
212
213#[derive(Copy, Clone)]
214#[repr(C)]
215pub struct GnomeXkbInfo {
216 pub parent_object: gobject::GObject,
217 pub priv_: *mut GnomeXkbInfoPrivate,
218}
219
220impl ::std::fmt::Debug for GnomeXkbInfo {
221 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
222 f.debug_struct(&format!("GnomeXkbInfo @ {self:p}"))
223 .field("parent_object", &self.parent_object)
224 .field("priv_", &self.priv_)
225 .finish()
226 }
227}
228
229#[link(name = "gnome-desktop-4")]
230extern "C" {
231
232 pub fn gnome_desktop_thumbnail_factory_get_type() -> GType;
236 pub fn gnome_desktop_thumbnail_factory_new(
237 size: GnomeDesktopThumbnailSize,
238 ) -> *mut GnomeDesktopThumbnailFactory;
239 pub fn gnome_desktop_thumbnail_factory_can_thumbnail(
240 factory: *mut GnomeDesktopThumbnailFactory,
241 uri: *const c_char,
242 mime_type: *const c_char,
243 mtime: c_long,
244 ) -> gboolean;
245 pub fn gnome_desktop_thumbnail_factory_create_failed_thumbnail(
246 factory: *mut GnomeDesktopThumbnailFactory,
247 uri: *const c_char,
248 mtime: c_long,
249 cancellable: *mut gio::GCancellable,
250 error: *mut *mut glib::GError,
251 ) -> gboolean;
252 pub fn gnome_desktop_thumbnail_factory_create_failed_thumbnail_async(
253 factory: *mut GnomeDesktopThumbnailFactory,
254 uri: *const c_char,
255 original_mtime: c_long,
256 cancellable: *mut gio::GCancellable,
257 callback: gio::GAsyncReadyCallback,
258 user_data: gpointer,
259 );
260 pub fn gnome_desktop_thumbnail_factory_create_failed_thumbnail_finish(
261 factory: *mut GnomeDesktopThumbnailFactory,
262 result: *mut gio::GAsyncResult,
263 error: *mut *mut glib::GError,
264 ) -> gboolean;
265 #[cfg(feature = "v42")]
266 #[cfg_attr(docsrs, doc(cfg(feature = "v42")))]
267 pub fn gnome_desktop_thumbnail_factory_generate_thumbnail(
268 factory: *mut GnomeDesktopThumbnailFactory,
269 uri: *const c_char,
270 mime_type: *const c_char,
271 cancellable: *mut gio::GCancellable,
272 error: *mut *mut glib::GError,
273 ) -> *mut gdk_pixbuf::GdkPixbuf;
274 pub fn gnome_desktop_thumbnail_factory_generate_thumbnail_async(
275 factory: *mut GnomeDesktopThumbnailFactory,
276 uri: *const c_char,
277 mime_type: *const c_char,
278 cancellable: *mut gio::GCancellable,
279 callback: gio::GAsyncReadyCallback,
280 user_data: gpointer,
281 );
282 pub fn gnome_desktop_thumbnail_factory_generate_thumbnail_finish(
283 factory: *mut GnomeDesktopThumbnailFactory,
284 result: *mut gio::GAsyncResult,
285 error: *mut *mut glib::GError,
286 ) -> *mut gdk_pixbuf::GdkPixbuf;
287 pub fn gnome_desktop_thumbnail_factory_has_valid_failed_thumbnail(
288 factory: *mut GnomeDesktopThumbnailFactory,
289 uri: *const c_char,
290 mtime: c_long,
291 ) -> gboolean;
292 pub fn gnome_desktop_thumbnail_factory_lookup(
293 factory: *mut GnomeDesktopThumbnailFactory,
294 uri: *const c_char,
295 mtime: c_long,
296 ) -> *mut c_char;
297 pub fn gnome_desktop_thumbnail_factory_save_thumbnail(
298 factory: *mut GnomeDesktopThumbnailFactory,
299 thumbnail: *mut gdk_pixbuf::GdkPixbuf,
300 uri: *const c_char,
301 original_mtime: c_long,
302 cancellable: *mut gio::GCancellable,
303 error: *mut *mut glib::GError,
304 ) -> gboolean;
305 pub fn gnome_desktop_thumbnail_factory_save_thumbnail_async(
306 factory: *mut GnomeDesktopThumbnailFactory,
307 thumbnail: *mut gdk_pixbuf::GdkPixbuf,
308 uri: *const c_char,
309 original_mtime: c_long,
310 cancellable: *mut gio::GCancellable,
311 callback: gio::GAsyncReadyCallback,
312 user_data: gpointer,
313 );
314 pub fn gnome_desktop_thumbnail_factory_save_thumbnail_finish(
315 factory: *mut GnomeDesktopThumbnailFactory,
316 result: *mut gio::GAsyncResult,
317 error: *mut *mut glib::GError,
318 ) -> gboolean;
319
320 pub fn gnome_idle_monitor_get_type() -> GType;
324 pub fn gnome_idle_monitor_new() -> *mut GnomeIdleMonitor;
325 pub fn gnome_idle_monitor_add_idle_watch(
326 monitor: *mut GnomeIdleMonitor,
327 interval_msec: u64,
328 callback: GnomeIdleMonitorWatchFunc,
329 user_data: gpointer,
330 notify: glib::GDestroyNotify,
331 ) -> c_uint;
332 pub fn gnome_idle_monitor_add_user_active_watch(
333 monitor: *mut GnomeIdleMonitor,
334 callback: GnomeIdleMonitorWatchFunc,
335 user_data: gpointer,
336 notify: glib::GDestroyNotify,
337 ) -> c_uint;
338 pub fn gnome_idle_monitor_get_idletime(monitor: *mut GnomeIdleMonitor) -> u64;
339 pub fn gnome_idle_monitor_remove_watch(monitor: *mut GnomeIdleMonitor, id: c_uint);
340
341 pub fn gnome_pnp_ids_get_type() -> GType;
345 pub fn gnome_pnp_ids_new() -> *mut GnomePnpIds;
346 pub fn gnome_pnp_ids_get_pnp_id(
347 pnp_ids: *mut GnomePnpIds,
348 pnp_id: *const c_char,
349 ) -> *mut c_char;
350
351 pub fn gnome_wall_clock_get_type() -> GType;
355 pub fn gnome_wall_clock_new() -> *mut GnomeWallClock;
356 pub fn gnome_wall_clock_get_clock(clock: *mut GnomeWallClock) -> *const c_char;
357 pub fn gnome_wall_clock_get_timezone(clock: *mut GnomeWallClock) -> *mut glib::GTimeZone;
358 pub fn gnome_wall_clock_string_for_datetime(
359 self_: *mut GnomeWallClock,
360 now: *mut glib::GDateTime,
361 clock_format: gdesktop_enums::GDesktopClockFormat,
362 show_weekday: gboolean,
363 show_full_date: gboolean,
364 show_seconds: gboolean,
365 ) -> *mut c_char;
366
367 pub fn gnome_xkb_info_get_type() -> GType;
371 pub fn gnome_xkb_info_new() -> *mut GnomeXkbInfo;
372 pub fn gnome_xkb_info_description_for_group(
373 self_: *mut GnomeXkbInfo,
374 group_id: *const c_char,
375 ) -> *const c_char;
376 pub fn gnome_xkb_info_description_for_option(
377 self_: *mut GnomeXkbInfo,
378 group_id: *const c_char,
379 id: *const c_char,
380 ) -> *const c_char;
381 pub fn gnome_xkb_info_get_all_layouts(self_: *mut GnomeXkbInfo) -> *mut glib::GList;
382 pub fn gnome_xkb_info_get_all_option_groups(self_: *mut GnomeXkbInfo) -> *mut glib::GList;
383 pub fn gnome_xkb_info_get_languages_for_layout(
384 self_: *mut GnomeXkbInfo,
385 layout_id: *const c_char,
386 ) -> *mut glib::GList;
387 pub fn gnome_xkb_info_get_layout_info(
388 self_: *mut GnomeXkbInfo,
389 id: *const c_char,
390 display_name: *mut *const c_char,
391 short_name: *mut *const c_char,
392 xkb_layout: *mut *const c_char,
393 xkb_variant: *mut *const c_char,
394 ) -> gboolean;
395 pub fn gnome_xkb_info_get_layouts_for_country(
396 self_: *mut GnomeXkbInfo,
397 country_code: *const c_char,
398 ) -> *mut glib::GList;
399 pub fn gnome_xkb_info_get_layouts_for_language(
400 self_: *mut GnomeXkbInfo,
401 language_code: *const c_char,
402 ) -> *mut glib::GList;
403 pub fn gnome_xkb_info_get_options_for_group(
404 self_: *mut GnomeXkbInfo,
405 group_id: *const c_char,
406 ) -> *mut glib::GList;
407
408 pub fn gnome_desktop_thumbnail_is_valid(
412 pixbuf: *mut gdk_pixbuf::GdkPixbuf,
413 uri: *const c_char,
414 mtime: c_long,
415 ) -> gboolean;
416 pub fn gnome_desktop_thumbnail_path_for_uri(
417 uri: *const c_char,
418 size: GnomeDesktopThumbnailSize,
419 ) -> *mut c_char;
420 pub fn gnome_get_all_locales() -> *mut *mut c_char;
421 pub fn gnome_get_country_from_code(
422 code: *const c_char,
423 translation: *const c_char,
424 ) -> *mut c_char;
425 pub fn gnome_get_country_from_locale(
426 locale: *const c_char,
427 translation: *const c_char,
428 ) -> *mut c_char;
429 pub fn gnome_get_input_source_from_locale(
430 locale: *const c_char,
431 type_: *mut *const c_char,
432 id: *mut *const c_char,
433 ) -> gboolean;
434 pub fn gnome_get_language_from_code(
435 code: *const c_char,
436 translation: *const c_char,
437 ) -> *mut c_char;
438 pub fn gnome_get_language_from_locale(
439 locale: *const c_char,
440 translation: *const c_char,
441 ) -> *mut c_char;
442 #[cfg(feature = "v43")]
443 #[cfg_attr(docsrs, doc(cfg(feature = "v43")))]
444 pub fn gnome_get_platform_version() -> c_int;
445 pub fn gnome_get_translated_modifier(
446 modifier: *const c_char,
447 translation: *const c_char,
448 ) -> *mut c_char;
449 pub fn gnome_language_has_translations(code: *const c_char) -> gboolean;
450 pub fn gnome_normalize_locale(locale: *const c_char) -> *mut c_char;
451 pub fn gnome_parse_locale(
452 locale: *const c_char,
453 language_codep: *mut *mut c_char,
454 country_codep: *mut *mut c_char,
455 codesetp: *mut *mut c_char,
456 modifierp: *mut *mut c_char,
457 ) -> gboolean;
458 pub fn gnome_start_systemd_scope(
459 name: *const c_char,
460 pid: i32,
461 description: *const c_char,
462 connection: *mut gio::GDBusConnection,
463 cancellable: *mut gio::GCancellable,
464 callback: gio::GAsyncReadyCallback,
465 user_data: gpointer,
466 );
467 pub fn gnome_start_systemd_scope_finish(
468 res: *mut gio::GAsyncResult,
469 error: *mut *mut glib::GError,
470 ) -> gboolean;
471
472}