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 gdk_sys as gdk;
16use gio_sys as gio;
17use glib_sys as glib;
18use gobject_sys as gobject;
19use gtk_sys as gtk;
20
21#[cfg(unix)]
22#[allow(unused_imports)]
23use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
24#[allow(unused_imports)]
25use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
26#[allow(unused_imports)]
27use std::ffi::{
28 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
29};
30
31#[allow(unused_imports)]
32use glib::{gboolean, gconstpointer, gpointer, GType};
33
34pub type GraniteServicesContractorError = c_int;
36pub const GRANITE_SERVICES_CONTRACTOR_ERROR_SERVICE_NOT_AVAILABLE: GraniteServicesContractorError =
37 0;
38
39pub type GraniteSettingsColorScheme = c_int;
40pub const GRANITE_SETTINGS_COLOR_SCHEME_NO_PREFERENCE: GraniteSettingsColorScheme = 0;
41pub const GRANITE_SETTINGS_COLOR_SCHEME_DARK: GraniteSettingsColorScheme = 1;
42pub const GRANITE_SETTINGS_COLOR_SCHEME_LIGHT: GraniteSettingsColorScheme = 2;
43
44pub type GraniteSettingsPageStatusType = c_int;
45pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_ERROR: GraniteSettingsPageStatusType = 0;
46pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_OFFLINE: GraniteSettingsPageStatusType = 1;
47pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_SUCCESS: GraniteSettingsPageStatusType = 2;
48pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_WARNING: GraniteSettingsPageStatusType = 3;
49pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_NONE: GraniteSettingsPageStatusType = 4;
50
51pub type GraniteToastDismissReason = c_int;
52pub const GRANITE_TOAST_DISMISS_REASON_EXPIRED: GraniteToastDismissReason = 1;
53pub const GRANITE_TOAST_DISMISS_REASON_CLOSED: GraniteToastDismissReason = 2;
54pub const GRANITE_TOAST_DISMISS_REASON_WITHDRAWN: GraniteToastDismissReason = 3;
55
56pub const GRANITE_SETTINGS_URI_LOCATION: &[u8] = b"settings://privacy/location\0";
58pub const GRANITE_SETTINGS_URI_ONLINE_ACCOUNTS: &[u8] = b"settings://accounts/online\0";
59pub const GRANITE_SETTINGS_URI_NETWORK: &[u8] = b"settings://network\0";
60pub const GRANITE_SETTINGS_URI_PERMISSIONS: &[u8] = b"settings://applications/permissions\0";
61pub const GRANITE_SETTINGS_URI_NOTIFICATIONS: &[u8] = b"settings://notifications\0";
62pub const GRANITE_SETTINGS_URI_SOUND_INPUT: &[u8] = b"settings://sound/input\0";
63pub const GRANITE_SETTINGS_URI_SHORTCUTS: &[u8] = b"settings://input/keyboard/shortcuts/custom\0";
64pub const GRANITE_STYLE_CLASS_ACCENT: &[u8] = b"accent\0";
65pub const GRANITE_STYLE_CLASS_BACK_BUTTON: &[u8] = b"back-button\0";
66pub const GRANITE_STYLE_CLASS_BACKGROUND: &[u8] = b"background\0";
67pub const GRANITE_STYLE_CLASS_BADGE: &[u8] = b"badge\0";
68pub const GRANITE_STYLE_CLASS_CARD: &[u8] = b"card\0";
69pub const GRANITE_STYLE_CLASS_CHECKERBOARD: &[u8] = b"checkerboard\0";
70pub const GRANITE_STYLE_CLASS_CIRCULAR: &[u8] = b"circular\0";
71pub const GRANITE_STYLE_CLASS_COLOR_BUTTON: &[u8] = b"color-button\0";
72pub const GRANITE_STYLE_CLASS_DEFAULT_DECORATION: &[u8] = b"default-decoration\0";
73pub const GRANITE_STYLE_CLASS_DESTRUCTIVE_ACTION: &[u8] = b"destructive-action\0";
74pub const GRANITE_STYLE_CLASS_DIALOG_CONTENT_AREA: &[u8] = b"dialog-content-area\0";
75pub const GRANITE_STYLE_CLASS_FRAME: &[u8] = b"frame\0";
76pub const GRANITE_STYLE_CLASS_H1_LABEL: &[u8] = b"title-1\0";
77pub const GRANITE_STYLE_CLASS_H2_LABEL: &[u8] = b"title-2\0";
78pub const GRANITE_STYLE_CLASS_H3_LABEL: &[u8] = b"title-3\0";
79pub const GRANITE_STYLE_CLASS_H4_LABEL: &[u8] = b"title-4\0";
80pub const GRANITE_STYLE_CLASS_KEYCAP: &[u8] = b"keycap\0";
81pub const GRANITE_STYLE_CLASS_LARGE_ICONS: &[u8] = b"large-icons\0";
82pub const GRANITE_STYLE_CLASS_MODE_SWITCH: &[u8] = b"mode-switch\0";
83pub const GRANITE_STYLE_CLASS_OSD: &[u8] = b"osd\0";
84pub const GRANITE_STYLE_CLASS_ROUNDED: &[u8] = b"rounded\0";
85pub const GRANITE_STYLE_CLASS_SIDEBAR: &[u8] = b"sidebar\0";
86pub const GRANITE_STYLE_CLASS_SMALL_LABEL: &[u8] = b"small-label\0";
87pub const GRANITE_STYLE_CLASS_SUCCESS: &[u8] = b"success\0";
88pub const GRANITE_STYLE_CLASS_TERMINAL: &[u8] = b"terminal\0";
89pub const GRANITE_STYLE_CLASS_TITLE_LABEL: &[u8] = b"title\0";
90pub const GRANITE_STYLE_CLASS_WARMTH: &[u8] = b"warmth\0";
91pub const GRANITE_STYLE_CLASS_TEMPERATURE: &[u8] = b"temperature\0";
92pub const GRANITE_STYLE_CLASS_LINKED: &[u8] = b"linked\0";
93pub const GRANITE_STYLE_CLASS_MENU: &[u8] = b"menu\0";
94pub const GRANITE_STYLE_CLASS_MENUITEM: &[u8] = b"menuitem\0";
95pub const GRANITE_STYLE_CLASS_DIM_LABEL: &[u8] = b"dim-label\0";
96pub const GRANITE_STYLE_CLASS_ERROR: &[u8] = b"error\0";
97pub const GRANITE_STYLE_CLASS_FLAT: &[u8] = b"flat\0";
98pub const GRANITE_STYLE_CLASS_MESSAGE_DIALOG: &[u8] = b"message\0";
99pub const GRANITE_STYLE_CLASS_RICH_LIST: &[u8] = b"rich-list\0";
100pub const GRANITE_STYLE_CLASS_SUGGESTED_ACTION: &[u8] = b"suggested-action\0";
101pub const GRANITE_STYLE_CLASS_VIEW: &[u8] = b"view\0";
102pub const GRANITE_STYLE_CLASS_WARNING: &[u8] = b"warning\0";
103pub const GRANITE_TRANSITION_DURATION_CLOSE: c_int = 200;
104pub const GRANITE_TRANSITION_DURATION_IN_PLACE: c_int = 100;
105pub const GRANITE_TRANSITION_DURATION_OPEN: c_int = 250;
106pub const GRANITE_TOOLTIP_SECONDARY_TEXT_MARKUP: &[u8] =
107 b"<span weight=\"600\" size=\"smaller\" alpha=\"75%\">%s</span>\0";
108
109#[derive(Copy, Clone)]
111#[repr(C)]
112pub struct GraniteAccelLabelClass {
113 pub parent_class: gtk::GtkBoxClass,
114}
115
116impl ::std::fmt::Debug for GraniteAccelLabelClass {
117 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
118 f.debug_struct(&format!("GraniteAccelLabelClass @ {self:p}"))
119 .finish()
120 }
121}
122
123#[repr(C)]
124#[allow(dead_code)]
125pub struct _GraniteAccelLabelPrivate {
126 _data: [u8; 0],
127 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
128}
129
130pub type GraniteAccelLabelPrivate = _GraniteAccelLabelPrivate;
131
132#[derive(Copy, Clone)]
133#[repr(C)]
134pub struct GraniteBinClass {
135 pub parent_class: gtk::GtkWidgetClass,
136}
137
138impl ::std::fmt::Debug for GraniteBinClass {
139 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
140 f.debug_struct(&format!("GraniteBinClass @ {self:p}"))
141 .finish()
142 }
143}
144
145#[repr(C)]
146#[allow(dead_code)]
147pub struct _GraniteBinPrivate {
148 _data: [u8; 0],
149 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
150}
151
152pub type GraniteBinPrivate = _GraniteBinPrivate;
153
154#[derive(Copy, Clone)]
155#[repr(C)]
156pub struct GraniteDatePickerClass {
157 pub parent_class: gtk::GtkEntryClass,
158}
159
160impl ::std::fmt::Debug for GraniteDatePickerClass {
161 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
162 f.debug_struct(&format!("GraniteDatePickerClass @ {self:p}"))
163 .finish()
164 }
165}
166
167#[repr(C)]
168#[allow(dead_code)]
169pub struct _GraniteDatePickerPrivate {
170 _data: [u8; 0],
171 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
172}
173
174pub type GraniteDatePickerPrivate = _GraniteDatePickerPrivate;
175
176#[derive(Copy, Clone)]
177#[repr(C)]
178pub struct GraniteDialogClass {
179 pub parent_class: gtk::GtkDialogClass,
180}
181
182impl ::std::fmt::Debug for GraniteDialogClass {
183 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
184 f.debug_struct(&format!("GraniteDialogClass @ {self:p}"))
185 .finish()
186 }
187}
188
189#[repr(C)]
190#[allow(dead_code)]
191pub struct _GraniteDialogPrivate {
192 _data: [u8; 0],
193 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
194}
195
196pub type GraniteDialogPrivate = _GraniteDialogPrivate;
197
198#[derive(Copy, Clone)]
199#[repr(C)]
200pub struct GraniteHeaderLabelClass {
201 pub parent_class: gtk::GtkWidgetClass,
202}
203
204impl ::std::fmt::Debug for GraniteHeaderLabelClass {
205 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
206 f.debug_struct(&format!("GraniteHeaderLabelClass @ {self:p}"))
207 .finish()
208 }
209}
210
211#[repr(C)]
212#[allow(dead_code)]
213pub struct _GraniteHeaderLabelPrivate {
214 _data: [u8; 0],
215 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
216}
217
218pub type GraniteHeaderLabelPrivate = _GraniteHeaderLabelPrivate;
219
220#[derive(Copy, Clone)]
221#[repr(C)]
222pub struct GraniteHyperTextViewClass {
223 pub parent_class: gtk::GtkTextViewClass,
224}
225
226impl ::std::fmt::Debug for GraniteHyperTextViewClass {
227 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
228 f.debug_struct(&format!("GraniteHyperTextViewClass @ {self:p}"))
229 .finish()
230 }
231}
232
233#[repr(C)]
234#[allow(dead_code)]
235pub struct _GraniteHyperTextViewPrivate {
236 _data: [u8; 0],
237 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
238}
239
240pub type GraniteHyperTextViewPrivate = _GraniteHyperTextViewPrivate;
241
242#[derive(Copy, Clone)]
243#[repr(C)]
244pub struct GraniteMessageDialogClass {
245 pub parent_class: GraniteDialogClass,
246}
247
248impl ::std::fmt::Debug for GraniteMessageDialogClass {
249 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
250 f.debug_struct(&format!("GraniteMessageDialogClass @ {self:p}"))
251 .finish()
252 }
253}
254
255#[repr(C)]
256#[allow(dead_code)]
257pub struct _GraniteMessageDialogPrivate {
258 _data: [u8; 0],
259 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
260}
261
262pub type GraniteMessageDialogPrivate = _GraniteMessageDialogPrivate;
263
264#[derive(Copy, Clone)]
265#[repr(C)]
266pub struct GraniteModeSwitchClass {
267 pub parent_class: gtk::GtkBoxClass,
268}
269
270impl ::std::fmt::Debug for GraniteModeSwitchClass {
271 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
272 f.debug_struct(&format!("GraniteModeSwitchClass @ {self:p}"))
273 .finish()
274 }
275}
276
277#[repr(C)]
278#[allow(dead_code)]
279pub struct _GraniteModeSwitchPrivate {
280 _data: [u8; 0],
281 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
282}
283
284pub type GraniteModeSwitchPrivate = _GraniteModeSwitchPrivate;
285
286#[derive(Copy, Clone)]
287#[repr(C)]
288pub struct GraniteOverlayBarClass {
289 pub parent_class: gtk::GtkWidgetClass,
290}
291
292impl ::std::fmt::Debug for GraniteOverlayBarClass {
293 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
294 f.debug_struct(&format!("GraniteOverlayBarClass @ {self:p}"))
295 .finish()
296 }
297}
298
299#[repr(C)]
300#[allow(dead_code)]
301pub struct _GraniteOverlayBarPrivate {
302 _data: [u8; 0],
303 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
304}
305
306pub type GraniteOverlayBarPrivate = _GraniteOverlayBarPrivate;
307
308#[derive(Copy, Clone)]
309#[repr(C)]
310pub struct GranitePlaceholderClass {
311 pub parent_class: gtk::GtkWidgetClass,
312}
313
314impl ::std::fmt::Debug for GranitePlaceholderClass {
315 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
316 f.debug_struct(&format!("GranitePlaceholderClass @ {self:p}"))
317 .finish()
318 }
319}
320
321#[repr(C)]
322#[allow(dead_code)]
323pub struct _GranitePlaceholderPrivate {
324 _data: [u8; 0],
325 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
326}
327
328pub type GranitePlaceholderPrivate = _GranitePlaceholderPrivate;
329
330#[derive(Copy, Clone)]
331#[repr(C)]
332pub struct GraniteServicesContractIface {
333 pub parent_iface: gobject::GTypeInterface,
334 pub get_display_name: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut c_char>,
335 pub get_description: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut c_char>,
336 pub get_icon: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut gio::GIcon>,
337 pub execute_with_file: Option<
338 unsafe extern "C" fn(*mut GraniteServicesContract, *mut gio::GFile, *mut *mut glib::GError),
339 >,
340 pub execute_with_files: Option<
341 unsafe extern "C" fn(
342 *mut GraniteServicesContract,
343 *mut *mut gio::GFile,
344 c_int,
345 *mut *mut glib::GError,
346 ),
347 >,
348}
349
350impl ::std::fmt::Debug for GraniteServicesContractIface {
351 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
352 f.debug_struct(&format!("GraniteServicesContractIface @ {self:p}"))
353 .field("get_display_name", &self.get_display_name)
354 .field("get_description", &self.get_description)
355 .field("get_icon", &self.get_icon)
356 .field("execute_with_file", &self.execute_with_file)
357 .field("execute_with_files", &self.execute_with_files)
358 .finish()
359 }
360}
361
362#[derive(Copy, Clone)]
363#[repr(C)]
364pub struct GraniteServicesContractorProxyClass {
365 pub parent_class: gobject::GObjectClass,
366}
367
368impl ::std::fmt::Debug for GraniteServicesContractorProxyClass {
369 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
370 f.debug_struct(&format!("GraniteServicesContractorProxyClass @ {self:p}"))
371 .finish()
372 }
373}
374
375#[repr(C)]
376#[allow(dead_code)]
377pub struct _GraniteServicesContractorProxyPrivate {
378 _data: [u8; 0],
379 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
380}
381
382pub type GraniteServicesContractorProxyPrivate = _GraniteServicesContractorProxyPrivate;
383
384#[derive(Copy, Clone)]
385#[repr(C)]
386pub struct GraniteServicesSettingsSerializableIface {
387 pub parent_iface: gobject::GTypeInterface,
388 pub settings_serialize:
389 Option<unsafe extern "C" fn(*mut GraniteServicesSettingsSerializable) -> *mut c_char>,
390 pub settings_deserialize:
391 Option<unsafe extern "C" fn(*mut GraniteServicesSettingsSerializable, *const c_char)>,
392}
393
394impl ::std::fmt::Debug for GraniteServicesSettingsSerializableIface {
395 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
396 f.debug_struct(&format!(
397 "GraniteServicesSettingsSerializableIface @ {self:p}"
398 ))
399 .field("settings_serialize", &self.settings_serialize)
400 .field("settings_deserialize", &self.settings_deserialize)
401 .finish()
402 }
403}
404
405#[derive(Copy, Clone)]
406#[repr(C)]
407pub struct GraniteServicesSystemClass {
408 pub parent_class: gobject::GObjectClass,
409}
410
411impl ::std::fmt::Debug for GraniteServicesSystemClass {
412 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
413 f.debug_struct(&format!("GraniteServicesSystemClass @ {self:p}"))
414 .finish()
415 }
416}
417
418#[repr(C)]
419#[allow(dead_code)]
420pub struct _GraniteServicesSystemPrivate {
421 _data: [u8; 0],
422 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
423}
424
425pub type GraniteServicesSystemPrivate = _GraniteServicesSystemPrivate;
426
427#[derive(Copy, Clone)]
428#[repr(C)]
429pub struct GraniteSettingsClass {
430 pub parent_class: gobject::GObjectClass,
431}
432
433impl ::std::fmt::Debug for GraniteSettingsClass {
434 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
435 f.debug_struct(&format!("GraniteSettingsClass @ {self:p}"))
436 .finish()
437 }
438}
439
440#[derive(Copy, Clone)]
441#[repr(C)]
442pub struct GraniteSettingsPageClass {
443 pub parent_class: gtk::GtkBoxClass,
444}
445
446impl ::std::fmt::Debug for GraniteSettingsPageClass {
447 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
448 f.debug_struct(&format!("GraniteSettingsPageClass @ {self:p}"))
449 .finish()
450 }
451}
452
453#[repr(C)]
454#[allow(dead_code)]
455pub struct _GraniteSettingsPagePrivate {
456 _data: [u8; 0],
457 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
458}
459
460pub type GraniteSettingsPagePrivate = _GraniteSettingsPagePrivate;
461
462#[repr(C)]
463#[allow(dead_code)]
464pub struct _GraniteSettingsPrivate {
465 _data: [u8; 0],
466 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
467}
468
469pub type GraniteSettingsPrivate = _GraniteSettingsPrivate;
470
471#[derive(Copy, Clone)]
472#[repr(C)]
473pub struct GraniteSettingsSidebarClass {
474 pub parent_class: gtk::GtkWidgetClass,
475}
476
477impl ::std::fmt::Debug for GraniteSettingsSidebarClass {
478 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
479 f.debug_struct(&format!("GraniteSettingsSidebarClass @ {self:p}"))
480 .finish()
481 }
482}
483
484#[repr(C)]
485#[allow(dead_code)]
486pub struct _GraniteSettingsSidebarPrivate {
487 _data: [u8; 0],
488 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
489}
490
491pub type GraniteSettingsSidebarPrivate = _GraniteSettingsSidebarPrivate;
492
493#[derive(Copy, Clone)]
494#[repr(C)]
495pub struct GraniteSimpleSettingsPageClass {
496 pub parent_class: GraniteSettingsPageClass,
497}
498
499impl ::std::fmt::Debug for GraniteSimpleSettingsPageClass {
500 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
501 f.debug_struct(&format!("GraniteSimpleSettingsPageClass @ {self:p}"))
502 .finish()
503 }
504}
505
506#[repr(C)]
507#[allow(dead_code)]
508pub struct _GraniteSimpleSettingsPagePrivate {
509 _data: [u8; 0],
510 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
511}
512
513pub type GraniteSimpleSettingsPagePrivate = _GraniteSimpleSettingsPagePrivate;
514
515#[derive(Copy, Clone)]
516#[repr(C)]
517pub struct GraniteSwitchModelButtonClass {
518 pub parent_class: gtk::GtkToggleButtonClass,
519}
520
521impl ::std::fmt::Debug for GraniteSwitchModelButtonClass {
522 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
523 f.debug_struct(&format!("GraniteSwitchModelButtonClass @ {self:p}"))
524 .finish()
525 }
526}
527
528#[repr(C)]
529#[allow(dead_code)]
530pub struct _GraniteSwitchModelButtonPrivate {
531 _data: [u8; 0],
532 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
533}
534
535pub type GraniteSwitchModelButtonPrivate = _GraniteSwitchModelButtonPrivate;
536
537#[derive(Copy, Clone)]
538#[repr(C)]
539pub struct GraniteTimePickerClass {
540 pub parent_class: gtk::GtkEntryClass,
541}
542
543impl ::std::fmt::Debug for GraniteTimePickerClass {
544 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
545 f.debug_struct(&format!("GraniteTimePickerClass @ {self:p}"))
546 .finish()
547 }
548}
549
550#[repr(C)]
551#[allow(dead_code)]
552pub struct _GraniteTimePickerPrivate {
553 _data: [u8; 0],
554 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
555}
556
557pub type GraniteTimePickerPrivate = _GraniteTimePickerPrivate;
558
559#[derive(Copy, Clone)]
560#[repr(C)]
561pub struct GraniteToastClass {
562 pub parent_class: gtk::GtkWidgetClass,
563}
564
565impl ::std::fmt::Debug for GraniteToastClass {
566 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
567 f.debug_struct(&format!("GraniteToastClass @ {self:p}"))
568 .finish()
569 }
570}
571
572#[repr(C)]
573#[allow(dead_code)]
574pub struct _GraniteToastPrivate {
575 _data: [u8; 0],
576 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
577}
578
579pub type GraniteToastPrivate = _GraniteToastPrivate;
580
581#[derive(Copy, Clone)]
582#[repr(C)]
583pub struct GraniteValidatedEntryClass {
584 pub parent_class: gtk::GtkEntryClass,
585}
586
587impl ::std::fmt::Debug for GraniteValidatedEntryClass {
588 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
589 f.debug_struct(&format!("GraniteValidatedEntryClass @ {self:p}"))
590 .finish()
591 }
592}
593
594#[repr(C)]
595#[allow(dead_code)]
596pub struct _GraniteValidatedEntryPrivate {
597 _data: [u8; 0],
598 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
599}
600
601pub type GraniteValidatedEntryPrivate = _GraniteValidatedEntryPrivate;
602
603#[derive(Copy, Clone)]
605#[repr(C)]
606pub struct GraniteAccelLabel {
607 pub parent_instance: gtk::GtkBox,
608 pub priv_: *mut GraniteAccelLabelPrivate,
609}
610
611impl ::std::fmt::Debug for GraniteAccelLabel {
612 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
613 f.debug_struct(&format!("GraniteAccelLabel @ {self:p}"))
614 .finish()
615 }
616}
617
618#[derive(Copy, Clone)]
619#[repr(C)]
620pub struct GraniteBin {
621 pub parent_instance: gtk::GtkWidget,
622 pub priv_: *mut GraniteBinPrivate,
623}
624
625impl ::std::fmt::Debug for GraniteBin {
626 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
627 f.debug_struct(&format!("GraniteBin @ {self:p}")).finish()
628 }
629}
630
631#[derive(Copy, Clone)]
632#[repr(C)]
633pub struct GraniteDatePicker {
634 pub parent_instance: gtk::GtkEntry,
635 pub priv_: *mut GraniteDatePickerPrivate,
636}
637
638impl ::std::fmt::Debug for GraniteDatePicker {
639 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
640 f.debug_struct(&format!("GraniteDatePicker @ {self:p}"))
641 .finish()
642 }
643}
644
645#[derive(Copy, Clone)]
646#[repr(C)]
647pub struct GraniteDialog {
648 pub parent_instance: gtk::GtkDialog,
649 pub priv_: *mut GraniteDialogPrivate,
650}
651
652impl ::std::fmt::Debug for GraniteDialog {
653 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
654 f.debug_struct(&format!("GraniteDialog @ {self:p}"))
655 .finish()
656 }
657}
658
659#[derive(Copy, Clone)]
660#[repr(C)]
661pub struct GraniteHeaderLabel {
662 pub parent_instance: gtk::GtkWidget,
663 pub priv_: *mut GraniteHeaderLabelPrivate,
664}
665
666impl ::std::fmt::Debug for GraniteHeaderLabel {
667 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
668 f.debug_struct(&format!("GraniteHeaderLabel @ {self:p}"))
669 .finish()
670 }
671}
672
673#[derive(Copy, Clone)]
674#[repr(C)]
675pub struct GraniteHyperTextView {
676 pub parent_instance: gtk::GtkTextView,
677 pub priv_: *mut GraniteHyperTextViewPrivate,
678}
679
680impl ::std::fmt::Debug for GraniteHyperTextView {
681 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
682 f.debug_struct(&format!("GraniteHyperTextView @ {self:p}"))
683 .finish()
684 }
685}
686
687#[derive(Copy, Clone)]
688#[repr(C)]
689pub struct GraniteMessageDialog {
690 pub parent_instance: GraniteDialog,
691 pub priv_: *mut GraniteMessageDialogPrivate,
692}
693
694impl ::std::fmt::Debug for GraniteMessageDialog {
695 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
696 f.debug_struct(&format!("GraniteMessageDialog @ {self:p}"))
697 .finish()
698 }
699}
700
701#[derive(Copy, Clone)]
702#[repr(C)]
703pub struct GraniteModeSwitch {
704 pub parent_instance: gtk::GtkBox,
705 pub priv_: *mut GraniteModeSwitchPrivate,
706}
707
708impl ::std::fmt::Debug for GraniteModeSwitch {
709 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
710 f.debug_struct(&format!("GraniteModeSwitch @ {self:p}"))
711 .finish()
712 }
713}
714
715#[derive(Copy, Clone)]
716#[repr(C)]
717pub struct GraniteOverlayBar {
718 pub parent_instance: gtk::GtkWidget,
719 pub priv_: *mut GraniteOverlayBarPrivate,
720}
721
722impl ::std::fmt::Debug for GraniteOverlayBar {
723 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
724 f.debug_struct(&format!("GraniteOverlayBar @ {self:p}"))
725 .finish()
726 }
727}
728
729#[derive(Copy, Clone)]
730#[repr(C)]
731pub struct GranitePlaceholder {
732 pub parent_instance: gtk::GtkWidget,
733 pub priv_: *mut GranitePlaceholderPrivate,
734}
735
736impl ::std::fmt::Debug for GranitePlaceholder {
737 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
738 f.debug_struct(&format!("GranitePlaceholder @ {self:p}"))
739 .finish()
740 }
741}
742
743#[derive(Copy, Clone)]
744#[repr(C)]
745pub struct GraniteServicesContractorProxy {
746 pub parent_instance: gobject::GObject,
747 pub priv_: *mut GraniteServicesContractorProxyPrivate,
748}
749
750impl ::std::fmt::Debug for GraniteServicesContractorProxy {
751 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
752 f.debug_struct(&format!("GraniteServicesContractorProxy @ {self:p}"))
753 .finish()
754 }
755}
756
757#[derive(Copy, Clone)]
758#[repr(C)]
759pub struct GraniteServicesSystem {
760 pub parent_instance: gobject::GObject,
761 pub priv_: *mut GraniteServicesSystemPrivate,
762}
763
764impl ::std::fmt::Debug for GraniteServicesSystem {
765 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
766 f.debug_struct(&format!("GraniteServicesSystem @ {self:p}"))
767 .finish()
768 }
769}
770
771#[derive(Copy, Clone)]
772#[repr(C)]
773pub struct GraniteSettings {
774 pub parent_instance: gobject::GObject,
775 pub priv_: *mut GraniteSettingsPrivate,
776}
777
778impl ::std::fmt::Debug for GraniteSettings {
779 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
780 f.debug_struct(&format!("GraniteSettings @ {self:p}"))
781 .finish()
782 }
783}
784
785#[derive(Copy, Clone)]
786#[repr(C)]
787pub struct GraniteSettingsPage {
788 pub parent_instance: gtk::GtkBox,
789 pub _icon_name: *mut c_char,
790 pub _title: *mut c_char,
791 pub priv_: *mut GraniteSettingsPagePrivate,
792}
793
794impl ::std::fmt::Debug for GraniteSettingsPage {
795 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
796 f.debug_struct(&format!("GraniteSettingsPage @ {self:p}"))
797 .field("_icon_name", &self._icon_name)
798 .field("_title", &self._title)
799 .finish()
800 }
801}
802
803#[derive(Copy, Clone)]
804#[repr(C)]
805pub struct GraniteSettingsSidebar {
806 pub parent_instance: gtk::GtkWidget,
807 pub priv_: *mut GraniteSettingsSidebarPrivate,
808}
809
810impl ::std::fmt::Debug for GraniteSettingsSidebar {
811 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
812 f.debug_struct(&format!("GraniteSettingsSidebar @ {self:p}"))
813 .finish()
814 }
815}
816
817#[derive(Copy, Clone)]
818#[repr(C)]
819pub struct GraniteSimpleSettingsPage {
820 pub parent_instance: GraniteSettingsPage,
821 pub priv_: *mut GraniteSimpleSettingsPagePrivate,
822}
823
824impl ::std::fmt::Debug for GraniteSimpleSettingsPage {
825 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
826 f.debug_struct(&format!("GraniteSimpleSettingsPage @ {self:p}"))
827 .finish()
828 }
829}
830
831#[derive(Copy, Clone)]
832#[repr(C)]
833pub struct GraniteSwitchModelButton {
834 pub parent_instance: gtk::GtkToggleButton,
835 pub priv_: *mut GraniteSwitchModelButtonPrivate,
836}
837
838impl ::std::fmt::Debug for GraniteSwitchModelButton {
839 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
840 f.debug_struct(&format!("GraniteSwitchModelButton @ {self:p}"))
841 .finish()
842 }
843}
844
845#[derive(Copy, Clone)]
846#[repr(C)]
847pub struct GraniteTimePicker {
848 pub parent_instance: gtk::GtkEntry,
849 pub priv_: *mut GraniteTimePickerPrivate,
850}
851
852impl ::std::fmt::Debug for GraniteTimePicker {
853 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
854 f.debug_struct(&format!("GraniteTimePicker @ {self:p}"))
855 .finish()
856 }
857}
858
859#[derive(Copy, Clone)]
860#[repr(C)]
861pub struct GraniteToast {
862 pub parent_instance: gtk::GtkWidget,
863 pub priv_: *mut GraniteToastPrivate,
864}
865
866impl ::std::fmt::Debug for GraniteToast {
867 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
868 f.debug_struct(&format!("GraniteToast @ {self:p}")).finish()
869 }
870}
871
872#[derive(Copy, Clone)]
873#[repr(C)]
874pub struct GraniteValidatedEntry {
875 pub parent_instance: gtk::GtkEntry,
876 pub priv_: *mut GraniteValidatedEntryPrivate,
877}
878
879impl ::std::fmt::Debug for GraniteValidatedEntry {
880 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
881 f.debug_struct(&format!("GraniteValidatedEntry @ {self:p}"))
882 .finish()
883 }
884}
885
886#[repr(C)]
888#[allow(dead_code)]
889pub struct GraniteServicesContract {
890 _data: [u8; 0],
891 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
892}
893
894impl ::std::fmt::Debug for GraniteServicesContract {
895 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
896 write!(f, "GraniteServicesContract @ {self:p}")
897 }
898}
899
900#[repr(C)]
901#[allow(dead_code)]
902pub struct GraniteServicesSettingsSerializable {
903 _data: [u8; 0],
904 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
905}
906
907impl ::std::fmt::Debug for GraniteServicesSettingsSerializable {
908 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
909 write!(f, "GraniteServicesSettingsSerializable @ {self:p}")
910 }
911}
912
913extern "C" {
914
915 pub fn granite_services_contractor_error_get_type() -> GType;
919
920 pub fn granite_settings_color_scheme_get_type() -> GType;
924
925 pub fn granite_settings_page_status_type_get_type() -> GType;
929
930 #[cfg(feature = "v7_5")]
934 #[cfg_attr(docsrs, doc(cfg(feature = "v7_5")))]
935 pub fn granite_toast_dismiss_reason_get_type() -> GType;
936
937 pub fn granite_accel_label_get_type() -> GType;
941 pub fn granite_accel_label_get_action_name(self_: *mut GraniteAccelLabel) -> *const c_char;
942 pub fn granite_accel_label_set_action_name(self_: *mut GraniteAccelLabel, value: *const c_char);
943 pub fn granite_accel_label_get_accel_string(self_: *mut GraniteAccelLabel) -> *const c_char;
944 pub fn granite_accel_label_set_accel_string(
945 self_: *mut GraniteAccelLabel,
946 value: *const c_char,
947 );
948 pub fn granite_accel_label_get_label(self_: *mut GraniteAccelLabel) -> *const c_char;
949 pub fn granite_accel_label_set_label(self_: *mut GraniteAccelLabel, value: *const c_char);
950 pub fn granite_accel_label_new(
951 label: *const c_char,
952 accel_string: *const c_char,
953 ) -> *mut GraniteAccelLabel;
954 pub fn granite_accel_label_new_from_action_name(
955 label: *const c_char,
956 action_name: *const c_char,
957 ) -> *mut GraniteAccelLabel;
958
959 #[cfg(feature = "v7_6")]
963 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
964 pub fn granite_bin_get_type() -> GType;
965 #[cfg(feature = "v7_6")]
966 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
967 pub fn granite_bin_get_child(self_: *mut GraniteBin) -> *mut gtk::GtkWidget;
968 #[cfg(feature = "v7_6")]
969 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
970 pub fn granite_bin_set_child(self_: *mut GraniteBin, value: *mut gtk::GtkWidget);
971 #[cfg(feature = "v7_6")]
972 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
973 pub fn granite_bin_new() -> *mut GraniteBin;
974
975 pub fn granite_date_picker_get_type() -> GType;
979 pub fn granite_date_picker_get_format(self_: *mut GraniteDatePicker) -> *const c_char;
980 pub fn granite_date_picker_get_date(self_: *mut GraniteDatePicker) -> *mut glib::GDateTime;
981 pub fn granite_date_picker_set_date(self_: *mut GraniteDatePicker, value: *mut glib::GDateTime);
982 pub fn granite_date_picker_new_with_format(format: *const c_char) -> *mut GraniteDatePicker;
983 pub fn granite_date_picker_new() -> *mut GraniteDatePicker;
984
985 pub fn granite_dialog_get_type() -> GType;
989 pub fn granite_dialog_new() -> *mut GraniteDialog;
990 #[cfg(feature = "v7_5")]
991 #[cfg_attr(docsrs, doc(cfg(feature = "v7_5")))]
992 pub fn granite_dialog_add_button(
993 self_: *mut GraniteDialog,
994 button_text: *const c_char,
995 response_id: c_int,
996 ) -> *mut gtk::GtkWidget;
997
998 pub fn granite_header_label_get_type() -> GType;
1002 pub fn granite_header_label_get_label(self_: *mut GraniteHeaderLabel) -> *const c_char;
1003 pub fn granite_header_label_set_label(self_: *mut GraniteHeaderLabel, value: *const c_char);
1004 #[cfg(feature = "v7_4")]
1005 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1006 pub fn granite_header_label_get_mnemonic_widget(
1007 self_: *mut GraniteHeaderLabel,
1008 ) -> *mut gtk::GtkWidget;
1009 #[cfg(feature = "v7_4")]
1010 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1011 pub fn granite_header_label_set_mnemonic_widget(
1012 self_: *mut GraniteHeaderLabel,
1013 value: *mut gtk::GtkWidget,
1014 );
1015 #[cfg(feature = "v7_1")]
1016 #[cfg_attr(docsrs, doc(cfg(feature = "v7_1")))]
1017 pub fn granite_header_label_get_secondary_text(self_: *mut GraniteHeaderLabel)
1018 -> *const c_char;
1019 #[cfg(feature = "v7_1")]
1020 #[cfg_attr(docsrs, doc(cfg(feature = "v7_1")))]
1021 pub fn granite_header_label_set_secondary_text(
1022 self_: *mut GraniteHeaderLabel,
1023 value: *const c_char,
1024 );
1025 pub fn granite_header_label_new(label: *const c_char) -> *mut GraniteHeaderLabel;
1026
1027 pub fn granite_hyper_text_view_get_type() -> GType;
1031 pub fn granite_hyper_text_view_new() -> *mut GraniteHyperTextView;
1032
1033 pub fn granite_message_dialog_get_type() -> GType;
1037 pub fn granite_message_dialog_get_primary_text(
1038 self_: *mut GraniteMessageDialog,
1039 ) -> *const c_char;
1040 pub fn granite_message_dialog_set_primary_text(
1041 self_: *mut GraniteMessageDialog,
1042 value: *const c_char,
1043 );
1044 pub fn granite_message_dialog_get_secondary_text(
1045 self_: *mut GraniteMessageDialog,
1046 ) -> *const c_char;
1047 pub fn granite_message_dialog_set_secondary_text(
1048 self_: *mut GraniteMessageDialog,
1049 value: *const c_char,
1050 );
1051 pub fn granite_message_dialog_get_image_icon(
1052 self_: *mut GraniteMessageDialog,
1053 ) -> *mut gio::GIcon;
1054 pub fn granite_message_dialog_set_image_icon(
1055 self_: *mut GraniteMessageDialog,
1056 value: *mut gio::GIcon,
1057 );
1058 pub fn granite_message_dialog_get_badge_icon(
1059 self_: *mut GraniteMessageDialog,
1060 ) -> *mut gio::GIcon;
1061 pub fn granite_message_dialog_set_badge_icon(
1062 self_: *mut GraniteMessageDialog,
1063 value: *mut gio::GIcon,
1064 );
1065 pub fn granite_message_dialog_get_primary_label(
1066 self_: *mut GraniteMessageDialog,
1067 ) -> *mut gtk::GtkLabel;
1068 pub fn granite_message_dialog_get_secondary_label(
1069 self_: *mut GraniteMessageDialog,
1070 ) -> *mut gtk::GtkLabel;
1071 pub fn granite_message_dialog_get_custom_bin(
1072 self_: *mut GraniteMessageDialog,
1073 ) -> *mut gtk::GtkBox;
1074 pub fn granite_message_dialog_new(
1075 primary_text: *const c_char,
1076 secondary_text: *const c_char,
1077 image_icon: *mut gio::GIcon,
1078 buttons: gtk::GtkButtonsType,
1079 ) -> *mut GraniteMessageDialog;
1080 pub fn granite_message_dialog_new_with_image_from_icon_name(
1081 primary_text: *const c_char,
1082 secondary_text: *const c_char,
1083 image_icon_name: *const c_char,
1084 buttons: gtk::GtkButtonsType,
1085 ) -> *mut GraniteMessageDialog;
1086 pub fn granite_message_dialog_show_error_details(
1087 self_: *mut GraniteMessageDialog,
1088 error_message: *const c_char,
1089 );
1090
1091 pub fn granite_mode_switch_get_type() -> GType;
1095 pub fn granite_mode_switch_get_active(self_: *mut GraniteModeSwitch) -> gboolean;
1096 pub fn granite_mode_switch_set_active(self_: *mut GraniteModeSwitch, value: gboolean);
1097 pub fn granite_mode_switch_get_primary_icon_gicon(
1098 self_: *mut GraniteModeSwitch,
1099 ) -> *mut gio::GIcon;
1100 pub fn granite_mode_switch_set_primary_icon_gicon(
1101 self_: *mut GraniteModeSwitch,
1102 value: *mut gio::GIcon,
1103 );
1104 pub fn granite_mode_switch_get_primary_icon_name(
1105 self_: *mut GraniteModeSwitch,
1106 ) -> *const c_char;
1107 pub fn granite_mode_switch_set_primary_icon_name(
1108 self_: *mut GraniteModeSwitch,
1109 value: *const c_char,
1110 );
1111 pub fn granite_mode_switch_get_primary_icon_tooltip_text(
1112 self_: *mut GraniteModeSwitch,
1113 ) -> *const c_char;
1114 pub fn granite_mode_switch_set_primary_icon_tooltip_text(
1115 self_: *mut GraniteModeSwitch,
1116 value: *const c_char,
1117 );
1118 pub fn granite_mode_switch_get_secondary_icon_gicon(
1119 self_: *mut GraniteModeSwitch,
1120 ) -> *mut gio::GIcon;
1121 pub fn granite_mode_switch_set_secondary_icon_gicon(
1122 self_: *mut GraniteModeSwitch,
1123 value: *mut gio::GIcon,
1124 );
1125 pub fn granite_mode_switch_get_secondary_icon_name(
1126 self_: *mut GraniteModeSwitch,
1127 ) -> *const c_char;
1128 pub fn granite_mode_switch_set_secondary_icon_name(
1129 self_: *mut GraniteModeSwitch,
1130 value: *const c_char,
1131 );
1132 pub fn granite_mode_switch_get_secondary_icon_tooltip_text(
1133 self_: *mut GraniteModeSwitch,
1134 ) -> *const c_char;
1135 pub fn granite_mode_switch_set_secondary_icon_tooltip_text(
1136 self_: *mut GraniteModeSwitch,
1137 value: *const c_char,
1138 );
1139 pub fn granite_mode_switch_new(
1140 primary_icon_gicon: *mut gio::GIcon,
1141 secondary_icon_gicon: *mut gio::GIcon,
1142 ) -> *mut GraniteModeSwitch;
1143 pub fn granite_mode_switch_new_from_icon_name(
1144 primary_icon_name: *const c_char,
1145 secondary_icon_name: *const c_char,
1146 ) -> *mut GraniteModeSwitch;
1147
1148 pub fn granite_overlay_bar_get_type() -> GType;
1152 pub fn granite_overlay_bar_get_overlay(self_: *mut GraniteOverlayBar) -> *mut gtk::GtkOverlay;
1153 pub fn granite_overlay_bar_get_label(self_: *mut GraniteOverlayBar) -> *const c_char;
1154 pub fn granite_overlay_bar_set_label(self_: *mut GraniteOverlayBar, value: *const c_char);
1155 pub fn granite_overlay_bar_get_active(self_: *mut GraniteOverlayBar) -> gboolean;
1156 pub fn granite_overlay_bar_set_active(self_: *mut GraniteOverlayBar, value: gboolean);
1157 pub fn granite_overlay_bar_new(overlay: *mut gtk::GtkOverlay) -> *mut GraniteOverlayBar;
1158
1159 pub fn granite_placeholder_get_type() -> GType;
1163 pub fn granite_placeholder_get_title(self_: *mut GranitePlaceholder) -> *const c_char;
1164 pub fn granite_placeholder_set_title(self_: *mut GranitePlaceholder, value: *const c_char);
1165 pub fn granite_placeholder_get_description(self_: *mut GranitePlaceholder) -> *const c_char;
1166 pub fn granite_placeholder_set_description(
1167 self_: *mut GranitePlaceholder,
1168 value: *const c_char,
1169 );
1170 pub fn granite_placeholder_get_icon(self_: *mut GranitePlaceholder) -> *mut gio::GIcon;
1171 pub fn granite_placeholder_set_icon(self_: *mut GranitePlaceholder, value: *mut gio::GIcon);
1172 pub fn granite_placeholder_new(title: *const c_char) -> *mut GranitePlaceholder;
1173 pub fn granite_placeholder_append_button(
1174 self_: *mut GranitePlaceholder,
1175 icon: *mut gio::GIcon,
1176 label: *const c_char,
1177 description: *const c_char,
1178 ) -> *mut gtk::GtkButton;
1179
1180 pub fn granite_services_contractor_proxy_get_type() -> GType;
1184 pub fn granite_services_contractor_proxy_get_instance(
1185 error: *mut *mut glib::GError,
1186 ) -> *mut GraniteServicesContractorProxy;
1187
1188 pub fn granite_services_system_get_type() -> GType;
1192 pub fn granite_services_system_history_is_enabled() -> gboolean;
1193 pub fn granite_services_system_new() -> *mut GraniteServicesSystem;
1194
1195 pub fn granite_settings_get_type() -> GType;
1199 pub fn granite_settings_get_prefers_color_scheme(
1200 self_: *mut GraniteSettings,
1201 ) -> GraniteSettingsColorScheme;
1202 pub fn granite_settings_get_default() -> *mut GraniteSettings;
1203
1204 pub fn granite_settings_page_get_type() -> GType;
1208 pub fn granite_settings_page_get_status_type(
1209 self_: *mut GraniteSettingsPage,
1210 ) -> GraniteSettingsPageStatusType;
1211 pub fn granite_settings_page_set_status_type(
1212 self_: *mut GraniteSettingsPage,
1213 value: GraniteSettingsPageStatusType,
1214 );
1215 pub fn granite_settings_page_get_display_widget(
1216 self_: *mut GraniteSettingsPage,
1217 ) -> *mut gtk::GtkWidget;
1218 pub fn granite_settings_page_get_header(self_: *mut GraniteSettingsPage) -> *const c_char;
1219 pub fn granite_settings_page_get_status(self_: *mut GraniteSettingsPage) -> *const c_char;
1220 pub fn granite_settings_page_set_status(self_: *mut GraniteSettingsPage, value: *const c_char);
1221 pub fn granite_settings_page_get_icon_name(self_: *mut GraniteSettingsPage) -> *const c_char;
1222 pub fn granite_settings_page_set_icon_name(
1223 self_: *mut GraniteSettingsPage,
1224 value: *const c_char,
1225 );
1226 pub fn granite_settings_page_get_title(self_: *mut GraniteSettingsPage) -> *const c_char;
1227 pub fn granite_settings_page_set_title(self_: *mut GraniteSettingsPage, value: *const c_char);
1228 pub fn granite_settings_page_get_child(self_: *mut GraniteSettingsPage) -> *mut gtk::GtkWidget;
1229 pub fn granite_settings_page_set_child(
1230 self_: *mut GraniteSettingsPage,
1231 value: *mut gtk::GtkWidget,
1232 );
1233
1234 pub fn granite_settings_sidebar_get_type() -> GType;
1238 pub fn granite_settings_sidebar_get_stack(
1239 self_: *mut GraniteSettingsSidebar,
1240 ) -> *mut gtk::GtkStack;
1241 pub fn granite_settings_sidebar_get_visible_child_name(
1242 self_: *mut GraniteSettingsSidebar,
1243 ) -> *const c_char;
1244 pub fn granite_settings_sidebar_set_visible_child_name(
1245 self_: *mut GraniteSettingsSidebar,
1246 value: *const c_char,
1247 );
1248 pub fn granite_settings_sidebar_new(stack: *mut gtk::GtkStack) -> *mut GraniteSettingsSidebar;
1249
1250 pub fn granite_simple_settings_page_get_type() -> GType;
1254 pub fn granite_simple_settings_page_get_action_area(
1255 self_: *mut GraniteSimpleSettingsPage,
1256 ) -> *mut gtk::GtkBox;
1257 pub fn granite_simple_settings_page_get_content_area(
1258 self_: *mut GraniteSimpleSettingsPage,
1259 ) -> *mut gtk::GtkGrid;
1260 pub fn granite_simple_settings_page_get_status_switch(
1261 self_: *mut GraniteSimpleSettingsPage,
1262 ) -> *mut gtk::GtkSwitch;
1263 pub fn granite_simple_settings_page_get_activatable(
1264 self_: *mut GraniteSimpleSettingsPage,
1265 ) -> gboolean;
1266 pub fn granite_simple_settings_page_get_description(
1267 self_: *mut GraniteSimpleSettingsPage,
1268 ) -> *const c_char;
1269 pub fn granite_simple_settings_page_set_description(
1270 self_: *mut GraniteSimpleSettingsPage,
1271 value: *const c_char,
1272 );
1273
1274 pub fn granite_switch_model_button_get_type() -> GType;
1278 pub fn granite_switch_model_button_get_text(
1279 self_: *mut GraniteSwitchModelButton,
1280 ) -> *const c_char;
1281 pub fn granite_switch_model_button_set_text(
1282 self_: *mut GraniteSwitchModelButton,
1283 value: *const c_char,
1284 );
1285 pub fn granite_switch_model_button_get_description(
1286 self_: *mut GraniteSwitchModelButton,
1287 ) -> *const c_char;
1288 pub fn granite_switch_model_button_set_description(
1289 self_: *mut GraniteSwitchModelButton,
1290 value: *const c_char,
1291 );
1292 pub fn granite_switch_model_button_new(text: *const c_char) -> *mut GraniteSwitchModelButton;
1293
1294 pub fn granite_time_picker_get_type() -> GType;
1298 pub fn granite_time_picker_get_format_12(self_: *mut GraniteTimePicker) -> *const c_char;
1299 pub fn granite_time_picker_get_format_24(self_: *mut GraniteTimePicker) -> *const c_char;
1300 pub fn granite_time_picker_get_time(self_: *mut GraniteTimePicker) -> *mut glib::GDateTime;
1301 pub fn granite_time_picker_set_time(self_: *mut GraniteTimePicker, value: *mut glib::GDateTime);
1302 pub fn granite_time_picker_new_with_format(
1303 format_12: *const c_char,
1304 format_24: *const c_char,
1305 ) -> *mut GraniteTimePicker;
1306 pub fn granite_time_picker_new() -> *mut GraniteTimePicker;
1307
1308 pub fn granite_toast_get_type() -> GType;
1312 pub fn granite_toast_get_title(self_: *mut GraniteToast) -> *const c_char;
1313 pub fn granite_toast_set_title(self_: *mut GraniteToast, value: *const c_char);
1314 pub fn granite_toast_new(title: *const c_char) -> *mut GraniteToast;
1315 pub fn granite_toast_set_default_action(self_: *mut GraniteToast, label: *const c_char);
1316 pub fn granite_toast_send_notification(self_: *mut GraniteToast);
1317 #[cfg(feature = "v7_4")]
1318 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1319 pub fn granite_toast_withdraw(self_: *mut GraniteToast);
1320
1321 pub fn granite_validated_entry_get_type() -> GType;
1325 pub fn granite_validated_entry_get_is_valid(self_: *mut GraniteValidatedEntry) -> gboolean;
1326 pub fn granite_validated_entry_set_is_valid(self_: *mut GraniteValidatedEntry, value: gboolean);
1327 pub fn granite_validated_entry_get_min_length(self_: *mut GraniteValidatedEntry) -> c_int;
1328 pub fn granite_validated_entry_set_min_length(self_: *mut GraniteValidatedEntry, value: c_int);
1329 pub fn granite_validated_entry_get_regex(
1330 self_: *mut GraniteValidatedEntry,
1331 ) -> *mut glib::GRegex;
1332 pub fn granite_validated_entry_set_regex(
1333 self_: *mut GraniteValidatedEntry,
1334 value: *mut glib::GRegex,
1335 );
1336 pub fn granite_validated_entry_new_from_regex(
1337 regex_arg: *mut glib::GRegex,
1338 ) -> *mut GraniteValidatedEntry;
1339 pub fn granite_validated_entry_new() -> *mut GraniteValidatedEntry;
1340
1341 pub fn granite_services_contract_get_type() -> GType;
1345 pub fn granite_services_contract_get_display_name(
1346 self_: *mut GraniteServicesContract,
1347 ) -> *mut c_char;
1348 pub fn granite_services_contract_get_description(
1349 self_: *mut GraniteServicesContract,
1350 ) -> *mut c_char;
1351 pub fn granite_services_contract_get_icon(
1352 self_: *mut GraniteServicesContract,
1353 ) -> *mut gio::GIcon;
1354 pub fn granite_services_contract_execute_with_file(
1355 self_: *mut GraniteServicesContract,
1356 file: *mut gio::GFile,
1357 error: *mut *mut glib::GError,
1358 );
1359 pub fn granite_services_contract_execute_with_files(
1360 self_: *mut GraniteServicesContract,
1361 files: *mut *mut gio::GFile,
1362 files_length1: c_int,
1363 error: *mut *mut glib::GError,
1364 );
1365
1366 pub fn granite_services_settings_serializable_get_type() -> GType;
1370 pub fn granite_services_settings_serializable_settings_serialize(
1371 self_: *mut GraniteServicesSettingsSerializable,
1372 ) -> *mut c_char;
1373 pub fn granite_services_settings_serializable_settings_deserialize(
1374 self_: *mut GraniteServicesSettingsSerializable,
1375 s: *const c_char,
1376 );
1377
1378 pub fn granite_date_time_get_default_time_format(
1382 is_12h: gboolean,
1383 with_second: gboolean,
1384 ) -> *mut c_char;
1385 pub fn granite_date_time_get_relative_datetime(date_time: *mut glib::GDateTime) -> *mut c_char;
1386 pub fn granite_date_time_is_same_day(
1387 day1: *mut glib::GDateTime,
1388 day2: *mut glib::GDateTime,
1389 ) -> gboolean;
1390 pub fn granite_date_time_get_default_date_format(
1391 with_weekday: gboolean,
1392 with_day: gboolean,
1393 with_year: gboolean,
1394 ) -> *mut c_char;
1395 pub fn granite_date_time_seconds_to_time(seconds: c_int) -> *mut c_char;
1396 pub fn granite_services_application_set_badge(
1397 count: i64,
1398 _callback_: gio::GAsyncReadyCallback,
1399 _callback__target: *mut c_void,
1400 );
1401 pub fn granite_services_application_set_badge_finish(
1402 _res_: *mut gio::GAsyncResult,
1403 error: *mut *mut glib::GError,
1404 ) -> gboolean;
1405 pub fn granite_services_application_set_badge_visible(
1406 visible: gboolean,
1407 _callback_: gio::GAsyncReadyCallback,
1408 _callback__target: *mut c_void,
1409 );
1410 pub fn granite_services_application_set_badge_visible_finish(
1411 _res_: *mut gio::GAsyncResult,
1412 error: *mut *mut glib::GError,
1413 ) -> gboolean;
1414 pub fn granite_services_application_set_progress(
1415 progress: c_double,
1416 _callback_: gio::GAsyncReadyCallback,
1417 _callback__target: *mut c_void,
1418 );
1419 pub fn granite_services_application_set_progress_finish(
1420 _res_: *mut gio::GAsyncResult,
1421 error: *mut *mut glib::GError,
1422 ) -> gboolean;
1423 pub fn granite_services_application_set_progress_visible(
1424 visible: gboolean,
1425 _callback_: gio::GAsyncReadyCallback,
1426 _callback__target: *mut c_void,
1427 );
1428 pub fn granite_services_application_set_progress_visible_finish(
1429 _res_: *mut gio::GAsyncResult,
1430 error: *mut *mut glib::GError,
1431 ) -> gboolean;
1432 pub fn granite_widgets_utils_set_color_primary(
1433 window: *mut gtk::GtkWidget,
1434 color: *mut gdk::GdkRGBA,
1435 priority: c_int,
1436 ) -> *mut gtk::GtkCssProvider;
1437 #[cfg(feature = "v7_2")]
1438 #[cfg_attr(docsrs, doc(cfg(feature = "v7_2")))]
1439 pub fn granite_init();
1440 pub fn granite_accel_to_string(accel: *const c_char) -> *mut c_char;
1441 pub fn granite_markup_accel_tooltip(
1442 accels: *mut *mut c_char,
1443 accels_length1: c_int,
1444 description: *const c_char,
1445 ) -> *mut c_char;
1446 pub fn granite_contrasting_foreground_color(
1447 bg_color: *mut gdk::GdkRGBA,
1448 result: *mut gdk::GdkRGBA,
1449 );
1450
1451}