1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
8#![cfg_attr(docsrs, feature(doc_cfg))]
9
10use glib_sys as glib;
11use gobject_sys as gobject;
12use gdk_sys as gdk;
13use gio_sys as gio;
14use gtk_sys as gtk;
15use pango_sys as pango;
16
17#[allow(unused_imports)]
18use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
19 c_short, c_ushort, c_long, c_ulong,
20 c_void, size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
21#[cfg(unix)]
22#[allow(unused_imports)]
23use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
24
25#[allow(unused_imports)]
26use glib::{gboolean, gconstpointer, gpointer, GType};
27
28pub type BisAlbumTransitionType = c_int;
30pub const BIS_ALBUM_TRANSITION_TYPE_OVER: BisAlbumTransitionType = 0;
31pub const BIS_ALBUM_TRANSITION_TYPE_UNDER: BisAlbumTransitionType = 1;
32pub const BIS_ALBUM_TRANSITION_TYPE_SLIDE: BisAlbumTransitionType = 2;
33
34pub type BisAnimationState = c_int;
35pub const BIS_ANIMATION_IDLE: BisAnimationState = 0;
36pub const BIS_ANIMATION_PAUSED: BisAnimationState = 1;
37pub const BIS_ANIMATION_PLAYING: BisAnimationState = 2;
38pub const BIS_ANIMATION_FINISHED: BisAnimationState = 3;
39
40pub type BisEasing = c_int;
41pub const BIS_LINEAR: BisEasing = 0;
42pub const BIS_EASE_IN_QUAD: BisEasing = 1;
43pub const BIS_EASE_OUT_QUAD: BisEasing = 2;
44pub const BIS_EASE_IN_OUT_QUAD: BisEasing = 3;
45pub const BIS_EASE_IN_CUBIC: BisEasing = 4;
46pub const BIS_EASE_OUT_CUBIC: BisEasing = 5;
47pub const BIS_EASE_IN_OUT_CUBIC: BisEasing = 6;
48pub const BIS_EASE_IN_QUART: BisEasing = 7;
49pub const BIS_EASE_OUT_QUART: BisEasing = 8;
50pub const BIS_EASE_IN_OUT_QUART: BisEasing = 9;
51pub const BIS_EASE_IN_QUINT: BisEasing = 10;
52pub const BIS_EASE_OUT_QUINT: BisEasing = 11;
53pub const BIS_EASE_IN_OUT_QUINT: BisEasing = 12;
54pub const BIS_EASE_IN_SINE: BisEasing = 13;
55pub const BIS_EASE_OUT_SINE: BisEasing = 14;
56pub const BIS_EASE_IN_OUT_SINE: BisEasing = 15;
57pub const BIS_EASE_IN_EXPO: BisEasing = 16;
58pub const BIS_EASE_OUT_EXPO: BisEasing = 17;
59pub const BIS_EASE_IN_OUT_EXPO: BisEasing = 18;
60pub const BIS_EASE_IN_CIRC: BisEasing = 19;
61pub const BIS_EASE_OUT_CIRC: BisEasing = 20;
62pub const BIS_EASE_IN_OUT_CIRC: BisEasing = 21;
63pub const BIS_EASE_IN_ELASTIC: BisEasing = 22;
64pub const BIS_EASE_OUT_ELASTIC: BisEasing = 23;
65pub const BIS_EASE_IN_OUT_ELASTIC: BisEasing = 24;
66pub const BIS_EASE_IN_BACK: BisEasing = 25;
67pub const BIS_EASE_OUT_BACK: BisEasing = 26;
68pub const BIS_EASE_IN_OUT_BACK: BisEasing = 27;
69pub const BIS_EASE_IN_BOUNCE: BisEasing = 28;
70pub const BIS_EASE_OUT_BOUNCE: BisEasing = 29;
71pub const BIS_EASE_IN_OUT_BOUNCE: BisEasing = 30;
72
73pub type BisFoldThresholdPolicy = c_int;
74pub const BIS_FOLD_THRESHOLD_POLICY_MINIMUM: BisFoldThresholdPolicy = 0;
75pub const BIS_FOLD_THRESHOLD_POLICY_NATURAL: BisFoldThresholdPolicy = 1;
76
77pub type BisHuggerTransitionType = c_int;
78pub const BIS_HUGGER_TRANSITION_TYPE_NONE: BisHuggerTransitionType = 0;
79pub const BIS_HUGGER_TRANSITION_TYPE_CROSSFADE: BisHuggerTransitionType = 1;
80
81pub type BisLapelFoldPolicy = c_int;
82pub const BIS_LAPEL_FOLD_POLICY_NEVER: BisLapelFoldPolicy = 0;
83pub const BIS_LAPEL_FOLD_POLICY_ALWAYS: BisLapelFoldPolicy = 1;
84pub const BIS_LAPEL_FOLD_POLICY_AUTO: BisLapelFoldPolicy = 2;
85
86pub type BisLapelTransitionType = c_int;
87pub const BIS_LAPEL_TRANSITION_TYPE_OVER: BisLapelTransitionType = 0;
88pub const BIS_LAPEL_TRANSITION_TYPE_UNDER: BisLapelTransitionType = 1;
89pub const BIS_LAPEL_TRANSITION_TYPE_SLIDE: BisLapelTransitionType = 2;
90
91pub type BisNavigationDirection = c_int;
92pub const BIS_NAVIGATION_DIRECTION_BACK: BisNavigationDirection = 0;
93pub const BIS_NAVIGATION_DIRECTION_FORWARD: BisNavigationDirection = 1;
94
95pub const BIS_DURATION_INFINITE: c_uint = 4294967295;
97pub const BIS_MAJOR_VERSION: c_int = 1;
98pub const BIS_MICRO_VERSION: c_int = 0;
99pub const BIS_MINOR_VERSION: c_int = 0;
100pub const BIS_VERSION_S: &[u8] = b"1.0.0\0";
101
102pub type BisAnimationTargetFunc = Option<unsafe extern "C" fn(c_double, gpointer)>;
104
105#[derive(Copy, Clone)]
107#[repr(C)]
108pub struct BisAlbumClass {
109 pub parent_class: gtk::GtkWidgetClass,
110}
111
112impl ::std::fmt::Debug for BisAlbumClass {
113 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
114 f.debug_struct(&format!("BisAlbumClass @ {self:p}"))
115 .field("parent_class", &self.parent_class)
116 .finish()
117 }
118}
119
120#[derive(Copy, Clone)]
121#[repr(C)]
122pub struct BisAlbumPageClass {
123 pub parent_class: gobject::GObjectClass,
124}
125
126impl ::std::fmt::Debug for BisAlbumPageClass {
127 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
128 f.debug_struct(&format!("BisAlbumPageClass @ {self:p}"))
129 .field("parent_class", &self.parent_class)
130 .finish()
131 }
132}
133
134#[repr(C)]
135#[allow(dead_code)]
136pub struct _BisAnimationClass {
137 _data: [u8; 0],
138 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
139}
140
141pub type BisAnimationClass = _BisAnimationClass;
142
143#[repr(C)]
144#[allow(dead_code)]
145pub struct _BisAnimationTargetClass {
146 _data: [u8; 0],
147 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
148}
149
150pub type BisAnimationTargetClass = _BisAnimationTargetClass;
151
152#[derive(Copy, Clone)]
153#[repr(C)]
154pub struct BisBinClass {
155 pub parent_class: gtk::GtkWidgetClass,
156}
157
158impl ::std::fmt::Debug for BisBinClass {
159 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
160 f.debug_struct(&format!("BisBinClass @ {self:p}"))
161 .field("parent_class", &self.parent_class)
162 .finish()
163 }
164}
165
166#[repr(C)]
167#[allow(dead_code)]
168pub struct _BisCallbackAnimationTargetClass {
169 _data: [u8; 0],
170 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
171}
172
173pub type BisCallbackAnimationTargetClass = _BisCallbackAnimationTargetClass;
174
175#[derive(Copy, Clone)]
176#[repr(C)]
177pub struct BisCarouselClass {
178 pub parent_class: gtk::GtkWidgetClass,
179}
180
181impl ::std::fmt::Debug for BisCarouselClass {
182 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
183 f.debug_struct(&format!("BisCarouselClass @ {self:p}"))
184 .field("parent_class", &self.parent_class)
185 .finish()
186 }
187}
188
189#[derive(Copy, Clone)]
190#[repr(C)]
191pub struct BisCarouselIndicatorDotsClass {
192 pub parent_class: gtk::GtkWidgetClass,
193}
194
195impl ::std::fmt::Debug for BisCarouselIndicatorDotsClass {
196 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
197 f.debug_struct(&format!("BisCarouselIndicatorDotsClass @ {self:p}"))
198 .field("parent_class", &self.parent_class)
199 .finish()
200 }
201}
202
203#[derive(Copy, Clone)]
204#[repr(C)]
205pub struct BisCarouselIndicatorLinesClass {
206 pub parent_class: gtk::GtkWidgetClass,
207}
208
209impl ::std::fmt::Debug for BisCarouselIndicatorLinesClass {
210 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
211 f.debug_struct(&format!("BisCarouselIndicatorLinesClass @ {self:p}"))
212 .field("parent_class", &self.parent_class)
213 .finish()
214 }
215}
216
217#[derive(Copy, Clone)]
218#[repr(C)]
219pub struct BisEnumListItemClass {
220 pub parent_class: gobject::GObjectClass,
221}
222
223impl ::std::fmt::Debug for BisEnumListItemClass {
224 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
225 f.debug_struct(&format!("BisEnumListItemClass @ {self:p}"))
226 .field("parent_class", &self.parent_class)
227 .finish()
228 }
229}
230
231#[derive(Copy, Clone)]
232#[repr(C)]
233pub struct BisEnumListModelClass {
234 pub parent_class: gobject::GObjectClass,
235}
236
237impl ::std::fmt::Debug for BisEnumListModelClass {
238 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
239 f.debug_struct(&format!("BisEnumListModelClass @ {self:p}"))
240 .field("parent_class", &self.parent_class)
241 .finish()
242 }
243}
244
245#[derive(Copy, Clone)]
246#[repr(C)]
247pub struct BisHuggerClass {
248 pub parent_class: gtk::GtkWidgetClass,
249}
250
251impl ::std::fmt::Debug for BisHuggerClass {
252 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
253 f.debug_struct(&format!("BisHuggerClass @ {self:p}"))
254 .field("parent_class", &self.parent_class)
255 .finish()
256 }
257}
258
259#[derive(Copy, Clone)]
260#[repr(C)]
261pub struct BisHuggerPageClass {
262 pub parent_class: gobject::GObjectClass,
263}
264
265impl ::std::fmt::Debug for BisHuggerPageClass {
266 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
267 f.debug_struct(&format!("BisHuggerPageClass @ {self:p}"))
268 .field("parent_class", &self.parent_class)
269 .finish()
270 }
271}
272
273#[derive(Copy, Clone)]
274#[repr(C)]
275pub struct BisLapelClass {
276 pub parent_class: gtk::GtkWidgetClass,
277}
278
279impl ::std::fmt::Debug for BisLapelClass {
280 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
281 f.debug_struct(&format!("BisLapelClass @ {self:p}"))
282 .field("parent_class", &self.parent_class)
283 .finish()
284 }
285}
286
287#[derive(Copy, Clone)]
288#[repr(C)]
289pub struct BisLatchClass {
290 pub parent_class: gtk::GtkWidgetClass,
291}
292
293impl ::std::fmt::Debug for BisLatchClass {
294 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
295 f.debug_struct(&format!("BisLatchClass @ {self:p}"))
296 .field("parent_class", &self.parent_class)
297 .finish()
298 }
299}
300
301#[derive(Copy, Clone)]
302#[repr(C)]
303pub struct BisLatchLayoutClass {
304 pub parent_class: gtk::GtkLayoutManagerClass,
305}
306
307impl ::std::fmt::Debug for BisLatchLayoutClass {
308 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
309 f.debug_struct(&format!("BisLatchLayoutClass @ {self:p}"))
310 .field("parent_class", &self.parent_class)
311 .finish()
312 }
313}
314
315#[derive(Copy, Clone)]
316#[repr(C)]
317pub struct BisLatchScrollableClass {
318 pub parent_class: gtk::GtkWidgetClass,
319}
320
321impl ::std::fmt::Debug for BisLatchScrollableClass {
322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
323 f.debug_struct(&format!("BisLatchScrollableClass @ {self:p}"))
324 .field("parent_class", &self.parent_class)
325 .finish()
326 }
327}
328
329#[repr(C)]
330#[allow(dead_code)]
331pub struct _BisPropertyAnimationTargetClass {
332 _data: [u8; 0],
333 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
334}
335
336pub type BisPropertyAnimationTargetClass = _BisPropertyAnimationTargetClass;
337
338#[repr(C)]
339#[allow(dead_code)]
340pub struct _BisSpringAnimationClass {
341 _data: [u8; 0],
342 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
343}
344
345pub type BisSpringAnimationClass = _BisSpringAnimationClass;
346
347#[repr(C)]
348#[allow(dead_code)]
349pub struct BisSpringParams {
350 _data: [u8; 0],
351 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
352}
353
354impl ::std::fmt::Debug for BisSpringParams {
355 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
356 f.debug_struct(&format!("BisSpringParams @ {self:p}"))
357 .finish()
358 }
359}
360
361#[derive(Copy, Clone)]
362#[repr(C)]
363pub struct BisSwipeTrackerClass {
364 pub parent_class: gobject::GObjectClass,
365}
366
367impl ::std::fmt::Debug for BisSwipeTrackerClass {
368 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
369 f.debug_struct(&format!("BisSwipeTrackerClass @ {self:p}"))
370 .field("parent_class", &self.parent_class)
371 .finish()
372 }
373}
374
375#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct BisSwipeableInterface {
378 pub parent: gobject::GTypeInterface,
379 pub get_distance: Option<unsafe extern "C" fn(*mut BisSwipeable) -> c_double>,
380 pub get_snap_points: Option<unsafe extern "C" fn(*mut BisSwipeable, *mut c_int) -> *mut c_double>,
381 pub get_progress: Option<unsafe extern "C" fn(*mut BisSwipeable) -> c_double>,
382 pub get_cancel_progress: Option<unsafe extern "C" fn(*mut BisSwipeable) -> c_double>,
383 pub get_swipe_area: Option<unsafe extern "C" fn(*mut BisSwipeable, BisNavigationDirection, gboolean, *mut gdk::GdkRectangle)>,
384 pub padding: [gpointer; 4],
385}
386
387impl ::std::fmt::Debug for BisSwipeableInterface {
388 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
389 f.debug_struct(&format!("BisSwipeableInterface @ {self:p}"))
390 .field("parent", &self.parent)
391 .field("get_distance", &self.get_distance)
392 .field("get_snap_points", &self.get_snap_points)
393 .field("get_progress", &self.get_progress)
394 .field("get_cancel_progress", &self.get_cancel_progress)
395 .field("get_swipe_area", &self.get_swipe_area)
396 .finish()
397 }
398}
399
400#[repr(C)]
401#[allow(dead_code)]
402pub struct _BisTimedAnimationClass {
403 _data: [u8; 0],
404 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
405}
406
407pub type BisTimedAnimationClass = _BisTimedAnimationClass;
408
409#[repr(C)]
411#[allow(dead_code)]
412pub struct BisAlbum {
413 _data: [u8; 0],
414 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
415}
416
417impl ::std::fmt::Debug for BisAlbum {
418 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
419 f.debug_struct(&format!("BisAlbum @ {self:p}"))
420 .finish()
421 }
422}
423
424#[repr(C)]
425#[allow(dead_code)]
426pub struct BisAlbumPage {
427 _data: [u8; 0],
428 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
429}
430
431impl ::std::fmt::Debug for BisAlbumPage {
432 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
433 f.debug_struct(&format!("BisAlbumPage @ {self:p}"))
434 .finish()
435 }
436}
437
438#[derive(Copy, Clone)]
439#[repr(C)]
440pub struct BisAnimation {
441 pub parent_instance: gobject::GObject,
442}
443
444impl ::std::fmt::Debug for BisAnimation {
445 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
446 f.debug_struct(&format!("BisAnimation @ {self:p}"))
447 .field("parent_instance", &self.parent_instance)
448 .finish()
449 }
450}
451
452#[repr(C)]
453#[allow(dead_code)]
454pub struct BisAnimationTarget {
455 _data: [u8; 0],
456 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
457}
458
459impl ::std::fmt::Debug for BisAnimationTarget {
460 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
461 f.debug_struct(&format!("BisAnimationTarget @ {self:p}"))
462 .finish()
463 }
464}
465
466#[derive(Copy, Clone)]
467#[repr(C)]
468pub struct BisBin {
469 pub parent_instance: gtk::GtkWidget,
470}
471
472impl ::std::fmt::Debug for BisBin {
473 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
474 f.debug_struct(&format!("BisBin @ {self:p}"))
475 .field("parent_instance", &self.parent_instance)
476 .finish()
477 }
478}
479
480#[repr(C)]
481#[allow(dead_code)]
482pub struct BisCallbackAnimationTarget {
483 _data: [u8; 0],
484 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
485}
486
487impl ::std::fmt::Debug for BisCallbackAnimationTarget {
488 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
489 f.debug_struct(&format!("BisCallbackAnimationTarget @ {self:p}"))
490 .finish()
491 }
492}
493
494#[repr(C)]
495#[allow(dead_code)]
496pub struct BisCarousel {
497 _data: [u8; 0],
498 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
499}
500
501impl ::std::fmt::Debug for BisCarousel {
502 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
503 f.debug_struct(&format!("BisCarousel @ {self:p}"))
504 .finish()
505 }
506}
507
508#[repr(C)]
509#[allow(dead_code)]
510pub struct BisCarouselIndicatorDots {
511 _data: [u8; 0],
512 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
513}
514
515impl ::std::fmt::Debug for BisCarouselIndicatorDots {
516 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
517 f.debug_struct(&format!("BisCarouselIndicatorDots @ {self:p}"))
518 .finish()
519 }
520}
521
522#[repr(C)]
523#[allow(dead_code)]
524pub struct BisCarouselIndicatorLines {
525 _data: [u8; 0],
526 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
527}
528
529impl ::std::fmt::Debug for BisCarouselIndicatorLines {
530 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
531 f.debug_struct(&format!("BisCarouselIndicatorLines @ {self:p}"))
532 .finish()
533 }
534}
535
536#[repr(C)]
537#[allow(dead_code)]
538pub struct BisEnumListItem {
539 _data: [u8; 0],
540 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
541}
542
543impl ::std::fmt::Debug for BisEnumListItem {
544 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
545 f.debug_struct(&format!("BisEnumListItem @ {self:p}"))
546 .finish()
547 }
548}
549
550#[repr(C)]
551#[allow(dead_code)]
552pub struct BisEnumListModel {
553 _data: [u8; 0],
554 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
555}
556
557impl ::std::fmt::Debug for BisEnumListModel {
558 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
559 f.debug_struct(&format!("BisEnumListModel @ {self:p}"))
560 .finish()
561 }
562}
563
564#[repr(C)]
565#[allow(dead_code)]
566pub struct BisHugger {
567 _data: [u8; 0],
568 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
569}
570
571impl ::std::fmt::Debug for BisHugger {
572 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
573 f.debug_struct(&format!("BisHugger @ {self:p}"))
574 .finish()
575 }
576}
577
578#[repr(C)]
579#[allow(dead_code)]
580pub struct BisHuggerPage {
581 _data: [u8; 0],
582 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
583}
584
585impl ::std::fmt::Debug for BisHuggerPage {
586 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
587 f.debug_struct(&format!("BisHuggerPage @ {self:p}"))
588 .finish()
589 }
590}
591
592#[repr(C)]
593#[allow(dead_code)]
594pub struct BisLapel {
595 _data: [u8; 0],
596 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
597}
598
599impl ::std::fmt::Debug for BisLapel {
600 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
601 f.debug_struct(&format!("BisLapel @ {self:p}"))
602 .finish()
603 }
604}
605
606#[repr(C)]
607#[allow(dead_code)]
608pub struct BisLatch {
609 _data: [u8; 0],
610 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
611}
612
613impl ::std::fmt::Debug for BisLatch {
614 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
615 f.debug_struct(&format!("BisLatch @ {self:p}"))
616 .finish()
617 }
618}
619
620#[repr(C)]
621#[allow(dead_code)]
622pub struct BisLatchLayout {
623 _data: [u8; 0],
624 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
625}
626
627impl ::std::fmt::Debug for BisLatchLayout {
628 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
629 f.debug_struct(&format!("BisLatchLayout @ {self:p}"))
630 .finish()
631 }
632}
633
634#[repr(C)]
635#[allow(dead_code)]
636pub struct BisLatchScrollable {
637 _data: [u8; 0],
638 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
639}
640
641impl ::std::fmt::Debug for BisLatchScrollable {
642 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
643 f.debug_struct(&format!("BisLatchScrollable @ {self:p}"))
644 .finish()
645 }
646}
647
648#[repr(C)]
649#[allow(dead_code)]
650pub struct BisPropertyAnimationTarget {
651 _data: [u8; 0],
652 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
653}
654
655impl ::std::fmt::Debug for BisPropertyAnimationTarget {
656 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
657 f.debug_struct(&format!("BisPropertyAnimationTarget @ {self:p}"))
658 .finish()
659 }
660}
661
662#[repr(C)]
663#[allow(dead_code)]
664pub struct BisSpringAnimation {
665 _data: [u8; 0],
666 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
667}
668
669impl ::std::fmt::Debug for BisSpringAnimation {
670 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
671 f.debug_struct(&format!("BisSpringAnimation @ {self:p}"))
672 .finish()
673 }
674}
675
676#[repr(C)]
677#[allow(dead_code)]
678pub struct BisSwipeTracker {
679 _data: [u8; 0],
680 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
681}
682
683impl ::std::fmt::Debug for BisSwipeTracker {
684 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
685 f.debug_struct(&format!("BisSwipeTracker @ {self:p}"))
686 .finish()
687 }
688}
689
690#[repr(C)]
691#[allow(dead_code)]
692pub struct BisTimedAnimation {
693 _data: [u8; 0],
694 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
695}
696
697impl ::std::fmt::Debug for BisTimedAnimation {
698 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
699 f.debug_struct(&format!("BisTimedAnimation @ {self:p}"))
700 .finish()
701 }
702}
703
704#[repr(C)]
706#[allow(dead_code)]
707pub struct BisSwipeable {
708 _data: [u8; 0],
709 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
710}
711
712impl ::std::fmt::Debug for BisSwipeable {
713 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
714 write!(f, "BisSwipeable @ {self:p}")
715 }
716}
717
718
719#[link(name = "bismuth-1")]
720extern "C" {
721
722 pub fn bis_album_transition_type_get_type() -> GType;
726
727 pub fn bis_animation_state_get_type() -> GType;
731
732 pub fn bis_easing_get_type() -> GType;
736 pub fn bis_easing_ease(self_: BisEasing, value: c_double) -> c_double;
737
738 pub fn bis_fold_threshold_policy_get_type() -> GType;
742
743 pub fn bis_hugger_transition_type_get_type() -> GType;
747
748 pub fn bis_lapel_fold_policy_get_type() -> GType;
752
753 pub fn bis_lapel_transition_type_get_type() -> GType;
757
758 pub fn bis_navigation_direction_get_type() -> GType;
762
763 pub fn bis_spring_params_get_type() -> GType;
767 pub fn bis_spring_params_new(damping_ratio: c_double, mass: c_double, stiffness: c_double) -> *mut BisSpringParams;
768 pub fn bis_spring_params_new_full(damping: c_double, mass: c_double, stiffness: c_double) -> *mut BisSpringParams;
769 pub fn bis_spring_params_get_damping(self_: *mut BisSpringParams) -> c_double;
770 pub fn bis_spring_params_get_damping_ratio(self_: *mut BisSpringParams) -> c_double;
771 pub fn bis_spring_params_get_mass(self_: *mut BisSpringParams) -> c_double;
772 pub fn bis_spring_params_get_stiffness(self_: *mut BisSpringParams) -> c_double;
773 pub fn bis_spring_params_ref(self_: *mut BisSpringParams) -> *mut BisSpringParams;
774 pub fn bis_spring_params_unref(self_: *mut BisSpringParams);
775
776 pub fn bis_album_get_type() -> GType;
780 pub fn bis_album_new() -> *mut gtk::GtkWidget;
781 pub fn bis_album_append(self_: *mut BisAlbum, child: *mut gtk::GtkWidget) -> *mut BisAlbumPage;
782 pub fn bis_album_get_adjacent_child(self_: *mut BisAlbum, direction: BisNavigationDirection) -> *mut gtk::GtkWidget;
783 pub fn bis_album_get_can_navigate_back(self_: *mut BisAlbum) -> gboolean;
784 pub fn bis_album_get_can_navigate_forward(self_: *mut BisAlbum) -> gboolean;
785 pub fn bis_album_get_can_unfold(self_: *mut BisAlbum) -> gboolean;
786 pub fn bis_album_get_child_by_name(self_: *mut BisAlbum, name: *const c_char) -> *mut gtk::GtkWidget;
787 pub fn bis_album_get_child_transition_params(self_: *mut BisAlbum) -> *mut BisSpringParams;
788 pub fn bis_album_get_child_transition_running(self_: *mut BisAlbum) -> gboolean;
789 pub fn bis_album_get_fold_threshold_policy(self_: *mut BisAlbum) -> BisFoldThresholdPolicy;
790 pub fn bis_album_get_folded(self_: *mut BisAlbum) -> gboolean;
791 pub fn bis_album_get_homogeneous(self_: *mut BisAlbum) -> gboolean;
792 pub fn bis_album_get_mode_transition_duration(self_: *mut BisAlbum) -> c_uint;
793 pub fn bis_album_get_page(self_: *mut BisAlbum, child: *mut gtk::GtkWidget) -> *mut BisAlbumPage;
794 pub fn bis_album_get_pages(self_: *mut BisAlbum) -> *mut gtk::GtkSelectionModel;
795 pub fn bis_album_get_transition_type(self_: *mut BisAlbum) -> BisAlbumTransitionType;
796 pub fn bis_album_get_visible_child(self_: *mut BisAlbum) -> *mut gtk::GtkWidget;
797 pub fn bis_album_get_visible_child_name(self_: *mut BisAlbum) -> *const c_char;
798 pub fn bis_album_insert_child_after(self_: *mut BisAlbum, child: *mut gtk::GtkWidget, sibling: *mut gtk::GtkWidget) -> *mut BisAlbumPage;
799 pub fn bis_album_navigate(self_: *mut BisAlbum, direction: BisNavigationDirection) -> gboolean;
800 pub fn bis_album_prepend(self_: *mut BisAlbum, child: *mut gtk::GtkWidget) -> *mut BisAlbumPage;
801 pub fn bis_album_remove(self_: *mut BisAlbum, child: *mut gtk::GtkWidget);
802 pub fn bis_album_reorder_child_after(self_: *mut BisAlbum, child: *mut gtk::GtkWidget, sibling: *mut gtk::GtkWidget);
803 pub fn bis_album_set_can_navigate_back(self_: *mut BisAlbum, can_navigate_back: gboolean);
804 pub fn bis_album_set_can_navigate_forward(self_: *mut BisAlbum, can_navigate_forward: gboolean);
805 pub fn bis_album_set_can_unfold(self_: *mut BisAlbum, can_unfold: gboolean);
806 pub fn bis_album_set_child_transition_params(self_: *mut BisAlbum, params: *mut BisSpringParams);
807 pub fn bis_album_set_fold_threshold_policy(self_: *mut BisAlbum, policy: BisFoldThresholdPolicy);
808 pub fn bis_album_set_homogeneous(self_: *mut BisAlbum, homogeneous: gboolean);
809 pub fn bis_album_set_mode_transition_duration(self_: *mut BisAlbum, duration: c_uint);
810 pub fn bis_album_set_transition_type(self_: *mut BisAlbum, transition: BisAlbumTransitionType);
811 pub fn bis_album_set_visible_child(self_: *mut BisAlbum, visible_child: *mut gtk::GtkWidget);
812 pub fn bis_album_set_visible_child_name(self_: *mut BisAlbum, name: *const c_char);
813
814 pub fn bis_album_page_get_type() -> GType;
818 pub fn bis_album_page_get_child(self_: *mut BisAlbumPage) -> *mut gtk::GtkWidget;
819 pub fn bis_album_page_get_name(self_: *mut BisAlbumPage) -> *const c_char;
820 pub fn bis_album_page_get_navigatable(self_: *mut BisAlbumPage) -> gboolean;
821 pub fn bis_album_page_set_name(self_: *mut BisAlbumPage, name: *const c_char);
822 pub fn bis_album_page_set_navigatable(self_: *mut BisAlbumPage, navigatable: gboolean);
823
824 pub fn bis_animation_get_type() -> GType;
828 pub fn bis_animation_get_state(self_: *mut BisAnimation) -> BisAnimationState;
829 pub fn bis_animation_get_target(self_: *mut BisAnimation) -> *mut BisAnimationTarget;
830 pub fn bis_animation_get_value(self_: *mut BisAnimation) -> c_double;
831 pub fn bis_animation_get_widget(self_: *mut BisAnimation) -> *mut gtk::GtkWidget;
832 pub fn bis_animation_pause(self_: *mut BisAnimation);
833 pub fn bis_animation_play(self_: *mut BisAnimation);
834 pub fn bis_animation_reset(self_: *mut BisAnimation);
835 pub fn bis_animation_resume(self_: *mut BisAnimation);
836 pub fn bis_animation_set_target(self_: *mut BisAnimation, target: *mut BisAnimationTarget);
837 pub fn bis_animation_skip(self_: *mut BisAnimation);
838
839 pub fn bis_animation_target_get_type() -> GType;
843
844 pub fn bis_bin_get_type() -> GType;
848 pub fn bis_bin_new() -> *mut gtk::GtkWidget;
849 pub fn bis_bin_get_child(self_: *mut BisBin) -> *mut gtk::GtkWidget;
850 pub fn bis_bin_set_child(self_: *mut BisBin, child: *mut gtk::GtkWidget);
851
852 pub fn bis_callback_animation_target_get_type() -> GType;
856 pub fn bis_callback_animation_target_new(callback: BisAnimationTargetFunc, user_data: gpointer, destroy: glib::GDestroyNotify) -> *mut BisAnimationTarget;
857
858 pub fn bis_carousel_get_type() -> GType;
862 pub fn bis_carousel_new() -> *mut gtk::GtkWidget;
863 pub fn bis_carousel_append(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
864 pub fn bis_carousel_get_allow_long_swipes(self_: *mut BisCarousel) -> gboolean;
865 pub fn bis_carousel_get_allow_mouse_drag(self_: *mut BisCarousel) -> gboolean;
866 pub fn bis_carousel_get_allow_scroll_wheel(self_: *mut BisCarousel) -> gboolean;
867 pub fn bis_carousel_get_interactive(self_: *mut BisCarousel) -> gboolean;
868 pub fn bis_carousel_get_n_pages(self_: *mut BisCarousel) -> c_uint;
869 pub fn bis_carousel_get_nth_page(self_: *mut BisCarousel, n: c_uint) -> *mut gtk::GtkWidget;
870 pub fn bis_carousel_get_position(self_: *mut BisCarousel) -> c_double;
871 pub fn bis_carousel_get_reveal_duration(self_: *mut BisCarousel) -> c_uint;
872 pub fn bis_carousel_get_scroll_params(self_: *mut BisCarousel) -> *mut BisSpringParams;
873 pub fn bis_carousel_get_spacing(self_: *mut BisCarousel) -> c_uint;
874 pub fn bis_carousel_insert(self_: *mut BisCarousel, child: *mut gtk::GtkWidget, position: c_int);
875 pub fn bis_carousel_prepend(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
876 pub fn bis_carousel_remove(self_: *mut BisCarousel, child: *mut gtk::GtkWidget);
877 pub fn bis_carousel_reorder(self_: *mut BisCarousel, child: *mut gtk::GtkWidget, position: c_int);
878 pub fn bis_carousel_scroll_to(self_: *mut BisCarousel, widget: *mut gtk::GtkWidget, animate: gboolean);
879 pub fn bis_carousel_set_allow_long_swipes(self_: *mut BisCarousel, allow_long_swipes: gboolean);
880 pub fn bis_carousel_set_allow_mouse_drag(self_: *mut BisCarousel, allow_mouse_drag: gboolean);
881 pub fn bis_carousel_set_allow_scroll_wheel(self_: *mut BisCarousel, allow_scroll_wheel: gboolean);
882 pub fn bis_carousel_set_interactive(self_: *mut BisCarousel, interactive: gboolean);
883 pub fn bis_carousel_set_reveal_duration(self_: *mut BisCarousel, reveal_duration: c_uint);
884 pub fn bis_carousel_set_scroll_params(self_: *mut BisCarousel, params: *mut BisSpringParams);
885 pub fn bis_carousel_set_spacing(self_: *mut BisCarousel, spacing: c_uint);
886
887 pub fn bis_carousel_indicator_dots_get_type() -> GType;
891 pub fn bis_carousel_indicator_dots_new() -> *mut gtk::GtkWidget;
892 pub fn bis_carousel_indicator_dots_get_carousel(self_: *mut BisCarouselIndicatorDots) -> *mut BisCarousel;
893 pub fn bis_carousel_indicator_dots_set_carousel(self_: *mut BisCarouselIndicatorDots, carousel: *mut BisCarousel);
894
895 pub fn bis_carousel_indicator_lines_get_type() -> GType;
899 pub fn bis_carousel_indicator_lines_new() -> *mut gtk::GtkWidget;
900 pub fn bis_carousel_indicator_lines_get_carousel(self_: *mut BisCarouselIndicatorLines) -> *mut BisCarousel;
901 pub fn bis_carousel_indicator_lines_set_carousel(self_: *mut BisCarouselIndicatorLines, carousel: *mut BisCarousel);
902
903 pub fn bis_enum_list_item_get_type() -> GType;
907 pub fn bis_enum_list_item_get_name(self_: *mut BisEnumListItem) -> *const c_char;
908 pub fn bis_enum_list_item_get_nick(self_: *mut BisEnumListItem) -> *const c_char;
909 pub fn bis_enum_list_item_get_value(self_: *mut BisEnumListItem) -> c_int;
910
911 pub fn bis_enum_list_model_get_type() -> GType;
915 pub fn bis_enum_list_model_new(enum_type: GType) -> *mut BisEnumListModel;
916 pub fn bis_enum_list_model_find_position(self_: *mut BisEnumListModel, value: c_int) -> c_uint;
917 pub fn bis_enum_list_model_get_enum_type(self_: *mut BisEnumListModel) -> GType;
918
919 pub fn bis_hugger_get_type() -> GType;
923 pub fn bis_hugger_new() -> *mut gtk::GtkWidget;
924 pub fn bis_hugger_add(self_: *mut BisHugger, child: *mut gtk::GtkWidget) -> *mut BisHuggerPage;
925 pub fn bis_hugger_get_allow_none(self_: *mut BisHugger) -> gboolean;
926 pub fn bis_hugger_get_homogeneous(self_: *mut BisHugger) -> gboolean;
927 pub fn bis_hugger_get_interpolate_size(self_: *mut BisHugger) -> gboolean;
928 pub fn bis_hugger_get_page(self_: *mut BisHugger, child: *mut gtk::GtkWidget) -> *mut BisHuggerPage;
929 pub fn bis_hugger_get_pages(self_: *mut BisHugger) -> *mut gtk::GtkSelectionModel;
930 pub fn bis_hugger_get_switch_threshold_policy(self_: *mut BisHugger) -> BisFoldThresholdPolicy;
931 pub fn bis_hugger_get_transition_duration(self_: *mut BisHugger) -> c_uint;
932 pub fn bis_hugger_get_transition_running(self_: *mut BisHugger) -> gboolean;
933 pub fn bis_hugger_get_transition_type(self_: *mut BisHugger) -> BisHuggerTransitionType;
934 pub fn bis_hugger_get_visible_child(self_: *mut BisHugger) -> *mut gtk::GtkWidget;
935 pub fn bis_hugger_get_xalign(self_: *mut BisHugger) -> c_float;
936 pub fn bis_hugger_get_yalign(self_: *mut BisHugger) -> c_float;
937 pub fn bis_hugger_remove(self_: *mut BisHugger, child: *mut gtk::GtkWidget);
938 pub fn bis_hugger_set_allow_none(self_: *mut BisHugger, allow_none: gboolean);
939 pub fn bis_hugger_set_homogeneous(self_: *mut BisHugger, homogeneous: gboolean);
940 pub fn bis_hugger_set_interpolate_size(self_: *mut BisHugger, interpolate_size: gboolean);
941 pub fn bis_hugger_set_switch_threshold_policy(self_: *mut BisHugger, policy: BisFoldThresholdPolicy);
942 pub fn bis_hugger_set_transition_duration(self_: *mut BisHugger, duration: c_uint);
943 pub fn bis_hugger_set_transition_type(self_: *mut BisHugger, transition: BisHuggerTransitionType);
944 pub fn bis_hugger_set_xalign(self_: *mut BisHugger, xalign: c_float);
945 pub fn bis_hugger_set_yalign(self_: *mut BisHugger, yalign: c_float);
946
947 pub fn bis_hugger_page_get_type() -> GType;
951 pub fn bis_hugger_page_get_child(self_: *mut BisHuggerPage) -> *mut gtk::GtkWidget;
952 pub fn bis_hugger_page_get_enabled(self_: *mut BisHuggerPage) -> gboolean;
953 pub fn bis_hugger_page_set_enabled(self_: *mut BisHuggerPage, enabled: gboolean);
954
955 pub fn bis_lapel_get_type() -> GType;
959 pub fn bis_lapel_new() -> *mut gtk::GtkWidget;
960 pub fn bis_lapel_get_content(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
961 pub fn bis_lapel_get_fold_duration(self_: *mut BisLapel) -> c_uint;
962 pub fn bis_lapel_get_fold_policy(self_: *mut BisLapel) -> BisLapelFoldPolicy;
963 pub fn bis_lapel_get_fold_threshold_policy(self_: *mut BisLapel) -> BisFoldThresholdPolicy;
964 pub fn bis_lapel_get_folded(self_: *mut BisLapel) -> gboolean;
965 pub fn bis_lapel_get_lapel(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
966 pub fn bis_lapel_get_lapel_position(self_: *mut BisLapel) -> gtk::GtkPackType;
967 pub fn bis_lapel_get_locked(self_: *mut BisLapel) -> gboolean;
968 pub fn bis_lapel_get_modal(self_: *mut BisLapel) -> gboolean;
969 pub fn bis_lapel_get_reveal_lapel(self_: *mut BisLapel) -> gboolean;
970 pub fn bis_lapel_get_reveal_params(self_: *mut BisLapel) -> *mut BisSpringParams;
971 pub fn bis_lapel_get_reveal_progress(self_: *mut BisLapel) -> c_double;
972 pub fn bis_lapel_get_separator(self_: *mut BisLapel) -> *mut gtk::GtkWidget;
973 pub fn bis_lapel_get_swipe_to_close(self_: *mut BisLapel) -> gboolean;
974 pub fn bis_lapel_get_swipe_to_open(self_: *mut BisLapel) -> gboolean;
975 pub fn bis_lapel_get_transition_type(self_: *mut BisLapel) -> BisLapelTransitionType;
976 pub fn bis_lapel_set_content(self_: *mut BisLapel, content: *mut gtk::GtkWidget);
977 pub fn bis_lapel_set_fold_duration(self_: *mut BisLapel, duration: c_uint);
978 pub fn bis_lapel_set_fold_policy(self_: *mut BisLapel, policy: BisLapelFoldPolicy);
979 pub fn bis_lapel_set_fold_threshold_policy(self_: *mut BisLapel, policy: BisFoldThresholdPolicy);
980 pub fn bis_lapel_set_lapel(self_: *mut BisLapel, lapel: *mut gtk::GtkWidget);
981 pub fn bis_lapel_set_lapel_position(self_: *mut BisLapel, position: gtk::GtkPackType);
982 pub fn bis_lapel_set_locked(self_: *mut BisLapel, locked: gboolean);
983 pub fn bis_lapel_set_modal(self_: *mut BisLapel, modal: gboolean);
984 pub fn bis_lapel_set_reveal_lapel(self_: *mut BisLapel, reveal_lapel: gboolean);
985 pub fn bis_lapel_set_reveal_params(self_: *mut BisLapel, params: *mut BisSpringParams);
986 pub fn bis_lapel_set_separator(self_: *mut BisLapel, separator: *mut gtk::GtkWidget);
987 pub fn bis_lapel_set_swipe_to_close(self_: *mut BisLapel, swipe_to_close: gboolean);
988 pub fn bis_lapel_set_swipe_to_open(self_: *mut BisLapel, swipe_to_open: gboolean);
989 pub fn bis_lapel_set_transition_type(self_: *mut BisLapel, transition_type: BisLapelTransitionType);
990
991 pub fn bis_latch_get_type() -> GType;
995 pub fn bis_latch_new() -> *mut gtk::GtkWidget;
996 pub fn bis_latch_get_child(self_: *mut BisLatch) -> *mut gtk::GtkWidget;
997 pub fn bis_latch_get_maximum_size(self_: *mut BisLatch) -> c_int;
998 pub fn bis_latch_get_tightening_threshold(self_: *mut BisLatch) -> c_int;
999 pub fn bis_latch_set_child(self_: *mut BisLatch, child: *mut gtk::GtkWidget);
1000 pub fn bis_latch_set_maximum_size(self_: *mut BisLatch, maximum_size: c_int);
1001 pub fn bis_latch_set_tightening_threshold(self_: *mut BisLatch, tightening_threshold: c_int);
1002
1003 pub fn bis_latch_layout_get_type() -> GType;
1007 pub fn bis_latch_layout_new() -> *mut gtk::GtkLayoutManager;
1008 pub fn bis_latch_layout_get_maximum_size(self_: *mut BisLatchLayout) -> c_int;
1009 pub fn bis_latch_layout_get_tightening_threshold(self_: *mut BisLatchLayout) -> c_int;
1010 pub fn bis_latch_layout_set_maximum_size(self_: *mut BisLatchLayout, maximum_size: c_int);
1011 pub fn bis_latch_layout_set_tightening_threshold(self_: *mut BisLatchLayout, tightening_threshold: c_int);
1012
1013 pub fn bis_latch_scrollable_get_type() -> GType;
1017 pub fn bis_latch_scrollable_new() -> *mut gtk::GtkWidget;
1018 pub fn bis_latch_scrollable_get_child(self_: *mut BisLatchScrollable) -> *mut gtk::GtkWidget;
1019 pub fn bis_latch_scrollable_get_maximum_size(self_: *mut BisLatchScrollable) -> c_int;
1020 pub fn bis_latch_scrollable_get_tightening_threshold(self_: *mut BisLatchScrollable) -> c_int;
1021 pub fn bis_latch_scrollable_set_child(self_: *mut BisLatchScrollable, child: *mut gtk::GtkWidget);
1022 pub fn bis_latch_scrollable_set_maximum_size(self_: *mut BisLatchScrollable, maximum_size: c_int);
1023 pub fn bis_latch_scrollable_set_tightening_threshold(self_: *mut BisLatchScrollable, tightening_threshold: c_int);
1024
1025 #[cfg(feature = "v1_2")]
1029 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1030 pub fn bis_property_animation_target_get_type() -> GType;
1031 #[cfg(feature = "v1_2")]
1032 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1033 pub fn bis_property_animation_target_new(object: *mut gobject::GObject, property_name: *const c_char) -> *mut BisAnimationTarget;
1034 #[cfg(feature = "v1_2")]
1035 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1036 pub fn bis_property_animation_target_new_for_pspec(object: *mut gobject::GObject, pspec: *mut gobject::GParamSpec) -> *mut BisAnimationTarget;
1037 #[cfg(feature = "v1_2")]
1038 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1039 pub fn bis_property_animation_target_get_object(self_: *mut BisPropertyAnimationTarget) -> *mut gobject::GObject;
1040 #[cfg(feature = "v1_2")]
1041 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
1042 pub fn bis_property_animation_target_get_pspec(self_: *mut BisPropertyAnimationTarget) -> *mut gobject::GParamSpec;
1043
1044 pub fn bis_spring_animation_get_type() -> GType;
1048 pub fn bis_spring_animation_new(widget: *mut gtk::GtkWidget, from: c_double, to: c_double, spring_params: *mut BisSpringParams, target: *mut BisAnimationTarget) -> *mut BisAnimation;
1049 pub fn bis_spring_animation_get_epsilon(self_: *mut BisSpringAnimation) -> c_double;
1050 pub fn bis_spring_animation_get_estimated_duration(self_: *mut BisSpringAnimation) -> c_uint;
1051 pub fn bis_spring_animation_get_initial_velocity(self_: *mut BisSpringAnimation) -> c_double;
1052 pub fn bis_spring_animation_get_latch(self_: *mut BisSpringAnimation) -> gboolean;
1053 pub fn bis_spring_animation_get_spring_params(self_: *mut BisSpringAnimation) -> *mut BisSpringParams;
1054 pub fn bis_spring_animation_get_value_from(self_: *mut BisSpringAnimation) -> c_double;
1055 pub fn bis_spring_animation_get_value_to(self_: *mut BisSpringAnimation) -> c_double;
1056 pub fn bis_spring_animation_get_velocity(self_: *mut BisSpringAnimation) -> c_double;
1057 pub fn bis_spring_animation_set_epsilon(self_: *mut BisSpringAnimation, epsilon: c_double);
1058 pub fn bis_spring_animation_set_initial_velocity(self_: *mut BisSpringAnimation, velocity: c_double);
1059 pub fn bis_spring_animation_set_latch(self_: *mut BisSpringAnimation, latch: gboolean);
1060 pub fn bis_spring_animation_set_spring_params(self_: *mut BisSpringAnimation, spring_params: *mut BisSpringParams);
1061 pub fn bis_spring_animation_set_value_from(self_: *mut BisSpringAnimation, value: c_double);
1062 pub fn bis_spring_animation_set_value_to(self_: *mut BisSpringAnimation, value: c_double);
1063
1064 pub fn bis_swipe_tracker_get_type() -> GType;
1068 pub fn bis_swipe_tracker_new(swipeable: *mut BisSwipeable) -> *mut BisSwipeTracker;
1069 pub fn bis_swipe_tracker_get_allow_long_swipes(self_: *mut BisSwipeTracker) -> gboolean;
1070 pub fn bis_swipe_tracker_get_allow_mouse_drag(self_: *mut BisSwipeTracker) -> gboolean;
1071 pub fn bis_swipe_tracker_get_enabled(self_: *mut BisSwipeTracker) -> gboolean;
1072 pub fn bis_swipe_tracker_get_reversed(self_: *mut BisSwipeTracker) -> gboolean;
1073 pub fn bis_swipe_tracker_get_swipeable(self_: *mut BisSwipeTracker) -> *mut BisSwipeable;
1074 pub fn bis_swipe_tracker_set_allow_long_swipes(self_: *mut BisSwipeTracker, allow_long_swipes: gboolean);
1075 pub fn bis_swipe_tracker_set_allow_mouse_drag(self_: *mut BisSwipeTracker, allow_mouse_drag: gboolean);
1076 pub fn bis_swipe_tracker_set_enabled(self_: *mut BisSwipeTracker, enabled: gboolean);
1077 pub fn bis_swipe_tracker_set_reversed(self_: *mut BisSwipeTracker, reversed: gboolean);
1078 pub fn bis_swipe_tracker_shift_position(self_: *mut BisSwipeTracker, delta: c_double);
1079
1080 pub fn bis_timed_animation_get_type() -> GType;
1084 pub fn bis_timed_animation_new(widget: *mut gtk::GtkWidget, from: c_double, to: c_double, duration: c_uint, target: *mut BisAnimationTarget) -> *mut BisAnimation;
1085 pub fn bis_timed_animation_get_alternate(self_: *mut BisTimedAnimation) -> gboolean;
1086 pub fn bis_timed_animation_get_duration(self_: *mut BisTimedAnimation) -> c_uint;
1087 pub fn bis_timed_animation_get_easing(self_: *mut BisTimedAnimation) -> BisEasing;
1088 pub fn bis_timed_animation_get_repeat_count(self_: *mut BisTimedAnimation) -> c_uint;
1089 pub fn bis_timed_animation_get_reverse(self_: *mut BisTimedAnimation) -> gboolean;
1090 pub fn bis_timed_animation_get_value_from(self_: *mut BisTimedAnimation) -> c_double;
1091 pub fn bis_timed_animation_get_value_to(self_: *mut BisTimedAnimation) -> c_double;
1092 pub fn bis_timed_animation_set_alternate(self_: *mut BisTimedAnimation, alternate: gboolean);
1093 pub fn bis_timed_animation_set_duration(self_: *mut BisTimedAnimation, duration: c_uint);
1094 pub fn bis_timed_animation_set_easing(self_: *mut BisTimedAnimation, easing: BisEasing);
1095 pub fn bis_timed_animation_set_repeat_count(self_: *mut BisTimedAnimation, repeat_count: c_uint);
1096 pub fn bis_timed_animation_set_reverse(self_: *mut BisTimedAnimation, reverse: gboolean);
1097 pub fn bis_timed_animation_set_value_from(self_: *mut BisTimedAnimation, value: c_double);
1098 pub fn bis_timed_animation_set_value_to(self_: *mut BisTimedAnimation, value: c_double);
1099
1100 pub fn bis_swipeable_get_type() -> GType;
1104 pub fn bis_swipeable_get_cancel_progress(self_: *mut BisSwipeable) -> c_double;
1105 pub fn bis_swipeable_get_distance(self_: *mut BisSwipeable) -> c_double;
1106 pub fn bis_swipeable_get_progress(self_: *mut BisSwipeable) -> c_double;
1107 pub fn bis_swipeable_get_snap_points(self_: *mut BisSwipeable, n_snap_points: *mut c_int) -> *mut c_double;
1108 pub fn bis_swipeable_get_swipe_area(self_: *mut BisSwipeable, navigation_direction: BisNavigationDirection, is_drag: gboolean, rect: *mut gdk::GdkRectangle);
1109
1110 pub fn bis_get_enable_animations(widget: *mut gtk::GtkWidget) -> gboolean;
1114 pub fn bis_get_major_version() -> c_uint;
1115 pub fn bis_get_micro_version() -> c_uint;
1116 pub fn bis_get_minor_version() -> c_uint;
1117 pub fn bis_init();
1118 pub fn bis_is_initialized() -> gboolean;
1119 pub fn bis_lerp(a: c_double, b: c_double, t: c_double) -> c_double;
1120
1121}