gtk/auto/
cell_renderer.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use cairo;
6use gdk;
7use glib::object::Cast;
8use glib::object::IsA;
9use glib::signal::connect_raw;
10use glib::signal::SignalHandlerId;
11use glib::translate::*;
12use glib::StaticType;
13use glib::Value;
14use glib_sys;
15use gobject_sys;
16use gtk_sys;
17use libc;
18use std::boxed::Box as Box_;
19use std::fmt;
20use std::mem;
21use std::mem::transmute;
22use CellEditable;
23use CellRendererMode;
24use CellRendererState;
25use Requisition;
26use SizeRequestMode;
27use StateFlags;
28use TreePath;
29use Widget;
30
31glib_wrapper! {
32    pub struct CellRenderer(Object<gtk_sys::GtkCellRenderer, gtk_sys::GtkCellRendererClass, CellRendererClass>);
33
34    match fn {
35        get_type => || gtk_sys::gtk_cell_renderer_get_type(),
36    }
37}
38
39pub const NONE_CELL_RENDERER: Option<&CellRenderer> = None;
40
41pub trait CellRendererExt: 'static {
42    fn activate<P: IsA<Widget>>(
43        &self,
44        event: &gdk::Event,
45        widget: &P,
46        path: &str,
47        background_area: &gdk::Rectangle,
48        cell_area: &gdk::Rectangle,
49        flags: CellRendererState,
50    ) -> bool;
51
52    fn get_aligned_area<P: IsA<Widget>>(
53        &self,
54        widget: &P,
55        flags: CellRendererState,
56        cell_area: &gdk::Rectangle,
57    ) -> gdk::Rectangle;
58
59    fn get_alignment(&self) -> (f32, f32);
60
61    fn get_fixed_size(&self) -> (i32, i32);
62
63    fn get_padding(&self) -> (i32, i32);
64
65    fn get_preferred_height<P: IsA<Widget>>(&self, widget: &P) -> (i32, i32);
66
67    fn get_preferred_height_for_width<P: IsA<Widget>>(&self, widget: &P, width: i32) -> (i32, i32);
68
69    fn get_preferred_size<P: IsA<Widget>>(&self, widget: &P) -> (Requisition, Requisition);
70
71    fn get_preferred_width<P: IsA<Widget>>(&self, widget: &P) -> (i32, i32);
72
73    fn get_preferred_width_for_height<P: IsA<Widget>>(&self, widget: &P, height: i32)
74        -> (i32, i32);
75
76    fn get_request_mode(&self) -> SizeRequestMode;
77
78    fn get_sensitive(&self) -> bool;
79
80    fn get_state<P: IsA<Widget>>(
81        &self,
82        widget: Option<&P>,
83        cell_state: CellRendererState,
84    ) -> StateFlags;
85
86    fn get_visible(&self) -> bool;
87
88    fn is_activatable(&self) -> bool;
89
90    fn render<P: IsA<Widget>>(
91        &self,
92        cr: &cairo::Context,
93        widget: &P,
94        background_area: &gdk::Rectangle,
95        cell_area: &gdk::Rectangle,
96        flags: CellRendererState,
97    );
98
99    fn set_alignment(&self, xalign: f32, yalign: f32);
100
101    fn set_fixed_size(&self, width: i32, height: i32);
102
103    fn set_padding(&self, xpad: i32, ypad: i32);
104
105    fn set_sensitive(&self, sensitive: bool);
106
107    fn set_visible(&self, visible: bool);
108
109    fn start_editing<P: IsA<Widget>>(
110        &self,
111        event: Option<&gdk::Event>,
112        widget: &P,
113        path: &str,
114        background_area: &gdk::Rectangle,
115        cell_area: &gdk::Rectangle,
116        flags: CellRendererState,
117    ) -> Option<CellEditable>;
118
119    fn stop_editing(&self, canceled: bool);
120
121    fn set_property_cell_background(&self, cell_background: Option<&str>);
122
123    fn get_property_cell_background_rgba(&self) -> Option<gdk::RGBA>;
124
125    fn set_property_cell_background_rgba(&self, cell_background_rgba: Option<&gdk::RGBA>);
126
127    fn get_property_cell_background_set(&self) -> bool;
128
129    fn set_property_cell_background_set(&self, cell_background_set: bool);
130
131    fn get_property_editing(&self) -> bool;
132
133    fn get_property_height(&self) -> i32;
134
135    fn set_property_height(&self, height: i32);
136
137    fn get_property_is_expanded(&self) -> bool;
138
139    fn set_property_is_expanded(&self, is_expanded: bool);
140
141    fn get_property_is_expander(&self) -> bool;
142
143    fn set_property_is_expander(&self, is_expander: bool);
144
145    fn get_property_mode(&self) -> CellRendererMode;
146
147    fn set_property_mode(&self, mode: CellRendererMode);
148
149    fn get_property_width(&self) -> i32;
150
151    fn set_property_width(&self, width: i32);
152
153    fn get_property_xalign(&self) -> f32;
154
155    fn set_property_xalign(&self, xalign: f32);
156
157    fn get_property_xpad(&self) -> u32;
158
159    fn set_property_xpad(&self, xpad: u32);
160
161    fn get_property_yalign(&self) -> f32;
162
163    fn set_property_yalign(&self, yalign: f32);
164
165    fn get_property_ypad(&self) -> u32;
166
167    fn set_property_ypad(&self, ypad: u32);
168
169    fn connect_editing_canceled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
170
171    fn connect_editing_started<F: Fn(&Self, &CellEditable, TreePath) + 'static>(
172        &self,
173        f: F,
174    ) -> SignalHandlerId;
175
176    fn connect_property_cell_background_notify<F: Fn(&Self) + 'static>(
177        &self,
178        f: F,
179    ) -> SignalHandlerId;
180
181    fn connect_property_cell_background_rgba_notify<F: Fn(&Self) + 'static>(
182        &self,
183        f: F,
184    ) -> SignalHandlerId;
185
186    fn connect_property_cell_background_set_notify<F: Fn(&Self) + 'static>(
187        &self,
188        f: F,
189    ) -> SignalHandlerId;
190
191    fn connect_property_editing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
192
193    fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
194
195    fn connect_property_is_expanded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
196
197    fn connect_property_is_expander_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
198
199    fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
200
201    fn connect_property_sensitive_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
202
203    fn connect_property_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
204
205    fn connect_property_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
206
207    fn connect_property_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
208
209    fn connect_property_xpad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
210
211    fn connect_property_yalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
212
213    fn connect_property_ypad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
214}
215
216impl<O: IsA<CellRenderer>> CellRendererExt for O {
217    fn activate<P: IsA<Widget>>(
218        &self,
219        event: &gdk::Event,
220        widget: &P,
221        path: &str,
222        background_area: &gdk::Rectangle,
223        cell_area: &gdk::Rectangle,
224        flags: CellRendererState,
225    ) -> bool {
226        unsafe {
227            from_glib(gtk_sys::gtk_cell_renderer_activate(
228                self.as_ref().to_glib_none().0,
229                mut_override(event.to_glib_none().0),
230                widget.as_ref().to_glib_none().0,
231                path.to_glib_none().0,
232                background_area.to_glib_none().0,
233                cell_area.to_glib_none().0,
234                flags.to_glib(),
235            ))
236        }
237    }
238
239    fn get_aligned_area<P: IsA<Widget>>(
240        &self,
241        widget: &P,
242        flags: CellRendererState,
243        cell_area: &gdk::Rectangle,
244    ) -> gdk::Rectangle {
245        unsafe {
246            let mut aligned_area = gdk::Rectangle::uninitialized();
247            gtk_sys::gtk_cell_renderer_get_aligned_area(
248                self.as_ref().to_glib_none().0,
249                widget.as_ref().to_glib_none().0,
250                flags.to_glib(),
251                cell_area.to_glib_none().0,
252                aligned_area.to_glib_none_mut().0,
253            );
254            aligned_area
255        }
256    }
257
258    fn get_alignment(&self) -> (f32, f32) {
259        unsafe {
260            let mut xalign = mem::uninitialized();
261            let mut yalign = mem::uninitialized();
262            gtk_sys::gtk_cell_renderer_get_alignment(
263                self.as_ref().to_glib_none().0,
264                &mut xalign,
265                &mut yalign,
266            );
267            (xalign, yalign)
268        }
269    }
270
271    fn get_fixed_size(&self) -> (i32, i32) {
272        unsafe {
273            let mut width = mem::uninitialized();
274            let mut height = mem::uninitialized();
275            gtk_sys::gtk_cell_renderer_get_fixed_size(
276                self.as_ref().to_glib_none().0,
277                &mut width,
278                &mut height,
279            );
280            (width, height)
281        }
282    }
283
284    fn get_padding(&self) -> (i32, i32) {
285        unsafe {
286            let mut xpad = mem::uninitialized();
287            let mut ypad = mem::uninitialized();
288            gtk_sys::gtk_cell_renderer_get_padding(
289                self.as_ref().to_glib_none().0,
290                &mut xpad,
291                &mut ypad,
292            );
293            (xpad, ypad)
294        }
295    }
296
297    fn get_preferred_height<P: IsA<Widget>>(&self, widget: &P) -> (i32, i32) {
298        unsafe {
299            let mut minimum_size = mem::uninitialized();
300            let mut natural_size = mem::uninitialized();
301            gtk_sys::gtk_cell_renderer_get_preferred_height(
302                self.as_ref().to_glib_none().0,
303                widget.as_ref().to_glib_none().0,
304                &mut minimum_size,
305                &mut natural_size,
306            );
307            (minimum_size, natural_size)
308        }
309    }
310
311    fn get_preferred_height_for_width<P: IsA<Widget>>(&self, widget: &P, width: i32) -> (i32, i32) {
312        unsafe {
313            let mut minimum_height = mem::uninitialized();
314            let mut natural_height = mem::uninitialized();
315            gtk_sys::gtk_cell_renderer_get_preferred_height_for_width(
316                self.as_ref().to_glib_none().0,
317                widget.as_ref().to_glib_none().0,
318                width,
319                &mut minimum_height,
320                &mut natural_height,
321            );
322            (minimum_height, natural_height)
323        }
324    }
325
326    fn get_preferred_size<P: IsA<Widget>>(&self, widget: &P) -> (Requisition, Requisition) {
327        unsafe {
328            let mut minimum_size = Requisition::uninitialized();
329            let mut natural_size = Requisition::uninitialized();
330            gtk_sys::gtk_cell_renderer_get_preferred_size(
331                self.as_ref().to_glib_none().0,
332                widget.as_ref().to_glib_none().0,
333                minimum_size.to_glib_none_mut().0,
334                natural_size.to_glib_none_mut().0,
335            );
336            (minimum_size, natural_size)
337        }
338    }
339
340    fn get_preferred_width<P: IsA<Widget>>(&self, widget: &P) -> (i32, i32) {
341        unsafe {
342            let mut minimum_size = mem::uninitialized();
343            let mut natural_size = mem::uninitialized();
344            gtk_sys::gtk_cell_renderer_get_preferred_width(
345                self.as_ref().to_glib_none().0,
346                widget.as_ref().to_glib_none().0,
347                &mut minimum_size,
348                &mut natural_size,
349            );
350            (minimum_size, natural_size)
351        }
352    }
353
354    fn get_preferred_width_for_height<P: IsA<Widget>>(
355        &self,
356        widget: &P,
357        height: i32,
358    ) -> (i32, i32) {
359        unsafe {
360            let mut minimum_width = mem::uninitialized();
361            let mut natural_width = mem::uninitialized();
362            gtk_sys::gtk_cell_renderer_get_preferred_width_for_height(
363                self.as_ref().to_glib_none().0,
364                widget.as_ref().to_glib_none().0,
365                height,
366                &mut minimum_width,
367                &mut natural_width,
368            );
369            (minimum_width, natural_width)
370        }
371    }
372
373    fn get_request_mode(&self) -> SizeRequestMode {
374        unsafe {
375            from_glib(gtk_sys::gtk_cell_renderer_get_request_mode(
376                self.as_ref().to_glib_none().0,
377            ))
378        }
379    }
380
381    fn get_sensitive(&self) -> bool {
382        unsafe {
383            from_glib(gtk_sys::gtk_cell_renderer_get_sensitive(
384                self.as_ref().to_glib_none().0,
385            ))
386        }
387    }
388
389    fn get_state<P: IsA<Widget>>(
390        &self,
391        widget: Option<&P>,
392        cell_state: CellRendererState,
393    ) -> StateFlags {
394        unsafe {
395            from_glib(gtk_sys::gtk_cell_renderer_get_state(
396                self.as_ref().to_glib_none().0,
397                widget.map(|p| p.as_ref()).to_glib_none().0,
398                cell_state.to_glib(),
399            ))
400        }
401    }
402
403    fn get_visible(&self) -> bool {
404        unsafe {
405            from_glib(gtk_sys::gtk_cell_renderer_get_visible(
406                self.as_ref().to_glib_none().0,
407            ))
408        }
409    }
410
411    fn is_activatable(&self) -> bool {
412        unsafe {
413            from_glib(gtk_sys::gtk_cell_renderer_is_activatable(
414                self.as_ref().to_glib_none().0,
415            ))
416        }
417    }
418
419    fn render<P: IsA<Widget>>(
420        &self,
421        cr: &cairo::Context,
422        widget: &P,
423        background_area: &gdk::Rectangle,
424        cell_area: &gdk::Rectangle,
425        flags: CellRendererState,
426    ) {
427        unsafe {
428            gtk_sys::gtk_cell_renderer_render(
429                self.as_ref().to_glib_none().0,
430                mut_override(cr.to_glib_none().0),
431                widget.as_ref().to_glib_none().0,
432                background_area.to_glib_none().0,
433                cell_area.to_glib_none().0,
434                flags.to_glib(),
435            );
436        }
437    }
438
439    fn set_alignment(&self, xalign: f32, yalign: f32) {
440        unsafe {
441            gtk_sys::gtk_cell_renderer_set_alignment(
442                self.as_ref().to_glib_none().0,
443                xalign,
444                yalign,
445            );
446        }
447    }
448
449    fn set_fixed_size(&self, width: i32, height: i32) {
450        unsafe {
451            gtk_sys::gtk_cell_renderer_set_fixed_size(
452                self.as_ref().to_glib_none().0,
453                width,
454                height,
455            );
456        }
457    }
458
459    fn set_padding(&self, xpad: i32, ypad: i32) {
460        unsafe {
461            gtk_sys::gtk_cell_renderer_set_padding(self.as_ref().to_glib_none().0, xpad, ypad);
462        }
463    }
464
465    fn set_sensitive(&self, sensitive: bool) {
466        unsafe {
467            gtk_sys::gtk_cell_renderer_set_sensitive(
468                self.as_ref().to_glib_none().0,
469                sensitive.to_glib(),
470            );
471        }
472    }
473
474    fn set_visible(&self, visible: bool) {
475        unsafe {
476            gtk_sys::gtk_cell_renderer_set_visible(
477                self.as_ref().to_glib_none().0,
478                visible.to_glib(),
479            );
480        }
481    }
482
483    fn start_editing<P: IsA<Widget>>(
484        &self,
485        event: Option<&gdk::Event>,
486        widget: &P,
487        path: &str,
488        background_area: &gdk::Rectangle,
489        cell_area: &gdk::Rectangle,
490        flags: CellRendererState,
491    ) -> Option<CellEditable> {
492        unsafe {
493            from_glib_none(gtk_sys::gtk_cell_renderer_start_editing(
494                self.as_ref().to_glib_none().0,
495                mut_override(event.to_glib_none().0),
496                widget.as_ref().to_glib_none().0,
497                path.to_glib_none().0,
498                background_area.to_glib_none().0,
499                cell_area.to_glib_none().0,
500                flags.to_glib(),
501            ))
502        }
503    }
504
505    fn stop_editing(&self, canceled: bool) {
506        unsafe {
507            gtk_sys::gtk_cell_renderer_stop_editing(
508                self.as_ref().to_glib_none().0,
509                canceled.to_glib(),
510            );
511        }
512    }
513
514    fn set_property_cell_background(&self, cell_background: Option<&str>) {
515        unsafe {
516            gobject_sys::g_object_set_property(
517                self.to_glib_none().0 as *mut gobject_sys::GObject,
518                b"cell-background\0".as_ptr() as *const _,
519                Value::from(cell_background).to_glib_none().0,
520            );
521        }
522    }
523
524    fn get_property_cell_background_rgba(&self) -> Option<gdk::RGBA> {
525        unsafe {
526            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
527            gobject_sys::g_object_get_property(
528                self.to_glib_none().0 as *mut gobject_sys::GObject,
529                b"cell-background-rgba\0".as_ptr() as *const _,
530                value.to_glib_none_mut().0,
531            );
532            value.get()
533        }
534    }
535
536    fn set_property_cell_background_rgba(&self, cell_background_rgba: Option<&gdk::RGBA>) {
537        unsafe {
538            gobject_sys::g_object_set_property(
539                self.to_glib_none().0 as *mut gobject_sys::GObject,
540                b"cell-background-rgba\0".as_ptr() as *const _,
541                Value::from(cell_background_rgba).to_glib_none().0,
542            );
543        }
544    }
545
546    fn get_property_cell_background_set(&self) -> bool {
547        unsafe {
548            let mut value = Value::from_type(<bool as StaticType>::static_type());
549            gobject_sys::g_object_get_property(
550                self.to_glib_none().0 as *mut gobject_sys::GObject,
551                b"cell-background-set\0".as_ptr() as *const _,
552                value.to_glib_none_mut().0,
553            );
554            value.get().unwrap()
555        }
556    }
557
558    fn set_property_cell_background_set(&self, cell_background_set: bool) {
559        unsafe {
560            gobject_sys::g_object_set_property(
561                self.to_glib_none().0 as *mut gobject_sys::GObject,
562                b"cell-background-set\0".as_ptr() as *const _,
563                Value::from(&cell_background_set).to_glib_none().0,
564            );
565        }
566    }
567
568    fn get_property_editing(&self) -> bool {
569        unsafe {
570            let mut value = Value::from_type(<bool as StaticType>::static_type());
571            gobject_sys::g_object_get_property(
572                self.to_glib_none().0 as *mut gobject_sys::GObject,
573                b"editing\0".as_ptr() as *const _,
574                value.to_glib_none_mut().0,
575            );
576            value.get().unwrap()
577        }
578    }
579
580    fn get_property_height(&self) -> i32 {
581        unsafe {
582            let mut value = Value::from_type(<i32 as StaticType>::static_type());
583            gobject_sys::g_object_get_property(
584                self.to_glib_none().0 as *mut gobject_sys::GObject,
585                b"height\0".as_ptr() as *const _,
586                value.to_glib_none_mut().0,
587            );
588            value.get().unwrap()
589        }
590    }
591
592    fn set_property_height(&self, height: i32) {
593        unsafe {
594            gobject_sys::g_object_set_property(
595                self.to_glib_none().0 as *mut gobject_sys::GObject,
596                b"height\0".as_ptr() as *const _,
597                Value::from(&height).to_glib_none().0,
598            );
599        }
600    }
601
602    fn get_property_is_expanded(&self) -> bool {
603        unsafe {
604            let mut value = Value::from_type(<bool as StaticType>::static_type());
605            gobject_sys::g_object_get_property(
606                self.to_glib_none().0 as *mut gobject_sys::GObject,
607                b"is-expanded\0".as_ptr() as *const _,
608                value.to_glib_none_mut().0,
609            );
610            value.get().unwrap()
611        }
612    }
613
614    fn set_property_is_expanded(&self, is_expanded: bool) {
615        unsafe {
616            gobject_sys::g_object_set_property(
617                self.to_glib_none().0 as *mut gobject_sys::GObject,
618                b"is-expanded\0".as_ptr() as *const _,
619                Value::from(&is_expanded).to_glib_none().0,
620            );
621        }
622    }
623
624    fn get_property_is_expander(&self) -> bool {
625        unsafe {
626            let mut value = Value::from_type(<bool as StaticType>::static_type());
627            gobject_sys::g_object_get_property(
628                self.to_glib_none().0 as *mut gobject_sys::GObject,
629                b"is-expander\0".as_ptr() as *const _,
630                value.to_glib_none_mut().0,
631            );
632            value.get().unwrap()
633        }
634    }
635
636    fn set_property_is_expander(&self, is_expander: bool) {
637        unsafe {
638            gobject_sys::g_object_set_property(
639                self.to_glib_none().0 as *mut gobject_sys::GObject,
640                b"is-expander\0".as_ptr() as *const _,
641                Value::from(&is_expander).to_glib_none().0,
642            );
643        }
644    }
645
646    fn get_property_mode(&self) -> CellRendererMode {
647        unsafe {
648            let mut value = Value::from_type(<CellRendererMode as StaticType>::static_type());
649            gobject_sys::g_object_get_property(
650                self.to_glib_none().0 as *mut gobject_sys::GObject,
651                b"mode\0".as_ptr() as *const _,
652                value.to_glib_none_mut().0,
653            );
654            value.get().unwrap()
655        }
656    }
657
658    fn set_property_mode(&self, mode: CellRendererMode) {
659        unsafe {
660            gobject_sys::g_object_set_property(
661                self.to_glib_none().0 as *mut gobject_sys::GObject,
662                b"mode\0".as_ptr() as *const _,
663                Value::from(&mode).to_glib_none().0,
664            );
665        }
666    }
667
668    fn get_property_width(&self) -> i32 {
669        unsafe {
670            let mut value = Value::from_type(<i32 as StaticType>::static_type());
671            gobject_sys::g_object_get_property(
672                self.to_glib_none().0 as *mut gobject_sys::GObject,
673                b"width\0".as_ptr() as *const _,
674                value.to_glib_none_mut().0,
675            );
676            value.get().unwrap()
677        }
678    }
679
680    fn set_property_width(&self, width: i32) {
681        unsafe {
682            gobject_sys::g_object_set_property(
683                self.to_glib_none().0 as *mut gobject_sys::GObject,
684                b"width\0".as_ptr() as *const _,
685                Value::from(&width).to_glib_none().0,
686            );
687        }
688    }
689
690    fn get_property_xalign(&self) -> f32 {
691        unsafe {
692            let mut value = Value::from_type(<f32 as StaticType>::static_type());
693            gobject_sys::g_object_get_property(
694                self.to_glib_none().0 as *mut gobject_sys::GObject,
695                b"xalign\0".as_ptr() as *const _,
696                value.to_glib_none_mut().0,
697            );
698            value.get().unwrap()
699        }
700    }
701
702    fn set_property_xalign(&self, xalign: f32) {
703        unsafe {
704            gobject_sys::g_object_set_property(
705                self.to_glib_none().0 as *mut gobject_sys::GObject,
706                b"xalign\0".as_ptr() as *const _,
707                Value::from(&xalign).to_glib_none().0,
708            );
709        }
710    }
711
712    fn get_property_xpad(&self) -> u32 {
713        unsafe {
714            let mut value = Value::from_type(<u32 as StaticType>::static_type());
715            gobject_sys::g_object_get_property(
716                self.to_glib_none().0 as *mut gobject_sys::GObject,
717                b"xpad\0".as_ptr() as *const _,
718                value.to_glib_none_mut().0,
719            );
720            value.get().unwrap()
721        }
722    }
723
724    fn set_property_xpad(&self, xpad: u32) {
725        unsafe {
726            gobject_sys::g_object_set_property(
727                self.to_glib_none().0 as *mut gobject_sys::GObject,
728                b"xpad\0".as_ptr() as *const _,
729                Value::from(&xpad).to_glib_none().0,
730            );
731        }
732    }
733
734    fn get_property_yalign(&self) -> f32 {
735        unsafe {
736            let mut value = Value::from_type(<f32 as StaticType>::static_type());
737            gobject_sys::g_object_get_property(
738                self.to_glib_none().0 as *mut gobject_sys::GObject,
739                b"yalign\0".as_ptr() as *const _,
740                value.to_glib_none_mut().0,
741            );
742            value.get().unwrap()
743        }
744    }
745
746    fn set_property_yalign(&self, yalign: f32) {
747        unsafe {
748            gobject_sys::g_object_set_property(
749                self.to_glib_none().0 as *mut gobject_sys::GObject,
750                b"yalign\0".as_ptr() as *const _,
751                Value::from(&yalign).to_glib_none().0,
752            );
753        }
754    }
755
756    fn get_property_ypad(&self) -> u32 {
757        unsafe {
758            let mut value = Value::from_type(<u32 as StaticType>::static_type());
759            gobject_sys::g_object_get_property(
760                self.to_glib_none().0 as *mut gobject_sys::GObject,
761                b"ypad\0".as_ptr() as *const _,
762                value.to_glib_none_mut().0,
763            );
764            value.get().unwrap()
765        }
766    }
767
768    fn set_property_ypad(&self, ypad: u32) {
769        unsafe {
770            gobject_sys::g_object_set_property(
771                self.to_glib_none().0 as *mut gobject_sys::GObject,
772                b"ypad\0".as_ptr() as *const _,
773                Value::from(&ypad).to_glib_none().0,
774            );
775        }
776    }
777
778    fn connect_editing_canceled<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
779        unsafe extern "C" fn editing_canceled_trampoline<P, F: Fn(&P) + 'static>(
780            this: *mut gtk_sys::GtkCellRenderer,
781            f: glib_sys::gpointer,
782        ) where
783            P: IsA<CellRenderer>,
784        {
785            let f: &F = &*(f as *const F);
786            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
787        }
788        unsafe {
789            let f: Box_<F> = Box_::new(f);
790            connect_raw(
791                self.as_ptr() as *mut _,
792                b"editing-canceled\0".as_ptr() as *const _,
793                Some(transmute(editing_canceled_trampoline::<Self, F> as usize)),
794                Box_::into_raw(f),
795            )
796        }
797    }
798
799    fn connect_editing_started<F: Fn(&Self, &CellEditable, TreePath) + 'static>(
800        &self,
801        f: F,
802    ) -> SignalHandlerId {
803        unsafe extern "C" fn editing_started_trampoline<
804            P,
805            F: Fn(&P, &CellEditable, TreePath) + 'static,
806        >(
807            this: *mut gtk_sys::GtkCellRenderer,
808            editable: *mut gtk_sys::GtkCellEditable,
809            path: *mut libc::c_char,
810            f: glib_sys::gpointer,
811        ) where
812            P: IsA<CellRenderer>,
813        {
814            let f: &F = &*(f as *const F);
815            let path = from_glib_full(gtk_sys::gtk_tree_path_new_from_string(path));
816            f(
817                &CellRenderer::from_glib_borrow(this).unsafe_cast(),
818                &from_glib_borrow(editable),
819                path,
820            )
821        }
822        unsafe {
823            let f: Box_<F> = Box_::new(f);
824            connect_raw(
825                self.as_ptr() as *mut _,
826                b"editing-started\0".as_ptr() as *const _,
827                Some(transmute(editing_started_trampoline::<Self, F> as usize)),
828                Box_::into_raw(f),
829            )
830        }
831    }
832
833    fn connect_property_cell_background_notify<F: Fn(&Self) + 'static>(
834        &self,
835        f: F,
836    ) -> SignalHandlerId {
837        unsafe extern "C" fn notify_cell_background_trampoline<P, F: Fn(&P) + 'static>(
838            this: *mut gtk_sys::GtkCellRenderer,
839            _param_spec: glib_sys::gpointer,
840            f: glib_sys::gpointer,
841        ) where
842            P: IsA<CellRenderer>,
843        {
844            let f: &F = &*(f as *const F);
845            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
846        }
847        unsafe {
848            let f: Box_<F> = Box_::new(f);
849            connect_raw(
850                self.as_ptr() as *mut _,
851                b"notify::cell-background\0".as_ptr() as *const _,
852                Some(transmute(
853                    notify_cell_background_trampoline::<Self, F> as usize,
854                )),
855                Box_::into_raw(f),
856            )
857        }
858    }
859
860    fn connect_property_cell_background_rgba_notify<F: Fn(&Self) + 'static>(
861        &self,
862        f: F,
863    ) -> SignalHandlerId {
864        unsafe extern "C" fn notify_cell_background_rgba_trampoline<P, F: Fn(&P) + 'static>(
865            this: *mut gtk_sys::GtkCellRenderer,
866            _param_spec: glib_sys::gpointer,
867            f: glib_sys::gpointer,
868        ) where
869            P: IsA<CellRenderer>,
870        {
871            let f: &F = &*(f as *const F);
872            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
873        }
874        unsafe {
875            let f: Box_<F> = Box_::new(f);
876            connect_raw(
877                self.as_ptr() as *mut _,
878                b"notify::cell-background-rgba\0".as_ptr() as *const _,
879                Some(transmute(
880                    notify_cell_background_rgba_trampoline::<Self, F> as usize,
881                )),
882                Box_::into_raw(f),
883            )
884        }
885    }
886
887    fn connect_property_cell_background_set_notify<F: Fn(&Self) + 'static>(
888        &self,
889        f: F,
890    ) -> SignalHandlerId {
891        unsafe extern "C" fn notify_cell_background_set_trampoline<P, F: Fn(&P) + 'static>(
892            this: *mut gtk_sys::GtkCellRenderer,
893            _param_spec: glib_sys::gpointer,
894            f: glib_sys::gpointer,
895        ) where
896            P: IsA<CellRenderer>,
897        {
898            let f: &F = &*(f as *const F);
899            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
900        }
901        unsafe {
902            let f: Box_<F> = Box_::new(f);
903            connect_raw(
904                self.as_ptr() as *mut _,
905                b"notify::cell-background-set\0".as_ptr() as *const _,
906                Some(transmute(
907                    notify_cell_background_set_trampoline::<Self, F> as usize,
908                )),
909                Box_::into_raw(f),
910            )
911        }
912    }
913
914    fn connect_property_editing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
915        unsafe extern "C" fn notify_editing_trampoline<P, F: Fn(&P) + 'static>(
916            this: *mut gtk_sys::GtkCellRenderer,
917            _param_spec: glib_sys::gpointer,
918            f: glib_sys::gpointer,
919        ) where
920            P: IsA<CellRenderer>,
921        {
922            let f: &F = &*(f as *const F);
923            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
924        }
925        unsafe {
926            let f: Box_<F> = Box_::new(f);
927            connect_raw(
928                self.as_ptr() as *mut _,
929                b"notify::editing\0".as_ptr() as *const _,
930                Some(transmute(notify_editing_trampoline::<Self, F> as usize)),
931                Box_::into_raw(f),
932            )
933        }
934    }
935
936    fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
937        unsafe extern "C" fn notify_height_trampoline<P, F: Fn(&P) + 'static>(
938            this: *mut gtk_sys::GtkCellRenderer,
939            _param_spec: glib_sys::gpointer,
940            f: glib_sys::gpointer,
941        ) where
942            P: IsA<CellRenderer>,
943        {
944            let f: &F = &*(f as *const F);
945            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
946        }
947        unsafe {
948            let f: Box_<F> = Box_::new(f);
949            connect_raw(
950                self.as_ptr() as *mut _,
951                b"notify::height\0".as_ptr() as *const _,
952                Some(transmute(notify_height_trampoline::<Self, F> as usize)),
953                Box_::into_raw(f),
954            )
955        }
956    }
957
958    fn connect_property_is_expanded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
959        unsafe extern "C" fn notify_is_expanded_trampoline<P, F: Fn(&P) + 'static>(
960            this: *mut gtk_sys::GtkCellRenderer,
961            _param_spec: glib_sys::gpointer,
962            f: glib_sys::gpointer,
963        ) where
964            P: IsA<CellRenderer>,
965        {
966            let f: &F = &*(f as *const F);
967            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
968        }
969        unsafe {
970            let f: Box_<F> = Box_::new(f);
971            connect_raw(
972                self.as_ptr() as *mut _,
973                b"notify::is-expanded\0".as_ptr() as *const _,
974                Some(transmute(notify_is_expanded_trampoline::<Self, F> as usize)),
975                Box_::into_raw(f),
976            )
977        }
978    }
979
980    fn connect_property_is_expander_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
981        unsafe extern "C" fn notify_is_expander_trampoline<P, F: Fn(&P) + 'static>(
982            this: *mut gtk_sys::GtkCellRenderer,
983            _param_spec: glib_sys::gpointer,
984            f: glib_sys::gpointer,
985        ) where
986            P: IsA<CellRenderer>,
987        {
988            let f: &F = &*(f as *const F);
989            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
990        }
991        unsafe {
992            let f: Box_<F> = Box_::new(f);
993            connect_raw(
994                self.as_ptr() as *mut _,
995                b"notify::is-expander\0".as_ptr() as *const _,
996                Some(transmute(notify_is_expander_trampoline::<Self, F> as usize)),
997                Box_::into_raw(f),
998            )
999        }
1000    }
1001
1002    fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1003        unsafe extern "C" fn notify_mode_trampoline<P, F: Fn(&P) + 'static>(
1004            this: *mut gtk_sys::GtkCellRenderer,
1005            _param_spec: glib_sys::gpointer,
1006            f: glib_sys::gpointer,
1007        ) where
1008            P: IsA<CellRenderer>,
1009        {
1010            let f: &F = &*(f as *const F);
1011            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1012        }
1013        unsafe {
1014            let f: Box_<F> = Box_::new(f);
1015            connect_raw(
1016                self.as_ptr() as *mut _,
1017                b"notify::mode\0".as_ptr() as *const _,
1018                Some(transmute(notify_mode_trampoline::<Self, F> as usize)),
1019                Box_::into_raw(f),
1020            )
1021        }
1022    }
1023
1024    fn connect_property_sensitive_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1025        unsafe extern "C" fn notify_sensitive_trampoline<P, F: Fn(&P) + 'static>(
1026            this: *mut gtk_sys::GtkCellRenderer,
1027            _param_spec: glib_sys::gpointer,
1028            f: glib_sys::gpointer,
1029        ) where
1030            P: IsA<CellRenderer>,
1031        {
1032            let f: &F = &*(f as *const F);
1033            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1034        }
1035        unsafe {
1036            let f: Box_<F> = Box_::new(f);
1037            connect_raw(
1038                self.as_ptr() as *mut _,
1039                b"notify::sensitive\0".as_ptr() as *const _,
1040                Some(transmute(notify_sensitive_trampoline::<Self, F> as usize)),
1041                Box_::into_raw(f),
1042            )
1043        }
1044    }
1045
1046    fn connect_property_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1047        unsafe extern "C" fn notify_visible_trampoline<P, F: Fn(&P) + 'static>(
1048            this: *mut gtk_sys::GtkCellRenderer,
1049            _param_spec: glib_sys::gpointer,
1050            f: glib_sys::gpointer,
1051        ) where
1052            P: IsA<CellRenderer>,
1053        {
1054            let f: &F = &*(f as *const F);
1055            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1056        }
1057        unsafe {
1058            let f: Box_<F> = Box_::new(f);
1059            connect_raw(
1060                self.as_ptr() as *mut _,
1061                b"notify::visible\0".as_ptr() as *const _,
1062                Some(transmute(notify_visible_trampoline::<Self, F> as usize)),
1063                Box_::into_raw(f),
1064            )
1065        }
1066    }
1067
1068    fn connect_property_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1069        unsafe extern "C" fn notify_width_trampoline<P, F: Fn(&P) + 'static>(
1070            this: *mut gtk_sys::GtkCellRenderer,
1071            _param_spec: glib_sys::gpointer,
1072            f: glib_sys::gpointer,
1073        ) where
1074            P: IsA<CellRenderer>,
1075        {
1076            let f: &F = &*(f as *const F);
1077            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1078        }
1079        unsafe {
1080            let f: Box_<F> = Box_::new(f);
1081            connect_raw(
1082                self.as_ptr() as *mut _,
1083                b"notify::width\0".as_ptr() as *const _,
1084                Some(transmute(notify_width_trampoline::<Self, F> as usize)),
1085                Box_::into_raw(f),
1086            )
1087        }
1088    }
1089
1090    fn connect_property_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1091        unsafe extern "C" fn notify_xalign_trampoline<P, F: Fn(&P) + 'static>(
1092            this: *mut gtk_sys::GtkCellRenderer,
1093            _param_spec: glib_sys::gpointer,
1094            f: glib_sys::gpointer,
1095        ) where
1096            P: IsA<CellRenderer>,
1097        {
1098            let f: &F = &*(f as *const F);
1099            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1100        }
1101        unsafe {
1102            let f: Box_<F> = Box_::new(f);
1103            connect_raw(
1104                self.as_ptr() as *mut _,
1105                b"notify::xalign\0".as_ptr() as *const _,
1106                Some(transmute(notify_xalign_trampoline::<Self, F> as usize)),
1107                Box_::into_raw(f),
1108            )
1109        }
1110    }
1111
1112    fn connect_property_xpad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1113        unsafe extern "C" fn notify_xpad_trampoline<P, F: Fn(&P) + 'static>(
1114            this: *mut gtk_sys::GtkCellRenderer,
1115            _param_spec: glib_sys::gpointer,
1116            f: glib_sys::gpointer,
1117        ) where
1118            P: IsA<CellRenderer>,
1119        {
1120            let f: &F = &*(f as *const F);
1121            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1122        }
1123        unsafe {
1124            let f: Box_<F> = Box_::new(f);
1125            connect_raw(
1126                self.as_ptr() as *mut _,
1127                b"notify::xpad\0".as_ptr() as *const _,
1128                Some(transmute(notify_xpad_trampoline::<Self, F> as usize)),
1129                Box_::into_raw(f),
1130            )
1131        }
1132    }
1133
1134    fn connect_property_yalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1135        unsafe extern "C" fn notify_yalign_trampoline<P, F: Fn(&P) + 'static>(
1136            this: *mut gtk_sys::GtkCellRenderer,
1137            _param_spec: glib_sys::gpointer,
1138            f: glib_sys::gpointer,
1139        ) where
1140            P: IsA<CellRenderer>,
1141        {
1142            let f: &F = &*(f as *const F);
1143            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1144        }
1145        unsafe {
1146            let f: Box_<F> = Box_::new(f);
1147            connect_raw(
1148                self.as_ptr() as *mut _,
1149                b"notify::yalign\0".as_ptr() as *const _,
1150                Some(transmute(notify_yalign_trampoline::<Self, F> as usize)),
1151                Box_::into_raw(f),
1152            )
1153        }
1154    }
1155
1156    fn connect_property_ypad_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1157        unsafe extern "C" fn notify_ypad_trampoline<P, F: Fn(&P) + 'static>(
1158            this: *mut gtk_sys::GtkCellRenderer,
1159            _param_spec: glib_sys::gpointer,
1160            f: glib_sys::gpointer,
1161        ) where
1162            P: IsA<CellRenderer>,
1163        {
1164            let f: &F = &*(f as *const F);
1165            f(&CellRenderer::from_glib_borrow(this).unsafe_cast())
1166        }
1167        unsafe {
1168            let f: Box_<F> = Box_::new(f);
1169            connect_raw(
1170                self.as_ptr() as *mut _,
1171                b"notify::ypad\0".as_ptr() as *const _,
1172                Some(transmute(notify_ypad_trampoline::<Self, F> as usize)),
1173                Box_::into_raw(f),
1174            )
1175        }
1176    }
1177}
1178
1179impl fmt::Display for CellRenderer {
1180    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1181        write!(f, "CellRenderer")
1182    }
1183}