1use 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 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 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 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 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}