1use gdk;
6use gdk_sys;
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::ToValue;
14use glib::Value;
15use glib_sys;
16use gobject_sys;
17use gtk_sys;
18use libc;
19use pango;
20use std::boxed::Box as Box_;
21use std::fmt;
22use std::mem::transmute;
23use CellRenderer;
24use CellRendererAccelMode;
25use CellRendererMode;
26use CellRendererText;
27use TreePath;
28
29glib_wrapper! {
30 pub struct CellRendererAccel(Object<gtk_sys::GtkCellRendererAccel, gtk_sys::GtkCellRendererAccelClass, CellRendererAccelClass>) @extends CellRendererText, CellRenderer;
31
32 match fn {
33 get_type => || gtk_sys::gtk_cell_renderer_accel_get_type(),
34 }
35}
36
37impl CellRendererAccel {
38 pub fn new() -> CellRendererAccel {
39 assert_initialized_main_thread!();
40 unsafe {
41 CellRenderer::from_glib_none(gtk_sys::gtk_cell_renderer_accel_new()).unsafe_cast()
42 }
43 }
44}
45
46impl Default for CellRendererAccel {
47 fn default() -> Self {
48 Self::new()
49 }
50}
51
52pub struct CellRendererAccelBuilder {
53 accel_key: Option<u32>,
54 accel_mode: Option<CellRendererAccelMode>,
55 accel_mods: Option<gdk::ModifierType>,
56 keycode: Option<u32>,
57 align_set: Option<bool>,
58 alignment: Option<pango::Alignment>,
59 attributes: Option<pango::AttrList>,
60 background: Option<String>,
61 background_rgba: Option<gdk::RGBA>,
62 background_set: Option<bool>,
63 editable: Option<bool>,
64 editable_set: Option<bool>,
65 ellipsize: Option<pango::EllipsizeMode>,
66 ellipsize_set: Option<bool>,
67 family: Option<String>,
68 family_set: Option<bool>,
69 font: Option<String>,
70 font_desc: Option<pango::FontDescription>,
71 foreground: Option<String>,
72 foreground_rgba: Option<gdk::RGBA>,
73 foreground_set: Option<bool>,
74 language: Option<String>,
75 language_set: Option<bool>,
76 markup: Option<String>,
77 max_width_chars: Option<i32>,
78 placeholder_text: Option<String>,
79 rise: Option<i32>,
80 rise_set: Option<bool>,
81 scale: Option<f64>,
82 scale_set: Option<bool>,
83 single_paragraph_mode: Option<bool>,
84 size: Option<i32>,
85 size_points: Option<f64>,
86 size_set: Option<bool>,
87 stretch: Option<pango::Stretch>,
88 stretch_set: Option<bool>,
89 strikethrough: Option<bool>,
90 strikethrough_set: Option<bool>,
91 style: Option<pango::Style>,
92 style_set: Option<bool>,
93 text: Option<String>,
94 underline: Option<pango::Underline>,
95 underline_set: Option<bool>,
96 variant: Option<pango::Variant>,
97 variant_set: Option<bool>,
98 weight: Option<i32>,
99 weight_set: Option<bool>,
100 width_chars: Option<i32>,
101 wrap_mode: Option<pango::WrapMode>,
102 wrap_width: Option<i32>,
103 cell_background: Option<String>,
104 cell_background_rgba: Option<gdk::RGBA>,
105 cell_background_set: Option<bool>,
106 height: Option<i32>,
107 is_expanded: Option<bool>,
108 is_expander: Option<bool>,
109 mode: Option<CellRendererMode>,
110 sensitive: Option<bool>,
111 visible: Option<bool>,
112 width: Option<i32>,
113 xalign: Option<f32>,
114 xpad: Option<u32>,
115 yalign: Option<f32>,
116 ypad: Option<u32>,
117}
118
119impl CellRendererAccelBuilder {
120 pub fn new() -> Self {
121 Self {
122 accel_key: None,
123 accel_mode: None,
124 accel_mods: None,
125 keycode: None,
126 align_set: None,
127 alignment: None,
128 attributes: None,
129 background: None,
130 background_rgba: None,
131 background_set: None,
132 editable: None,
133 editable_set: None,
134 ellipsize: None,
135 ellipsize_set: None,
136 family: None,
137 family_set: None,
138 font: None,
139 font_desc: None,
140 foreground: None,
141 foreground_rgba: None,
142 foreground_set: None,
143 language: None,
144 language_set: None,
145 markup: None,
146 max_width_chars: None,
147 placeholder_text: None,
148 rise: None,
149 rise_set: None,
150 scale: None,
151 scale_set: None,
152 single_paragraph_mode: None,
153 size: None,
154 size_points: None,
155 size_set: None,
156 stretch: None,
157 stretch_set: None,
158 strikethrough: None,
159 strikethrough_set: None,
160 style: None,
161 style_set: None,
162 text: None,
163 underline: None,
164 underline_set: None,
165 variant: None,
166 variant_set: None,
167 weight: None,
168 weight_set: None,
169 width_chars: None,
170 wrap_mode: None,
171 wrap_width: None,
172 cell_background: None,
173 cell_background_rgba: None,
174 cell_background_set: None,
175 height: None,
176 is_expanded: None,
177 is_expander: None,
178 mode: None,
179 sensitive: None,
180 visible: None,
181 width: None,
182 xalign: None,
183 xpad: None,
184 yalign: None,
185 ypad: None,
186 }
187 }
188
189 pub fn build(self) -> CellRendererAccel {
190 let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
191 if let Some(ref accel_key) = self.accel_key {
192 properties.push(("accel-key", accel_key));
193 }
194 if let Some(ref accel_mode) = self.accel_mode {
195 properties.push(("accel-mode", accel_mode));
196 }
197 if let Some(ref accel_mods) = self.accel_mods {
198 properties.push(("accel-mods", accel_mods));
199 }
200 if let Some(ref keycode) = self.keycode {
201 properties.push(("keycode", keycode));
202 }
203 if let Some(ref align_set) = self.align_set {
204 properties.push(("align-set", align_set));
205 }
206 if let Some(ref alignment) = self.alignment {
207 properties.push(("alignment", alignment));
208 }
209 if let Some(ref attributes) = self.attributes {
210 properties.push(("attributes", attributes));
211 }
212 if let Some(ref background) = self.background {
213 properties.push(("background", background));
214 }
215 if let Some(ref background_rgba) = self.background_rgba {
216 properties.push(("background-rgba", background_rgba));
217 }
218 if let Some(ref background_set) = self.background_set {
219 properties.push(("background-set", background_set));
220 }
221 if let Some(ref editable) = self.editable {
222 properties.push(("editable", editable));
223 }
224 if let Some(ref editable_set) = self.editable_set {
225 properties.push(("editable-set", editable_set));
226 }
227 if let Some(ref ellipsize) = self.ellipsize {
228 properties.push(("ellipsize", ellipsize));
229 }
230 if let Some(ref ellipsize_set) = self.ellipsize_set {
231 properties.push(("ellipsize-set", ellipsize_set));
232 }
233 if let Some(ref family) = self.family {
234 properties.push(("family", family));
235 }
236 if let Some(ref family_set) = self.family_set {
237 properties.push(("family-set", family_set));
238 }
239 if let Some(ref font) = self.font {
240 properties.push(("font", font));
241 }
242 if let Some(ref font_desc) = self.font_desc {
243 properties.push(("font-desc", font_desc));
244 }
245 if let Some(ref foreground) = self.foreground {
246 properties.push(("foreground", foreground));
247 }
248 if let Some(ref foreground_rgba) = self.foreground_rgba {
249 properties.push(("foreground-rgba", foreground_rgba));
250 }
251 if let Some(ref foreground_set) = self.foreground_set {
252 properties.push(("foreground-set", foreground_set));
253 }
254 if let Some(ref language) = self.language {
255 properties.push(("language", language));
256 }
257 if let Some(ref language_set) = self.language_set {
258 properties.push(("language-set", language_set));
259 }
260 if let Some(ref markup) = self.markup {
261 properties.push(("markup", markup));
262 }
263 if let Some(ref max_width_chars) = self.max_width_chars {
264 properties.push(("max-width-chars", max_width_chars));
265 }
266 if let Some(ref placeholder_text) = self.placeholder_text {
267 properties.push(("placeholder-text", placeholder_text));
268 }
269 if let Some(ref rise) = self.rise {
270 properties.push(("rise", rise));
271 }
272 if let Some(ref rise_set) = self.rise_set {
273 properties.push(("rise-set", rise_set));
274 }
275 if let Some(ref scale) = self.scale {
276 properties.push(("scale", scale));
277 }
278 if let Some(ref scale_set) = self.scale_set {
279 properties.push(("scale-set", scale_set));
280 }
281 if let Some(ref single_paragraph_mode) = self.single_paragraph_mode {
282 properties.push(("single-paragraph-mode", single_paragraph_mode));
283 }
284 if let Some(ref size) = self.size {
285 properties.push(("size", size));
286 }
287 if let Some(ref size_points) = self.size_points {
288 properties.push(("size-points", size_points));
289 }
290 if let Some(ref size_set) = self.size_set {
291 properties.push(("size-set", size_set));
292 }
293 if let Some(ref stretch) = self.stretch {
294 properties.push(("stretch", stretch));
295 }
296 if let Some(ref stretch_set) = self.stretch_set {
297 properties.push(("stretch-set", stretch_set));
298 }
299 if let Some(ref strikethrough) = self.strikethrough {
300 properties.push(("strikethrough", strikethrough));
301 }
302 if let Some(ref strikethrough_set) = self.strikethrough_set {
303 properties.push(("strikethrough-set", strikethrough_set));
304 }
305 if let Some(ref style) = self.style {
306 properties.push(("style", style));
307 }
308 if let Some(ref style_set) = self.style_set {
309 properties.push(("style-set", style_set));
310 }
311 if let Some(ref text) = self.text {
312 properties.push(("text", text));
313 }
314 if let Some(ref underline) = self.underline {
315 properties.push(("underline", underline));
316 }
317 if let Some(ref underline_set) = self.underline_set {
318 properties.push(("underline-set", underline_set));
319 }
320 if let Some(ref variant) = self.variant {
321 properties.push(("variant", variant));
322 }
323 if let Some(ref variant_set) = self.variant_set {
324 properties.push(("variant-set", variant_set));
325 }
326 if let Some(ref weight) = self.weight {
327 properties.push(("weight", weight));
328 }
329 if let Some(ref weight_set) = self.weight_set {
330 properties.push(("weight-set", weight_set));
331 }
332 if let Some(ref width_chars) = self.width_chars {
333 properties.push(("width-chars", width_chars));
334 }
335 if let Some(ref wrap_mode) = self.wrap_mode {
336 properties.push(("wrap-mode", wrap_mode));
337 }
338 if let Some(ref wrap_width) = self.wrap_width {
339 properties.push(("wrap-width", wrap_width));
340 }
341 if let Some(ref cell_background) = self.cell_background {
342 properties.push(("cell-background", cell_background));
343 }
344 if let Some(ref cell_background_rgba) = self.cell_background_rgba {
345 properties.push(("cell-background-rgba", cell_background_rgba));
346 }
347 if let Some(ref cell_background_set) = self.cell_background_set {
348 properties.push(("cell-background-set", cell_background_set));
349 }
350 if let Some(ref height) = self.height {
351 properties.push(("height", height));
352 }
353 if let Some(ref is_expanded) = self.is_expanded {
354 properties.push(("is-expanded", is_expanded));
355 }
356 if let Some(ref is_expander) = self.is_expander {
357 properties.push(("is-expander", is_expander));
358 }
359 if let Some(ref mode) = self.mode {
360 properties.push(("mode", mode));
361 }
362 if let Some(ref sensitive) = self.sensitive {
363 properties.push(("sensitive", sensitive));
364 }
365 if let Some(ref visible) = self.visible {
366 properties.push(("visible", visible));
367 }
368 if let Some(ref width) = self.width {
369 properties.push(("width", width));
370 }
371 if let Some(ref xalign) = self.xalign {
372 properties.push(("xalign", xalign));
373 }
374 if let Some(ref xpad) = self.xpad {
375 properties.push(("xpad", xpad));
376 }
377 if let Some(ref yalign) = self.yalign {
378 properties.push(("yalign", yalign));
379 }
380 if let Some(ref ypad) = self.ypad {
381 properties.push(("ypad", ypad));
382 }
383 glib::Object::new(CellRendererAccel::static_type(), &properties)
384 .expect("object new")
385 .downcast()
386 .expect("downcast")
387 }
388
389 pub fn accel_key(mut self, accel_key: u32) -> Self {
390 self.accel_key = Some(accel_key);
391 self
392 }
393
394 pub fn accel_mode(mut self, accel_mode: CellRendererAccelMode) -> Self {
395 self.accel_mode = Some(accel_mode);
396 self
397 }
398
399 pub fn accel_mods(mut self, accel_mods: gdk::ModifierType) -> Self {
400 self.accel_mods = Some(accel_mods);
401 self
402 }
403
404 pub fn keycode(mut self, keycode: u32) -> Self {
405 self.keycode = Some(keycode);
406 self
407 }
408
409 pub fn align_set(mut self, align_set: bool) -> Self {
410 self.align_set = Some(align_set);
411 self
412 }
413
414 pub fn alignment(mut self, alignment: pango::Alignment) -> Self {
415 self.alignment = Some(alignment);
416 self
417 }
418
419 pub fn attributes(mut self, attributes: &pango::AttrList) -> Self {
420 self.attributes = Some(attributes.clone());
421 self
422 }
423
424 pub fn background(mut self, background: &str) -> Self {
425 self.background = Some(background.to_string());
426 self
427 }
428
429 pub fn background_rgba(mut self, background_rgba: &gdk::RGBA) -> Self {
430 self.background_rgba = Some(background_rgba.clone());
431 self
432 }
433
434 pub fn background_set(mut self, background_set: bool) -> Self {
435 self.background_set = Some(background_set);
436 self
437 }
438
439 pub fn editable(mut self, editable: bool) -> Self {
440 self.editable = Some(editable);
441 self
442 }
443
444 pub fn editable_set(mut self, editable_set: bool) -> Self {
445 self.editable_set = Some(editable_set);
446 self
447 }
448
449 pub fn ellipsize(mut self, ellipsize: pango::EllipsizeMode) -> Self {
450 self.ellipsize = Some(ellipsize);
451 self
452 }
453
454 pub fn ellipsize_set(mut self, ellipsize_set: bool) -> Self {
455 self.ellipsize_set = Some(ellipsize_set);
456 self
457 }
458
459 pub fn family(mut self, family: &str) -> Self {
460 self.family = Some(family.to_string());
461 self
462 }
463
464 pub fn family_set(mut self, family_set: bool) -> Self {
465 self.family_set = Some(family_set);
466 self
467 }
468
469 pub fn font(mut self, font: &str) -> Self {
470 self.font = Some(font.to_string());
471 self
472 }
473
474 pub fn font_desc(mut self, font_desc: &pango::FontDescription) -> Self {
475 self.font_desc = Some(font_desc.clone());
476 self
477 }
478
479 pub fn foreground(mut self, foreground: &str) -> Self {
480 self.foreground = Some(foreground.to_string());
481 self
482 }
483
484 pub fn foreground_rgba(mut self, foreground_rgba: &gdk::RGBA) -> Self {
485 self.foreground_rgba = Some(foreground_rgba.clone());
486 self
487 }
488
489 pub fn foreground_set(mut self, foreground_set: bool) -> Self {
490 self.foreground_set = Some(foreground_set);
491 self
492 }
493
494 pub fn language(mut self, language: &str) -> Self {
495 self.language = Some(language.to_string());
496 self
497 }
498
499 pub fn language_set(mut self, language_set: bool) -> Self {
500 self.language_set = Some(language_set);
501 self
502 }
503
504 pub fn markup(mut self, markup: &str) -> Self {
505 self.markup = Some(markup.to_string());
506 self
507 }
508
509 pub fn max_width_chars(mut self, max_width_chars: i32) -> Self {
510 self.max_width_chars = Some(max_width_chars);
511 self
512 }
513
514 pub fn placeholder_text(mut self, placeholder_text: &str) -> Self {
515 self.placeholder_text = Some(placeholder_text.to_string());
516 self
517 }
518
519 pub fn rise(mut self, rise: i32) -> Self {
520 self.rise = Some(rise);
521 self
522 }
523
524 pub fn rise_set(mut self, rise_set: bool) -> Self {
525 self.rise_set = Some(rise_set);
526 self
527 }
528
529 pub fn scale(mut self, scale: f64) -> Self {
530 self.scale = Some(scale);
531 self
532 }
533
534 pub fn scale_set(mut self, scale_set: bool) -> Self {
535 self.scale_set = Some(scale_set);
536 self
537 }
538
539 pub fn single_paragraph_mode(mut self, single_paragraph_mode: bool) -> Self {
540 self.single_paragraph_mode = Some(single_paragraph_mode);
541 self
542 }
543
544 pub fn size(mut self, size: i32) -> Self {
545 self.size = Some(size);
546 self
547 }
548
549 pub fn size_points(mut self, size_points: f64) -> Self {
550 self.size_points = Some(size_points);
551 self
552 }
553
554 pub fn size_set(mut self, size_set: bool) -> Self {
555 self.size_set = Some(size_set);
556 self
557 }
558
559 pub fn stretch(mut self, stretch: pango::Stretch) -> Self {
560 self.stretch = Some(stretch);
561 self
562 }
563
564 pub fn stretch_set(mut self, stretch_set: bool) -> Self {
565 self.stretch_set = Some(stretch_set);
566 self
567 }
568
569 pub fn strikethrough(mut self, strikethrough: bool) -> Self {
570 self.strikethrough = Some(strikethrough);
571 self
572 }
573
574 pub fn strikethrough_set(mut self, strikethrough_set: bool) -> Self {
575 self.strikethrough_set = Some(strikethrough_set);
576 self
577 }
578
579 pub fn style(mut self, style: pango::Style) -> Self {
580 self.style = Some(style);
581 self
582 }
583
584 pub fn style_set(mut self, style_set: bool) -> Self {
585 self.style_set = Some(style_set);
586 self
587 }
588
589 pub fn text(mut self, text: &str) -> Self {
590 self.text = Some(text.to_string());
591 self
592 }
593
594 pub fn underline(mut self, underline: pango::Underline) -> Self {
595 self.underline = Some(underline);
596 self
597 }
598
599 pub fn underline_set(mut self, underline_set: bool) -> Self {
600 self.underline_set = Some(underline_set);
601 self
602 }
603
604 pub fn variant(mut self, variant: pango::Variant) -> Self {
605 self.variant = Some(variant);
606 self
607 }
608
609 pub fn variant_set(mut self, variant_set: bool) -> Self {
610 self.variant_set = Some(variant_set);
611 self
612 }
613
614 pub fn weight(mut self, weight: i32) -> Self {
615 self.weight = Some(weight);
616 self
617 }
618
619 pub fn weight_set(mut self, weight_set: bool) -> Self {
620 self.weight_set = Some(weight_set);
621 self
622 }
623
624 pub fn width_chars(mut self, width_chars: i32) -> Self {
625 self.width_chars = Some(width_chars);
626 self
627 }
628
629 pub fn wrap_mode(mut self, wrap_mode: pango::WrapMode) -> Self {
630 self.wrap_mode = Some(wrap_mode);
631 self
632 }
633
634 pub fn wrap_width(mut self, wrap_width: i32) -> Self {
635 self.wrap_width = Some(wrap_width);
636 self
637 }
638
639 pub fn cell_background(mut self, cell_background: &str) -> Self {
640 self.cell_background = Some(cell_background.to_string());
641 self
642 }
643
644 pub fn cell_background_rgba(mut self, cell_background_rgba: &gdk::RGBA) -> Self {
645 self.cell_background_rgba = Some(cell_background_rgba.clone());
646 self
647 }
648
649 pub fn cell_background_set(mut self, cell_background_set: bool) -> Self {
650 self.cell_background_set = Some(cell_background_set);
651 self
652 }
653
654 pub fn height(mut self, height: i32) -> Self {
655 self.height = Some(height);
656 self
657 }
658
659 pub fn is_expanded(mut self, is_expanded: bool) -> Self {
660 self.is_expanded = Some(is_expanded);
661 self
662 }
663
664 pub fn is_expander(mut self, is_expander: bool) -> Self {
665 self.is_expander = Some(is_expander);
666 self
667 }
668
669 pub fn mode(mut self, mode: CellRendererMode) -> Self {
670 self.mode = Some(mode);
671 self
672 }
673
674 pub fn sensitive(mut self, sensitive: bool) -> Self {
675 self.sensitive = Some(sensitive);
676 self
677 }
678
679 pub fn visible(mut self, visible: bool) -> Self {
680 self.visible = Some(visible);
681 self
682 }
683
684 pub fn width(mut self, width: i32) -> Self {
685 self.width = Some(width);
686 self
687 }
688
689 pub fn xalign(mut self, xalign: f32) -> Self {
690 self.xalign = Some(xalign);
691 self
692 }
693
694 pub fn xpad(mut self, xpad: u32) -> Self {
695 self.xpad = Some(xpad);
696 self
697 }
698
699 pub fn yalign(mut self, yalign: f32) -> Self {
700 self.yalign = Some(yalign);
701 self
702 }
703
704 pub fn ypad(mut self, ypad: u32) -> Self {
705 self.ypad = Some(ypad);
706 self
707 }
708}
709
710pub const NONE_CELL_RENDERER_ACCEL: Option<&CellRendererAccel> = None;
711
712pub trait CellRendererAccelExt: 'static {
713 fn get_property_accel_key(&self) -> u32;
714
715 fn set_property_accel_key(&self, accel_key: u32);
716
717 fn get_property_accel_mode(&self) -> CellRendererAccelMode;
718
719 fn set_property_accel_mode(&self, accel_mode: CellRendererAccelMode);
720
721 fn get_property_accel_mods(&self) -> gdk::ModifierType;
722
723 fn set_property_accel_mods(&self, accel_mods: gdk::ModifierType);
724
725 fn get_property_keycode(&self) -> u32;
726
727 fn set_property_keycode(&self, keycode: u32);
728
729 fn connect_accel_cleared<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId;
730
731 fn connect_accel_edited<F: Fn(&Self, TreePath, u32, gdk::ModifierType, u32) + 'static>(
732 &self,
733 f: F,
734 ) -> SignalHandlerId;
735
736 fn connect_property_accel_key_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
737
738 fn connect_property_accel_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
739
740 fn connect_property_accel_mods_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
741
742 fn connect_property_keycode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
743}
744
745impl<O: IsA<CellRendererAccel>> CellRendererAccelExt for O {
746 fn get_property_accel_key(&self) -> u32 {
747 unsafe {
748 let mut value = Value::from_type(<u32 as StaticType>::static_type());
749 gobject_sys::g_object_get_property(
750 self.to_glib_none().0 as *mut gobject_sys::GObject,
751 b"accel-key\0".as_ptr() as *const _,
752 value.to_glib_none_mut().0,
753 );
754 value.get().unwrap()
755 }
756 }
757
758 fn set_property_accel_key(&self, accel_key: u32) {
759 unsafe {
760 gobject_sys::g_object_set_property(
761 self.to_glib_none().0 as *mut gobject_sys::GObject,
762 b"accel-key\0".as_ptr() as *const _,
763 Value::from(&accel_key).to_glib_none().0,
764 );
765 }
766 }
767
768 fn get_property_accel_mode(&self) -> CellRendererAccelMode {
769 unsafe {
770 let mut value = Value::from_type(<CellRendererAccelMode as StaticType>::static_type());
771 gobject_sys::g_object_get_property(
772 self.to_glib_none().0 as *mut gobject_sys::GObject,
773 b"accel-mode\0".as_ptr() as *const _,
774 value.to_glib_none_mut().0,
775 );
776 value.get().unwrap()
777 }
778 }
779
780 fn set_property_accel_mode(&self, accel_mode: CellRendererAccelMode) {
781 unsafe {
782 gobject_sys::g_object_set_property(
783 self.to_glib_none().0 as *mut gobject_sys::GObject,
784 b"accel-mode\0".as_ptr() as *const _,
785 Value::from(&accel_mode).to_glib_none().0,
786 );
787 }
788 }
789
790 fn get_property_accel_mods(&self) -> gdk::ModifierType {
791 unsafe {
792 let mut value = Value::from_type(<gdk::ModifierType as StaticType>::static_type());
793 gobject_sys::g_object_get_property(
794 self.to_glib_none().0 as *mut gobject_sys::GObject,
795 b"accel-mods\0".as_ptr() as *const _,
796 value.to_glib_none_mut().0,
797 );
798 value.get().unwrap()
799 }
800 }
801
802 fn set_property_accel_mods(&self, accel_mods: gdk::ModifierType) {
803 unsafe {
804 gobject_sys::g_object_set_property(
805 self.to_glib_none().0 as *mut gobject_sys::GObject,
806 b"accel-mods\0".as_ptr() as *const _,
807 Value::from(&accel_mods).to_glib_none().0,
808 );
809 }
810 }
811
812 fn get_property_keycode(&self) -> u32 {
813 unsafe {
814 let mut value = Value::from_type(<u32 as StaticType>::static_type());
815 gobject_sys::g_object_get_property(
816 self.to_glib_none().0 as *mut gobject_sys::GObject,
817 b"keycode\0".as_ptr() as *const _,
818 value.to_glib_none_mut().0,
819 );
820 value.get().unwrap()
821 }
822 }
823
824 fn set_property_keycode(&self, keycode: u32) {
825 unsafe {
826 gobject_sys::g_object_set_property(
827 self.to_glib_none().0 as *mut gobject_sys::GObject,
828 b"keycode\0".as_ptr() as *const _,
829 Value::from(&keycode).to_glib_none().0,
830 );
831 }
832 }
833
834 fn connect_accel_cleared<F: Fn(&Self, TreePath) + 'static>(&self, f: F) -> SignalHandlerId {
835 unsafe extern "C" fn accel_cleared_trampoline<P, F: Fn(&P, TreePath) + 'static>(
836 this: *mut gtk_sys::GtkCellRendererAccel,
837 path_string: *mut libc::c_char,
838 f: glib_sys::gpointer,
839 ) where
840 P: IsA<CellRendererAccel>,
841 {
842 let f: &F = &*(f as *const F);
843 let path = from_glib_full(gtk_sys::gtk_tree_path_new_from_string(path_string));
844 f(
845 &CellRendererAccel::from_glib_borrow(this).unsafe_cast(),
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"accel-cleared\0".as_ptr() as *const _,
854 Some(transmute(accel_cleared_trampoline::<Self, F> as usize)),
855 Box_::into_raw(f),
856 )
857 }
858 }
859
860 fn connect_accel_edited<F: Fn(&Self, TreePath, u32, gdk::ModifierType, u32) + 'static>(
861 &self,
862 f: F,
863 ) -> SignalHandlerId {
864 unsafe extern "C" fn accel_edited_trampoline<
865 P,
866 F: Fn(&P, TreePath, u32, gdk::ModifierType, u32) + 'static,
867 >(
868 this: *mut gtk_sys::GtkCellRendererAccel,
869 path_string: *mut libc::c_char,
870 accel_key: libc::c_uint,
871 accel_mods: gdk_sys::GdkModifierType,
872 hardware_keycode: libc::c_uint,
873 f: glib_sys::gpointer,
874 ) where
875 P: IsA<CellRendererAccel>,
876 {
877 let f: &F = &*(f as *const F);
878 let path = from_glib_full(gtk_sys::gtk_tree_path_new_from_string(path_string));
879 f(
880 &CellRendererAccel::from_glib_borrow(this).unsafe_cast(),
881 path,
882 accel_key,
883 from_glib(accel_mods),
884 hardware_keycode,
885 )
886 }
887 unsafe {
888 let f: Box_<F> = Box_::new(f);
889 connect_raw(
890 self.as_ptr() as *mut _,
891 b"accel-edited\0".as_ptr() as *const _,
892 Some(transmute(accel_edited_trampoline::<Self, F> as usize)),
893 Box_::into_raw(f),
894 )
895 }
896 }
897
898 fn connect_property_accel_key_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
899 unsafe extern "C" fn notify_accel_key_trampoline<P, F: Fn(&P) + 'static>(
900 this: *mut gtk_sys::GtkCellRendererAccel,
901 _param_spec: glib_sys::gpointer,
902 f: glib_sys::gpointer,
903 ) where
904 P: IsA<CellRendererAccel>,
905 {
906 let f: &F = &*(f as *const F);
907 f(&CellRendererAccel::from_glib_borrow(this).unsafe_cast())
908 }
909 unsafe {
910 let f: Box_<F> = Box_::new(f);
911 connect_raw(
912 self.as_ptr() as *mut _,
913 b"notify::accel-key\0".as_ptr() as *const _,
914 Some(transmute(notify_accel_key_trampoline::<Self, F> as usize)),
915 Box_::into_raw(f),
916 )
917 }
918 }
919
920 fn connect_property_accel_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
921 unsafe extern "C" fn notify_accel_mode_trampoline<P, F: Fn(&P) + 'static>(
922 this: *mut gtk_sys::GtkCellRendererAccel,
923 _param_spec: glib_sys::gpointer,
924 f: glib_sys::gpointer,
925 ) where
926 P: IsA<CellRendererAccel>,
927 {
928 let f: &F = &*(f as *const F);
929 f(&CellRendererAccel::from_glib_borrow(this).unsafe_cast())
930 }
931 unsafe {
932 let f: Box_<F> = Box_::new(f);
933 connect_raw(
934 self.as_ptr() as *mut _,
935 b"notify::accel-mode\0".as_ptr() as *const _,
936 Some(transmute(notify_accel_mode_trampoline::<Self, F> as usize)),
937 Box_::into_raw(f),
938 )
939 }
940 }
941
942 fn connect_property_accel_mods_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
943 unsafe extern "C" fn notify_accel_mods_trampoline<P, F: Fn(&P) + 'static>(
944 this: *mut gtk_sys::GtkCellRendererAccel,
945 _param_spec: glib_sys::gpointer,
946 f: glib_sys::gpointer,
947 ) where
948 P: IsA<CellRendererAccel>,
949 {
950 let f: &F = &*(f as *const F);
951 f(&CellRendererAccel::from_glib_borrow(this).unsafe_cast())
952 }
953 unsafe {
954 let f: Box_<F> = Box_::new(f);
955 connect_raw(
956 self.as_ptr() as *mut _,
957 b"notify::accel-mods\0".as_ptr() as *const _,
958 Some(transmute(notify_accel_mods_trampoline::<Self, F> as usize)),
959 Box_::into_raw(f),
960 )
961 }
962 }
963
964 fn connect_property_keycode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
965 unsafe extern "C" fn notify_keycode_trampoline<P, F: Fn(&P) + 'static>(
966 this: *mut gtk_sys::GtkCellRendererAccel,
967 _param_spec: glib_sys::gpointer,
968 f: glib_sys::gpointer,
969 ) where
970 P: IsA<CellRendererAccel>,
971 {
972 let f: &F = &*(f as *const F);
973 f(&CellRendererAccel::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::keycode\0".as_ptr() as *const _,
980 Some(transmute(notify_keycode_trampoline::<Self, F> as usize)),
981 Box_::into_raw(f),
982 )
983 }
984 }
985}
986
987impl fmt::Display for CellRendererAccel {
988 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
989 write!(f, "CellRendererAccel")
990 }
991}