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 GraniteBoxSpacing = c_int;
36pub const GRANITE_BOX_SPACING_NONE: GraniteBoxSpacing = 0;
37pub const GRANITE_BOX_SPACING_HALF: GraniteBoxSpacing = 1;
38pub const GRANITE_BOX_SPACING_SINGLE: GraniteBoxSpacing = 2;
39pub const GRANITE_BOX_SPACING_DOUBLE: GraniteBoxSpacing = 3;
40pub const GRANITE_BOX_SPACING_LINKED: GraniteBoxSpacing = 4;
41
42pub type GraniteHeaderLabelSize = c_int;
43pub const GRANITE_HEADER_LABEL_SIZE_H1: GraniteHeaderLabelSize = 0;
44pub const GRANITE_HEADER_LABEL_SIZE_H2: GraniteHeaderLabelSize = 1;
45pub const GRANITE_HEADER_LABEL_SIZE_H3: GraniteHeaderLabelSize = 2;
46pub const GRANITE_HEADER_LABEL_SIZE_H4: GraniteHeaderLabelSize = 3;
47
48pub type GraniteServicesContractorError = c_int;
49pub const GRANITE_SERVICES_CONTRACTOR_ERROR_SERVICE_NOT_AVAILABLE: GraniteServicesContractorError =
50 0;
51
52pub type GraniteSettingsColorScheme = c_int;
53pub const GRANITE_SETTINGS_COLOR_SCHEME_NO_PREFERENCE: GraniteSettingsColorScheme = 0;
54pub const GRANITE_SETTINGS_COLOR_SCHEME_DARK: GraniteSettingsColorScheme = 1;
55pub const GRANITE_SETTINGS_COLOR_SCHEME_LIGHT: GraniteSettingsColorScheme = 2;
56
57pub type GraniteSettingsPageStatusType = c_int;
58pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_ERROR: GraniteSettingsPageStatusType = 0;
59pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_OFFLINE: GraniteSettingsPageStatusType = 1;
60pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_SUCCESS: GraniteSettingsPageStatusType = 2;
61pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_WARNING: GraniteSettingsPageStatusType = 3;
62pub const GRANITE_SETTINGS_PAGE_STATUS_TYPE_NONE: GraniteSettingsPageStatusType = 4;
63
64pub type GraniteToastDismissReason = c_int;
65pub const GRANITE_TOAST_DISMISS_REASON_EXPIRED: GraniteToastDismissReason = 1;
66pub const GRANITE_TOAST_DISMISS_REASON_CLOSED: GraniteToastDismissReason = 2;
67pub const GRANITE_TOAST_DISMISS_REASON_WITHDRAWN: GraniteToastDismissReason = 3;
68
69pub const GRANITE_CSS_CLASS_ACCENT: &[u8] = b"accent\0";
71pub const GRANITE_CSS_CLASS_CARD: &[u8] = b"card\0";
72pub const GRANITE_CSS_CLASS_CHECKERBOARD: &[u8] = b"checkerboard\0";
73pub const GRANITE_CSS_CLASS_CIRCULAR: &[u8] = b"circular\0";
74pub const GRANITE_CSS_CLASS_DESTRUCTIVE: &[u8] = b"destructive\0";
75pub const GRANITE_CSS_CLASS_DIM: &[u8] = b"dim-label\0";
76pub const GRANITE_CSS_CLASS_ERROR: &[u8] = b"error\0";
77pub const GRANITE_CSS_CLASS_NUMERIC: &[u8] = b"numeric\0";
78pub const GRANITE_CSS_CLASS_SMALL: &[u8] = b"small-label\0";
79pub const GRANITE_CSS_CLASS_SUGGESTED: &[u8] = b"suggested\0";
80pub const GRANITE_CSS_CLASS_SUCCESS: &[u8] = b"success\0";
81pub const GRANITE_CSS_CLASS_WARNING: &[u8] = b"warning\0";
82pub const GRANITE_CSS_CLASS_MONOSPACE: &[u8] = b"monospace\0";
83pub const GRANITE_SETTINGS_URI_LOCATION: &[u8] = b"settings://privacy/location\0";
84pub const GRANITE_SETTINGS_URI_ONLINE_ACCOUNTS: &[u8] = b"settings://accounts/online\0";
85pub const GRANITE_SETTINGS_URI_NETWORK: &[u8] = b"settings://network\0";
86pub const GRANITE_SETTINGS_URI_PERMISSIONS: &[u8] = b"settings://applications/permissions\0";
87pub const GRANITE_SETTINGS_URI_NOTIFICATIONS: &[u8] = b"settings://notifications\0";
88pub const GRANITE_SETTINGS_URI_SOUND_INPUT: &[u8] = b"settings://sound/input\0";
89pub const GRANITE_SETTINGS_URI_SHORTCUTS: &[u8] = b"settings://input/keyboard/shortcuts/custom\0";
90pub const GRANITE_STYLE_CLASS_ACCENT: &[u8] = b"accent\0";
91pub const GRANITE_STYLE_CLASS_BACK_BUTTON: &[u8] = b"back-button\0";
92pub const GRANITE_STYLE_CLASS_BACKGROUND: &[u8] = b"background\0";
93pub const GRANITE_STYLE_CLASS_BADGE: &[u8] = b"badge\0";
94pub const GRANITE_STYLE_CLASS_CARD: &[u8] = b"card\0";
95pub const GRANITE_STYLE_CLASS_CHECKERBOARD: &[u8] = b"checkerboard\0";
96pub const GRANITE_STYLE_CLASS_CIRCULAR: &[u8] = b"circular\0";
97pub const GRANITE_STYLE_CLASS_COLOR_BUTTON: &[u8] = b"color-button\0";
98pub const GRANITE_STYLE_CLASS_DEFAULT_DECORATION: &[u8] = b"default-decoration\0";
99pub const GRANITE_STYLE_CLASS_DESTRUCTIVE_ACTION: &[u8] = b"destructive-action\0";
100pub const GRANITE_STYLE_CLASS_DIALOG_CONTENT_AREA: &[u8] = b"dialog-content-area\0";
101pub const GRANITE_STYLE_CLASS_FRAME: &[u8] = b"frame\0";
102pub const GRANITE_STYLE_CLASS_H1_LABEL: &[u8] = b"title-1\0";
103pub const GRANITE_STYLE_CLASS_H2_LABEL: &[u8] = b"title-2\0";
104pub const GRANITE_STYLE_CLASS_H3_LABEL: &[u8] = b"title-3\0";
105pub const GRANITE_STYLE_CLASS_H4_LABEL: &[u8] = b"title-4\0";
106pub const GRANITE_STYLE_CLASS_KEYCAP: &[u8] = b"keycap\0";
107pub const GRANITE_STYLE_CLASS_LARGE_ICONS: &[u8] = b"large-icons\0";
108pub const GRANITE_STYLE_CLASS_MODE_SWITCH: &[u8] = b"mode-switch\0";
109pub const GRANITE_STYLE_CLASS_OSD: &[u8] = b"osd\0";
110pub const GRANITE_STYLE_CLASS_ROUNDED: &[u8] = b"rounded\0";
111pub const GRANITE_STYLE_CLASS_SIDEBAR: &[u8] = b"sidebar\0";
112pub const GRANITE_STYLE_CLASS_SMALL_LABEL: &[u8] = b"small-label\0";
113pub const GRANITE_STYLE_CLASS_SUCCESS: &[u8] = b"success\0";
114pub const GRANITE_STYLE_CLASS_TERMINAL: &[u8] = b"terminal\0";
115pub const GRANITE_STYLE_CLASS_TITLE_LABEL: &[u8] = b"title\0";
116pub const GRANITE_STYLE_CLASS_WARMTH: &[u8] = b"warmth\0";
117pub const GRANITE_STYLE_CLASS_TEMPERATURE: &[u8] = b"temperature\0";
118pub const GRANITE_STYLE_CLASS_LINKED: &[u8] = b"linked\0";
119pub const GRANITE_STYLE_CLASS_MENU: &[u8] = b"menu\0";
120pub const GRANITE_STYLE_CLASS_MENUITEM: &[u8] = b"menuitem\0";
121pub const GRANITE_STYLE_CLASS_DIM_LABEL: &[u8] = b"dim-label\0";
122pub const GRANITE_STYLE_CLASS_ERROR: &[u8] = b"error\0";
123pub const GRANITE_STYLE_CLASS_FLAT: &[u8] = b"flat\0";
124pub const GRANITE_STYLE_CLASS_MESSAGE_DIALOG: &[u8] = b"message\0";
125pub const GRANITE_STYLE_CLASS_RICH_LIST: &[u8] = b"rich-list\0";
126pub const GRANITE_STYLE_CLASS_SUGGESTED_ACTION: &[u8] = b"suggested-action\0";
127pub const GRANITE_STYLE_CLASS_VIEW: &[u8] = b"view\0";
128pub const GRANITE_STYLE_CLASS_WARNING: &[u8] = b"warning\0";
129pub const GRANITE_TRANSITION_DURATION_CLOSE: c_int = 200;
130pub const GRANITE_TRANSITION_DURATION_IN_PLACE: c_int = 100;
131pub const GRANITE_TRANSITION_DURATION_OPEN: c_int = 250;
132pub const GRANITE_TOOLTIP_SECONDARY_TEXT_MARKUP: &[u8] =
133 b"<span weight=\"600\" size=\"smaller\" alpha=\"75%\">%s</span>\0";
134
135#[derive(Copy, Clone)]
137#[repr(C)]
138pub struct GraniteAccelLabelClass {
139 pub parent_class: gtk::GtkBoxClass,
140}
141
142impl ::std::fmt::Debug for GraniteAccelLabelClass {
143 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
144 f.debug_struct(&format!("GraniteAccelLabelClass @ {self:p}"))
145 .finish()
146 }
147}
148
149#[repr(C)]
150#[allow(dead_code)]
151pub struct _GraniteAccelLabelPrivate {
152 _data: [u8; 0],
153 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
154}
155
156pub type GraniteAccelLabelPrivate = _GraniteAccelLabelPrivate;
157
158#[derive(Copy, Clone)]
159#[repr(C)]
160pub struct GraniteBackButtonClass {
161 pub parent_class: gtk::GtkButtonClass,
162}
163
164impl ::std::fmt::Debug for GraniteBackButtonClass {
165 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
166 f.debug_struct(&format!("GraniteBackButtonClass @ {self:p}"))
167 .finish()
168 }
169}
170
171#[repr(C)]
172#[allow(dead_code)]
173pub struct _GraniteBackButtonPrivate {
174 _data: [u8; 0],
175 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
176}
177
178pub type GraniteBackButtonPrivate = _GraniteBackButtonPrivate;
179
180#[derive(Copy, Clone)]
181#[repr(C)]
182pub struct GraniteBinClass {
183 pub parent_class: gtk::GtkWidgetClass,
184}
185
186impl ::std::fmt::Debug for GraniteBinClass {
187 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
188 f.debug_struct(&format!("GraniteBinClass @ {self:p}"))
189 .finish()
190 }
191}
192
193#[repr(C)]
194#[allow(dead_code)]
195pub struct _GraniteBinPrivate {
196 _data: [u8; 0],
197 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
198}
199
200pub type GraniteBinPrivate = _GraniteBinPrivate;
201
202#[derive(Copy, Clone)]
203#[repr(C)]
204pub struct GraniteBoxClass {
205 pub parent_class: gtk::GtkBoxClass,
206}
207
208impl ::std::fmt::Debug for GraniteBoxClass {
209 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
210 f.debug_struct(&format!("GraniteBoxClass @ {self:p}"))
211 .finish()
212 }
213}
214
215#[repr(C)]
216#[allow(dead_code)]
217pub struct _GraniteBoxPrivate {
218 _data: [u8; 0],
219 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
220}
221
222pub type GraniteBoxPrivate = _GraniteBoxPrivate;
223
224#[derive(Copy, Clone)]
225#[repr(C)]
226pub struct GraniteDatePickerClass {
227 pub parent_class: gtk::GtkEntryClass,
228}
229
230impl ::std::fmt::Debug for GraniteDatePickerClass {
231 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
232 f.debug_struct(&format!("GraniteDatePickerClass @ {self:p}"))
233 .finish()
234 }
235}
236
237#[repr(C)]
238#[allow(dead_code)]
239pub struct _GraniteDatePickerPrivate {
240 _data: [u8; 0],
241 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
242}
243
244pub type GraniteDatePickerPrivate = _GraniteDatePickerPrivate;
245
246#[derive(Copy, Clone)]
247#[repr(C)]
248pub struct GraniteDialogClass {
249 pub parent_class: gtk::GtkDialogClass,
250}
251
252impl ::std::fmt::Debug for GraniteDialogClass {
253 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
254 f.debug_struct(&format!("GraniteDialogClass @ {self:p}"))
255 .finish()
256 }
257}
258
259#[repr(C)]
260#[allow(dead_code)]
261pub struct _GraniteDialogPrivate {
262 _data: [u8; 0],
263 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
264}
265
266pub type GraniteDialogPrivate = _GraniteDialogPrivate;
267
268#[derive(Copy, Clone)]
269#[repr(C)]
270pub struct GraniteHeaderLabelClass {
271 pub parent_class: gtk::GtkWidgetClass,
272}
273
274impl ::std::fmt::Debug for GraniteHeaderLabelClass {
275 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
276 f.debug_struct(&format!("GraniteHeaderLabelClass @ {self:p}"))
277 .finish()
278 }
279}
280
281#[repr(C)]
282#[allow(dead_code)]
283pub struct _GraniteHeaderLabelPrivate {
284 _data: [u8; 0],
285 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
286}
287
288pub type GraniteHeaderLabelPrivate = _GraniteHeaderLabelPrivate;
289
290#[derive(Copy, Clone)]
291#[repr(C)]
292pub struct GraniteHyperTextViewClass {
293 pub parent_class: gtk::GtkTextViewClass,
294}
295
296impl ::std::fmt::Debug for GraniteHyperTextViewClass {
297 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
298 f.debug_struct(&format!("GraniteHyperTextViewClass @ {self:p}"))
299 .finish()
300 }
301}
302
303#[repr(C)]
304#[allow(dead_code)]
305pub struct _GraniteHyperTextViewPrivate {
306 _data: [u8; 0],
307 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
308}
309
310pub type GraniteHyperTextViewPrivate = _GraniteHyperTextViewPrivate;
311
312#[derive(Copy, Clone)]
313#[repr(C)]
314pub struct GraniteListItemClass {
315 pub parent_class: gtk::GtkWidgetClass,
316}
317
318impl ::std::fmt::Debug for GraniteListItemClass {
319 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
320 f.debug_struct(&format!("GraniteListItemClass @ {self:p}"))
321 .finish()
322 }
323}
324
325#[repr(C)]
326#[allow(dead_code)]
327pub struct _GraniteListItemPrivate {
328 _data: [u8; 0],
329 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
330}
331
332pub type GraniteListItemPrivate = _GraniteListItemPrivate;
333
334#[derive(Copy, Clone)]
335#[repr(C)]
336pub struct GraniteMessageDialogClass {
337 pub parent_class: GraniteDialogClass,
338}
339
340impl ::std::fmt::Debug for GraniteMessageDialogClass {
341 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
342 f.debug_struct(&format!("GraniteMessageDialogClass @ {self:p}"))
343 .finish()
344 }
345}
346
347#[repr(C)]
348#[allow(dead_code)]
349pub struct _GraniteMessageDialogPrivate {
350 _data: [u8; 0],
351 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
352}
353
354pub type GraniteMessageDialogPrivate = _GraniteMessageDialogPrivate;
355
356#[derive(Copy, Clone)]
357#[repr(C)]
358pub struct GraniteModeSwitchClass {
359 pub parent_class: gtk::GtkBoxClass,
360}
361
362impl ::std::fmt::Debug for GraniteModeSwitchClass {
363 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
364 f.debug_struct(&format!("GraniteModeSwitchClass @ {self:p}"))
365 .finish()
366 }
367}
368
369#[repr(C)]
370#[allow(dead_code)]
371pub struct _GraniteModeSwitchPrivate {
372 _data: [u8; 0],
373 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
374}
375
376pub type GraniteModeSwitchPrivate = _GraniteModeSwitchPrivate;
377
378#[derive(Copy, Clone)]
379#[repr(C)]
380pub struct GraniteOverlayBarClass {
381 pub parent_class: gtk::GtkWidgetClass,
382}
383
384impl ::std::fmt::Debug for GraniteOverlayBarClass {
385 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
386 f.debug_struct(&format!("GraniteOverlayBarClass @ {self:p}"))
387 .finish()
388 }
389}
390
391#[repr(C)]
392#[allow(dead_code)]
393pub struct _GraniteOverlayBarPrivate {
394 _data: [u8; 0],
395 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
396}
397
398pub type GraniteOverlayBarPrivate = _GraniteOverlayBarPrivate;
399
400#[derive(Copy, Clone)]
401#[repr(C)]
402pub struct GranitePlaceholderClass {
403 pub parent_class: gtk::GtkWidgetClass,
404}
405
406impl ::std::fmt::Debug for GranitePlaceholderClass {
407 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
408 f.debug_struct(&format!("GranitePlaceholderClass @ {self:p}"))
409 .finish()
410 }
411}
412
413#[repr(C)]
414#[allow(dead_code)]
415pub struct _GranitePlaceholderPrivate {
416 _data: [u8; 0],
417 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
418}
419
420pub type GranitePlaceholderPrivate = _GranitePlaceholderPrivate;
421
422#[derive(Copy, Clone)]
423#[repr(C)]
424pub struct GraniteServicesContractIface {
425 pub parent_iface: gobject::GTypeInterface,
426 pub get_display_name: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut c_char>,
427 pub get_description: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut c_char>,
428 pub get_icon: Option<unsafe extern "C" fn(*mut GraniteServicesContract) -> *mut gio::GIcon>,
429 pub execute_with_file: Option<
430 unsafe extern "C" fn(*mut GraniteServicesContract, *mut gio::GFile, *mut *mut glib::GError),
431 >,
432 pub execute_with_files: Option<
433 unsafe extern "C" fn(
434 *mut GraniteServicesContract,
435 *mut *mut gio::GFile,
436 c_int,
437 *mut *mut glib::GError,
438 ),
439 >,
440}
441
442impl ::std::fmt::Debug for GraniteServicesContractIface {
443 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
444 f.debug_struct(&format!("GraniteServicesContractIface @ {self:p}"))
445 .field("get_display_name", &self.get_display_name)
446 .field("get_description", &self.get_description)
447 .field("get_icon", &self.get_icon)
448 .field("execute_with_file", &self.execute_with_file)
449 .field("execute_with_files", &self.execute_with_files)
450 .finish()
451 }
452}
453
454#[derive(Copy, Clone)]
455#[repr(C)]
456pub struct GraniteServicesContractorProxyClass {
457 pub parent_class: gobject::GObjectClass,
458}
459
460impl ::std::fmt::Debug for GraniteServicesContractorProxyClass {
461 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
462 f.debug_struct(&format!("GraniteServicesContractorProxyClass @ {self:p}"))
463 .finish()
464 }
465}
466
467#[repr(C)]
468#[allow(dead_code)]
469pub struct _GraniteServicesContractorProxyPrivate {
470 _data: [u8; 0],
471 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
472}
473
474pub type GraniteServicesContractorProxyPrivate = _GraniteServicesContractorProxyPrivate;
475
476#[derive(Copy, Clone)]
477#[repr(C)]
478pub struct GraniteServicesSettingsSerializableIface {
479 pub parent_iface: gobject::GTypeInterface,
480 pub settings_serialize:
481 Option<unsafe extern "C" fn(*mut GraniteServicesSettingsSerializable) -> *mut c_char>,
482 pub settings_deserialize:
483 Option<unsafe extern "C" fn(*mut GraniteServicesSettingsSerializable, *const c_char)>,
484}
485
486impl ::std::fmt::Debug for GraniteServicesSettingsSerializableIface {
487 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
488 f.debug_struct(&format!(
489 "GraniteServicesSettingsSerializableIface @ {self:p}"
490 ))
491 .field("settings_serialize", &self.settings_serialize)
492 .field("settings_deserialize", &self.settings_deserialize)
493 .finish()
494 }
495}
496
497#[derive(Copy, Clone)]
498#[repr(C)]
499pub struct GraniteServicesSystemClass {
500 pub parent_class: gobject::GObjectClass,
501}
502
503impl ::std::fmt::Debug for GraniteServicesSystemClass {
504 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
505 f.debug_struct(&format!("GraniteServicesSystemClass @ {self:p}"))
506 .finish()
507 }
508}
509
510#[repr(C)]
511#[allow(dead_code)]
512pub struct _GraniteServicesSystemPrivate {
513 _data: [u8; 0],
514 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
515}
516
517pub type GraniteServicesSystemPrivate = _GraniteServicesSystemPrivate;
518
519#[derive(Copy, Clone)]
520#[repr(C)]
521pub struct GraniteSettingsClass {
522 pub parent_class: gobject::GObjectClass,
523}
524
525impl ::std::fmt::Debug for GraniteSettingsClass {
526 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
527 f.debug_struct(&format!("GraniteSettingsClass @ {self:p}"))
528 .finish()
529 }
530}
531
532#[derive(Copy, Clone)]
533#[repr(C)]
534pub struct GraniteSettingsPageClass {
535 pub parent_class: gtk::GtkBoxClass,
536}
537
538impl ::std::fmt::Debug for GraniteSettingsPageClass {
539 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
540 f.debug_struct(&format!("GraniteSettingsPageClass @ {self:p}"))
541 .finish()
542 }
543}
544
545#[repr(C)]
546#[allow(dead_code)]
547pub struct _GraniteSettingsPagePrivate {
548 _data: [u8; 0],
549 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
550}
551
552pub type GraniteSettingsPagePrivate = _GraniteSettingsPagePrivate;
553
554#[repr(C)]
555#[allow(dead_code)]
556pub struct _GraniteSettingsPrivate {
557 _data: [u8; 0],
558 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
559}
560
561pub type GraniteSettingsPrivate = _GraniteSettingsPrivate;
562
563#[derive(Copy, Clone)]
564#[repr(C)]
565pub struct GraniteSettingsSidebarClass {
566 pub parent_class: gtk::GtkWidgetClass,
567}
568
569impl ::std::fmt::Debug for GraniteSettingsSidebarClass {
570 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
571 f.debug_struct(&format!("GraniteSettingsSidebarClass @ {self:p}"))
572 .finish()
573 }
574}
575
576#[repr(C)]
577#[allow(dead_code)]
578pub struct _GraniteSettingsSidebarPrivate {
579 _data: [u8; 0],
580 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
581}
582
583pub type GraniteSettingsSidebarPrivate = _GraniteSettingsSidebarPrivate;
584
585#[derive(Copy, Clone)]
586#[repr(C)]
587pub struct GraniteSimpleSettingsPageClass {
588 pub parent_class: GraniteSettingsPageClass,
589}
590
591impl ::std::fmt::Debug for GraniteSimpleSettingsPageClass {
592 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
593 f.debug_struct(&format!("GraniteSimpleSettingsPageClass @ {self:p}"))
594 .finish()
595 }
596}
597
598#[repr(C)]
599#[allow(dead_code)]
600pub struct _GraniteSimpleSettingsPagePrivate {
601 _data: [u8; 0],
602 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
603}
604
605pub type GraniteSimpleSettingsPagePrivate = _GraniteSimpleSettingsPagePrivate;
606
607#[derive(Copy, Clone)]
608#[repr(C)]
609pub struct GraniteStyleManagerClass {
610 pub parent_class: gobject::GObjectClass,
611}
612
613impl ::std::fmt::Debug for GraniteStyleManagerClass {
614 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
615 f.debug_struct(&format!("GraniteStyleManagerClass @ {self:p}"))
616 .finish()
617 }
618}
619
620#[repr(C)]
621#[allow(dead_code)]
622pub struct _GraniteStyleManagerPrivate {
623 _data: [u8; 0],
624 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
625}
626
627pub type GraniteStyleManagerPrivate = _GraniteStyleManagerPrivate;
628
629#[derive(Copy, Clone)]
630#[repr(C)]
631pub struct GraniteSwitchModelButtonClass {
632 pub parent_class: gtk::GtkToggleButtonClass,
633}
634
635impl ::std::fmt::Debug for GraniteSwitchModelButtonClass {
636 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
637 f.debug_struct(&format!("GraniteSwitchModelButtonClass @ {self:p}"))
638 .finish()
639 }
640}
641
642#[repr(C)]
643#[allow(dead_code)]
644pub struct _GraniteSwitchModelButtonPrivate {
645 _data: [u8; 0],
646 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
647}
648
649pub type GraniteSwitchModelButtonPrivate = _GraniteSwitchModelButtonPrivate;
650
651#[derive(Copy, Clone)]
652#[repr(C)]
653pub struct GraniteTimePickerClass {
654 pub parent_class: gtk::GtkEntryClass,
655}
656
657impl ::std::fmt::Debug for GraniteTimePickerClass {
658 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
659 f.debug_struct(&format!("GraniteTimePickerClass @ {self:p}"))
660 .finish()
661 }
662}
663
664#[repr(C)]
665#[allow(dead_code)]
666pub struct _GraniteTimePickerPrivate {
667 _data: [u8; 0],
668 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
669}
670
671pub type GraniteTimePickerPrivate = _GraniteTimePickerPrivate;
672
673#[derive(Copy, Clone)]
674#[repr(C)]
675pub struct GraniteToastClass {
676 pub parent_class: gtk::GtkWidgetClass,
677}
678
679impl ::std::fmt::Debug for GraniteToastClass {
680 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
681 f.debug_struct(&format!("GraniteToastClass @ {self:p}"))
682 .finish()
683 }
684}
685
686#[repr(C)]
687#[allow(dead_code)]
688pub struct _GraniteToastPrivate {
689 _data: [u8; 0],
690 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
691}
692
693pub type GraniteToastPrivate = _GraniteToastPrivate;
694
695#[derive(Copy, Clone)]
696#[repr(C)]
697pub struct GraniteToolBoxClass {
698 pub parent_class: gtk::GtkWidgetClass,
699}
700
701impl ::std::fmt::Debug for GraniteToolBoxClass {
702 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
703 f.debug_struct(&format!("GraniteToolBoxClass @ {self:p}"))
704 .finish()
705 }
706}
707
708#[repr(C)]
709#[allow(dead_code)]
710pub struct _GraniteToolBoxPrivate {
711 _data: [u8; 0],
712 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
713}
714
715pub type GraniteToolBoxPrivate = _GraniteToolBoxPrivate;
716
717#[derive(Copy, Clone)]
718#[repr(C)]
719pub struct GraniteValidatedEntryClass {
720 pub parent_class: gtk::GtkEntryClass,
721}
722
723impl ::std::fmt::Debug for GraniteValidatedEntryClass {
724 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
725 f.debug_struct(&format!("GraniteValidatedEntryClass @ {self:p}"))
726 .finish()
727 }
728}
729
730#[repr(C)]
731#[allow(dead_code)]
732pub struct _GraniteValidatedEntryPrivate {
733 _data: [u8; 0],
734 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
735}
736
737pub type GraniteValidatedEntryPrivate = _GraniteValidatedEntryPrivate;
738
739#[derive(Copy, Clone)]
741#[repr(C)]
742pub struct GraniteAccelLabel {
743 pub parent_instance: gtk::GtkBox,
744 pub priv_: *mut GraniteAccelLabelPrivate,
745}
746
747impl ::std::fmt::Debug for GraniteAccelLabel {
748 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
749 f.debug_struct(&format!("GraniteAccelLabel @ {self:p}"))
750 .finish()
751 }
752}
753
754#[derive(Copy, Clone)]
755#[repr(C)]
756pub struct GraniteBackButton {
757 pub parent_instance: gtk::GtkButton,
758 pub priv_: *mut GraniteBackButtonPrivate,
759}
760
761impl ::std::fmt::Debug for GraniteBackButton {
762 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
763 f.debug_struct(&format!("GraniteBackButton @ {self:p}"))
764 .finish()
765 }
766}
767
768#[derive(Copy, Clone)]
769#[repr(C)]
770pub struct GraniteBin {
771 pub parent_instance: gtk::GtkWidget,
772 pub priv_: *mut GraniteBinPrivate,
773}
774
775impl ::std::fmt::Debug for GraniteBin {
776 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
777 f.debug_struct(&format!("GraniteBin @ {self:p}")).finish()
778 }
779}
780
781#[derive(Copy, Clone)]
782#[repr(C)]
783pub struct GraniteBox {
784 pub parent_instance: gtk::GtkBox,
785 pub priv_: *mut GraniteBoxPrivate,
786}
787
788impl ::std::fmt::Debug for GraniteBox {
789 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
790 f.debug_struct(&format!("GraniteBox @ {self:p}")).finish()
791 }
792}
793
794#[derive(Copy, Clone)]
795#[repr(C)]
796pub struct GraniteDatePicker {
797 pub parent_instance: gtk::GtkEntry,
798 pub priv_: *mut GraniteDatePickerPrivate,
799}
800
801impl ::std::fmt::Debug for GraniteDatePicker {
802 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
803 f.debug_struct(&format!("GraniteDatePicker @ {self:p}"))
804 .finish()
805 }
806}
807
808#[derive(Copy, Clone)]
809#[repr(C)]
810pub struct GraniteDialog {
811 pub parent_instance: gtk::GtkDialog,
812 pub priv_: *mut GraniteDialogPrivate,
813}
814
815impl ::std::fmt::Debug for GraniteDialog {
816 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
817 f.debug_struct(&format!("GraniteDialog @ {self:p}"))
818 .finish()
819 }
820}
821
822#[derive(Copy, Clone)]
823#[repr(C)]
824pub struct GraniteHeaderLabel {
825 pub parent_instance: gtk::GtkWidget,
826 pub priv_: *mut GraniteHeaderLabelPrivate,
827}
828
829impl ::std::fmt::Debug for GraniteHeaderLabel {
830 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
831 f.debug_struct(&format!("GraniteHeaderLabel @ {self:p}"))
832 .finish()
833 }
834}
835
836#[derive(Copy, Clone)]
837#[repr(C)]
838pub struct GraniteHyperTextView {
839 pub parent_instance: gtk::GtkTextView,
840 pub priv_: *mut GraniteHyperTextViewPrivate,
841}
842
843impl ::std::fmt::Debug for GraniteHyperTextView {
844 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
845 f.debug_struct(&format!("GraniteHyperTextView @ {self:p}"))
846 .finish()
847 }
848}
849
850#[derive(Copy, Clone)]
851#[repr(C)]
852pub struct GraniteListItem {
853 pub parent_instance: gtk::GtkWidget,
854 pub priv_: *mut GraniteListItemPrivate,
855}
856
857impl ::std::fmt::Debug for GraniteListItem {
858 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
859 f.debug_struct(&format!("GraniteListItem @ {self:p}"))
860 .finish()
861 }
862}
863
864#[derive(Copy, Clone)]
865#[repr(C)]
866pub struct GraniteMessageDialog {
867 pub parent_instance: GraniteDialog,
868 pub priv_: *mut GraniteMessageDialogPrivate,
869}
870
871impl ::std::fmt::Debug for GraniteMessageDialog {
872 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
873 f.debug_struct(&format!("GraniteMessageDialog @ {self:p}"))
874 .finish()
875 }
876}
877
878#[derive(Copy, Clone)]
879#[repr(C)]
880pub struct GraniteModeSwitch {
881 pub parent_instance: gtk::GtkBox,
882 pub priv_: *mut GraniteModeSwitchPrivate,
883}
884
885impl ::std::fmt::Debug for GraniteModeSwitch {
886 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
887 f.debug_struct(&format!("GraniteModeSwitch @ {self:p}"))
888 .finish()
889 }
890}
891
892#[derive(Copy, Clone)]
893#[repr(C)]
894pub struct GraniteOverlayBar {
895 pub parent_instance: gtk::GtkWidget,
896 pub priv_: *mut GraniteOverlayBarPrivate,
897}
898
899impl ::std::fmt::Debug for GraniteOverlayBar {
900 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
901 f.debug_struct(&format!("GraniteOverlayBar @ {self:p}"))
902 .finish()
903 }
904}
905
906#[derive(Copy, Clone)]
907#[repr(C)]
908pub struct GranitePlaceholder {
909 pub parent_instance: gtk::GtkWidget,
910 pub priv_: *mut GranitePlaceholderPrivate,
911}
912
913impl ::std::fmt::Debug for GranitePlaceholder {
914 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
915 f.debug_struct(&format!("GranitePlaceholder @ {self:p}"))
916 .finish()
917 }
918}
919
920#[derive(Copy, Clone)]
921#[repr(C)]
922pub struct GraniteServicesContractorProxy {
923 pub parent_instance: gobject::GObject,
924 pub priv_: *mut GraniteServicesContractorProxyPrivate,
925}
926
927impl ::std::fmt::Debug for GraniteServicesContractorProxy {
928 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
929 f.debug_struct(&format!("GraniteServicesContractorProxy @ {self:p}"))
930 .finish()
931 }
932}
933
934#[derive(Copy, Clone)]
935#[repr(C)]
936pub struct GraniteServicesSystem {
937 pub parent_instance: gobject::GObject,
938 pub priv_: *mut GraniteServicesSystemPrivate,
939}
940
941impl ::std::fmt::Debug for GraniteServicesSystem {
942 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
943 f.debug_struct(&format!("GraniteServicesSystem @ {self:p}"))
944 .finish()
945 }
946}
947
948#[derive(Copy, Clone)]
949#[repr(C)]
950pub struct GraniteSettings {
951 pub parent_instance: gobject::GObject,
952 pub priv_: *mut GraniteSettingsPrivate,
953}
954
955impl ::std::fmt::Debug for GraniteSettings {
956 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
957 f.debug_struct(&format!("GraniteSettings @ {self:p}"))
958 .finish()
959 }
960}
961
962#[derive(Copy, Clone)]
963#[repr(C)]
964pub struct GraniteSettingsPage {
965 pub parent_instance: gtk::GtkBox,
966 pub _icon_name: *mut c_char,
967 pub _title: *mut c_char,
968 pub priv_: *mut GraniteSettingsPagePrivate,
969}
970
971impl ::std::fmt::Debug for GraniteSettingsPage {
972 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
973 f.debug_struct(&format!("GraniteSettingsPage @ {self:p}"))
974 .field("_icon_name", &self._icon_name)
975 .field("_title", &self._title)
976 .finish()
977 }
978}
979
980#[derive(Copy, Clone)]
981#[repr(C)]
982pub struct GraniteSettingsSidebar {
983 pub parent_instance: gtk::GtkWidget,
984 pub priv_: *mut GraniteSettingsSidebarPrivate,
985}
986
987impl ::std::fmt::Debug for GraniteSettingsSidebar {
988 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
989 f.debug_struct(&format!("GraniteSettingsSidebar @ {self:p}"))
990 .finish()
991 }
992}
993
994#[derive(Copy, Clone)]
995#[repr(C)]
996pub struct GraniteSimpleSettingsPage {
997 pub parent_instance: GraniteSettingsPage,
998 pub priv_: *mut GraniteSimpleSettingsPagePrivate,
999}
1000
1001impl ::std::fmt::Debug for GraniteSimpleSettingsPage {
1002 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1003 f.debug_struct(&format!("GraniteSimpleSettingsPage @ {self:p}"))
1004 .finish()
1005 }
1006}
1007
1008#[derive(Copy, Clone)]
1009#[repr(C)]
1010pub struct GraniteStyleManager {
1011 pub parent_instance: gobject::GObject,
1012 pub priv_: *mut GraniteStyleManagerPrivate,
1013}
1014
1015impl ::std::fmt::Debug for GraniteStyleManager {
1016 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1017 f.debug_struct(&format!("GraniteStyleManager @ {self:p}"))
1018 .finish()
1019 }
1020}
1021
1022#[derive(Copy, Clone)]
1023#[repr(C)]
1024pub struct GraniteSwitchModelButton {
1025 pub parent_instance: gtk::GtkToggleButton,
1026 pub priv_: *mut GraniteSwitchModelButtonPrivate,
1027}
1028
1029impl ::std::fmt::Debug for GraniteSwitchModelButton {
1030 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1031 f.debug_struct(&format!("GraniteSwitchModelButton @ {self:p}"))
1032 .finish()
1033 }
1034}
1035
1036#[derive(Copy, Clone)]
1037#[repr(C)]
1038pub struct GraniteTimePicker {
1039 pub parent_instance: gtk::GtkEntry,
1040 pub priv_: *mut GraniteTimePickerPrivate,
1041}
1042
1043impl ::std::fmt::Debug for GraniteTimePicker {
1044 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1045 f.debug_struct(&format!("GraniteTimePicker @ {self:p}"))
1046 .finish()
1047 }
1048}
1049
1050#[derive(Copy, Clone)]
1051#[repr(C)]
1052pub struct GraniteToast {
1053 pub parent_instance: gtk::GtkWidget,
1054 pub priv_: *mut GraniteToastPrivate,
1055}
1056
1057impl ::std::fmt::Debug for GraniteToast {
1058 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1059 f.debug_struct(&format!("GraniteToast @ {self:p}")).finish()
1060 }
1061}
1062
1063#[derive(Copy, Clone)]
1064#[repr(C)]
1065pub struct GraniteToolBox {
1066 pub parent_instance: gtk::GtkWidget,
1067 pub priv_: *mut GraniteToolBoxPrivate,
1068}
1069
1070impl ::std::fmt::Debug for GraniteToolBox {
1071 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1072 f.debug_struct(&format!("GraniteToolBox @ {self:p}"))
1073 .finish()
1074 }
1075}
1076
1077#[derive(Copy, Clone)]
1078#[repr(C)]
1079pub struct GraniteValidatedEntry {
1080 pub parent_instance: gtk::GtkEntry,
1081 pub priv_: *mut GraniteValidatedEntryPrivate,
1082}
1083
1084impl ::std::fmt::Debug for GraniteValidatedEntry {
1085 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1086 f.debug_struct(&format!("GraniteValidatedEntry @ {self:p}"))
1087 .finish()
1088 }
1089}
1090
1091#[repr(C)]
1093#[allow(dead_code)]
1094pub struct GraniteServicesContract {
1095 _data: [u8; 0],
1096 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1097}
1098
1099impl ::std::fmt::Debug for GraniteServicesContract {
1100 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1101 write!(f, "GraniteServicesContract @ {self:p}")
1102 }
1103}
1104
1105#[repr(C)]
1106#[allow(dead_code)]
1107pub struct GraniteServicesSettingsSerializable {
1108 _data: [u8; 0],
1109 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1110}
1111
1112impl ::std::fmt::Debug for GraniteServicesSettingsSerializable {
1113 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1114 write!(f, "GraniteServicesSettingsSerializable @ {self:p}")
1115 }
1116}
1117
1118extern "C" {
1119
1120 #[cfg(feature = "v7_7")]
1124 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1125 pub fn granite_box_spacing_get_type() -> GType;
1126
1127 #[cfg(feature = "v7_7")]
1131 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1132 pub fn granite_header_label_size_get_type() -> GType;
1133
1134 pub fn granite_services_contractor_error_get_type() -> GType;
1138
1139 pub fn granite_settings_color_scheme_get_type() -> GType;
1143
1144 pub fn granite_settings_page_status_type_get_type() -> GType;
1148
1149 #[cfg(feature = "v7_5")]
1153 #[cfg_attr(docsrs, doc(cfg(feature = "v7_5")))]
1154 pub fn granite_toast_dismiss_reason_get_type() -> GType;
1155
1156 pub fn granite_accel_label_get_type() -> GType;
1160 pub fn granite_accel_label_get_action_name(self_: *mut GraniteAccelLabel) -> *const c_char;
1161 pub fn granite_accel_label_set_action_name(self_: *mut GraniteAccelLabel, value: *const c_char);
1162 pub fn granite_accel_label_get_accel_string(self_: *mut GraniteAccelLabel) -> *const c_char;
1163 pub fn granite_accel_label_set_accel_string(
1164 self_: *mut GraniteAccelLabel,
1165 value: *const c_char,
1166 );
1167 pub fn granite_accel_label_get_label(self_: *mut GraniteAccelLabel) -> *const c_char;
1168 pub fn granite_accel_label_set_label(self_: *mut GraniteAccelLabel, value: *const c_char);
1169 pub fn granite_accel_label_new(
1170 label: *const c_char,
1171 accel_string: *const c_char,
1172 ) -> *mut GraniteAccelLabel;
1173 pub fn granite_accel_label_new_from_action_name(
1174 label: *const c_char,
1175 action_name: *const c_char,
1176 ) -> *mut GraniteAccelLabel;
1177
1178 #[cfg(feature = "v7_7")]
1182 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1183 pub fn granite_back_button_get_type() -> GType;
1184 #[cfg(feature = "v7_7")]
1185 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1186 pub fn granite_back_button_get_label(self_: *mut GraniteBackButton) -> *const c_char;
1187 #[cfg(feature = "v7_7")]
1188 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1189 pub fn granite_back_button_set_label(self_: *mut GraniteBackButton, value: *const c_char);
1190 #[cfg(feature = "v7_7")]
1191 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1192 pub fn granite_back_button_new(label: *const c_char) -> *mut GraniteBackButton;
1193
1194 #[cfg(feature = "v7_6")]
1198 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
1199 pub fn granite_bin_get_type() -> GType;
1200 #[cfg(feature = "v7_6")]
1201 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
1202 pub fn granite_bin_get_child(self_: *mut GraniteBin) -> *mut gtk::GtkWidget;
1203 #[cfg(feature = "v7_6")]
1204 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
1205 pub fn granite_bin_set_child(self_: *mut GraniteBin, value: *mut gtk::GtkWidget);
1206 #[cfg(feature = "v7_6")]
1207 #[cfg_attr(docsrs, doc(cfg(feature = "v7_6")))]
1208 pub fn granite_bin_new() -> *mut GraniteBin;
1209
1210 #[cfg(feature = "v7_7")]
1214 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1215 pub fn granite_box_get_type() -> GType;
1216 #[cfg(feature = "v7_7")]
1217 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1218 pub fn granite_box_get_child_spacing(self_: *mut GraniteBox) -> GraniteBoxSpacing;
1219 #[cfg(feature = "v7_7")]
1220 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1221 pub fn granite_box_set_child_spacing(self_: *mut GraniteBox, value: GraniteBoxSpacing);
1222 #[cfg(feature = "v7_7")]
1223 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1224 pub fn granite_box_new(
1225 orientation: gtk::GtkOrientation,
1226 child_spacing: GraniteBoxSpacing,
1227 ) -> *mut GraniteBox;
1228
1229 pub fn granite_date_picker_get_type() -> GType;
1233 pub fn granite_date_picker_get_format(self_: *mut GraniteDatePicker) -> *const c_char;
1234 pub fn granite_date_picker_get_date(self_: *mut GraniteDatePicker) -> *mut glib::GDateTime;
1235 pub fn granite_date_picker_set_date(self_: *mut GraniteDatePicker, value: *mut glib::GDateTime);
1236 pub fn granite_date_picker_new_with_format(format: *const c_char) -> *mut GraniteDatePicker;
1237 pub fn granite_date_picker_new() -> *mut GraniteDatePicker;
1238
1239 pub fn granite_dialog_get_type() -> GType;
1243 pub fn granite_dialog_new() -> *mut GraniteDialog;
1244 #[cfg(feature = "v7_5")]
1245 #[cfg_attr(docsrs, doc(cfg(feature = "v7_5")))]
1246 pub fn granite_dialog_add_button(
1247 self_: *mut GraniteDialog,
1248 button_text: *const c_char,
1249 response_id: c_int,
1250 ) -> *mut gtk::GtkWidget;
1251
1252 pub fn granite_header_label_get_type() -> GType;
1256 pub fn granite_header_label_get_label(self_: *mut GraniteHeaderLabel) -> *const c_char;
1257 pub fn granite_header_label_set_label(self_: *mut GraniteHeaderLabel, value: *const c_char);
1258 #[cfg(feature = "v7_4")]
1259 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1260 pub fn granite_header_label_get_mnemonic_widget(
1261 self_: *mut GraniteHeaderLabel,
1262 ) -> *mut gtk::GtkWidget;
1263 #[cfg(feature = "v7_4")]
1264 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1265 pub fn granite_header_label_set_mnemonic_widget(
1266 self_: *mut GraniteHeaderLabel,
1267 value: *mut gtk::GtkWidget,
1268 );
1269 #[cfg(feature = "v7_7")]
1270 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1271 pub fn granite_header_label_get_size(self_: *mut GraniteHeaderLabel) -> GraniteHeaderLabelSize;
1272 #[cfg(feature = "v7_7")]
1273 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1274 pub fn granite_header_label_set_size(
1275 self_: *mut GraniteHeaderLabel,
1276 value: GraniteHeaderLabelSize,
1277 );
1278 #[cfg(feature = "v7_1")]
1279 #[cfg_attr(docsrs, doc(cfg(feature = "v7_1")))]
1280 pub fn granite_header_label_get_secondary_text(self_: *mut GraniteHeaderLabel)
1281 -> *const c_char;
1282 #[cfg(feature = "v7_1")]
1283 #[cfg_attr(docsrs, doc(cfg(feature = "v7_1")))]
1284 pub fn granite_header_label_set_secondary_text(
1285 self_: *mut GraniteHeaderLabel,
1286 value: *const c_char,
1287 );
1288 pub fn granite_header_label_new(label: *const c_char) -> *mut GraniteHeaderLabel;
1289
1290 pub fn granite_hyper_text_view_get_type() -> GType;
1294 pub fn granite_hyper_text_view_new() -> *mut GraniteHyperTextView;
1295
1296 #[cfg(feature = "v7_7")]
1300 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1301 pub fn granite_list_item_get_type() -> GType;
1302 #[cfg(feature = "v7_7")]
1303 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1304 pub fn granite_list_item_get_text(self_: *mut GraniteListItem) -> *const c_char;
1305 #[cfg(feature = "v7_7")]
1306 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1307 pub fn granite_list_item_set_text(self_: *mut GraniteListItem, value: *const c_char);
1308 #[cfg(feature = "v7_7")]
1309 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1310 pub fn granite_list_item_get_description(self_: *mut GraniteListItem) -> *const c_char;
1311 #[cfg(feature = "v7_7")]
1312 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1313 pub fn granite_list_item_set_description(self_: *mut GraniteListItem, value: *const c_char);
1314 #[cfg(feature = "v7_7")]
1315 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1316 pub fn granite_list_item_get_child(self_: *mut GraniteListItem) -> *mut gtk::GtkWidget;
1317 #[cfg(feature = "v7_7")]
1318 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1319 pub fn granite_list_item_set_child(self_: *mut GraniteListItem, value: *mut gtk::GtkWidget);
1320 #[cfg(feature = "v7_7")]
1321 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1322 pub fn granite_list_item_new() -> *mut GraniteListItem;
1323
1324 pub fn granite_message_dialog_get_type() -> GType;
1328 pub fn granite_message_dialog_get_primary_text(
1329 self_: *mut GraniteMessageDialog,
1330 ) -> *const c_char;
1331 pub fn granite_message_dialog_set_primary_text(
1332 self_: *mut GraniteMessageDialog,
1333 value: *const c_char,
1334 );
1335 pub fn granite_message_dialog_get_secondary_text(
1336 self_: *mut GraniteMessageDialog,
1337 ) -> *const c_char;
1338 pub fn granite_message_dialog_set_secondary_text(
1339 self_: *mut GraniteMessageDialog,
1340 value: *const c_char,
1341 );
1342 pub fn granite_message_dialog_get_image_icon(
1343 self_: *mut GraniteMessageDialog,
1344 ) -> *mut gio::GIcon;
1345 pub fn granite_message_dialog_set_image_icon(
1346 self_: *mut GraniteMessageDialog,
1347 value: *mut gio::GIcon,
1348 );
1349 pub fn granite_message_dialog_get_badge_icon(
1350 self_: *mut GraniteMessageDialog,
1351 ) -> *mut gio::GIcon;
1352 pub fn granite_message_dialog_set_badge_icon(
1353 self_: *mut GraniteMessageDialog,
1354 value: *mut gio::GIcon,
1355 );
1356 pub fn granite_message_dialog_get_primary_label(
1357 self_: *mut GraniteMessageDialog,
1358 ) -> *mut gtk::GtkLabel;
1359 pub fn granite_message_dialog_get_secondary_label(
1360 self_: *mut GraniteMessageDialog,
1361 ) -> *mut gtk::GtkLabel;
1362 pub fn granite_message_dialog_get_custom_bin(
1363 self_: *mut GraniteMessageDialog,
1364 ) -> *mut gtk::GtkBox;
1365 pub fn granite_message_dialog_new(
1366 primary_text: *const c_char,
1367 secondary_text: *const c_char,
1368 image_icon: *mut gio::GIcon,
1369 buttons: gtk::GtkButtonsType,
1370 ) -> *mut GraniteMessageDialog;
1371 pub fn granite_message_dialog_new_with_image_from_icon_name(
1372 primary_text: *const c_char,
1373 secondary_text: *const c_char,
1374 image_icon_name: *const c_char,
1375 buttons: gtk::GtkButtonsType,
1376 ) -> *mut GraniteMessageDialog;
1377 pub fn granite_message_dialog_show_error_details(
1378 self_: *mut GraniteMessageDialog,
1379 error_message: *const c_char,
1380 );
1381
1382 pub fn granite_mode_switch_get_type() -> GType;
1386 pub fn granite_mode_switch_get_active(self_: *mut GraniteModeSwitch) -> gboolean;
1387 pub fn granite_mode_switch_set_active(self_: *mut GraniteModeSwitch, value: gboolean);
1388 pub fn granite_mode_switch_get_primary_icon_gicon(
1389 self_: *mut GraniteModeSwitch,
1390 ) -> *mut gio::GIcon;
1391 pub fn granite_mode_switch_set_primary_icon_gicon(
1392 self_: *mut GraniteModeSwitch,
1393 value: *mut gio::GIcon,
1394 );
1395 pub fn granite_mode_switch_get_primary_icon_name(
1396 self_: *mut GraniteModeSwitch,
1397 ) -> *const c_char;
1398 pub fn granite_mode_switch_set_primary_icon_name(
1399 self_: *mut GraniteModeSwitch,
1400 value: *const c_char,
1401 );
1402 pub fn granite_mode_switch_get_primary_icon_tooltip_text(
1403 self_: *mut GraniteModeSwitch,
1404 ) -> *const c_char;
1405 pub fn granite_mode_switch_set_primary_icon_tooltip_text(
1406 self_: *mut GraniteModeSwitch,
1407 value: *const c_char,
1408 );
1409 pub fn granite_mode_switch_get_secondary_icon_gicon(
1410 self_: *mut GraniteModeSwitch,
1411 ) -> *mut gio::GIcon;
1412 pub fn granite_mode_switch_set_secondary_icon_gicon(
1413 self_: *mut GraniteModeSwitch,
1414 value: *mut gio::GIcon,
1415 );
1416 pub fn granite_mode_switch_get_secondary_icon_name(
1417 self_: *mut GraniteModeSwitch,
1418 ) -> *const c_char;
1419 pub fn granite_mode_switch_set_secondary_icon_name(
1420 self_: *mut GraniteModeSwitch,
1421 value: *const c_char,
1422 );
1423 pub fn granite_mode_switch_get_secondary_icon_tooltip_text(
1424 self_: *mut GraniteModeSwitch,
1425 ) -> *const c_char;
1426 pub fn granite_mode_switch_set_secondary_icon_tooltip_text(
1427 self_: *mut GraniteModeSwitch,
1428 value: *const c_char,
1429 );
1430 pub fn granite_mode_switch_new(
1431 primary_icon_gicon: *mut gio::GIcon,
1432 secondary_icon_gicon: *mut gio::GIcon,
1433 ) -> *mut GraniteModeSwitch;
1434 pub fn granite_mode_switch_new_from_icon_name(
1435 primary_icon_name: *const c_char,
1436 secondary_icon_name: *const c_char,
1437 ) -> *mut GraniteModeSwitch;
1438
1439 pub fn granite_overlay_bar_get_type() -> GType;
1443 pub fn granite_overlay_bar_get_overlay(self_: *mut GraniteOverlayBar) -> *mut gtk::GtkOverlay;
1444 pub fn granite_overlay_bar_get_label(self_: *mut GraniteOverlayBar) -> *const c_char;
1445 pub fn granite_overlay_bar_set_label(self_: *mut GraniteOverlayBar, value: *const c_char);
1446 pub fn granite_overlay_bar_get_active(self_: *mut GraniteOverlayBar) -> gboolean;
1447 pub fn granite_overlay_bar_set_active(self_: *mut GraniteOverlayBar, value: gboolean);
1448 pub fn granite_overlay_bar_new(overlay: *mut gtk::GtkOverlay) -> *mut GraniteOverlayBar;
1449
1450 pub fn granite_placeholder_get_type() -> GType;
1454 pub fn granite_placeholder_get_title(self_: *mut GranitePlaceholder) -> *const c_char;
1455 pub fn granite_placeholder_set_title(self_: *mut GranitePlaceholder, value: *const c_char);
1456 pub fn granite_placeholder_get_description(self_: *mut GranitePlaceholder) -> *const c_char;
1457 pub fn granite_placeholder_set_description(
1458 self_: *mut GranitePlaceholder,
1459 value: *const c_char,
1460 );
1461 pub fn granite_placeholder_get_icon(self_: *mut GranitePlaceholder) -> *mut gio::GIcon;
1462 pub fn granite_placeholder_set_icon(self_: *mut GranitePlaceholder, value: *mut gio::GIcon);
1463 pub fn granite_placeholder_new(title: *const c_char) -> *mut GranitePlaceholder;
1464 pub fn granite_placeholder_append_button(
1465 self_: *mut GranitePlaceholder,
1466 icon: *mut gio::GIcon,
1467 label: *const c_char,
1468 description: *const c_char,
1469 ) -> *mut gtk::GtkButton;
1470
1471 pub fn granite_services_contractor_proxy_get_type() -> GType;
1475 pub fn granite_services_contractor_proxy_get_instance(
1476 error: *mut *mut glib::GError,
1477 ) -> *mut GraniteServicesContractorProxy;
1478
1479 pub fn granite_services_system_get_type() -> GType;
1483 pub fn granite_services_system_history_is_enabled() -> gboolean;
1484 pub fn granite_services_system_new() -> *mut GraniteServicesSystem;
1485
1486 pub fn granite_settings_get_type() -> GType;
1490 pub fn granite_settings_get_accent_color(
1491 self_: *mut GraniteSettings,
1492 result: *mut gdk::GdkRGBA,
1493 );
1494 pub fn granite_settings_get_prefers_color_scheme(
1495 self_: *mut GraniteSettings,
1496 ) -> GraniteSettingsColorScheme;
1497 pub fn granite_settings_get_default() -> *mut GraniteSettings;
1498
1499 pub fn granite_settings_page_get_type() -> GType;
1503 pub fn granite_settings_page_get_status_type(
1504 self_: *mut GraniteSettingsPage,
1505 ) -> GraniteSettingsPageStatusType;
1506 pub fn granite_settings_page_set_status_type(
1507 self_: *mut GraniteSettingsPage,
1508 value: GraniteSettingsPageStatusType,
1509 );
1510 pub fn granite_settings_page_get_display_widget(
1511 self_: *mut GraniteSettingsPage,
1512 ) -> *mut gtk::GtkWidget;
1513 pub fn granite_settings_page_get_header(self_: *mut GraniteSettingsPage) -> *const c_char;
1514 pub fn granite_settings_page_get_status(self_: *mut GraniteSettingsPage) -> *const c_char;
1515 pub fn granite_settings_page_set_status(self_: *mut GraniteSettingsPage, value: *const c_char);
1516 pub fn granite_settings_page_get_icon_name(self_: *mut GraniteSettingsPage) -> *const c_char;
1517 pub fn granite_settings_page_set_icon_name(
1518 self_: *mut GraniteSettingsPage,
1519 value: *const c_char,
1520 );
1521 pub fn granite_settings_page_get_title(self_: *mut GraniteSettingsPage) -> *const c_char;
1522 pub fn granite_settings_page_set_title(self_: *mut GraniteSettingsPage, value: *const c_char);
1523 pub fn granite_settings_page_get_child(self_: *mut GraniteSettingsPage) -> *mut gtk::GtkWidget;
1524 pub fn granite_settings_page_set_child(
1525 self_: *mut GraniteSettingsPage,
1526 value: *mut gtk::GtkWidget,
1527 );
1528
1529 pub fn granite_settings_sidebar_get_type() -> GType;
1533 pub fn granite_settings_sidebar_get_stack(
1534 self_: *mut GraniteSettingsSidebar,
1535 ) -> *mut gtk::GtkStack;
1536 pub fn granite_settings_sidebar_get_visible_child_name(
1537 self_: *mut GraniteSettingsSidebar,
1538 ) -> *const c_char;
1539 pub fn granite_settings_sidebar_set_visible_child_name(
1540 self_: *mut GraniteSettingsSidebar,
1541 value: *const c_char,
1542 );
1543 pub fn granite_settings_sidebar_new(stack: *mut gtk::GtkStack) -> *mut GraniteSettingsSidebar;
1544
1545 pub fn granite_simple_settings_page_get_type() -> GType;
1549 pub fn granite_simple_settings_page_get_action_area(
1550 self_: *mut GraniteSimpleSettingsPage,
1551 ) -> *mut gtk::GtkBox;
1552 pub fn granite_simple_settings_page_get_content_area(
1553 self_: *mut GraniteSimpleSettingsPage,
1554 ) -> *mut gtk::GtkGrid;
1555 pub fn granite_simple_settings_page_get_status_switch(
1556 self_: *mut GraniteSimpleSettingsPage,
1557 ) -> *mut gtk::GtkSwitch;
1558 pub fn granite_simple_settings_page_get_activatable(
1559 self_: *mut GraniteSimpleSettingsPage,
1560 ) -> gboolean;
1561 pub fn granite_simple_settings_page_get_description(
1562 self_: *mut GraniteSimpleSettingsPage,
1563 ) -> *const c_char;
1564 pub fn granite_simple_settings_page_set_description(
1565 self_: *mut GraniteSimpleSettingsPage,
1566 value: *const c_char,
1567 );
1568
1569 #[cfg(feature = "v7_7")]
1573 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1574 pub fn granite_style_manager_get_type() -> GType;
1575 #[cfg(feature = "v7_7")]
1576 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1577 pub fn granite_style_manager_get_default() -> *mut GraniteStyleManager;
1578 #[cfg(feature = "v7_7")]
1579 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1580 pub fn granite_style_manager_get_for_display(
1581 display: *mut gdk::GdkDisplay,
1582 ) -> *mut GraniteStyleManager;
1583 #[cfg(feature = "v7_7")]
1584 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1585 pub fn granite_style_manager_get_color_scheme(
1586 self_: *mut GraniteStyleManager,
1587 ) -> GraniteSettingsColorScheme;
1588 #[cfg(feature = "v7_7")]
1589 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1590 pub fn granite_style_manager_set_color_scheme(
1591 self_: *mut GraniteStyleManager,
1592 value: GraniteSettingsColorScheme,
1593 );
1594 #[cfg(feature = "v7_7")]
1595 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1596 pub fn granite_style_manager_get_display(
1597 self_: *mut GraniteStyleManager,
1598 ) -> *mut gdk::GdkDisplay;
1599
1600 pub fn granite_switch_model_button_get_type() -> GType;
1604 pub fn granite_switch_model_button_get_text(
1605 self_: *mut GraniteSwitchModelButton,
1606 ) -> *const c_char;
1607 pub fn granite_switch_model_button_set_text(
1608 self_: *mut GraniteSwitchModelButton,
1609 value: *const c_char,
1610 );
1611 pub fn granite_switch_model_button_get_description(
1612 self_: *mut GraniteSwitchModelButton,
1613 ) -> *const c_char;
1614 pub fn granite_switch_model_button_set_description(
1615 self_: *mut GraniteSwitchModelButton,
1616 value: *const c_char,
1617 );
1618 pub fn granite_switch_model_button_new(text: *const c_char) -> *mut GraniteSwitchModelButton;
1619
1620 pub fn granite_time_picker_get_type() -> GType;
1624 pub fn granite_time_picker_get_format_12(self_: *mut GraniteTimePicker) -> *const c_char;
1625 pub fn granite_time_picker_get_format_24(self_: *mut GraniteTimePicker) -> *const c_char;
1626 pub fn granite_time_picker_get_time(self_: *mut GraniteTimePicker) -> *mut glib::GDateTime;
1627 pub fn granite_time_picker_set_time(self_: *mut GraniteTimePicker, value: *mut glib::GDateTime);
1628 pub fn granite_time_picker_new_with_format(
1629 format_12: *const c_char,
1630 format_24: *const c_char,
1631 ) -> *mut GraniteTimePicker;
1632 pub fn granite_time_picker_new() -> *mut GraniteTimePicker;
1633
1634 pub fn granite_toast_get_type() -> GType;
1638 pub fn granite_toast_get_title(self_: *mut GraniteToast) -> *const c_char;
1639 pub fn granite_toast_set_title(self_: *mut GraniteToast, value: *const c_char);
1640 pub fn granite_toast_new(title: *const c_char) -> *mut GraniteToast;
1641 pub fn granite_toast_set_default_action(self_: *mut GraniteToast, label: *const c_char);
1642 pub fn granite_toast_send_notification(self_: *mut GraniteToast);
1643 #[cfg(feature = "v7_4")]
1644 #[cfg_attr(docsrs, doc(cfg(feature = "v7_4")))]
1645 pub fn granite_toast_withdraw(self_: *mut GraniteToast);
1646
1647 #[cfg(feature = "v7_7")]
1651 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1652 pub fn granite_tool_box_get_type() -> GType;
1653 #[cfg(feature = "v7_7")]
1654 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1655 pub fn granite_tool_box_get_content(self_: *mut GraniteToolBox) -> *mut gtk::GtkWidget;
1656 #[cfg(feature = "v7_7")]
1657 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1658 pub fn granite_tool_box_set_content(self_: *mut GraniteToolBox, value: *mut gtk::GtkWidget);
1659 #[cfg(feature = "v7_7")]
1660 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1661 pub fn granite_tool_box_add_top_bar(self_: *mut GraniteToolBox, widget: *mut gtk::GtkWidget);
1662 #[cfg(feature = "v7_7")]
1663 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1664 pub fn granite_tool_box_add_bottom_bar(self_: *mut GraniteToolBox, widget: *mut gtk::GtkWidget);
1665 #[cfg(feature = "v7_7")]
1666 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1667 pub fn granite_tool_box_remove(self_: *mut GraniteToolBox, widget: *mut gtk::GtkWidget);
1668 #[cfg(feature = "v7_7")]
1669 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1670 pub fn granite_tool_box_new() -> *mut GraniteToolBox;
1671
1672 pub fn granite_validated_entry_get_type() -> GType;
1676 pub fn granite_validated_entry_get_is_valid(self_: *mut GraniteValidatedEntry) -> gboolean;
1677 pub fn granite_validated_entry_set_is_valid(self_: *mut GraniteValidatedEntry, value: gboolean);
1678 pub fn granite_validated_entry_get_min_length(self_: *mut GraniteValidatedEntry) -> c_int;
1679 pub fn granite_validated_entry_set_min_length(self_: *mut GraniteValidatedEntry, value: c_int);
1680 pub fn granite_validated_entry_get_regex(
1681 self_: *mut GraniteValidatedEntry,
1682 ) -> *mut glib::GRegex;
1683 pub fn granite_validated_entry_set_regex(
1684 self_: *mut GraniteValidatedEntry,
1685 value: *mut glib::GRegex,
1686 );
1687 pub fn granite_validated_entry_new_from_regex(
1688 regex_arg: *mut glib::GRegex,
1689 ) -> *mut GraniteValidatedEntry;
1690 pub fn granite_validated_entry_new() -> *mut GraniteValidatedEntry;
1691
1692 pub fn granite_services_contract_get_type() -> GType;
1696 pub fn granite_services_contract_get_display_name(
1697 self_: *mut GraniteServicesContract,
1698 ) -> *mut c_char;
1699 pub fn granite_services_contract_get_description(
1700 self_: *mut GraniteServicesContract,
1701 ) -> *mut c_char;
1702 pub fn granite_services_contract_get_icon(
1703 self_: *mut GraniteServicesContract,
1704 ) -> *mut gio::GIcon;
1705 pub fn granite_services_contract_execute_with_file(
1706 self_: *mut GraniteServicesContract,
1707 file: *mut gio::GFile,
1708 error: *mut *mut glib::GError,
1709 );
1710 pub fn granite_services_contract_execute_with_files(
1711 self_: *mut GraniteServicesContract,
1712 files: *mut *mut gio::GFile,
1713 files_length1: c_int,
1714 error: *mut *mut glib::GError,
1715 );
1716
1717 pub fn granite_services_settings_serializable_get_type() -> GType;
1721 pub fn granite_services_settings_serializable_settings_serialize(
1722 self_: *mut GraniteServicesSettingsSerializable,
1723 ) -> *mut c_char;
1724 pub fn granite_services_settings_serializable_settings_deserialize(
1725 self_: *mut GraniteServicesSettingsSerializable,
1726 s: *const c_char,
1727 );
1728
1729 pub fn granite_date_time_get_default_time_format(
1733 is_12h: gboolean,
1734 with_second: gboolean,
1735 ) -> *mut c_char;
1736 pub fn granite_date_time_get_relative_datetime(date_time: *mut glib::GDateTime) -> *mut c_char;
1737 pub fn granite_date_time_is_same_day(
1738 day1: *mut glib::GDateTime,
1739 day2: *mut glib::GDateTime,
1740 ) -> gboolean;
1741 pub fn granite_date_time_get_default_date_format(
1742 with_weekday: gboolean,
1743 with_day: gboolean,
1744 with_year: gboolean,
1745 ) -> *mut c_char;
1746 pub fn granite_date_time_seconds_to_time(seconds: c_int) -> *mut c_char;
1747 pub fn granite_services_application_set_badge(
1748 count: i64,
1749 _callback_: gio::GAsyncReadyCallback,
1750 _callback__target: *mut c_void,
1751 );
1752 pub fn granite_services_application_set_badge_finish(
1753 _res_: *mut gio::GAsyncResult,
1754 error: *mut *mut glib::GError,
1755 ) -> gboolean;
1756 pub fn granite_services_application_set_badge_visible(
1757 visible: gboolean,
1758 _callback_: gio::GAsyncReadyCallback,
1759 _callback__target: *mut c_void,
1760 );
1761 pub fn granite_services_application_set_badge_visible_finish(
1762 _res_: *mut gio::GAsyncResult,
1763 error: *mut *mut glib::GError,
1764 ) -> gboolean;
1765 pub fn granite_services_application_set_progress(
1766 progress: c_double,
1767 _callback_: gio::GAsyncReadyCallback,
1768 _callback__target: *mut c_void,
1769 );
1770 pub fn granite_services_application_set_progress_finish(
1771 _res_: *mut gio::GAsyncResult,
1772 error: *mut *mut glib::GError,
1773 ) -> gboolean;
1774 pub fn granite_services_application_set_progress_visible(
1775 visible: gboolean,
1776 _callback_: gio::GAsyncReadyCallback,
1777 _callback__target: *mut c_void,
1778 );
1779 pub fn granite_services_application_set_progress_visible_finish(
1780 _res_: *mut gio::GAsyncResult,
1781 error: *mut *mut glib::GError,
1782 ) -> gboolean;
1783 pub fn granite_widgets_utils_set_color_primary(
1784 window: *mut gtk::GtkWidget,
1785 color: *mut gdk::GdkRGBA,
1786 priority: c_int,
1787 ) -> *mut gtk::GtkCssProvider;
1788 #[cfg(feature = "v7_7")]
1789 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1790 pub fn granite_box_spacing_to_string(self_: GraniteBoxSpacing) -> *mut c_char;
1791 #[cfg(feature = "v7_7")]
1792 #[cfg_attr(docsrs, doc(cfg(feature = "v7_7")))]
1793 pub fn granite_header_label_size_to_string(self_: GraniteHeaderLabelSize) -> *mut c_char;
1794 #[cfg(feature = "v7_2")]
1795 #[cfg_attr(docsrs, doc(cfg(feature = "v7_2")))]
1796 pub fn granite_init();
1797 pub fn granite_accel_to_string(accel: *const c_char) -> *mut c_char;
1798 pub fn granite_markup_accel_tooltip(
1799 accels: *mut *mut c_char,
1800 accels_length1: c_int,
1801 description: *const c_char,
1802 ) -> *mut c_char;
1803 pub fn granite_contrasting_foreground_color(
1804 bg_color: *mut gdk::GdkRGBA,
1805 result: *mut gdk::GdkRGBA,
1806 );
1807
1808}