1#![allow(deprecated)]
5
6use crate::{
7 ffi, CellEditable, CellRendererMode, CellRendererState, Requisition, SizeRequestMode, Snapshot,
8 StateFlags, TreePath, Widget,
9};
10use glib::{
11 object::ObjectType as _,
12 prelude::*,
13 signal::{connect_raw, SignalHandlerId},
14 translate::*,
15};
16use std::boxed::Box as Box_;
17
18glib::wrapper! {
19 #[doc(alias = "GtkCellRenderer")]
20 pub struct CellRenderer(Object<ffi::GtkCellRenderer, ffi::GtkCellRendererClass>);
21
22 match fn {
23 type_ => || ffi::gtk_cell_renderer_get_type(),
24 }
25}
26
27impl CellRenderer {
28 pub const NONE: Option<&'static CellRenderer> = None;
29}
30
31mod sealed {
32 pub trait Sealed {}
33 impl<T: super::IsA<super::CellRenderer>> Sealed for T {}
34}
35
36pub trait CellRendererExt: IsA<CellRenderer> + sealed::Sealed + 'static {
37 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
38 #[allow(deprecated)]
39 #[doc(alias = "gtk_cell_renderer_activate")]
40 fn activate(
41 &self,
42 event: impl AsRef<gdk::Event>,
43 widget: &impl IsA<Widget>,
44 path: &str,
45 background_area: &gdk::Rectangle,
46 cell_area: &gdk::Rectangle,
47 flags: CellRendererState,
48 ) -> bool {
49 unsafe {
50 from_glib(ffi::gtk_cell_renderer_activate(
51 self.as_ref().to_glib_none().0,
52 event.as_ref().to_glib_none().0,
53 widget.as_ref().to_glib_none().0,
54 path.to_glib_none().0,
55 background_area.to_glib_none().0,
56 cell_area.to_glib_none().0,
57 flags.into_glib(),
58 ))
59 }
60 }
61
62 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
63 #[allow(deprecated)]
64 #[doc(alias = "gtk_cell_renderer_get_aligned_area")]
65 #[doc(alias = "get_aligned_area")]
66 fn aligned_area(
67 &self,
68 widget: &impl IsA<Widget>,
69 flags: CellRendererState,
70 cell_area: &gdk::Rectangle,
71 ) -> gdk::Rectangle {
72 unsafe {
73 let mut aligned_area = gdk::Rectangle::uninitialized();
74 ffi::gtk_cell_renderer_get_aligned_area(
75 self.as_ref().to_glib_none().0,
76 widget.as_ref().to_glib_none().0,
77 flags.into_glib(),
78 cell_area.to_glib_none().0,
79 aligned_area.to_glib_none_mut().0,
80 );
81 aligned_area
82 }
83 }
84
85 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
86 #[allow(deprecated)]
87 #[doc(alias = "gtk_cell_renderer_get_alignment")]
88 #[doc(alias = "get_alignment")]
89 fn alignment(&self) -> (f32, f32) {
90 unsafe {
91 let mut xalign = std::mem::MaybeUninit::uninit();
92 let mut yalign = std::mem::MaybeUninit::uninit();
93 ffi::gtk_cell_renderer_get_alignment(
94 self.as_ref().to_glib_none().0,
95 xalign.as_mut_ptr(),
96 yalign.as_mut_ptr(),
97 );
98 (xalign.assume_init(), yalign.assume_init())
99 }
100 }
101
102 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
103 #[allow(deprecated)]
104 #[doc(alias = "gtk_cell_renderer_get_fixed_size")]
105 #[doc(alias = "get_fixed_size")]
106 fn fixed_size(&self) -> (i32, i32) {
107 unsafe {
108 let mut width = std::mem::MaybeUninit::uninit();
109 let mut height = std::mem::MaybeUninit::uninit();
110 ffi::gtk_cell_renderer_get_fixed_size(
111 self.as_ref().to_glib_none().0,
112 width.as_mut_ptr(),
113 height.as_mut_ptr(),
114 );
115 (width.assume_init(), height.assume_init())
116 }
117 }
118
119 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
120 #[allow(deprecated)]
121 #[doc(alias = "gtk_cell_renderer_get_is_expanded")]
122 #[doc(alias = "get_is_expanded")]
123 #[doc(alias = "is-expanded")]
124 fn is_expanded(&self) -> bool {
125 unsafe {
126 from_glib(ffi::gtk_cell_renderer_get_is_expanded(
127 self.as_ref().to_glib_none().0,
128 ))
129 }
130 }
131
132 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
133 #[allow(deprecated)]
134 #[doc(alias = "gtk_cell_renderer_get_is_expander")]
135 #[doc(alias = "get_is_expander")]
136 #[doc(alias = "is-expander")]
137 fn is_expander(&self) -> bool {
138 unsafe {
139 from_glib(ffi::gtk_cell_renderer_get_is_expander(
140 self.as_ref().to_glib_none().0,
141 ))
142 }
143 }
144
145 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
146 #[allow(deprecated)]
147 #[doc(alias = "gtk_cell_renderer_get_padding")]
148 #[doc(alias = "get_padding")]
149 fn padding(&self) -> (i32, i32) {
150 unsafe {
151 let mut xpad = std::mem::MaybeUninit::uninit();
152 let mut ypad = std::mem::MaybeUninit::uninit();
153 ffi::gtk_cell_renderer_get_padding(
154 self.as_ref().to_glib_none().0,
155 xpad.as_mut_ptr(),
156 ypad.as_mut_ptr(),
157 );
158 (xpad.assume_init(), ypad.assume_init())
159 }
160 }
161
162 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
163 #[allow(deprecated)]
164 #[doc(alias = "gtk_cell_renderer_get_preferred_height")]
165 #[doc(alias = "get_preferred_height")]
166 fn preferred_height(&self, widget: &impl IsA<Widget>) -> (i32, i32) {
167 unsafe {
168 let mut minimum_size = std::mem::MaybeUninit::uninit();
169 let mut natural_size = std::mem::MaybeUninit::uninit();
170 ffi::gtk_cell_renderer_get_preferred_height(
171 self.as_ref().to_glib_none().0,
172 widget.as_ref().to_glib_none().0,
173 minimum_size.as_mut_ptr(),
174 natural_size.as_mut_ptr(),
175 );
176 (minimum_size.assume_init(), natural_size.assume_init())
177 }
178 }
179
180 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
181 #[allow(deprecated)]
182 #[doc(alias = "gtk_cell_renderer_get_preferred_height_for_width")]
183 #[doc(alias = "get_preferred_height_for_width")]
184 fn preferred_height_for_width(&self, widget: &impl IsA<Widget>, width: i32) -> (i32, i32) {
185 unsafe {
186 let mut minimum_height = std::mem::MaybeUninit::uninit();
187 let mut natural_height = std::mem::MaybeUninit::uninit();
188 ffi::gtk_cell_renderer_get_preferred_height_for_width(
189 self.as_ref().to_glib_none().0,
190 widget.as_ref().to_glib_none().0,
191 width,
192 minimum_height.as_mut_ptr(),
193 natural_height.as_mut_ptr(),
194 );
195 (minimum_height.assume_init(), natural_height.assume_init())
196 }
197 }
198
199 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
200 #[allow(deprecated)]
201 #[doc(alias = "gtk_cell_renderer_get_preferred_size")]
202 #[doc(alias = "get_preferred_size")]
203 fn preferred_size(&self, widget: &impl IsA<Widget>) -> (Requisition, Requisition) {
204 unsafe {
205 let mut minimum_size = Requisition::uninitialized();
206 let mut natural_size = Requisition::uninitialized();
207 ffi::gtk_cell_renderer_get_preferred_size(
208 self.as_ref().to_glib_none().0,
209 widget.as_ref().to_glib_none().0,
210 minimum_size.to_glib_none_mut().0,
211 natural_size.to_glib_none_mut().0,
212 );
213 (minimum_size, natural_size)
214 }
215 }
216
217 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
218 #[allow(deprecated)]
219 #[doc(alias = "gtk_cell_renderer_get_preferred_width")]
220 #[doc(alias = "get_preferred_width")]
221 fn preferred_width(&self, widget: &impl IsA<Widget>) -> (i32, i32) {
222 unsafe {
223 let mut minimum_size = std::mem::MaybeUninit::uninit();
224 let mut natural_size = std::mem::MaybeUninit::uninit();
225 ffi::gtk_cell_renderer_get_preferred_width(
226 self.as_ref().to_glib_none().0,
227 widget.as_ref().to_glib_none().0,
228 minimum_size.as_mut_ptr(),
229 natural_size.as_mut_ptr(),
230 );
231 (minimum_size.assume_init(), natural_size.assume_init())
232 }
233 }
234
235 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
236 #[allow(deprecated)]
237 #[doc(alias = "gtk_cell_renderer_get_preferred_width_for_height")]
238 #[doc(alias = "get_preferred_width_for_height")]
239 fn preferred_width_for_height(&self, widget: &impl IsA<Widget>, height: i32) -> (i32, i32) {
240 unsafe {
241 let mut minimum_width = std::mem::MaybeUninit::uninit();
242 let mut natural_width = std::mem::MaybeUninit::uninit();
243 ffi::gtk_cell_renderer_get_preferred_width_for_height(
244 self.as_ref().to_glib_none().0,
245 widget.as_ref().to_glib_none().0,
246 height,
247 minimum_width.as_mut_ptr(),
248 natural_width.as_mut_ptr(),
249 );
250 (minimum_width.assume_init(), natural_width.assume_init())
251 }
252 }
253
254 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
255 #[allow(deprecated)]
256 #[doc(alias = "gtk_cell_renderer_get_request_mode")]
257 #[doc(alias = "get_request_mode")]
258 fn request_mode(&self) -> SizeRequestMode {
259 unsafe {
260 from_glib(ffi::gtk_cell_renderer_get_request_mode(
261 self.as_ref().to_glib_none().0,
262 ))
263 }
264 }
265
266 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
267 #[allow(deprecated)]
268 #[doc(alias = "gtk_cell_renderer_get_sensitive")]
269 #[doc(alias = "get_sensitive")]
270 #[doc(alias = "sensitive")]
271 fn is_sensitive(&self) -> bool {
272 unsafe {
273 from_glib(ffi::gtk_cell_renderer_get_sensitive(
274 self.as_ref().to_glib_none().0,
275 ))
276 }
277 }
278
279 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
280 #[allow(deprecated)]
281 #[doc(alias = "gtk_cell_renderer_get_state")]
282 #[doc(alias = "get_state")]
283 fn state(
284 &self,
285 widget: Option<&impl IsA<Widget>>,
286 cell_state: CellRendererState,
287 ) -> StateFlags {
288 unsafe {
289 from_glib(ffi::gtk_cell_renderer_get_state(
290 self.as_ref().to_glib_none().0,
291 widget.map(|p| p.as_ref()).to_glib_none().0,
292 cell_state.into_glib(),
293 ))
294 }
295 }
296
297 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
298 #[allow(deprecated)]
299 #[doc(alias = "gtk_cell_renderer_get_visible")]
300 #[doc(alias = "get_visible")]
301 #[doc(alias = "visible")]
302 fn is_visible(&self) -> bool {
303 unsafe {
304 from_glib(ffi::gtk_cell_renderer_get_visible(
305 self.as_ref().to_glib_none().0,
306 ))
307 }
308 }
309
310 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
311 #[allow(deprecated)]
312 #[doc(alias = "gtk_cell_renderer_is_activatable")]
313 fn is_activatable(&self) -> bool {
314 unsafe {
315 from_glib(ffi::gtk_cell_renderer_is_activatable(
316 self.as_ref().to_glib_none().0,
317 ))
318 }
319 }
320
321 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
322 #[allow(deprecated)]
323 #[doc(alias = "gtk_cell_renderer_set_alignment")]
324 fn set_alignment(&self, xalign: f32, yalign: f32) {
325 unsafe {
326 ffi::gtk_cell_renderer_set_alignment(self.as_ref().to_glib_none().0, xalign, yalign);
327 }
328 }
329
330 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
331 #[allow(deprecated)]
332 #[doc(alias = "gtk_cell_renderer_set_fixed_size")]
333 fn set_fixed_size(&self, width: i32, height: i32) {
334 unsafe {
335 ffi::gtk_cell_renderer_set_fixed_size(self.as_ref().to_glib_none().0, width, height);
336 }
337 }
338
339 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
340 #[allow(deprecated)]
341 #[doc(alias = "gtk_cell_renderer_set_is_expanded")]
342 #[doc(alias = "is-expanded")]
343 fn set_is_expanded(&self, is_expanded: bool) {
344 unsafe {
345 ffi::gtk_cell_renderer_set_is_expanded(
346 self.as_ref().to_glib_none().0,
347 is_expanded.into_glib(),
348 );
349 }
350 }
351
352 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
353 #[allow(deprecated)]
354 #[doc(alias = "gtk_cell_renderer_set_is_expander")]
355 #[doc(alias = "is-expander")]
356 fn set_is_expander(&self, is_expander: bool) {
357 unsafe {
358 ffi::gtk_cell_renderer_set_is_expander(
359 self.as_ref().to_glib_none().0,
360 is_expander.into_glib(),
361 );
362 }
363 }
364
365 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
366 #[allow(deprecated)]
367 #[doc(alias = "gtk_cell_renderer_set_padding")]
368 fn set_padding(&self, xpad: i32, ypad: i32) {
369 unsafe {
370 ffi::gtk_cell_renderer_set_padding(self.as_ref().to_glib_none().0, xpad, ypad);
371 }
372 }
373
374 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
375 #[allow(deprecated)]
376 #[doc(alias = "gtk_cell_renderer_set_sensitive")]
377 #[doc(alias = "sensitive")]
378 fn set_sensitive(&self, sensitive: bool) {
379 unsafe {
380 ffi::gtk_cell_renderer_set_sensitive(
381 self.as_ref().to_glib_none().0,
382 sensitive.into_glib(),
383 );
384 }
385 }
386
387 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
388 #[allow(deprecated)]
389 #[doc(alias = "gtk_cell_renderer_set_visible")]
390 #[doc(alias = "visible")]
391 fn set_visible(&self, visible: bool) {
392 unsafe {
393 ffi::gtk_cell_renderer_set_visible(self.as_ref().to_glib_none().0, visible.into_glib());
394 }
395 }
396
397 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
398 #[allow(deprecated)]
399 #[doc(alias = "gtk_cell_renderer_snapshot")]
400 fn snapshot(
401 &self,
402 snapshot: &impl IsA<Snapshot>,
403 widget: &impl IsA<Widget>,
404 background_area: &gdk::Rectangle,
405 cell_area: &gdk::Rectangle,
406 flags: CellRendererState,
407 ) {
408 unsafe {
409 ffi::gtk_cell_renderer_snapshot(
410 self.as_ref().to_glib_none().0,
411 snapshot.as_ref().to_glib_none().0,
412 widget.as_ref().to_glib_none().0,
413 background_area.to_glib_none().0,
414 cell_area.to_glib_none().0,
415 flags.into_glib(),
416 );
417 }
418 }
419
420 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
421 #[allow(deprecated)]
422 #[doc(alias = "gtk_cell_renderer_start_editing")]
423 fn start_editing(
424 &self,
425 event: Option<impl AsRef<gdk::Event>>,
426 widget: &impl IsA<Widget>,
427 path: &str,
428 background_area: &gdk::Rectangle,
429 cell_area: &gdk::Rectangle,
430 flags: CellRendererState,
431 ) -> Option<CellEditable> {
432 unsafe {
433 from_glib_none(ffi::gtk_cell_renderer_start_editing(
434 self.as_ref().to_glib_none().0,
435 event.as_ref().map(|p| p.as_ref()).to_glib_none().0,
436 widget.as_ref().to_glib_none().0,
437 path.to_glib_none().0,
438 background_area.to_glib_none().0,
439 cell_area.to_glib_none().0,
440 flags.into_glib(),
441 ))
442 }
443 }
444
445 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
446 #[allow(deprecated)]
447 #[doc(alias = "gtk_cell_renderer_stop_editing")]
448 fn stop_editing(&self, canceled: bool) {
449 unsafe {
450 ffi::gtk_cell_renderer_stop_editing(
451 self.as_ref().to_glib_none().0,
452 canceled.into_glib(),
453 );
454 }
455 }
456
457 #[doc(alias = "cell-background")]
458 fn set_cell_background(&self, cell_background: Option<&str>) {
459 ObjectExt::set_property(self.as_ref(), "cell-background", cell_background)
460 }
461
462 #[doc(alias = "cell-background-rgba")]
463 fn cell_background_rgba(&self) -> Option<gdk::RGBA> {
464 ObjectExt::property(self.as_ref(), "cell-background-rgba")
465 }
466
467 #[doc(alias = "cell-background-rgba")]
468 fn set_cell_background_rgba(&self, cell_background_rgba: Option<&gdk::RGBA>) {
469 ObjectExt::set_property(self.as_ref(), "cell-background-rgba", cell_background_rgba)
470 }
471
472 #[doc(alias = "cell-background-set")]
473 fn is_cell_background_set(&self) -> bool {
474 ObjectExt::property(self.as_ref(), "cell-background-set")
475 }
476
477 fn is_editing(&self) -> bool {
478 ObjectExt::property(self.as_ref(), "editing")
479 }
480
481 fn height(&self) -> i32 {
482 ObjectExt::property(self.as_ref(), "height")
483 }
484
485 fn set_height(&self, height: i32) {
486 ObjectExt::set_property(self.as_ref(), "height", height)
487 }
488
489 fn mode(&self) -> CellRendererMode {
490 ObjectExt::property(self.as_ref(), "mode")
491 }
492
493 fn set_mode(&self, mode: CellRendererMode) {
494 ObjectExt::set_property(self.as_ref(), "mode", mode)
495 }
496
497 fn width(&self) -> i32 {
498 ObjectExt::property(self.as_ref(), "width")
499 }
500
501 fn set_width(&self, width: i32) {
502 ObjectExt::set_property(self.as_ref(), "width", width)
503 }
504
505 fn xalign(&self) -> f32 {
506 ObjectExt::property(self.as_ref(), "xalign")
507 }
508
509 fn set_xalign(&self, xalign: f32) {
510 ObjectExt::set_property(self.as_ref(), "xalign", xalign)
511 }
512
513 fn xpad(&self) -> u32 {
514 ObjectExt::property(self.as_ref(), "xpad")
515 }
516
517 fn set_xpad(&self, xpad: u32) {
518 ObjectExt::set_property(self.as_ref(), "xpad", xpad)
519 }
520
521 fn yalign(&self) -> f32 {
522 ObjectExt::property(self.as_ref(), "yalign")
523 }
524
525 fn set_yalign(&self, yalign: f32) {
526 ObjectExt::set_property(self.as_ref(), "yalign", yalign)
527 }
528
529 fn ypad(&self) -> u32 {
530 ObjectExt::property(self.as_ref(), "ypad")
531 }
532
533 fn set_ypad(&self, ypad: u32) {
534 ObjectExt::set_property(self.as_ref(), "ypad", ypad)
535 }
536
537 #[doc(alias = "editing-canceled")]
538 fn connect_editing_canceled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
539 unsafe extern "C" fn editing_canceled_trampoline<
540 P: IsA<CellRenderer>,
541 F: Fn(&P) + 'static,
542 >(
543 this: *mut ffi::GtkCellRenderer,
544 f: glib::ffi::gpointer,
545 ) {
546 let f: &F = &*(f as *const F);
547 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
548 }
549 unsafe {
550 let f: Box_<F> = Box_::new(f);
551 connect_raw(
552 self.as_ptr() as *mut _,
553 b"editing-canceled\0".as_ptr() as *const _,
554 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
555 editing_canceled_trampoline::<Self, F> as *const (),
556 )),
557 Box_::into_raw(f),
558 )
559 }
560 }
561
562 #[doc(alias = "editing-started")]
563 fn connect_editing_started<F: Fn(&Self, &CellEditable, TreePath) + 'static>(
564 &self,
565 f: F,
566 ) -> SignalHandlerId {
567 unsafe extern "C" fn editing_started_trampoline<
568 P: IsA<CellRenderer>,
569 F: Fn(&P, &CellEditable, TreePath) + 'static,
570 >(
571 this: *mut ffi::GtkCellRenderer,
572 editable: *mut ffi::GtkCellEditable,
573 path: *mut std::ffi::c_char,
574 f: glib::ffi::gpointer,
575 ) {
576 let f: &F = &*(f as *const F);
577 let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path));
578 f(
579 CellRenderer::from_glib_borrow(this).unsafe_cast_ref(),
580 &from_glib_borrow(editable),
581 path,
582 )
583 }
584 unsafe {
585 let f: Box_<F> = Box_::new(f);
586 connect_raw(
587 self.as_ptr() as *mut _,
588 b"editing-started\0".as_ptr() as *const _,
589 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
590 editing_started_trampoline::<Self, F> as *const (),
591 )),
592 Box_::into_raw(f),
593 )
594 }
595 }
596
597 #[doc(alias = "cell-background")]
598 fn connect_cell_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
599 unsafe extern "C" fn notify_cell_background_trampoline<
600 P: IsA<CellRenderer>,
601 F: Fn(&P) + 'static,
602 >(
603 this: *mut ffi::GtkCellRenderer,
604 _param_spec: glib::ffi::gpointer,
605 f: glib::ffi::gpointer,
606 ) {
607 let f: &F = &*(f as *const F);
608 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
609 }
610 unsafe {
611 let f: Box_<F> = Box_::new(f);
612 connect_raw(
613 self.as_ptr() as *mut _,
614 b"notify::cell-background\0".as_ptr() as *const _,
615 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
616 notify_cell_background_trampoline::<Self, F> as *const (),
617 )),
618 Box_::into_raw(f),
619 )
620 }
621 }
622
623 #[doc(alias = "cell-background-rgba")]
624 fn connect_cell_background_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
625 unsafe extern "C" fn notify_cell_background_rgba_trampoline<
626 P: IsA<CellRenderer>,
627 F: Fn(&P) + 'static,
628 >(
629 this: *mut ffi::GtkCellRenderer,
630 _param_spec: glib::ffi::gpointer,
631 f: glib::ffi::gpointer,
632 ) {
633 let f: &F = &*(f as *const F);
634 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
635 }
636 unsafe {
637 let f: Box_<F> = Box_::new(f);
638 connect_raw(
639 self.as_ptr() as *mut _,
640 b"notify::cell-background-rgba\0".as_ptr() as *const _,
641 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
642 notify_cell_background_rgba_trampoline::<Self, F> as *const (),
643 )),
644 Box_::into_raw(f),
645 )
646 }
647 }
648
649 #[doc(alias = "cell-background-set")]
650 fn connect_cell_background_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
651 unsafe extern "C" fn notify_cell_background_set_trampoline<
652 P: IsA<CellRenderer>,
653 F: Fn(&P) + 'static,
654 >(
655 this: *mut ffi::GtkCellRenderer,
656 _param_spec: glib::ffi::gpointer,
657 f: glib::ffi::gpointer,
658 ) {
659 let f: &F = &*(f as *const F);
660 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
661 }
662 unsafe {
663 let f: Box_<F> = Box_::new(f);
664 connect_raw(
665 self.as_ptr() as *mut _,
666 b"notify::cell-background-set\0".as_ptr() as *const _,
667 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
668 notify_cell_background_set_trampoline::<Self, F> as *const (),
669 )),
670 Box_::into_raw(f),
671 )
672 }
673 }
674
675 #[doc(alias = "editing")]
676 fn connect_editing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
677 unsafe extern "C" fn notify_editing_trampoline<
678 P: IsA<CellRenderer>,
679 F: Fn(&P) + 'static,
680 >(
681 this: *mut ffi::GtkCellRenderer,
682 _param_spec: glib::ffi::gpointer,
683 f: glib::ffi::gpointer,
684 ) {
685 let f: &F = &*(f as *const F);
686 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
687 }
688 unsafe {
689 let f: Box_<F> = Box_::new(f);
690 connect_raw(
691 self.as_ptr() as *mut _,
692 b"notify::editing\0".as_ptr() as *const _,
693 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
694 notify_editing_trampoline::<Self, F> as *const (),
695 )),
696 Box_::into_raw(f),
697 )
698 }
699 }
700
701 #[doc(alias = "height")]
702 fn connect_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
703 unsafe extern "C" fn notify_height_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
704 this: *mut ffi::GtkCellRenderer,
705 _param_spec: glib::ffi::gpointer,
706 f: glib::ffi::gpointer,
707 ) {
708 let f: &F = &*(f as *const F);
709 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
710 }
711 unsafe {
712 let f: Box_<F> = Box_::new(f);
713 connect_raw(
714 self.as_ptr() as *mut _,
715 b"notify::height\0".as_ptr() as *const _,
716 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
717 notify_height_trampoline::<Self, F> as *const (),
718 )),
719 Box_::into_raw(f),
720 )
721 }
722 }
723
724 #[doc(alias = "is-expanded")]
725 fn connect_is_expanded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
726 unsafe extern "C" fn notify_is_expanded_trampoline<
727 P: IsA<CellRenderer>,
728 F: Fn(&P) + 'static,
729 >(
730 this: *mut ffi::GtkCellRenderer,
731 _param_spec: glib::ffi::gpointer,
732 f: glib::ffi::gpointer,
733 ) {
734 let f: &F = &*(f as *const F);
735 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
736 }
737 unsafe {
738 let f: Box_<F> = Box_::new(f);
739 connect_raw(
740 self.as_ptr() as *mut _,
741 b"notify::is-expanded\0".as_ptr() as *const _,
742 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
743 notify_is_expanded_trampoline::<Self, F> as *const (),
744 )),
745 Box_::into_raw(f),
746 )
747 }
748 }
749
750 #[doc(alias = "is-expander")]
751 fn connect_is_expander_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
752 unsafe extern "C" fn notify_is_expander_trampoline<
753 P: IsA<CellRenderer>,
754 F: Fn(&P) + 'static,
755 >(
756 this: *mut ffi::GtkCellRenderer,
757 _param_spec: glib::ffi::gpointer,
758 f: glib::ffi::gpointer,
759 ) {
760 let f: &F = &*(f as *const F);
761 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
762 }
763 unsafe {
764 let f: Box_<F> = Box_::new(f);
765 connect_raw(
766 self.as_ptr() as *mut _,
767 b"notify::is-expander\0".as_ptr() as *const _,
768 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
769 notify_is_expander_trampoline::<Self, F> as *const (),
770 )),
771 Box_::into_raw(f),
772 )
773 }
774 }
775
776 #[doc(alias = "mode")]
777 fn connect_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
778 unsafe extern "C" fn notify_mode_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
779 this: *mut ffi::GtkCellRenderer,
780 _param_spec: glib::ffi::gpointer,
781 f: glib::ffi::gpointer,
782 ) {
783 let f: &F = &*(f as *const F);
784 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
785 }
786 unsafe {
787 let f: Box_<F> = Box_::new(f);
788 connect_raw(
789 self.as_ptr() as *mut _,
790 b"notify::mode\0".as_ptr() as *const _,
791 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
792 notify_mode_trampoline::<Self, F> as *const (),
793 )),
794 Box_::into_raw(f),
795 )
796 }
797 }
798
799 #[doc(alias = "sensitive")]
800 fn connect_sensitive_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
801 unsafe extern "C" fn notify_sensitive_trampoline<
802 P: IsA<CellRenderer>,
803 F: Fn(&P) + 'static,
804 >(
805 this: *mut ffi::GtkCellRenderer,
806 _param_spec: glib::ffi::gpointer,
807 f: glib::ffi::gpointer,
808 ) {
809 let f: &F = &*(f as *const F);
810 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
811 }
812 unsafe {
813 let f: Box_<F> = Box_::new(f);
814 connect_raw(
815 self.as_ptr() as *mut _,
816 b"notify::sensitive\0".as_ptr() as *const _,
817 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
818 notify_sensitive_trampoline::<Self, F> as *const (),
819 )),
820 Box_::into_raw(f),
821 )
822 }
823 }
824
825 #[doc(alias = "visible")]
826 fn connect_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
827 unsafe extern "C" fn notify_visible_trampoline<
828 P: IsA<CellRenderer>,
829 F: Fn(&P) + 'static,
830 >(
831 this: *mut ffi::GtkCellRenderer,
832 _param_spec: glib::ffi::gpointer,
833 f: glib::ffi::gpointer,
834 ) {
835 let f: &F = &*(f as *const F);
836 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
837 }
838 unsafe {
839 let f: Box_<F> = Box_::new(f);
840 connect_raw(
841 self.as_ptr() as *mut _,
842 b"notify::visible\0".as_ptr() as *const _,
843 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
844 notify_visible_trampoline::<Self, F> as *const (),
845 )),
846 Box_::into_raw(f),
847 )
848 }
849 }
850
851 #[doc(alias = "width")]
852 fn connect_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
853 unsafe extern "C" fn notify_width_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
854 this: *mut ffi::GtkCellRenderer,
855 _param_spec: glib::ffi::gpointer,
856 f: glib::ffi::gpointer,
857 ) {
858 let f: &F = &*(f as *const F);
859 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
860 }
861 unsafe {
862 let f: Box_<F> = Box_::new(f);
863 connect_raw(
864 self.as_ptr() as *mut _,
865 b"notify::width\0".as_ptr() as *const _,
866 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
867 notify_width_trampoline::<Self, F> as *const (),
868 )),
869 Box_::into_raw(f),
870 )
871 }
872 }
873
874 #[doc(alias = "xalign")]
875 fn connect_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
876 unsafe extern "C" fn notify_xalign_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
877 this: *mut ffi::GtkCellRenderer,
878 _param_spec: glib::ffi::gpointer,
879 f: glib::ffi::gpointer,
880 ) {
881 let f: &F = &*(f as *const F);
882 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
883 }
884 unsafe {
885 let f: Box_<F> = Box_::new(f);
886 connect_raw(
887 self.as_ptr() as *mut _,
888 b"notify::xalign\0".as_ptr() as *const _,
889 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
890 notify_xalign_trampoline::<Self, F> as *const (),
891 )),
892 Box_::into_raw(f),
893 )
894 }
895 }
896
897 #[doc(alias = "xpad")]
898 fn connect_xpad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
899 unsafe extern "C" fn notify_xpad_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
900 this: *mut ffi::GtkCellRenderer,
901 _param_spec: glib::ffi::gpointer,
902 f: glib::ffi::gpointer,
903 ) {
904 let f: &F = &*(f as *const F);
905 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
906 }
907 unsafe {
908 let f: Box_<F> = Box_::new(f);
909 connect_raw(
910 self.as_ptr() as *mut _,
911 b"notify::xpad\0".as_ptr() as *const _,
912 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
913 notify_xpad_trampoline::<Self, F> as *const (),
914 )),
915 Box_::into_raw(f),
916 )
917 }
918 }
919
920 #[doc(alias = "yalign")]
921 fn connect_yalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
922 unsafe extern "C" fn notify_yalign_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
923 this: *mut ffi::GtkCellRenderer,
924 _param_spec: glib::ffi::gpointer,
925 f: glib::ffi::gpointer,
926 ) {
927 let f: &F = &*(f as *const F);
928 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
929 }
930 unsafe {
931 let f: Box_<F> = Box_::new(f);
932 connect_raw(
933 self.as_ptr() as *mut _,
934 b"notify::yalign\0".as_ptr() as *const _,
935 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
936 notify_yalign_trampoline::<Self, F> as *const (),
937 )),
938 Box_::into_raw(f),
939 )
940 }
941 }
942
943 #[doc(alias = "ypad")]
944 fn connect_ypad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
945 unsafe extern "C" fn notify_ypad_trampoline<P: IsA<CellRenderer>, F: Fn(&P) + 'static>(
946 this: *mut ffi::GtkCellRenderer,
947 _param_spec: glib::ffi::gpointer,
948 f: glib::ffi::gpointer,
949 ) {
950 let f: &F = &*(f as *const F);
951 f(CellRenderer::from_glib_borrow(this).unsafe_cast_ref())
952 }
953 unsafe {
954 let f: Box_<F> = Box_::new(f);
955 connect_raw(
956 self.as_ptr() as *mut _,
957 b"notify::ypad\0".as_ptr() as *const _,
958 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
959 notify_ypad_trampoline::<Self, F> as *const (),
960 )),
961 Box_::into_raw(f),
962 )
963 }
964 }
965}
966
967impl<O: IsA<CellRenderer>> CellRendererExt for O {}