1use crate::ffi;
7use glib::{
8 prelude::*,
9 signal::{connect_raw, SignalHandlerId},
10 translate::*,
11};
12use std::boxed::Box as Box_;
13
14glib::wrapper! {
15 #[doc(alias = "AdwTabPage")]
16 pub struct TabPage(Object<ffi::AdwTabPage, ffi::AdwTabPageClass>) @implements gtk::Accessible;
17
18 match fn {
19 type_ => || ffi::adw_tab_page_get_type(),
20 }
21}
22
23impl TabPage {
24 #[doc(alias = "adw_tab_page_get_child")]
25 #[doc(alias = "get_child")]
26 pub fn child(&self) -> gtk::Widget {
27 unsafe { from_glib_none(ffi::adw_tab_page_get_child(self.to_glib_none().0)) }
28 }
29
30 #[doc(alias = "adw_tab_page_get_icon")]
31 #[doc(alias = "get_icon")]
32 pub fn icon(&self) -> Option<gio::Icon> {
33 unsafe { from_glib_none(ffi::adw_tab_page_get_icon(self.to_glib_none().0)) }
34 }
35
36 #[doc(alias = "adw_tab_page_get_indicator_activatable")]
37 #[doc(alias = "get_indicator_activatable")]
38 #[doc(alias = "indicator-activatable")]
39 pub fn is_indicator_activatable(&self) -> bool {
40 unsafe {
41 from_glib(ffi::adw_tab_page_get_indicator_activatable(
42 self.to_glib_none().0,
43 ))
44 }
45 }
46
47 #[doc(alias = "adw_tab_page_get_indicator_icon")]
48 #[doc(alias = "get_indicator_icon")]
49 #[doc(alias = "indicator-icon")]
50 pub fn indicator_icon(&self) -> Option<gio::Icon> {
51 unsafe { from_glib_none(ffi::adw_tab_page_get_indicator_icon(self.to_glib_none().0)) }
52 }
53
54 #[cfg(feature = "v1_2")]
55 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
56 #[doc(alias = "adw_tab_page_get_indicator_tooltip")]
57 #[doc(alias = "get_indicator_tooltip")]
58 #[doc(alias = "indicator-tooltip")]
59 pub fn indicator_tooltip(&self) -> glib::GString {
60 unsafe {
61 from_glib_none(ffi::adw_tab_page_get_indicator_tooltip(
62 self.to_glib_none().0,
63 ))
64 }
65 }
66
67 #[cfg(feature = "v1_3")]
68 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
69 #[doc(alias = "adw_tab_page_get_keyword")]
70 #[doc(alias = "get_keyword")]
71 pub fn keyword(&self) -> Option<glib::GString> {
72 unsafe { from_glib_none(ffi::adw_tab_page_get_keyword(self.to_glib_none().0)) }
73 }
74
75 #[cfg(feature = "v1_3")]
76 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
77 #[doc(alias = "adw_tab_page_get_live_thumbnail")]
78 #[doc(alias = "get_live_thumbnail")]
79 #[doc(alias = "live-thumbnail")]
80 pub fn is_live_thumbnail(&self) -> bool {
81 unsafe { from_glib(ffi::adw_tab_page_get_live_thumbnail(self.to_glib_none().0)) }
82 }
83
84 #[doc(alias = "adw_tab_page_get_loading")]
85 #[doc(alias = "get_loading")]
86 #[doc(alias = "loading")]
87 pub fn is_loading(&self) -> bool {
88 unsafe { from_glib(ffi::adw_tab_page_get_loading(self.to_glib_none().0)) }
89 }
90
91 #[doc(alias = "adw_tab_page_get_needs_attention")]
92 #[doc(alias = "get_needs_attention")]
93 #[doc(alias = "needs-attention")]
94 pub fn needs_attention(&self) -> bool {
95 unsafe { from_glib(ffi::adw_tab_page_get_needs_attention(self.to_glib_none().0)) }
96 }
97
98 #[doc(alias = "adw_tab_page_get_parent")]
99 #[doc(alias = "get_parent")]
100 #[must_use]
101 pub fn parent(&self) -> Option<TabPage> {
102 unsafe { from_glib_none(ffi::adw_tab_page_get_parent(self.to_glib_none().0)) }
103 }
104
105 #[doc(alias = "adw_tab_page_get_pinned")]
106 #[doc(alias = "get_pinned")]
107 #[doc(alias = "pinned")]
108 pub fn is_pinned(&self) -> bool {
109 unsafe { from_glib(ffi::adw_tab_page_get_pinned(self.to_glib_none().0)) }
110 }
111
112 #[doc(alias = "adw_tab_page_get_selected")]
113 #[doc(alias = "get_selected")]
114 #[doc(alias = "selected")]
115 pub fn is_selected(&self) -> bool {
116 unsafe { from_glib(ffi::adw_tab_page_get_selected(self.to_glib_none().0)) }
117 }
118
119 #[cfg(feature = "v1_3")]
120 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
121 #[doc(alias = "adw_tab_page_get_thumbnail_xalign")]
122 #[doc(alias = "get_thumbnail_xalign")]
123 #[doc(alias = "thumbnail-xalign")]
124 pub fn thumbnail_xalign(&self) -> f32 {
125 unsafe { ffi::adw_tab_page_get_thumbnail_xalign(self.to_glib_none().0) }
126 }
127
128 #[cfg(feature = "v1_3")]
129 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
130 #[doc(alias = "adw_tab_page_get_thumbnail_yalign")]
131 #[doc(alias = "get_thumbnail_yalign")]
132 #[doc(alias = "thumbnail-yalign")]
133 pub fn thumbnail_yalign(&self) -> f32 {
134 unsafe { ffi::adw_tab_page_get_thumbnail_yalign(self.to_glib_none().0) }
135 }
136
137 #[doc(alias = "adw_tab_page_get_title")]
138 #[doc(alias = "get_title")]
139 pub fn title(&self) -> glib::GString {
140 unsafe { from_glib_none(ffi::adw_tab_page_get_title(self.to_glib_none().0)) }
141 }
142
143 #[doc(alias = "adw_tab_page_get_tooltip")]
144 #[doc(alias = "get_tooltip")]
145 pub fn tooltip(&self) -> Option<glib::GString> {
146 unsafe { from_glib_none(ffi::adw_tab_page_get_tooltip(self.to_glib_none().0)) }
147 }
148
149 #[cfg(feature = "v1_3")]
150 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
151 #[doc(alias = "adw_tab_page_invalidate_thumbnail")]
152 pub fn invalidate_thumbnail(&self) {
153 unsafe {
154 ffi::adw_tab_page_invalidate_thumbnail(self.to_glib_none().0);
155 }
156 }
157
158 #[doc(alias = "adw_tab_page_set_icon")]
159 #[doc(alias = "icon")]
160 pub fn set_icon(&self, icon: Option<&impl IsA<gio::Icon>>) {
161 unsafe {
162 ffi::adw_tab_page_set_icon(
163 self.to_glib_none().0,
164 icon.map(|p| p.as_ref()).to_glib_none().0,
165 );
166 }
167 }
168
169 #[doc(alias = "adw_tab_page_set_indicator_activatable")]
170 #[doc(alias = "indicator-activatable")]
171 pub fn set_indicator_activatable(&self, activatable: bool) {
172 unsafe {
173 ffi::adw_tab_page_set_indicator_activatable(
174 self.to_glib_none().0,
175 activatable.into_glib(),
176 );
177 }
178 }
179
180 #[doc(alias = "adw_tab_page_set_indicator_icon")]
181 #[doc(alias = "indicator-icon")]
182 pub fn set_indicator_icon(&self, indicator_icon: Option<&impl IsA<gio::Icon>>) {
183 unsafe {
184 ffi::adw_tab_page_set_indicator_icon(
185 self.to_glib_none().0,
186 indicator_icon.map(|p| p.as_ref()).to_glib_none().0,
187 );
188 }
189 }
190
191 #[cfg(feature = "v1_2")]
192 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
193 #[doc(alias = "adw_tab_page_set_indicator_tooltip")]
194 #[doc(alias = "indicator-tooltip")]
195 pub fn set_indicator_tooltip(&self, tooltip: &str) {
196 unsafe {
197 ffi::adw_tab_page_set_indicator_tooltip(
198 self.to_glib_none().0,
199 tooltip.to_glib_none().0,
200 );
201 }
202 }
203
204 #[cfg(feature = "v1_3")]
205 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
206 #[doc(alias = "adw_tab_page_set_keyword")]
207 #[doc(alias = "keyword")]
208 pub fn set_keyword(&self, keyword: &str) {
209 unsafe {
210 ffi::adw_tab_page_set_keyword(self.to_glib_none().0, keyword.to_glib_none().0);
211 }
212 }
213
214 #[cfg(feature = "v1_3")]
215 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
216 #[doc(alias = "adw_tab_page_set_live_thumbnail")]
217 #[doc(alias = "live-thumbnail")]
218 pub fn set_live_thumbnail(&self, live_thumbnail: bool) {
219 unsafe {
220 ffi::adw_tab_page_set_live_thumbnail(self.to_glib_none().0, live_thumbnail.into_glib());
221 }
222 }
223
224 #[doc(alias = "adw_tab_page_set_loading")]
225 #[doc(alias = "loading")]
226 pub fn set_loading(&self, loading: bool) {
227 unsafe {
228 ffi::adw_tab_page_set_loading(self.to_glib_none().0, loading.into_glib());
229 }
230 }
231
232 #[doc(alias = "adw_tab_page_set_needs_attention")]
233 #[doc(alias = "needs-attention")]
234 pub fn set_needs_attention(&self, needs_attention: bool) {
235 unsafe {
236 ffi::adw_tab_page_set_needs_attention(
237 self.to_glib_none().0,
238 needs_attention.into_glib(),
239 );
240 }
241 }
242
243 #[cfg(feature = "v1_3")]
244 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
245 #[doc(alias = "adw_tab_page_set_thumbnail_xalign")]
246 #[doc(alias = "thumbnail-xalign")]
247 pub fn set_thumbnail_xalign(&self, xalign: f32) {
248 unsafe {
249 ffi::adw_tab_page_set_thumbnail_xalign(self.to_glib_none().0, xalign);
250 }
251 }
252
253 #[cfg(feature = "v1_3")]
254 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
255 #[doc(alias = "adw_tab_page_set_thumbnail_yalign")]
256 #[doc(alias = "thumbnail-yalign")]
257 pub fn set_thumbnail_yalign(&self, yalign: f32) {
258 unsafe {
259 ffi::adw_tab_page_set_thumbnail_yalign(self.to_glib_none().0, yalign);
260 }
261 }
262
263 #[doc(alias = "adw_tab_page_set_title")]
264 #[doc(alias = "title")]
265 pub fn set_title(&self, title: &str) {
266 unsafe {
267 ffi::adw_tab_page_set_title(self.to_glib_none().0, title.to_glib_none().0);
268 }
269 }
270
271 #[doc(alias = "adw_tab_page_set_tooltip")]
272 #[doc(alias = "tooltip")]
273 pub fn set_tooltip(&self, tooltip: &str) {
274 unsafe {
275 ffi::adw_tab_page_set_tooltip(self.to_glib_none().0, tooltip.to_glib_none().0);
276 }
277 }
278
279 #[doc(alias = "icon")]
280 pub fn connect_icon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
281 unsafe extern "C" fn notify_icon_trampoline<F: Fn(&TabPage) + 'static>(
282 this: *mut ffi::AdwTabPage,
283 _param_spec: glib::ffi::gpointer,
284 f: glib::ffi::gpointer,
285 ) {
286 let f: &F = &*(f as *const F);
287 f(&from_glib_borrow(this))
288 }
289 unsafe {
290 let f: Box_<F> = Box_::new(f);
291 connect_raw(
292 self.as_ptr() as *mut _,
293 c"notify::icon".as_ptr() as *const _,
294 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
295 notify_icon_trampoline::<F> as *const (),
296 )),
297 Box_::into_raw(f),
298 )
299 }
300 }
301
302 #[doc(alias = "indicator-activatable")]
303 pub fn connect_indicator_activatable_notify<F: Fn(&Self) + 'static>(
304 &self,
305 f: F,
306 ) -> SignalHandlerId {
307 unsafe extern "C" fn notify_indicator_activatable_trampoline<F: Fn(&TabPage) + 'static>(
308 this: *mut ffi::AdwTabPage,
309 _param_spec: glib::ffi::gpointer,
310 f: glib::ffi::gpointer,
311 ) {
312 let f: &F = &*(f as *const F);
313 f(&from_glib_borrow(this))
314 }
315 unsafe {
316 let f: Box_<F> = Box_::new(f);
317 connect_raw(
318 self.as_ptr() as *mut _,
319 c"notify::indicator-activatable".as_ptr() as *const _,
320 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
321 notify_indicator_activatable_trampoline::<F> as *const (),
322 )),
323 Box_::into_raw(f),
324 )
325 }
326 }
327
328 #[doc(alias = "indicator-icon")]
329 pub fn connect_indicator_icon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
330 unsafe extern "C" fn notify_indicator_icon_trampoline<F: Fn(&TabPage) + 'static>(
331 this: *mut ffi::AdwTabPage,
332 _param_spec: glib::ffi::gpointer,
333 f: glib::ffi::gpointer,
334 ) {
335 let f: &F = &*(f as *const F);
336 f(&from_glib_borrow(this))
337 }
338 unsafe {
339 let f: Box_<F> = Box_::new(f);
340 connect_raw(
341 self.as_ptr() as *mut _,
342 c"notify::indicator-icon".as_ptr() as *const _,
343 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
344 notify_indicator_icon_trampoline::<F> as *const (),
345 )),
346 Box_::into_raw(f),
347 )
348 }
349 }
350
351 #[cfg(feature = "v1_2")]
352 #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
353 #[doc(alias = "indicator-tooltip")]
354 pub fn connect_indicator_tooltip_notify<F: Fn(&Self) + 'static>(
355 &self,
356 f: F,
357 ) -> SignalHandlerId {
358 unsafe extern "C" fn notify_indicator_tooltip_trampoline<F: Fn(&TabPage) + 'static>(
359 this: *mut ffi::AdwTabPage,
360 _param_spec: glib::ffi::gpointer,
361 f: glib::ffi::gpointer,
362 ) {
363 let f: &F = &*(f as *const F);
364 f(&from_glib_borrow(this))
365 }
366 unsafe {
367 let f: Box_<F> = Box_::new(f);
368 connect_raw(
369 self.as_ptr() as *mut _,
370 c"notify::indicator-tooltip".as_ptr() as *const _,
371 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
372 notify_indicator_tooltip_trampoline::<F> as *const (),
373 )),
374 Box_::into_raw(f),
375 )
376 }
377 }
378
379 #[cfg(feature = "v1_3")]
380 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
381 #[doc(alias = "keyword")]
382 pub fn connect_keyword_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
383 unsafe extern "C" fn notify_keyword_trampoline<F: Fn(&TabPage) + 'static>(
384 this: *mut ffi::AdwTabPage,
385 _param_spec: glib::ffi::gpointer,
386 f: glib::ffi::gpointer,
387 ) {
388 let f: &F = &*(f as *const F);
389 f(&from_glib_borrow(this))
390 }
391 unsafe {
392 let f: Box_<F> = Box_::new(f);
393 connect_raw(
394 self.as_ptr() as *mut _,
395 c"notify::keyword".as_ptr() as *const _,
396 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
397 notify_keyword_trampoline::<F> as *const (),
398 )),
399 Box_::into_raw(f),
400 )
401 }
402 }
403
404 #[cfg(feature = "v1_3")]
405 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
406 #[doc(alias = "live-thumbnail")]
407 pub fn connect_live_thumbnail_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
408 unsafe extern "C" fn notify_live_thumbnail_trampoline<F: Fn(&TabPage) + 'static>(
409 this: *mut ffi::AdwTabPage,
410 _param_spec: glib::ffi::gpointer,
411 f: glib::ffi::gpointer,
412 ) {
413 let f: &F = &*(f as *const F);
414 f(&from_glib_borrow(this))
415 }
416 unsafe {
417 let f: Box_<F> = Box_::new(f);
418 connect_raw(
419 self.as_ptr() as *mut _,
420 c"notify::live-thumbnail".as_ptr() as *const _,
421 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
422 notify_live_thumbnail_trampoline::<F> as *const (),
423 )),
424 Box_::into_raw(f),
425 )
426 }
427 }
428
429 #[doc(alias = "loading")]
430 pub fn connect_loading_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
431 unsafe extern "C" fn notify_loading_trampoline<F: Fn(&TabPage) + 'static>(
432 this: *mut ffi::AdwTabPage,
433 _param_spec: glib::ffi::gpointer,
434 f: glib::ffi::gpointer,
435 ) {
436 let f: &F = &*(f as *const F);
437 f(&from_glib_borrow(this))
438 }
439 unsafe {
440 let f: Box_<F> = Box_::new(f);
441 connect_raw(
442 self.as_ptr() as *mut _,
443 c"notify::loading".as_ptr() as *const _,
444 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
445 notify_loading_trampoline::<F> as *const (),
446 )),
447 Box_::into_raw(f),
448 )
449 }
450 }
451
452 #[doc(alias = "needs-attention")]
453 pub fn connect_needs_attention_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
454 unsafe extern "C" fn notify_needs_attention_trampoline<F: Fn(&TabPage) + 'static>(
455 this: *mut ffi::AdwTabPage,
456 _param_spec: glib::ffi::gpointer,
457 f: glib::ffi::gpointer,
458 ) {
459 let f: &F = &*(f as *const F);
460 f(&from_glib_borrow(this))
461 }
462 unsafe {
463 let f: Box_<F> = Box_::new(f);
464 connect_raw(
465 self.as_ptr() as *mut _,
466 c"notify::needs-attention".as_ptr() as *const _,
467 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
468 notify_needs_attention_trampoline::<F> as *const (),
469 )),
470 Box_::into_raw(f),
471 )
472 }
473 }
474
475 #[doc(alias = "pinned")]
476 pub fn connect_pinned_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
477 unsafe extern "C" fn notify_pinned_trampoline<F: Fn(&TabPage) + 'static>(
478 this: *mut ffi::AdwTabPage,
479 _param_spec: glib::ffi::gpointer,
480 f: glib::ffi::gpointer,
481 ) {
482 let f: &F = &*(f as *const F);
483 f(&from_glib_borrow(this))
484 }
485 unsafe {
486 let f: Box_<F> = Box_::new(f);
487 connect_raw(
488 self.as_ptr() as *mut _,
489 c"notify::pinned".as_ptr() as *const _,
490 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
491 notify_pinned_trampoline::<F> as *const (),
492 )),
493 Box_::into_raw(f),
494 )
495 }
496 }
497
498 #[doc(alias = "selected")]
499 pub fn connect_selected_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
500 unsafe extern "C" fn notify_selected_trampoline<F: Fn(&TabPage) + 'static>(
501 this: *mut ffi::AdwTabPage,
502 _param_spec: glib::ffi::gpointer,
503 f: glib::ffi::gpointer,
504 ) {
505 let f: &F = &*(f as *const F);
506 f(&from_glib_borrow(this))
507 }
508 unsafe {
509 let f: Box_<F> = Box_::new(f);
510 connect_raw(
511 self.as_ptr() as *mut _,
512 c"notify::selected".as_ptr() as *const _,
513 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
514 notify_selected_trampoline::<F> as *const (),
515 )),
516 Box_::into_raw(f),
517 )
518 }
519 }
520
521 #[cfg(feature = "v1_3")]
522 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
523 #[doc(alias = "thumbnail-xalign")]
524 pub fn connect_thumbnail_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
525 unsafe extern "C" fn notify_thumbnail_xalign_trampoline<F: Fn(&TabPage) + 'static>(
526 this: *mut ffi::AdwTabPage,
527 _param_spec: glib::ffi::gpointer,
528 f: glib::ffi::gpointer,
529 ) {
530 let f: &F = &*(f as *const F);
531 f(&from_glib_borrow(this))
532 }
533 unsafe {
534 let f: Box_<F> = Box_::new(f);
535 connect_raw(
536 self.as_ptr() as *mut _,
537 c"notify::thumbnail-xalign".as_ptr() as *const _,
538 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
539 notify_thumbnail_xalign_trampoline::<F> as *const (),
540 )),
541 Box_::into_raw(f),
542 )
543 }
544 }
545
546 #[cfg(feature = "v1_3")]
547 #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
548 #[doc(alias = "thumbnail-yalign")]
549 pub fn connect_thumbnail_yalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
550 unsafe extern "C" fn notify_thumbnail_yalign_trampoline<F: Fn(&TabPage) + 'static>(
551 this: *mut ffi::AdwTabPage,
552 _param_spec: glib::ffi::gpointer,
553 f: glib::ffi::gpointer,
554 ) {
555 let f: &F = &*(f as *const F);
556 f(&from_glib_borrow(this))
557 }
558 unsafe {
559 let f: Box_<F> = Box_::new(f);
560 connect_raw(
561 self.as_ptr() as *mut _,
562 c"notify::thumbnail-yalign".as_ptr() as *const _,
563 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
564 notify_thumbnail_yalign_trampoline::<F> as *const (),
565 )),
566 Box_::into_raw(f),
567 )
568 }
569 }
570
571 #[doc(alias = "title")]
572 pub fn connect_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
573 unsafe extern "C" fn notify_title_trampoline<F: Fn(&TabPage) + 'static>(
574 this: *mut ffi::AdwTabPage,
575 _param_spec: glib::ffi::gpointer,
576 f: glib::ffi::gpointer,
577 ) {
578 let f: &F = &*(f as *const F);
579 f(&from_glib_borrow(this))
580 }
581 unsafe {
582 let f: Box_<F> = Box_::new(f);
583 connect_raw(
584 self.as_ptr() as *mut _,
585 c"notify::title".as_ptr() as *const _,
586 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
587 notify_title_trampoline::<F> as *const (),
588 )),
589 Box_::into_raw(f),
590 )
591 }
592 }
593
594 #[doc(alias = "tooltip")]
595 pub fn connect_tooltip_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
596 unsafe extern "C" fn notify_tooltip_trampoline<F: Fn(&TabPage) + 'static>(
597 this: *mut ffi::AdwTabPage,
598 _param_spec: glib::ffi::gpointer,
599 f: glib::ffi::gpointer,
600 ) {
601 let f: &F = &*(f as *const F);
602 f(&from_glib_borrow(this))
603 }
604 unsafe {
605 let f: Box_<F> = Box_::new(f);
606 connect_raw(
607 self.as_ptr() as *mut _,
608 c"notify::tooltip".as_ptr() as *const _,
609 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
610 notify_tooltip_trampoline::<F> as *const (),
611 )),
612 Box_::into_raw(f),
613 )
614 }
615 }
616}