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