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