gtk/auto/
cell_area.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 gdk_sys;
8use glib::object::Cast;
9use glib::object::IsA;
10use glib::signal::connect_raw;
11use glib::signal::SignalHandlerId;
12use glib::translate::*;
13use glib::GString;
14use glib_sys;
15use gtk_sys;
16use libc;
17use std::boxed::Box as Box_;
18use std::fmt;
19use std::mem;
20use std::mem::transmute;
21use Buildable;
22use CellAreaContext;
23use CellEditable;
24use CellLayout;
25use CellRenderer;
26use CellRendererState;
27use DirectionType;
28use Orientation;
29use SizeRequestMode;
30use TreeIter;
31use TreeModel;
32use TreePath;
33use Widget;
34
35glib_wrapper! {
36    pub struct CellArea(Object<gtk_sys::GtkCellArea, gtk_sys::GtkCellAreaClass, CellAreaClass>) @implements Buildable, CellLayout;
37
38    match fn {
39        get_type => || gtk_sys::gtk_cell_area_get_type(),
40    }
41}
42
43pub const NONE_CELL_AREA: Option<&CellArea> = None;
44
45pub trait CellAreaExt: 'static {
46    fn activate<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
47        &self,
48        context: &P,
49        widget: &Q,
50        cell_area: &gdk::Rectangle,
51        flags: CellRendererState,
52        edit_only: bool,
53    ) -> bool;
54
55    fn activate_cell<P: IsA<Widget>, Q: IsA<CellRenderer>>(
56        &self,
57        widget: &P,
58        renderer: &Q,
59        event: &gdk::Event,
60        cell_area: &gdk::Rectangle,
61        flags: CellRendererState,
62    ) -> bool;
63
64    fn add<P: IsA<CellRenderer>>(&self, renderer: &P);
65
66    fn add_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
67        &self,
68        renderer: &P,
69        sibling: &Q,
70    );
71
72    //fn add_with_properties<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
73
74    fn apply_attributes<P: IsA<TreeModel>>(
75        &self,
76        tree_model: &P,
77        iter: &TreeIter,
78        is_expander: bool,
79        is_expanded: bool,
80    );
81
82    fn attribute_connect<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str, column: i32);
83
84    fn attribute_disconnect<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str);
85
86    fn attribute_get_column<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str) -> i32;
87
88    //fn cell_get<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
89
90    //fn cell_get_valist<P: IsA<CellRenderer>>(&self, renderer: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);
91
92    //fn cell_set<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);
93
94    //fn cell_set_valist<P: IsA<CellRenderer>>(&self, renderer: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);
95
96    fn copy_context<P: IsA<CellAreaContext>>(&self, context: &P) -> Option<CellAreaContext>;
97
98    fn create_context(&self) -> Option<CellAreaContext>;
99
100    fn event<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
101        &self,
102        context: &P,
103        widget: &Q,
104        event: &gdk::Event,
105        cell_area: &gdk::Rectangle,
106        flags: CellRendererState,
107    ) -> i32;
108
109    fn focus(&self, direction: DirectionType) -> bool;
110
111    fn foreach<P: FnMut(&CellRenderer) -> bool>(&self, callback: P);
112
113    fn foreach_alloc<
114        P: IsA<CellAreaContext>,
115        Q: IsA<Widget>,
116        R: FnMut(&CellRenderer, &gdk::Rectangle, &gdk::Rectangle) -> bool,
117    >(
118        &self,
119        context: &P,
120        widget: &Q,
121        cell_area: &gdk::Rectangle,
122        background_area: &gdk::Rectangle,
123        callback: R,
124    );
125
126    fn get_cell_allocation<P: IsA<CellAreaContext>, Q: IsA<Widget>, R: IsA<CellRenderer>>(
127        &self,
128        context: &P,
129        widget: &Q,
130        renderer: &R,
131        cell_area: &gdk::Rectangle,
132    ) -> gdk::Rectangle;
133
134    fn get_cell_at_position<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
135        &self,
136        context: &P,
137        widget: &Q,
138        cell_area: &gdk::Rectangle,
139        x: i32,
140        y: i32,
141    ) -> (CellRenderer, gdk::Rectangle);
142
143    fn get_current_path_string(&self) -> Option<GString>;
144
145    fn get_edit_widget(&self) -> Option<CellEditable>;
146
147    fn get_edited_cell(&self) -> Option<CellRenderer>;
148
149    fn get_focus_cell(&self) -> Option<CellRenderer>;
150
151    fn get_focus_from_sibling<P: IsA<CellRenderer>>(&self, renderer: &P) -> Option<CellRenderer>;
152
153    fn get_focus_siblings<P: IsA<CellRenderer>>(&self, renderer: &P) -> Vec<CellRenderer>;
154
155    fn get_preferred_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
156        &self,
157        context: &P,
158        widget: &Q,
159    ) -> (i32, i32);
160
161    fn get_preferred_height_for_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
162        &self,
163        context: &P,
164        widget: &Q,
165        width: i32,
166    ) -> (i32, i32);
167
168    fn get_preferred_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
169        &self,
170        context: &P,
171        widget: &Q,
172    ) -> (i32, i32);
173
174    fn get_preferred_width_for_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
175        &self,
176        context: &P,
177        widget: &Q,
178        height: i32,
179    ) -> (i32, i32);
180
181    fn get_request_mode(&self) -> SizeRequestMode;
182
183    fn has_renderer<P: IsA<CellRenderer>>(&self, renderer: &P) -> bool;
184
185    fn inner_cell_area<P: IsA<Widget>>(
186        &self,
187        widget: &P,
188        cell_area: &gdk::Rectangle,
189    ) -> gdk::Rectangle;
190
191    fn is_activatable(&self) -> bool;
192
193    fn is_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
194        &self,
195        renderer: &P,
196        sibling: &Q,
197    ) -> bool;
198
199    fn remove<P: IsA<CellRenderer>>(&self, renderer: &P);
200
201    fn remove_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
202        &self,
203        renderer: &P,
204        sibling: &Q,
205    );
206
207    fn render<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
208        &self,
209        context: &P,
210        widget: &Q,
211        cr: &cairo::Context,
212        background_area: &gdk::Rectangle,
213        cell_area: &gdk::Rectangle,
214        flags: CellRendererState,
215        paint_focus: bool,
216    );
217
218    fn request_renderer<P: IsA<CellRenderer>, Q: IsA<Widget>>(
219        &self,
220        renderer: &P,
221        orientation: Orientation,
222        widget: &Q,
223        for_size: i32,
224    ) -> (i32, i32);
225
226    fn set_focus_cell<P: IsA<CellRenderer>>(&self, renderer: &P);
227
228    fn stop_editing(&self, canceled: bool);
229
230    fn connect_add_editable<
231        F: Fn(&Self, &CellRenderer, &CellEditable, &gdk::Rectangle, TreePath) + 'static,
232    >(
233        &self,
234        f: F,
235    ) -> SignalHandlerId;
236
237    fn connect_apply_attributes<F: Fn(&Self, &TreeModel, &TreeIter, bool, bool) + 'static>(
238        &self,
239        f: F,
240    ) -> SignalHandlerId;
241
242    fn connect_focus_changed<F: Fn(&Self, &CellRenderer, TreePath) + 'static>(
243        &self,
244        f: F,
245    ) -> SignalHandlerId;
246
247    fn connect_remove_editable<F: Fn(&Self, &CellRenderer, &CellEditable) + 'static>(
248        &self,
249        f: F,
250    ) -> SignalHandlerId;
251
252    fn connect_property_edit_widget_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
253
254    fn connect_property_edited_cell_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
255
256    fn connect_property_focus_cell_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
257}
258
259impl<O: IsA<CellArea>> CellAreaExt for O {
260    fn activate<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
261        &self,
262        context: &P,
263        widget: &Q,
264        cell_area: &gdk::Rectangle,
265        flags: CellRendererState,
266        edit_only: bool,
267    ) -> bool {
268        unsafe {
269            from_glib(gtk_sys::gtk_cell_area_activate(
270                self.as_ref().to_glib_none().0,
271                context.as_ref().to_glib_none().0,
272                widget.as_ref().to_glib_none().0,
273                cell_area.to_glib_none().0,
274                flags.to_glib(),
275                edit_only.to_glib(),
276            ))
277        }
278    }
279
280    fn activate_cell<P: IsA<Widget>, Q: IsA<CellRenderer>>(
281        &self,
282        widget: &P,
283        renderer: &Q,
284        event: &gdk::Event,
285        cell_area: &gdk::Rectangle,
286        flags: CellRendererState,
287    ) -> bool {
288        unsafe {
289            from_glib(gtk_sys::gtk_cell_area_activate_cell(
290                self.as_ref().to_glib_none().0,
291                widget.as_ref().to_glib_none().0,
292                renderer.as_ref().to_glib_none().0,
293                mut_override(event.to_glib_none().0),
294                cell_area.to_glib_none().0,
295                flags.to_glib(),
296            ))
297        }
298    }
299
300    fn add<P: IsA<CellRenderer>>(&self, renderer: &P) {
301        unsafe {
302            gtk_sys::gtk_cell_area_add(
303                self.as_ref().to_glib_none().0,
304                renderer.as_ref().to_glib_none().0,
305            );
306        }
307    }
308
309    fn add_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
310        &self,
311        renderer: &P,
312        sibling: &Q,
313    ) {
314        unsafe {
315            gtk_sys::gtk_cell_area_add_focus_sibling(
316                self.as_ref().to_glib_none().0,
317                renderer.as_ref().to_glib_none().0,
318                sibling.as_ref().to_glib_none().0,
319            );
320        }
321    }
322
323    //fn add_with_properties<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
324    //    unsafe { TODO: call gtk_sys:gtk_cell_area_add_with_properties() }
325    //}
326
327    fn apply_attributes<P: IsA<TreeModel>>(
328        &self,
329        tree_model: &P,
330        iter: &TreeIter,
331        is_expander: bool,
332        is_expanded: bool,
333    ) {
334        unsafe {
335            gtk_sys::gtk_cell_area_apply_attributes(
336                self.as_ref().to_glib_none().0,
337                tree_model.as_ref().to_glib_none().0,
338                mut_override(iter.to_glib_none().0),
339                is_expander.to_glib(),
340                is_expanded.to_glib(),
341            );
342        }
343    }
344
345    fn attribute_connect<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str, column: i32) {
346        unsafe {
347            gtk_sys::gtk_cell_area_attribute_connect(
348                self.as_ref().to_glib_none().0,
349                renderer.as_ref().to_glib_none().0,
350                attribute.to_glib_none().0,
351                column,
352            );
353        }
354    }
355
356    fn attribute_disconnect<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str) {
357        unsafe {
358            gtk_sys::gtk_cell_area_attribute_disconnect(
359                self.as_ref().to_glib_none().0,
360                renderer.as_ref().to_glib_none().0,
361                attribute.to_glib_none().0,
362            );
363        }
364    }
365
366    fn attribute_get_column<P: IsA<CellRenderer>>(&self, renderer: &P, attribute: &str) -> i32 {
367        unsafe {
368            gtk_sys::gtk_cell_area_attribute_get_column(
369                self.as_ref().to_glib_none().0,
370                renderer.as_ref().to_glib_none().0,
371                attribute.to_glib_none().0,
372            )
373        }
374    }
375
376    //fn cell_get<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
377    //    unsafe { TODO: call gtk_sys:gtk_cell_area_cell_get() }
378    //}
379
380    //fn cell_get_valist<P: IsA<CellRenderer>>(&self, renderer: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
381    //    unsafe { TODO: call gtk_sys:gtk_cell_area_cell_get_valist() }
382    //}
383
384    //fn cell_set<P: IsA<CellRenderer>>(&self, renderer: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
385    //    unsafe { TODO: call gtk_sys:gtk_cell_area_cell_set() }
386    //}
387
388    //fn cell_set_valist<P: IsA<CellRenderer>>(&self, renderer: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
389    //    unsafe { TODO: call gtk_sys:gtk_cell_area_cell_set_valist() }
390    //}
391
392    fn copy_context<P: IsA<CellAreaContext>>(&self, context: &P) -> Option<CellAreaContext> {
393        unsafe {
394            from_glib_full(gtk_sys::gtk_cell_area_copy_context(
395                self.as_ref().to_glib_none().0,
396                context.as_ref().to_glib_none().0,
397            ))
398        }
399    }
400
401    fn create_context(&self) -> Option<CellAreaContext> {
402        unsafe {
403            from_glib_full(gtk_sys::gtk_cell_area_create_context(
404                self.as_ref().to_glib_none().0,
405            ))
406        }
407    }
408
409    fn event<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
410        &self,
411        context: &P,
412        widget: &Q,
413        event: &gdk::Event,
414        cell_area: &gdk::Rectangle,
415        flags: CellRendererState,
416    ) -> i32 {
417        unsafe {
418            gtk_sys::gtk_cell_area_event(
419                self.as_ref().to_glib_none().0,
420                context.as_ref().to_glib_none().0,
421                widget.as_ref().to_glib_none().0,
422                mut_override(event.to_glib_none().0),
423                cell_area.to_glib_none().0,
424                flags.to_glib(),
425            )
426        }
427    }
428
429    fn focus(&self, direction: DirectionType) -> bool {
430        unsafe {
431            from_glib(gtk_sys::gtk_cell_area_focus(
432                self.as_ref().to_glib_none().0,
433                direction.to_glib(),
434            ))
435        }
436    }
437
438    fn foreach<P: FnMut(&CellRenderer) -> bool>(&self, callback: P) {
439        let callback_data: P = callback;
440        unsafe extern "C" fn callback_func<P: FnMut(&CellRenderer) -> bool>(
441            renderer: *mut gtk_sys::GtkCellRenderer,
442            data: glib_sys::gpointer,
443        ) -> glib_sys::gboolean {
444            let renderer = from_glib_borrow(renderer);
445            let callback: *mut P = data as *const _ as usize as *mut P;
446            let res = (*callback)(&renderer);
447            res.to_glib()
448        }
449        let callback = Some(callback_func::<P> as _);
450        let super_callback0: &P = &callback_data;
451        unsafe {
452            gtk_sys::gtk_cell_area_foreach(
453                self.as_ref().to_glib_none().0,
454                callback,
455                super_callback0 as *const _ as usize as *mut _,
456            );
457        }
458    }
459
460    fn foreach_alloc<
461        P: IsA<CellAreaContext>,
462        Q: IsA<Widget>,
463        R: FnMut(&CellRenderer, &gdk::Rectangle, &gdk::Rectangle) -> bool,
464    >(
465        &self,
466        context: &P,
467        widget: &Q,
468        cell_area: &gdk::Rectangle,
469        background_area: &gdk::Rectangle,
470        callback: R,
471    ) {
472        let callback_data: R = callback;
473        unsafe extern "C" fn callback_func<
474            P: IsA<CellAreaContext>,
475            Q: IsA<Widget>,
476            R: FnMut(&CellRenderer, &gdk::Rectangle, &gdk::Rectangle) -> bool,
477        >(
478            renderer: *mut gtk_sys::GtkCellRenderer,
479            cell_area: *const gdk_sys::GdkRectangle,
480            cell_background: *const gdk_sys::GdkRectangle,
481            data: glib_sys::gpointer,
482        ) -> glib_sys::gboolean {
483            let renderer = from_glib_borrow(renderer);
484            let cell_area = from_glib_borrow(cell_area);
485            let cell_background = from_glib_borrow(cell_background);
486            let callback: *mut R = data as *const _ as usize as *mut R;
487            let res = (*callback)(&renderer, &cell_area, &cell_background);
488            res.to_glib()
489        }
490        let callback = Some(callback_func::<P, Q, R> as _);
491        let super_callback0: &R = &callback_data;
492        unsafe {
493            gtk_sys::gtk_cell_area_foreach_alloc(
494                self.as_ref().to_glib_none().0,
495                context.as_ref().to_glib_none().0,
496                widget.as_ref().to_glib_none().0,
497                cell_area.to_glib_none().0,
498                background_area.to_glib_none().0,
499                callback,
500                super_callback0 as *const _ as usize as *mut _,
501            );
502        }
503    }
504
505    fn get_cell_allocation<P: IsA<CellAreaContext>, Q: IsA<Widget>, R: IsA<CellRenderer>>(
506        &self,
507        context: &P,
508        widget: &Q,
509        renderer: &R,
510        cell_area: &gdk::Rectangle,
511    ) -> gdk::Rectangle {
512        unsafe {
513            let mut allocation = gdk::Rectangle::uninitialized();
514            gtk_sys::gtk_cell_area_get_cell_allocation(
515                self.as_ref().to_glib_none().0,
516                context.as_ref().to_glib_none().0,
517                widget.as_ref().to_glib_none().0,
518                renderer.as_ref().to_glib_none().0,
519                cell_area.to_glib_none().0,
520                allocation.to_glib_none_mut().0,
521            );
522            allocation
523        }
524    }
525
526    fn get_cell_at_position<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
527        &self,
528        context: &P,
529        widget: &Q,
530        cell_area: &gdk::Rectangle,
531        x: i32,
532        y: i32,
533    ) -> (CellRenderer, gdk::Rectangle) {
534        unsafe {
535            let mut alloc_area = gdk::Rectangle::uninitialized();
536            let ret = from_glib_none(gtk_sys::gtk_cell_area_get_cell_at_position(
537                self.as_ref().to_glib_none().0,
538                context.as_ref().to_glib_none().0,
539                widget.as_ref().to_glib_none().0,
540                cell_area.to_glib_none().0,
541                x,
542                y,
543                alloc_area.to_glib_none_mut().0,
544            ));
545            (ret, alloc_area)
546        }
547    }
548
549    fn get_current_path_string(&self) -> Option<GString> {
550        unsafe {
551            from_glib_none(gtk_sys::gtk_cell_area_get_current_path_string(
552                self.as_ref().to_glib_none().0,
553            ))
554        }
555    }
556
557    fn get_edit_widget(&self) -> Option<CellEditable> {
558        unsafe {
559            from_glib_none(gtk_sys::gtk_cell_area_get_edit_widget(
560                self.as_ref().to_glib_none().0,
561            ))
562        }
563    }
564
565    fn get_edited_cell(&self) -> Option<CellRenderer> {
566        unsafe {
567            from_glib_none(gtk_sys::gtk_cell_area_get_edited_cell(
568                self.as_ref().to_glib_none().0,
569            ))
570        }
571    }
572
573    fn get_focus_cell(&self) -> Option<CellRenderer> {
574        unsafe {
575            from_glib_none(gtk_sys::gtk_cell_area_get_focus_cell(
576                self.as_ref().to_glib_none().0,
577            ))
578        }
579    }
580
581    fn get_focus_from_sibling<P: IsA<CellRenderer>>(&self, renderer: &P) -> Option<CellRenderer> {
582        unsafe {
583            from_glib_none(gtk_sys::gtk_cell_area_get_focus_from_sibling(
584                self.as_ref().to_glib_none().0,
585                renderer.as_ref().to_glib_none().0,
586            ))
587        }
588    }
589
590    fn get_focus_siblings<P: IsA<CellRenderer>>(&self, renderer: &P) -> Vec<CellRenderer> {
591        unsafe {
592            FromGlibPtrContainer::from_glib_none(gtk_sys::gtk_cell_area_get_focus_siblings(
593                self.as_ref().to_glib_none().0,
594                renderer.as_ref().to_glib_none().0,
595            ))
596        }
597    }
598
599    fn get_preferred_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
600        &self,
601        context: &P,
602        widget: &Q,
603    ) -> (i32, i32) {
604        unsafe {
605            let mut minimum_height = mem::uninitialized();
606            let mut natural_height = mem::uninitialized();
607            gtk_sys::gtk_cell_area_get_preferred_height(
608                self.as_ref().to_glib_none().0,
609                context.as_ref().to_glib_none().0,
610                widget.as_ref().to_glib_none().0,
611                &mut minimum_height,
612                &mut natural_height,
613            );
614            (minimum_height, natural_height)
615        }
616    }
617
618    fn get_preferred_height_for_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
619        &self,
620        context: &P,
621        widget: &Q,
622        width: i32,
623    ) -> (i32, i32) {
624        unsafe {
625            let mut minimum_height = mem::uninitialized();
626            let mut natural_height = mem::uninitialized();
627            gtk_sys::gtk_cell_area_get_preferred_height_for_width(
628                self.as_ref().to_glib_none().0,
629                context.as_ref().to_glib_none().0,
630                widget.as_ref().to_glib_none().0,
631                width,
632                &mut minimum_height,
633                &mut natural_height,
634            );
635            (minimum_height, natural_height)
636        }
637    }
638
639    fn get_preferred_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
640        &self,
641        context: &P,
642        widget: &Q,
643    ) -> (i32, i32) {
644        unsafe {
645            let mut minimum_width = mem::uninitialized();
646            let mut natural_width = mem::uninitialized();
647            gtk_sys::gtk_cell_area_get_preferred_width(
648                self.as_ref().to_glib_none().0,
649                context.as_ref().to_glib_none().0,
650                widget.as_ref().to_glib_none().0,
651                &mut minimum_width,
652                &mut natural_width,
653            );
654            (minimum_width, natural_width)
655        }
656    }
657
658    fn get_preferred_width_for_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
659        &self,
660        context: &P,
661        widget: &Q,
662        height: i32,
663    ) -> (i32, i32) {
664        unsafe {
665            let mut minimum_width = mem::uninitialized();
666            let mut natural_width = mem::uninitialized();
667            gtk_sys::gtk_cell_area_get_preferred_width_for_height(
668                self.as_ref().to_glib_none().0,
669                context.as_ref().to_glib_none().0,
670                widget.as_ref().to_glib_none().0,
671                height,
672                &mut minimum_width,
673                &mut natural_width,
674            );
675            (minimum_width, natural_width)
676        }
677    }
678
679    fn get_request_mode(&self) -> SizeRequestMode {
680        unsafe {
681            from_glib(gtk_sys::gtk_cell_area_get_request_mode(
682                self.as_ref().to_glib_none().0,
683            ))
684        }
685    }
686
687    fn has_renderer<P: IsA<CellRenderer>>(&self, renderer: &P) -> bool {
688        unsafe {
689            from_glib(gtk_sys::gtk_cell_area_has_renderer(
690                self.as_ref().to_glib_none().0,
691                renderer.as_ref().to_glib_none().0,
692            ))
693        }
694    }
695
696    fn inner_cell_area<P: IsA<Widget>>(
697        &self,
698        widget: &P,
699        cell_area: &gdk::Rectangle,
700    ) -> gdk::Rectangle {
701        unsafe {
702            let mut inner_area = gdk::Rectangle::uninitialized();
703            gtk_sys::gtk_cell_area_inner_cell_area(
704                self.as_ref().to_glib_none().0,
705                widget.as_ref().to_glib_none().0,
706                cell_area.to_glib_none().0,
707                inner_area.to_glib_none_mut().0,
708            );
709            inner_area
710        }
711    }
712
713    fn is_activatable(&self) -> bool {
714        unsafe {
715            from_glib(gtk_sys::gtk_cell_area_is_activatable(
716                self.as_ref().to_glib_none().0,
717            ))
718        }
719    }
720
721    fn is_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
722        &self,
723        renderer: &P,
724        sibling: &Q,
725    ) -> bool {
726        unsafe {
727            from_glib(gtk_sys::gtk_cell_area_is_focus_sibling(
728                self.as_ref().to_glib_none().0,
729                renderer.as_ref().to_glib_none().0,
730                sibling.as_ref().to_glib_none().0,
731            ))
732        }
733    }
734
735    fn remove<P: IsA<CellRenderer>>(&self, renderer: &P) {
736        unsafe {
737            gtk_sys::gtk_cell_area_remove(
738                self.as_ref().to_glib_none().0,
739                renderer.as_ref().to_glib_none().0,
740            );
741        }
742    }
743
744    fn remove_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
745        &self,
746        renderer: &P,
747        sibling: &Q,
748    ) {
749        unsafe {
750            gtk_sys::gtk_cell_area_remove_focus_sibling(
751                self.as_ref().to_glib_none().0,
752                renderer.as_ref().to_glib_none().0,
753                sibling.as_ref().to_glib_none().0,
754            );
755        }
756    }
757
758    fn render<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
759        &self,
760        context: &P,
761        widget: &Q,
762        cr: &cairo::Context,
763        background_area: &gdk::Rectangle,
764        cell_area: &gdk::Rectangle,
765        flags: CellRendererState,
766        paint_focus: bool,
767    ) {
768        unsafe {
769            gtk_sys::gtk_cell_area_render(
770                self.as_ref().to_glib_none().0,
771                context.as_ref().to_glib_none().0,
772                widget.as_ref().to_glib_none().0,
773                mut_override(cr.to_glib_none().0),
774                background_area.to_glib_none().0,
775                cell_area.to_glib_none().0,
776                flags.to_glib(),
777                paint_focus.to_glib(),
778            );
779        }
780    }
781
782    fn request_renderer<P: IsA<CellRenderer>, Q: IsA<Widget>>(
783        &self,
784        renderer: &P,
785        orientation: Orientation,
786        widget: &Q,
787        for_size: i32,
788    ) -> (i32, i32) {
789        unsafe {
790            let mut minimum_size = mem::uninitialized();
791            let mut natural_size = mem::uninitialized();
792            gtk_sys::gtk_cell_area_request_renderer(
793                self.as_ref().to_glib_none().0,
794                renderer.as_ref().to_glib_none().0,
795                orientation.to_glib(),
796                widget.as_ref().to_glib_none().0,
797                for_size,
798                &mut minimum_size,
799                &mut natural_size,
800            );
801            (minimum_size, natural_size)
802        }
803    }
804
805    fn set_focus_cell<P: IsA<CellRenderer>>(&self, renderer: &P) {
806        unsafe {
807            gtk_sys::gtk_cell_area_set_focus_cell(
808                self.as_ref().to_glib_none().0,
809                renderer.as_ref().to_glib_none().0,
810            );
811        }
812    }
813
814    fn stop_editing(&self, canceled: bool) {
815        unsafe {
816            gtk_sys::gtk_cell_area_stop_editing(self.as_ref().to_glib_none().0, canceled.to_glib());
817        }
818    }
819
820    fn connect_add_editable<
821        F: Fn(&Self, &CellRenderer, &CellEditable, &gdk::Rectangle, TreePath) + 'static,
822    >(
823        &self,
824        f: F,
825    ) -> SignalHandlerId {
826        unsafe extern "C" fn add_editable_trampoline<
827            P,
828            F: Fn(&P, &CellRenderer, &CellEditable, &gdk::Rectangle, TreePath) + 'static,
829        >(
830            this: *mut gtk_sys::GtkCellArea,
831            renderer: *mut gtk_sys::GtkCellRenderer,
832            editable: *mut gtk_sys::GtkCellEditable,
833            cell_area: *mut gdk_sys::GdkRectangle,
834            path: *mut libc::c_char,
835            f: glib_sys::gpointer,
836        ) where
837            P: IsA<CellArea>,
838        {
839            let f: &F = &*(f as *const F);
840            let path = from_glib_full(gtk_sys::gtk_tree_path_new_from_string(path));
841            f(
842                &CellArea::from_glib_borrow(this).unsafe_cast(),
843                &from_glib_borrow(renderer),
844                &from_glib_borrow(editable),
845                &from_glib_borrow(cell_area),
846                path,
847            )
848        }
849        unsafe {
850            let f: Box_<F> = Box_::new(f);
851            connect_raw(
852                self.as_ptr() as *mut _,
853                b"add-editable\0".as_ptr() as *const _,
854                Some(transmute(add_editable_trampoline::<Self, F> as usize)),
855                Box_::into_raw(f),
856            )
857        }
858    }
859
860    fn connect_apply_attributes<F: Fn(&Self, &TreeModel, &TreeIter, bool, bool) + 'static>(
861        &self,
862        f: F,
863    ) -> SignalHandlerId {
864        unsafe extern "C" fn apply_attributes_trampoline<
865            P,
866            F: Fn(&P, &TreeModel, &TreeIter, bool, bool) + 'static,
867        >(
868            this: *mut gtk_sys::GtkCellArea,
869            model: *mut gtk_sys::GtkTreeModel,
870            iter: *mut gtk_sys::GtkTreeIter,
871            is_expander: glib_sys::gboolean,
872            is_expanded: glib_sys::gboolean,
873            f: glib_sys::gpointer,
874        ) where
875            P: IsA<CellArea>,
876        {
877            let f: &F = &*(f as *const F);
878            f(
879                &CellArea::from_glib_borrow(this).unsafe_cast(),
880                &from_glib_borrow(model),
881                &from_glib_borrow(iter),
882                from_glib(is_expander),
883                from_glib(is_expanded),
884            )
885        }
886        unsafe {
887            let f: Box_<F> = Box_::new(f);
888            connect_raw(
889                self.as_ptr() as *mut _,
890                b"apply-attributes\0".as_ptr() as *const _,
891                Some(transmute(apply_attributes_trampoline::<Self, F> as usize)),
892                Box_::into_raw(f),
893            )
894        }
895    }
896
897    fn connect_focus_changed<F: Fn(&Self, &CellRenderer, TreePath) + 'static>(
898        &self,
899        f: F,
900    ) -> SignalHandlerId {
901        unsafe extern "C" fn focus_changed_trampoline<
902            P,
903            F: Fn(&P, &CellRenderer, TreePath) + 'static,
904        >(
905            this: *mut gtk_sys::GtkCellArea,
906            renderer: *mut gtk_sys::GtkCellRenderer,
907            path: *mut libc::c_char,
908            f: glib_sys::gpointer,
909        ) where
910            P: IsA<CellArea>,
911        {
912            let f: &F = &*(f as *const F);
913            let path = from_glib_full(gtk_sys::gtk_tree_path_new_from_string(path));
914            f(
915                &CellArea::from_glib_borrow(this).unsafe_cast(),
916                &from_glib_borrow(renderer),
917                path,
918            )
919        }
920        unsafe {
921            let f: Box_<F> = Box_::new(f);
922            connect_raw(
923                self.as_ptr() as *mut _,
924                b"focus-changed\0".as_ptr() as *const _,
925                Some(transmute(focus_changed_trampoline::<Self, F> as usize)),
926                Box_::into_raw(f),
927            )
928        }
929    }
930
931    fn connect_remove_editable<F: Fn(&Self, &CellRenderer, &CellEditable) + 'static>(
932        &self,
933        f: F,
934    ) -> SignalHandlerId {
935        unsafe extern "C" fn remove_editable_trampoline<
936            P,
937            F: Fn(&P, &CellRenderer, &CellEditable) + 'static,
938        >(
939            this: *mut gtk_sys::GtkCellArea,
940            renderer: *mut gtk_sys::GtkCellRenderer,
941            editable: *mut gtk_sys::GtkCellEditable,
942            f: glib_sys::gpointer,
943        ) where
944            P: IsA<CellArea>,
945        {
946            let f: &F = &*(f as *const F);
947            f(
948                &CellArea::from_glib_borrow(this).unsafe_cast(),
949                &from_glib_borrow(renderer),
950                &from_glib_borrow(editable),
951            )
952        }
953        unsafe {
954            let f: Box_<F> = Box_::new(f);
955            connect_raw(
956                self.as_ptr() as *mut _,
957                b"remove-editable\0".as_ptr() as *const _,
958                Some(transmute(remove_editable_trampoline::<Self, F> as usize)),
959                Box_::into_raw(f),
960            )
961        }
962    }
963
964    fn connect_property_edit_widget_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
965        unsafe extern "C" fn notify_edit_widget_trampoline<P, F: Fn(&P) + 'static>(
966            this: *mut gtk_sys::GtkCellArea,
967            _param_spec: glib_sys::gpointer,
968            f: glib_sys::gpointer,
969        ) where
970            P: IsA<CellArea>,
971        {
972            let f: &F = &*(f as *const F);
973            f(&CellArea::from_glib_borrow(this).unsafe_cast())
974        }
975        unsafe {
976            let f: Box_<F> = Box_::new(f);
977            connect_raw(
978                self.as_ptr() as *mut _,
979                b"notify::edit-widget\0".as_ptr() as *const _,
980                Some(transmute(notify_edit_widget_trampoline::<Self, F> as usize)),
981                Box_::into_raw(f),
982            )
983        }
984    }
985
986    fn connect_property_edited_cell_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
987        unsafe extern "C" fn notify_edited_cell_trampoline<P, F: Fn(&P) + 'static>(
988            this: *mut gtk_sys::GtkCellArea,
989            _param_spec: glib_sys::gpointer,
990            f: glib_sys::gpointer,
991        ) where
992            P: IsA<CellArea>,
993        {
994            let f: &F = &*(f as *const F);
995            f(&CellArea::from_glib_borrow(this).unsafe_cast())
996        }
997        unsafe {
998            let f: Box_<F> = Box_::new(f);
999            connect_raw(
1000                self.as_ptr() as *mut _,
1001                b"notify::edited-cell\0".as_ptr() as *const _,
1002                Some(transmute(notify_edited_cell_trampoline::<Self, F> as usize)),
1003                Box_::into_raw(f),
1004            )
1005        }
1006    }
1007
1008    fn connect_property_focus_cell_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1009        unsafe extern "C" fn notify_focus_cell_trampoline<P, F: Fn(&P) + 'static>(
1010            this: *mut gtk_sys::GtkCellArea,
1011            _param_spec: glib_sys::gpointer,
1012            f: glib_sys::gpointer,
1013        ) where
1014            P: IsA<CellArea>,
1015        {
1016            let f: &F = &*(f as *const F);
1017            f(&CellArea::from_glib_borrow(this).unsafe_cast())
1018        }
1019        unsafe {
1020            let f: Box_<F> = Box_::new(f);
1021            connect_raw(
1022                self.as_ptr() as *mut _,
1023                b"notify::focus-cell\0".as_ptr() as *const _,
1024                Some(transmute(notify_focus_cell_trampoline::<Self, F> as usize)),
1025                Box_::into_raw(f),
1026            )
1027        }
1028    }
1029}
1030
1031impl fmt::Display for CellArea {
1032    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1033        write!(f, "CellArea")
1034    }
1035}