1use crate::{Adjustment, Border, ScrollablePolicy, ffi};
6use glib::{
7 prelude::*,
8 signal::{SignalHandlerId, connect_raw},
9 translate::*,
10};
11use std::boxed::Box as Box_;
12
13glib::wrapper! {
14 #[doc(alias = "GtkScrollable")]
15 pub struct Scrollable(Interface<ffi::GtkScrollable, ffi::GtkScrollableInterface>);
16
17 match fn {
18 type_ => || ffi::gtk_scrollable_get_type(),
19 }
20}
21
22impl Scrollable {
23 pub const NONE: Option<&'static Scrollable> = None;
24}
25
26pub trait ScrollableExt: IsA<Scrollable> + 'static {
27 #[doc(alias = "gtk_scrollable_get_border")]
28 #[doc(alias = "get_border")]
29 fn border(&self) -> Option<Border> {
30 unsafe {
31 let mut border = Border::uninitialized();
32 let ret = from_glib(ffi::gtk_scrollable_get_border(
33 self.as_ref().to_glib_none().0,
34 border.to_glib_none_mut().0,
35 ));
36 if ret { Some(border) } else { None }
37 }
38 }
39
40 #[doc(alias = "gtk_scrollable_get_hadjustment")]
41 #[doc(alias = "get_hadjustment")]
42 fn hadjustment(&self) -> Option<Adjustment> {
43 unsafe {
44 from_glib_none(ffi::gtk_scrollable_get_hadjustment(
45 self.as_ref().to_glib_none().0,
46 ))
47 }
48 }
49
50 #[doc(alias = "gtk_scrollable_get_hscroll_policy")]
51 #[doc(alias = "get_hscroll_policy")]
52 #[doc(alias = "hscroll-policy")]
53 fn hscroll_policy(&self) -> ScrollablePolicy {
54 unsafe {
55 from_glib(ffi::gtk_scrollable_get_hscroll_policy(
56 self.as_ref().to_glib_none().0,
57 ))
58 }
59 }
60
61 #[doc(alias = "gtk_scrollable_get_vadjustment")]
62 #[doc(alias = "get_vadjustment")]
63 fn vadjustment(&self) -> Option<Adjustment> {
64 unsafe {
65 from_glib_none(ffi::gtk_scrollable_get_vadjustment(
66 self.as_ref().to_glib_none().0,
67 ))
68 }
69 }
70
71 #[doc(alias = "gtk_scrollable_get_vscroll_policy")]
72 #[doc(alias = "get_vscroll_policy")]
73 #[doc(alias = "vscroll-policy")]
74 fn vscroll_policy(&self) -> ScrollablePolicy {
75 unsafe {
76 from_glib(ffi::gtk_scrollable_get_vscroll_policy(
77 self.as_ref().to_glib_none().0,
78 ))
79 }
80 }
81
82 #[doc(alias = "gtk_scrollable_set_hadjustment")]
83 #[doc(alias = "hadjustment")]
84 fn set_hadjustment(&self, hadjustment: Option<&impl IsA<Adjustment>>) {
85 unsafe {
86 ffi::gtk_scrollable_set_hadjustment(
87 self.as_ref().to_glib_none().0,
88 hadjustment.map(|p| p.as_ref()).to_glib_none().0,
89 );
90 }
91 }
92
93 #[doc(alias = "gtk_scrollable_set_hscroll_policy")]
94 #[doc(alias = "hscroll-policy")]
95 fn set_hscroll_policy(&self, policy: ScrollablePolicy) {
96 unsafe {
97 ffi::gtk_scrollable_set_hscroll_policy(
98 self.as_ref().to_glib_none().0,
99 policy.into_glib(),
100 );
101 }
102 }
103
104 #[doc(alias = "gtk_scrollable_set_vadjustment")]
105 #[doc(alias = "vadjustment")]
106 fn set_vadjustment(&self, vadjustment: Option<&impl IsA<Adjustment>>) {
107 unsafe {
108 ffi::gtk_scrollable_set_vadjustment(
109 self.as_ref().to_glib_none().0,
110 vadjustment.map(|p| p.as_ref()).to_glib_none().0,
111 );
112 }
113 }
114
115 #[doc(alias = "gtk_scrollable_set_vscroll_policy")]
116 #[doc(alias = "vscroll-policy")]
117 fn set_vscroll_policy(&self, policy: ScrollablePolicy) {
118 unsafe {
119 ffi::gtk_scrollable_set_vscroll_policy(
120 self.as_ref().to_glib_none().0,
121 policy.into_glib(),
122 );
123 }
124 }
125
126 #[doc(alias = "hadjustment")]
127 fn connect_hadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
128 unsafe extern "C" fn notify_hadjustment_trampoline<
129 P: IsA<Scrollable>,
130 F: Fn(&P) + 'static,
131 >(
132 this: *mut ffi::GtkScrollable,
133 _param_spec: glib::ffi::gpointer,
134 f: glib::ffi::gpointer,
135 ) {
136 unsafe {
137 let f: &F = &*(f as *const F);
138 f(Scrollable::from_glib_borrow(this).unsafe_cast_ref())
139 }
140 }
141 unsafe {
142 let f: Box_<F> = Box_::new(f);
143 connect_raw(
144 self.as_ptr() as *mut _,
145 c"notify::hadjustment".as_ptr(),
146 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
147 notify_hadjustment_trampoline::<Self, F> as *const (),
148 )),
149 Box_::into_raw(f),
150 )
151 }
152 }
153
154 #[doc(alias = "hscroll-policy")]
155 fn connect_hscroll_policy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
156 unsafe extern "C" fn notify_hscroll_policy_trampoline<
157 P: IsA<Scrollable>,
158 F: Fn(&P) + 'static,
159 >(
160 this: *mut ffi::GtkScrollable,
161 _param_spec: glib::ffi::gpointer,
162 f: glib::ffi::gpointer,
163 ) {
164 unsafe {
165 let f: &F = &*(f as *const F);
166 f(Scrollable::from_glib_borrow(this).unsafe_cast_ref())
167 }
168 }
169 unsafe {
170 let f: Box_<F> = Box_::new(f);
171 connect_raw(
172 self.as_ptr() as *mut _,
173 c"notify::hscroll-policy".as_ptr(),
174 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
175 notify_hscroll_policy_trampoline::<Self, F> as *const (),
176 )),
177 Box_::into_raw(f),
178 )
179 }
180 }
181
182 #[doc(alias = "vadjustment")]
183 fn connect_vadjustment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
184 unsafe extern "C" fn notify_vadjustment_trampoline<
185 P: IsA<Scrollable>,
186 F: Fn(&P) + 'static,
187 >(
188 this: *mut ffi::GtkScrollable,
189 _param_spec: glib::ffi::gpointer,
190 f: glib::ffi::gpointer,
191 ) {
192 unsafe {
193 let f: &F = &*(f as *const F);
194 f(Scrollable::from_glib_borrow(this).unsafe_cast_ref())
195 }
196 }
197 unsafe {
198 let f: Box_<F> = Box_::new(f);
199 connect_raw(
200 self.as_ptr() as *mut _,
201 c"notify::vadjustment".as_ptr(),
202 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
203 notify_vadjustment_trampoline::<Self, F> as *const (),
204 )),
205 Box_::into_raw(f),
206 )
207 }
208 }
209
210 #[doc(alias = "vscroll-policy")]
211 fn connect_vscroll_policy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
212 unsafe extern "C" fn notify_vscroll_policy_trampoline<
213 P: IsA<Scrollable>,
214 F: Fn(&P) + 'static,
215 >(
216 this: *mut ffi::GtkScrollable,
217 _param_spec: glib::ffi::gpointer,
218 f: glib::ffi::gpointer,
219 ) {
220 unsafe {
221 let f: &F = &*(f as *const F);
222 f(Scrollable::from_glib_borrow(this).unsafe_cast_ref())
223 }
224 }
225 unsafe {
226 let f: Box_<F> = Box_::new(f);
227 connect_raw(
228 self.as_ptr() as *mut _,
229 c"notify::vscroll-policy".as_ptr(),
230 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
231 notify_vscroll_policy_trampoline::<Self, F> as *const (),
232 )),
233 Box_::into_raw(f),
234 )
235 }
236 }
237}
238
239impl<O: IsA<Scrollable>> ScrollableExt for O {}