gtk4/auto/
cell_renderer_text.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#![allow(deprecated)]
5
6use crate::{ffi, CellRenderer, CellRendererMode, TreePath};
7use glib::{
8    object::ObjectType as _,
9    prelude::*,
10    signal::{connect_raw, SignalHandlerId},
11    translate::*,
12};
13use std::boxed::Box as Box_;
14
15glib::wrapper! {
16    #[doc(alias = "GtkCellRendererText")]
17    pub struct CellRendererText(Object<ffi::GtkCellRendererText, ffi::GtkCellRendererTextClass>) @extends CellRenderer;
18
19    match fn {
20        type_ => || ffi::gtk_cell_renderer_text_get_type(),
21    }
22}
23
24impl CellRendererText {
25    pub const NONE: Option<&'static CellRendererText> = None;
26
27    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
28    #[allow(deprecated)]
29    #[doc(alias = "gtk_cell_renderer_text_new")]
30    pub fn new() -> CellRendererText {
31        assert_initialized_main_thread!();
32        unsafe { CellRenderer::from_glib_none(ffi::gtk_cell_renderer_text_new()).unsafe_cast() }
33    }
34
35    // rustdoc-stripper-ignore-next
36    /// Creates a new builder-pattern struct instance to construct [`CellRendererText`] objects.
37    ///
38    /// This method returns an instance of [`CellRendererTextBuilder`](crate::builders::CellRendererTextBuilder) which can be used to create [`CellRendererText`] objects.
39    pub fn builder() -> CellRendererTextBuilder {
40        CellRendererTextBuilder::new()
41    }
42}
43
44impl Default for CellRendererText {
45    fn default() -> Self {
46        Self::new()
47    }
48}
49
50// rustdoc-stripper-ignore-next
51/// A [builder-pattern] type to construct [`CellRendererText`] objects.
52///
53/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
54#[must_use = "The builder must be built to be used"]
55pub struct CellRendererTextBuilder {
56    builder: glib::object::ObjectBuilder<'static, CellRendererText>,
57}
58
59impl CellRendererTextBuilder {
60    fn new() -> Self {
61        Self {
62            builder: glib::object::Object::builder(),
63        }
64    }
65
66    pub fn align_set(self, align_set: bool) -> Self {
67        Self {
68            builder: self.builder.property("align-set", align_set),
69        }
70    }
71
72    pub fn alignment(self, alignment: pango::Alignment) -> Self {
73        Self {
74            builder: self.builder.property("alignment", alignment),
75        }
76    }
77
78    pub fn attributes(self, attributes: &pango::AttrList) -> Self {
79        Self {
80            builder: self.builder.property("attributes", attributes.clone()),
81        }
82    }
83
84    pub fn background(self, background: impl Into<glib::GString>) -> Self {
85        Self {
86            builder: self.builder.property("background", background.into()),
87        }
88    }
89
90    pub fn background_rgba(self, background_rgba: &gdk::RGBA) -> Self {
91        Self {
92            builder: self.builder.property("background-rgba", background_rgba),
93        }
94    }
95
96    pub fn background_set(self, background_set: bool) -> Self {
97        Self {
98            builder: self.builder.property("background-set", background_set),
99        }
100    }
101
102    pub fn editable(self, editable: bool) -> Self {
103        Self {
104            builder: self.builder.property("editable", editable),
105        }
106    }
107
108    pub fn editable_set(self, editable_set: bool) -> Self {
109        Self {
110            builder: self.builder.property("editable-set", editable_set),
111        }
112    }
113
114    pub fn ellipsize(self, ellipsize: pango::EllipsizeMode) -> Self {
115        Self {
116            builder: self.builder.property("ellipsize", ellipsize),
117        }
118    }
119
120    pub fn ellipsize_set(self, ellipsize_set: bool) -> Self {
121        Self {
122            builder: self.builder.property("ellipsize-set", ellipsize_set),
123        }
124    }
125
126    pub fn family(self, family: impl Into<glib::GString>) -> Self {
127        Self {
128            builder: self.builder.property("family", family.into()),
129        }
130    }
131
132    pub fn family_set(self, family_set: bool) -> Self {
133        Self {
134            builder: self.builder.property("family-set", family_set),
135        }
136    }
137
138    pub fn font(self, font: impl Into<glib::GString>) -> Self {
139        Self {
140            builder: self.builder.property("font", font.into()),
141        }
142    }
143
144    pub fn font_desc(self, font_desc: &pango::FontDescription) -> Self {
145        Self {
146            builder: self.builder.property("font-desc", font_desc),
147        }
148    }
149
150    pub fn foreground(self, foreground: impl Into<glib::GString>) -> Self {
151        Self {
152            builder: self.builder.property("foreground", foreground.into()),
153        }
154    }
155
156    pub fn foreground_rgba(self, foreground_rgba: &gdk::RGBA) -> Self {
157        Self {
158            builder: self.builder.property("foreground-rgba", foreground_rgba),
159        }
160    }
161
162    pub fn foreground_set(self, foreground_set: bool) -> Self {
163        Self {
164            builder: self.builder.property("foreground-set", foreground_set),
165        }
166    }
167
168    pub fn language(self, language: impl Into<glib::GString>) -> Self {
169        Self {
170            builder: self.builder.property("language", language.into()),
171        }
172    }
173
174    pub fn language_set(self, language_set: bool) -> Self {
175        Self {
176            builder: self.builder.property("language-set", language_set),
177        }
178    }
179
180    pub fn markup(self, markup: impl Into<glib::GString>) -> Self {
181        Self {
182            builder: self.builder.property("markup", markup.into()),
183        }
184    }
185
186    pub fn max_width_chars(self, max_width_chars: i32) -> Self {
187        Self {
188            builder: self.builder.property("max-width-chars", max_width_chars),
189        }
190    }
191
192    pub fn placeholder_text(self, placeholder_text: impl Into<glib::GString>) -> Self {
193        Self {
194            builder: self
195                .builder
196                .property("placeholder-text", placeholder_text.into()),
197        }
198    }
199
200    pub fn rise(self, rise: i32) -> Self {
201        Self {
202            builder: self.builder.property("rise", rise),
203        }
204    }
205
206    pub fn rise_set(self, rise_set: bool) -> Self {
207        Self {
208            builder: self.builder.property("rise-set", rise_set),
209        }
210    }
211
212    pub fn scale(self, scale: f64) -> Self {
213        Self {
214            builder: self.builder.property("scale", scale),
215        }
216    }
217
218    pub fn scale_set(self, scale_set: bool) -> Self {
219        Self {
220            builder: self.builder.property("scale-set", scale_set),
221        }
222    }
223
224    pub fn single_paragraph_mode(self, single_paragraph_mode: bool) -> Self {
225        Self {
226            builder: self
227                .builder
228                .property("single-paragraph-mode", single_paragraph_mode),
229        }
230    }
231
232    pub fn size(self, size: i32) -> Self {
233        Self {
234            builder: self.builder.property("size", size),
235        }
236    }
237
238    pub fn size_points(self, size_points: f64) -> Self {
239        Self {
240            builder: self.builder.property("size-points", size_points),
241        }
242    }
243
244    pub fn size_set(self, size_set: bool) -> Self {
245        Self {
246            builder: self.builder.property("size-set", size_set),
247        }
248    }
249
250    pub fn stretch(self, stretch: pango::Stretch) -> Self {
251        Self {
252            builder: self.builder.property("stretch", stretch),
253        }
254    }
255
256    pub fn stretch_set(self, stretch_set: bool) -> Self {
257        Self {
258            builder: self.builder.property("stretch-set", stretch_set),
259        }
260    }
261
262    pub fn strikethrough(self, strikethrough: bool) -> Self {
263        Self {
264            builder: self.builder.property("strikethrough", strikethrough),
265        }
266    }
267
268    pub fn strikethrough_set(self, strikethrough_set: bool) -> Self {
269        Self {
270            builder: self
271                .builder
272                .property("strikethrough-set", strikethrough_set),
273        }
274    }
275
276    pub fn style(self, style: pango::Style) -> Self {
277        Self {
278            builder: self.builder.property("style", style),
279        }
280    }
281
282    pub fn style_set(self, style_set: bool) -> Self {
283        Self {
284            builder: self.builder.property("style-set", style_set),
285        }
286    }
287
288    pub fn text(self, text: impl Into<glib::GString>) -> Self {
289        Self {
290            builder: self.builder.property("text", text.into()),
291        }
292    }
293
294    pub fn underline(self, underline: pango::Underline) -> Self {
295        Self {
296            builder: self.builder.property("underline", underline),
297        }
298    }
299
300    pub fn underline_set(self, underline_set: bool) -> Self {
301        Self {
302            builder: self.builder.property("underline-set", underline_set),
303        }
304    }
305
306    pub fn variant(self, variant: pango::Variant) -> Self {
307        Self {
308            builder: self.builder.property("variant", variant),
309        }
310    }
311
312    pub fn variant_set(self, variant_set: bool) -> Self {
313        Self {
314            builder: self.builder.property("variant-set", variant_set),
315        }
316    }
317
318    pub fn weight(self, weight: i32) -> Self {
319        Self {
320            builder: self.builder.property("weight", weight),
321        }
322    }
323
324    pub fn weight_set(self, weight_set: bool) -> Self {
325        Self {
326            builder: self.builder.property("weight-set", weight_set),
327        }
328    }
329
330    pub fn width_chars(self, width_chars: i32) -> Self {
331        Self {
332            builder: self.builder.property("width-chars", width_chars),
333        }
334    }
335
336    pub fn wrap_mode(self, wrap_mode: pango::WrapMode) -> Self {
337        Self {
338            builder: self.builder.property("wrap-mode", wrap_mode),
339        }
340    }
341
342    pub fn wrap_width(self, wrap_width: i32) -> Self {
343        Self {
344            builder: self.builder.property("wrap-width", wrap_width),
345        }
346    }
347
348    pub fn cell_background(self, cell_background: impl Into<glib::GString>) -> Self {
349        Self {
350            builder: self
351                .builder
352                .property("cell-background", cell_background.into()),
353        }
354    }
355
356    pub fn cell_background_rgba(self, cell_background_rgba: &gdk::RGBA) -> Self {
357        Self {
358            builder: self
359                .builder
360                .property("cell-background-rgba", cell_background_rgba),
361        }
362    }
363
364    pub fn cell_background_set(self, cell_background_set: bool) -> Self {
365        Self {
366            builder: self
367                .builder
368                .property("cell-background-set", cell_background_set),
369        }
370    }
371
372    pub fn height(self, height: i32) -> Self {
373        Self {
374            builder: self.builder.property("height", height),
375        }
376    }
377
378    pub fn is_expanded(self, is_expanded: bool) -> Self {
379        Self {
380            builder: self.builder.property("is-expanded", is_expanded),
381        }
382    }
383
384    pub fn is_expander(self, is_expander: bool) -> Self {
385        Self {
386            builder: self.builder.property("is-expander", is_expander),
387        }
388    }
389
390    pub fn mode(self, mode: CellRendererMode) -> Self {
391        Self {
392            builder: self.builder.property("mode", mode),
393        }
394    }
395
396    pub fn sensitive(self, sensitive: bool) -> Self {
397        Self {
398            builder: self.builder.property("sensitive", sensitive),
399        }
400    }
401
402    pub fn visible(self, visible: bool) -> Self {
403        Self {
404            builder: self.builder.property("visible", visible),
405        }
406    }
407
408    pub fn width(self, width: i32) -> Self {
409        Self {
410            builder: self.builder.property("width", width),
411        }
412    }
413
414    pub fn xalign(self, xalign: f32) -> Self {
415        Self {
416            builder: self.builder.property("xalign", xalign),
417        }
418    }
419
420    pub fn xpad(self, xpad: u32) -> Self {
421        Self {
422            builder: self.builder.property("xpad", xpad),
423        }
424    }
425
426    pub fn yalign(self, yalign: f32) -> Self {
427        Self {
428            builder: self.builder.property("yalign", yalign),
429        }
430    }
431
432    pub fn ypad(self, ypad: u32) -> Self {
433        Self {
434            builder: self.builder.property("ypad", ypad),
435        }
436    }
437
438    // rustdoc-stripper-ignore-next
439    /// Build the [`CellRendererText`].
440    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
441    pub fn build(self) -> CellRendererText {
442        assert_initialized_main_thread!();
443        self.builder.build()
444    }
445}
446
447pub trait CellRendererTextExt: IsA<CellRendererText> + 'static {
448    #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
449    #[allow(deprecated)]
450    #[doc(alias = "gtk_cell_renderer_text_set_fixed_height_from_font")]
451    fn set_fixed_height_from_font(&self, number_of_rows: i32) {
452        unsafe {
453            ffi::gtk_cell_renderer_text_set_fixed_height_from_font(
454                self.as_ref().to_glib_none().0,
455                number_of_rows,
456            );
457        }
458    }
459
460    #[doc(alias = "align-set")]
461    fn is_align_set(&self) -> bool {
462        ObjectExt::property(self.as_ref(), "align-set")
463    }
464
465    fn alignment(&self) -> pango::Alignment {
466        ObjectExt::property(self.as_ref(), "alignment")
467    }
468
469    fn set_alignment(&self, alignment: pango::Alignment) {
470        ObjectExt::set_property(self.as_ref(), "alignment", alignment)
471    }
472
473    fn attributes(&self) -> Option<pango::AttrList> {
474        ObjectExt::property(self.as_ref(), "attributes")
475    }
476
477    fn set_attributes(&self, attributes: Option<&pango::AttrList>) {
478        ObjectExt::set_property(self.as_ref(), "attributes", attributes)
479    }
480
481    fn set_background(&self, background: Option<&str>) {
482        ObjectExt::set_property(self.as_ref(), "background", background)
483    }
484
485    #[doc(alias = "background-rgba")]
486    fn background_rgba(&self) -> Option<gdk::RGBA> {
487        ObjectExt::property(self.as_ref(), "background-rgba")
488    }
489
490    #[doc(alias = "background-rgba")]
491    fn set_background_rgba(&self, background_rgba: Option<&gdk::RGBA>) {
492        ObjectExt::set_property(self.as_ref(), "background-rgba", background_rgba)
493    }
494
495    #[doc(alias = "background-set")]
496    fn is_background_set(&self) -> bool {
497        ObjectExt::property(self.as_ref(), "background-set")
498    }
499
500    fn is_editable(&self) -> bool {
501        ObjectExt::property(self.as_ref(), "editable")
502    }
503
504    fn set_editable(&self, editable: bool) {
505        ObjectExt::set_property(self.as_ref(), "editable", editable)
506    }
507
508    #[doc(alias = "editable-set")]
509    fn is_editable_set(&self) -> bool {
510        ObjectExt::property(self.as_ref(), "editable-set")
511    }
512
513    fn ellipsize(&self) -> pango::EllipsizeMode {
514        ObjectExt::property(self.as_ref(), "ellipsize")
515    }
516
517    fn set_ellipsize(&self, ellipsize: pango::EllipsizeMode) {
518        ObjectExt::set_property(self.as_ref(), "ellipsize", ellipsize)
519    }
520
521    #[doc(alias = "ellipsize-set")]
522    fn is_ellipsize_set(&self) -> bool {
523        ObjectExt::property(self.as_ref(), "ellipsize-set")
524    }
525
526    fn family(&self) -> Option<glib::GString> {
527        ObjectExt::property(self.as_ref(), "family")
528    }
529
530    fn set_family(&self, family: Option<&str>) {
531        ObjectExt::set_property(self.as_ref(), "family", family)
532    }
533
534    #[doc(alias = "family-set")]
535    fn is_family_set(&self) -> bool {
536        ObjectExt::property(self.as_ref(), "family-set")
537    }
538
539    fn font(&self) -> Option<glib::GString> {
540        ObjectExt::property(self.as_ref(), "font")
541    }
542
543    fn set_font(&self, font: Option<&str>) {
544        ObjectExt::set_property(self.as_ref(), "font", font)
545    }
546
547    #[doc(alias = "font-desc")]
548    fn font_desc(&self) -> Option<pango::FontDescription> {
549        ObjectExt::property(self.as_ref(), "font-desc")
550    }
551
552    #[doc(alias = "font-desc")]
553    fn set_font_desc(&self, font_desc: Option<&pango::FontDescription>) {
554        ObjectExt::set_property(self.as_ref(), "font-desc", font_desc)
555    }
556
557    fn set_foreground(&self, foreground: Option<&str>) {
558        ObjectExt::set_property(self.as_ref(), "foreground", foreground)
559    }
560
561    #[doc(alias = "foreground-rgba")]
562    fn foreground_rgba(&self) -> Option<gdk::RGBA> {
563        ObjectExt::property(self.as_ref(), "foreground-rgba")
564    }
565
566    #[doc(alias = "foreground-rgba")]
567    fn set_foreground_rgba(&self, foreground_rgba: Option<&gdk::RGBA>) {
568        ObjectExt::set_property(self.as_ref(), "foreground-rgba", foreground_rgba)
569    }
570
571    #[doc(alias = "foreground-set")]
572    fn is_foreground_set(&self) -> bool {
573        ObjectExt::property(self.as_ref(), "foreground-set")
574    }
575
576    fn language(&self) -> Option<glib::GString> {
577        ObjectExt::property(self.as_ref(), "language")
578    }
579
580    fn set_language(&self, language: Option<&str>) {
581        ObjectExt::set_property(self.as_ref(), "language", language)
582    }
583
584    #[doc(alias = "language-set")]
585    fn is_language_set(&self) -> bool {
586        ObjectExt::property(self.as_ref(), "language-set")
587    }
588
589    fn set_markup(&self, markup: Option<&str>) {
590        ObjectExt::set_property(self.as_ref(), "markup", markup)
591    }
592
593    #[doc(alias = "max-width-chars")]
594    fn max_width_chars(&self) -> i32 {
595        ObjectExt::property(self.as_ref(), "max-width-chars")
596    }
597
598    #[doc(alias = "max-width-chars")]
599    fn set_max_width_chars(&self, max_width_chars: i32) {
600        ObjectExt::set_property(self.as_ref(), "max-width-chars", max_width_chars)
601    }
602
603    #[doc(alias = "placeholder-text")]
604    fn placeholder_text(&self) -> Option<glib::GString> {
605        ObjectExt::property(self.as_ref(), "placeholder-text")
606    }
607
608    #[doc(alias = "placeholder-text")]
609    fn set_placeholder_text(&self, placeholder_text: Option<&str>) {
610        ObjectExt::set_property(self.as_ref(), "placeholder-text", placeholder_text)
611    }
612
613    fn rise(&self) -> i32 {
614        ObjectExt::property(self.as_ref(), "rise")
615    }
616
617    fn set_rise(&self, rise: i32) {
618        ObjectExt::set_property(self.as_ref(), "rise", rise)
619    }
620
621    #[doc(alias = "rise-set")]
622    fn is_rise_set(&self) -> bool {
623        ObjectExt::property(self.as_ref(), "rise-set")
624    }
625
626    fn scale(&self) -> f64 {
627        ObjectExt::property(self.as_ref(), "scale")
628    }
629
630    fn set_scale(&self, scale: f64) {
631        ObjectExt::set_property(self.as_ref(), "scale", scale)
632    }
633
634    #[doc(alias = "scale-set")]
635    fn is_scale_set(&self) -> bool {
636        ObjectExt::property(self.as_ref(), "scale-set")
637    }
638
639    #[doc(alias = "single-paragraph-mode")]
640    fn is_single_paragraph_mode(&self) -> bool {
641        ObjectExt::property(self.as_ref(), "single-paragraph-mode")
642    }
643
644    #[doc(alias = "single-paragraph-mode")]
645    fn set_single_paragraph_mode(&self, single_paragraph_mode: bool) {
646        ObjectExt::set_property(
647            self.as_ref(),
648            "single-paragraph-mode",
649            single_paragraph_mode,
650        )
651    }
652
653    fn size(&self) -> i32 {
654        ObjectExt::property(self.as_ref(), "size")
655    }
656
657    fn set_size(&self, size: i32) {
658        ObjectExt::set_property(self.as_ref(), "size", size)
659    }
660
661    #[doc(alias = "size-points")]
662    fn size_points(&self) -> f64 {
663        ObjectExt::property(self.as_ref(), "size-points")
664    }
665
666    #[doc(alias = "size-points")]
667    fn set_size_points(&self, size_points: f64) {
668        ObjectExt::set_property(self.as_ref(), "size-points", size_points)
669    }
670
671    #[doc(alias = "size-set")]
672    fn is_size_set(&self) -> bool {
673        ObjectExt::property(self.as_ref(), "size-set")
674    }
675
676    fn stretch(&self) -> pango::Stretch {
677        ObjectExt::property(self.as_ref(), "stretch")
678    }
679
680    fn set_stretch(&self, stretch: pango::Stretch) {
681        ObjectExt::set_property(self.as_ref(), "stretch", stretch)
682    }
683
684    #[doc(alias = "stretch-set")]
685    fn is_stretch_set(&self) -> bool {
686        ObjectExt::property(self.as_ref(), "stretch-set")
687    }
688
689    fn is_strikethrough(&self) -> bool {
690        ObjectExt::property(self.as_ref(), "strikethrough")
691    }
692
693    fn set_strikethrough(&self, strikethrough: bool) {
694        ObjectExt::set_property(self.as_ref(), "strikethrough", strikethrough)
695    }
696
697    #[doc(alias = "strikethrough-set")]
698    fn is_strikethrough_set(&self) -> bool {
699        ObjectExt::property(self.as_ref(), "strikethrough-set")
700    }
701
702    fn style(&self) -> pango::Style {
703        ObjectExt::property(self.as_ref(), "style")
704    }
705
706    fn set_style(&self, style: pango::Style) {
707        ObjectExt::set_property(self.as_ref(), "style", style)
708    }
709
710    #[doc(alias = "style-set")]
711    fn is_style_set(&self) -> bool {
712        ObjectExt::property(self.as_ref(), "style-set")
713    }
714
715    fn text(&self) -> Option<glib::GString> {
716        ObjectExt::property(self.as_ref(), "text")
717    }
718
719    fn set_text(&self, text: Option<&str>) {
720        ObjectExt::set_property(self.as_ref(), "text", text)
721    }
722
723    fn underline(&self) -> pango::Underline {
724        ObjectExt::property(self.as_ref(), "underline")
725    }
726
727    fn set_underline(&self, underline: pango::Underline) {
728        ObjectExt::set_property(self.as_ref(), "underline", underline)
729    }
730
731    #[doc(alias = "underline-set")]
732    fn is_underline_set(&self) -> bool {
733        ObjectExt::property(self.as_ref(), "underline-set")
734    }
735
736    fn variant(&self) -> pango::Variant {
737        ObjectExt::property(self.as_ref(), "variant")
738    }
739
740    fn set_variant(&self, variant: pango::Variant) {
741        ObjectExt::set_property(self.as_ref(), "variant", variant)
742    }
743
744    #[doc(alias = "variant-set")]
745    fn is_variant_set(&self) -> bool {
746        ObjectExt::property(self.as_ref(), "variant-set")
747    }
748
749    fn weight(&self) -> i32 {
750        ObjectExt::property(self.as_ref(), "weight")
751    }
752
753    fn set_weight(&self, weight: i32) {
754        ObjectExt::set_property(self.as_ref(), "weight", weight)
755    }
756
757    #[doc(alias = "weight-set")]
758    fn is_weight_set(&self) -> bool {
759        ObjectExt::property(self.as_ref(), "weight-set")
760    }
761
762    #[doc(alias = "width-chars")]
763    fn width_chars(&self) -> i32 {
764        ObjectExt::property(self.as_ref(), "width-chars")
765    }
766
767    #[doc(alias = "width-chars")]
768    fn set_width_chars(&self, width_chars: i32) {
769        ObjectExt::set_property(self.as_ref(), "width-chars", width_chars)
770    }
771
772    #[doc(alias = "wrap-mode")]
773    fn wrap_mode(&self) -> pango::WrapMode {
774        ObjectExt::property(self.as_ref(), "wrap-mode")
775    }
776
777    #[doc(alias = "wrap-mode")]
778    fn set_wrap_mode(&self, wrap_mode: pango::WrapMode) {
779        ObjectExt::set_property(self.as_ref(), "wrap-mode", wrap_mode)
780    }
781
782    #[doc(alias = "wrap-width")]
783    fn wrap_width(&self) -> i32 {
784        ObjectExt::property(self.as_ref(), "wrap-width")
785    }
786
787    #[doc(alias = "wrap-width")]
788    fn set_wrap_width(&self, wrap_width: i32) {
789        ObjectExt::set_property(self.as_ref(), "wrap-width", wrap_width)
790    }
791
792    #[doc(alias = "edited")]
793    fn connect_edited<F: Fn(&Self, TreePath, &str) + 'static>(&self, f: F) -> SignalHandlerId {
794        unsafe extern "C" fn edited_trampoline<
795            P: IsA<CellRendererText>,
796            F: Fn(&P, TreePath, &str) + 'static,
797        >(
798            this: *mut ffi::GtkCellRendererText,
799            path: *mut std::ffi::c_char,
800            new_text: *mut std::ffi::c_char,
801            f: glib::ffi::gpointer,
802        ) {
803            let f: &F = &*(f as *const F);
804            let path = from_glib_full(crate::ffi::gtk_tree_path_new_from_string(path));
805            f(
806                CellRendererText::from_glib_borrow(this).unsafe_cast_ref(),
807                path,
808                &glib::GString::from_glib_borrow(new_text),
809            )
810        }
811        unsafe {
812            let f: Box_<F> = Box_::new(f);
813            connect_raw(
814                self.as_ptr() as *mut _,
815                c"edited".as_ptr() as *const _,
816                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
817                    edited_trampoline::<Self, F> as *const (),
818                )),
819                Box_::into_raw(f),
820            )
821        }
822    }
823
824    #[doc(alias = "align-set")]
825    fn connect_align_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
826        unsafe extern "C" fn notify_align_set_trampoline<
827            P: IsA<CellRendererText>,
828            F: Fn(&P) + 'static,
829        >(
830            this: *mut ffi::GtkCellRendererText,
831            _param_spec: glib::ffi::gpointer,
832            f: glib::ffi::gpointer,
833        ) {
834            let f: &F = &*(f as *const F);
835            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
836        }
837        unsafe {
838            let f: Box_<F> = Box_::new(f);
839            connect_raw(
840                self.as_ptr() as *mut _,
841                c"notify::align-set".as_ptr() as *const _,
842                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
843                    notify_align_set_trampoline::<Self, F> as *const (),
844                )),
845                Box_::into_raw(f),
846            )
847        }
848    }
849
850    #[doc(alias = "alignment")]
851    fn connect_alignment_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
852        unsafe extern "C" fn notify_alignment_trampoline<
853            P: IsA<CellRendererText>,
854            F: Fn(&P) + 'static,
855        >(
856            this: *mut ffi::GtkCellRendererText,
857            _param_spec: glib::ffi::gpointer,
858            f: glib::ffi::gpointer,
859        ) {
860            let f: &F = &*(f as *const F);
861            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
862        }
863        unsafe {
864            let f: Box_<F> = Box_::new(f);
865            connect_raw(
866                self.as_ptr() as *mut _,
867                c"notify::alignment".as_ptr() as *const _,
868                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
869                    notify_alignment_trampoline::<Self, F> as *const (),
870                )),
871                Box_::into_raw(f),
872            )
873        }
874    }
875
876    #[doc(alias = "attributes")]
877    fn connect_attributes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
878        unsafe extern "C" fn notify_attributes_trampoline<
879            P: IsA<CellRendererText>,
880            F: Fn(&P) + 'static,
881        >(
882            this: *mut ffi::GtkCellRendererText,
883            _param_spec: glib::ffi::gpointer,
884            f: glib::ffi::gpointer,
885        ) {
886            let f: &F = &*(f as *const F);
887            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
888        }
889        unsafe {
890            let f: Box_<F> = Box_::new(f);
891            connect_raw(
892                self.as_ptr() as *mut _,
893                c"notify::attributes".as_ptr() as *const _,
894                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
895                    notify_attributes_trampoline::<Self, F> as *const (),
896                )),
897                Box_::into_raw(f),
898            )
899        }
900    }
901
902    #[doc(alias = "background")]
903    fn connect_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
904        unsafe extern "C" fn notify_background_trampoline<
905            P: IsA<CellRendererText>,
906            F: Fn(&P) + 'static,
907        >(
908            this: *mut ffi::GtkCellRendererText,
909            _param_spec: glib::ffi::gpointer,
910            f: glib::ffi::gpointer,
911        ) {
912            let f: &F = &*(f as *const F);
913            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
914        }
915        unsafe {
916            let f: Box_<F> = Box_::new(f);
917            connect_raw(
918                self.as_ptr() as *mut _,
919                c"notify::background".as_ptr() as *const _,
920                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
921                    notify_background_trampoline::<Self, F> as *const (),
922                )),
923                Box_::into_raw(f),
924            )
925        }
926    }
927
928    #[doc(alias = "background-rgba")]
929    fn connect_background_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
930        unsafe extern "C" fn notify_background_rgba_trampoline<
931            P: IsA<CellRendererText>,
932            F: Fn(&P) + 'static,
933        >(
934            this: *mut ffi::GtkCellRendererText,
935            _param_spec: glib::ffi::gpointer,
936            f: glib::ffi::gpointer,
937        ) {
938            let f: &F = &*(f as *const F);
939            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
940        }
941        unsafe {
942            let f: Box_<F> = Box_::new(f);
943            connect_raw(
944                self.as_ptr() as *mut _,
945                c"notify::background-rgba".as_ptr() as *const _,
946                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
947                    notify_background_rgba_trampoline::<Self, F> as *const (),
948                )),
949                Box_::into_raw(f),
950            )
951        }
952    }
953
954    #[doc(alias = "background-set")]
955    fn connect_background_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
956        unsafe extern "C" fn notify_background_set_trampoline<
957            P: IsA<CellRendererText>,
958            F: Fn(&P) + 'static,
959        >(
960            this: *mut ffi::GtkCellRendererText,
961            _param_spec: glib::ffi::gpointer,
962            f: glib::ffi::gpointer,
963        ) {
964            let f: &F = &*(f as *const F);
965            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
966        }
967        unsafe {
968            let f: Box_<F> = Box_::new(f);
969            connect_raw(
970                self.as_ptr() as *mut _,
971                c"notify::background-set".as_ptr() as *const _,
972                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
973                    notify_background_set_trampoline::<Self, F> as *const (),
974                )),
975                Box_::into_raw(f),
976            )
977        }
978    }
979
980    #[doc(alias = "editable")]
981    fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
982        unsafe extern "C" fn notify_editable_trampoline<
983            P: IsA<CellRendererText>,
984            F: Fn(&P) + 'static,
985        >(
986            this: *mut ffi::GtkCellRendererText,
987            _param_spec: glib::ffi::gpointer,
988            f: glib::ffi::gpointer,
989        ) {
990            let f: &F = &*(f as *const F);
991            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
992        }
993        unsafe {
994            let f: Box_<F> = Box_::new(f);
995            connect_raw(
996                self.as_ptr() as *mut _,
997                c"notify::editable".as_ptr() as *const _,
998                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
999                    notify_editable_trampoline::<Self, F> as *const (),
1000                )),
1001                Box_::into_raw(f),
1002            )
1003        }
1004    }
1005
1006    #[doc(alias = "editable-set")]
1007    fn connect_editable_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1008        unsafe extern "C" fn notify_editable_set_trampoline<
1009            P: IsA<CellRendererText>,
1010            F: Fn(&P) + 'static,
1011        >(
1012            this: *mut ffi::GtkCellRendererText,
1013            _param_spec: glib::ffi::gpointer,
1014            f: glib::ffi::gpointer,
1015        ) {
1016            let f: &F = &*(f as *const F);
1017            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1018        }
1019        unsafe {
1020            let f: Box_<F> = Box_::new(f);
1021            connect_raw(
1022                self.as_ptr() as *mut _,
1023                c"notify::editable-set".as_ptr() as *const _,
1024                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1025                    notify_editable_set_trampoline::<Self, F> as *const (),
1026                )),
1027                Box_::into_raw(f),
1028            )
1029        }
1030    }
1031
1032    #[doc(alias = "ellipsize")]
1033    fn connect_ellipsize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1034        unsafe extern "C" fn notify_ellipsize_trampoline<
1035            P: IsA<CellRendererText>,
1036            F: Fn(&P) + 'static,
1037        >(
1038            this: *mut ffi::GtkCellRendererText,
1039            _param_spec: glib::ffi::gpointer,
1040            f: glib::ffi::gpointer,
1041        ) {
1042            let f: &F = &*(f as *const F);
1043            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1044        }
1045        unsafe {
1046            let f: Box_<F> = Box_::new(f);
1047            connect_raw(
1048                self.as_ptr() as *mut _,
1049                c"notify::ellipsize".as_ptr() as *const _,
1050                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1051                    notify_ellipsize_trampoline::<Self, F> as *const (),
1052                )),
1053                Box_::into_raw(f),
1054            )
1055        }
1056    }
1057
1058    #[doc(alias = "ellipsize-set")]
1059    fn connect_ellipsize_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1060        unsafe extern "C" fn notify_ellipsize_set_trampoline<
1061            P: IsA<CellRendererText>,
1062            F: Fn(&P) + 'static,
1063        >(
1064            this: *mut ffi::GtkCellRendererText,
1065            _param_spec: glib::ffi::gpointer,
1066            f: glib::ffi::gpointer,
1067        ) {
1068            let f: &F = &*(f as *const F);
1069            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1070        }
1071        unsafe {
1072            let f: Box_<F> = Box_::new(f);
1073            connect_raw(
1074                self.as_ptr() as *mut _,
1075                c"notify::ellipsize-set".as_ptr() as *const _,
1076                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1077                    notify_ellipsize_set_trampoline::<Self, F> as *const (),
1078                )),
1079                Box_::into_raw(f),
1080            )
1081        }
1082    }
1083
1084    #[doc(alias = "family")]
1085    fn connect_family_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1086        unsafe extern "C" fn notify_family_trampoline<
1087            P: IsA<CellRendererText>,
1088            F: Fn(&P) + 'static,
1089        >(
1090            this: *mut ffi::GtkCellRendererText,
1091            _param_spec: glib::ffi::gpointer,
1092            f: glib::ffi::gpointer,
1093        ) {
1094            let f: &F = &*(f as *const F);
1095            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1096        }
1097        unsafe {
1098            let f: Box_<F> = Box_::new(f);
1099            connect_raw(
1100                self.as_ptr() as *mut _,
1101                c"notify::family".as_ptr() as *const _,
1102                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1103                    notify_family_trampoline::<Self, F> as *const (),
1104                )),
1105                Box_::into_raw(f),
1106            )
1107        }
1108    }
1109
1110    #[doc(alias = "family-set")]
1111    fn connect_family_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1112        unsafe extern "C" fn notify_family_set_trampoline<
1113            P: IsA<CellRendererText>,
1114            F: Fn(&P) + 'static,
1115        >(
1116            this: *mut ffi::GtkCellRendererText,
1117            _param_spec: glib::ffi::gpointer,
1118            f: glib::ffi::gpointer,
1119        ) {
1120            let f: &F = &*(f as *const F);
1121            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1122        }
1123        unsafe {
1124            let f: Box_<F> = Box_::new(f);
1125            connect_raw(
1126                self.as_ptr() as *mut _,
1127                c"notify::family-set".as_ptr() as *const _,
1128                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1129                    notify_family_set_trampoline::<Self, F> as *const (),
1130                )),
1131                Box_::into_raw(f),
1132            )
1133        }
1134    }
1135
1136    #[doc(alias = "font")]
1137    fn connect_font_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1138        unsafe extern "C" fn notify_font_trampoline<
1139            P: IsA<CellRendererText>,
1140            F: Fn(&P) + 'static,
1141        >(
1142            this: *mut ffi::GtkCellRendererText,
1143            _param_spec: glib::ffi::gpointer,
1144            f: glib::ffi::gpointer,
1145        ) {
1146            let f: &F = &*(f as *const F);
1147            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1148        }
1149        unsafe {
1150            let f: Box_<F> = Box_::new(f);
1151            connect_raw(
1152                self.as_ptr() as *mut _,
1153                c"notify::font".as_ptr() as *const _,
1154                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1155                    notify_font_trampoline::<Self, F> as *const (),
1156                )),
1157                Box_::into_raw(f),
1158            )
1159        }
1160    }
1161
1162    #[doc(alias = "font-desc")]
1163    fn connect_font_desc_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1164        unsafe extern "C" fn notify_font_desc_trampoline<
1165            P: IsA<CellRendererText>,
1166            F: Fn(&P) + 'static,
1167        >(
1168            this: *mut ffi::GtkCellRendererText,
1169            _param_spec: glib::ffi::gpointer,
1170            f: glib::ffi::gpointer,
1171        ) {
1172            let f: &F = &*(f as *const F);
1173            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1174        }
1175        unsafe {
1176            let f: Box_<F> = Box_::new(f);
1177            connect_raw(
1178                self.as_ptr() as *mut _,
1179                c"notify::font-desc".as_ptr() as *const _,
1180                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1181                    notify_font_desc_trampoline::<Self, F> as *const (),
1182                )),
1183                Box_::into_raw(f),
1184            )
1185        }
1186    }
1187
1188    #[doc(alias = "foreground")]
1189    fn connect_foreground_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1190        unsafe extern "C" fn notify_foreground_trampoline<
1191            P: IsA<CellRendererText>,
1192            F: Fn(&P) + 'static,
1193        >(
1194            this: *mut ffi::GtkCellRendererText,
1195            _param_spec: glib::ffi::gpointer,
1196            f: glib::ffi::gpointer,
1197        ) {
1198            let f: &F = &*(f as *const F);
1199            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1200        }
1201        unsafe {
1202            let f: Box_<F> = Box_::new(f);
1203            connect_raw(
1204                self.as_ptr() as *mut _,
1205                c"notify::foreground".as_ptr() as *const _,
1206                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1207                    notify_foreground_trampoline::<Self, F> as *const (),
1208                )),
1209                Box_::into_raw(f),
1210            )
1211        }
1212    }
1213
1214    #[doc(alias = "foreground-rgba")]
1215    fn connect_foreground_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1216        unsafe extern "C" fn notify_foreground_rgba_trampoline<
1217            P: IsA<CellRendererText>,
1218            F: Fn(&P) + 'static,
1219        >(
1220            this: *mut ffi::GtkCellRendererText,
1221            _param_spec: glib::ffi::gpointer,
1222            f: glib::ffi::gpointer,
1223        ) {
1224            let f: &F = &*(f as *const F);
1225            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1226        }
1227        unsafe {
1228            let f: Box_<F> = Box_::new(f);
1229            connect_raw(
1230                self.as_ptr() as *mut _,
1231                c"notify::foreground-rgba".as_ptr() as *const _,
1232                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1233                    notify_foreground_rgba_trampoline::<Self, F> as *const (),
1234                )),
1235                Box_::into_raw(f),
1236            )
1237        }
1238    }
1239
1240    #[doc(alias = "foreground-set")]
1241    fn connect_foreground_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1242        unsafe extern "C" fn notify_foreground_set_trampoline<
1243            P: IsA<CellRendererText>,
1244            F: Fn(&P) + 'static,
1245        >(
1246            this: *mut ffi::GtkCellRendererText,
1247            _param_spec: glib::ffi::gpointer,
1248            f: glib::ffi::gpointer,
1249        ) {
1250            let f: &F = &*(f as *const F);
1251            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1252        }
1253        unsafe {
1254            let f: Box_<F> = Box_::new(f);
1255            connect_raw(
1256                self.as_ptr() as *mut _,
1257                c"notify::foreground-set".as_ptr() as *const _,
1258                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1259                    notify_foreground_set_trampoline::<Self, F> as *const (),
1260                )),
1261                Box_::into_raw(f),
1262            )
1263        }
1264    }
1265
1266    #[doc(alias = "language")]
1267    fn connect_language_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1268        unsafe extern "C" fn notify_language_trampoline<
1269            P: IsA<CellRendererText>,
1270            F: Fn(&P) + 'static,
1271        >(
1272            this: *mut ffi::GtkCellRendererText,
1273            _param_spec: glib::ffi::gpointer,
1274            f: glib::ffi::gpointer,
1275        ) {
1276            let f: &F = &*(f as *const F);
1277            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1278        }
1279        unsafe {
1280            let f: Box_<F> = Box_::new(f);
1281            connect_raw(
1282                self.as_ptr() as *mut _,
1283                c"notify::language".as_ptr() as *const _,
1284                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1285                    notify_language_trampoline::<Self, F> as *const (),
1286                )),
1287                Box_::into_raw(f),
1288            )
1289        }
1290    }
1291
1292    #[doc(alias = "language-set")]
1293    fn connect_language_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1294        unsafe extern "C" fn notify_language_set_trampoline<
1295            P: IsA<CellRendererText>,
1296            F: Fn(&P) + 'static,
1297        >(
1298            this: *mut ffi::GtkCellRendererText,
1299            _param_spec: glib::ffi::gpointer,
1300            f: glib::ffi::gpointer,
1301        ) {
1302            let f: &F = &*(f as *const F);
1303            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1304        }
1305        unsafe {
1306            let f: Box_<F> = Box_::new(f);
1307            connect_raw(
1308                self.as_ptr() as *mut _,
1309                c"notify::language-set".as_ptr() as *const _,
1310                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1311                    notify_language_set_trampoline::<Self, F> as *const (),
1312                )),
1313                Box_::into_raw(f),
1314            )
1315        }
1316    }
1317
1318    #[doc(alias = "markup")]
1319    fn connect_markup_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1320        unsafe extern "C" fn notify_markup_trampoline<
1321            P: IsA<CellRendererText>,
1322            F: Fn(&P) + 'static,
1323        >(
1324            this: *mut ffi::GtkCellRendererText,
1325            _param_spec: glib::ffi::gpointer,
1326            f: glib::ffi::gpointer,
1327        ) {
1328            let f: &F = &*(f as *const F);
1329            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1330        }
1331        unsafe {
1332            let f: Box_<F> = Box_::new(f);
1333            connect_raw(
1334                self.as_ptr() as *mut _,
1335                c"notify::markup".as_ptr() as *const _,
1336                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1337                    notify_markup_trampoline::<Self, F> as *const (),
1338                )),
1339                Box_::into_raw(f),
1340            )
1341        }
1342    }
1343
1344    #[doc(alias = "max-width-chars")]
1345    fn connect_max_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1346        unsafe extern "C" fn notify_max_width_chars_trampoline<
1347            P: IsA<CellRendererText>,
1348            F: Fn(&P) + 'static,
1349        >(
1350            this: *mut ffi::GtkCellRendererText,
1351            _param_spec: glib::ffi::gpointer,
1352            f: glib::ffi::gpointer,
1353        ) {
1354            let f: &F = &*(f as *const F);
1355            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1356        }
1357        unsafe {
1358            let f: Box_<F> = Box_::new(f);
1359            connect_raw(
1360                self.as_ptr() as *mut _,
1361                c"notify::max-width-chars".as_ptr() as *const _,
1362                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1363                    notify_max_width_chars_trampoline::<Self, F> as *const (),
1364                )),
1365                Box_::into_raw(f),
1366            )
1367        }
1368    }
1369
1370    #[doc(alias = "placeholder-text")]
1371    fn connect_placeholder_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1372        unsafe extern "C" fn notify_placeholder_text_trampoline<
1373            P: IsA<CellRendererText>,
1374            F: Fn(&P) + 'static,
1375        >(
1376            this: *mut ffi::GtkCellRendererText,
1377            _param_spec: glib::ffi::gpointer,
1378            f: glib::ffi::gpointer,
1379        ) {
1380            let f: &F = &*(f as *const F);
1381            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1382        }
1383        unsafe {
1384            let f: Box_<F> = Box_::new(f);
1385            connect_raw(
1386                self.as_ptr() as *mut _,
1387                c"notify::placeholder-text".as_ptr() as *const _,
1388                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1389                    notify_placeholder_text_trampoline::<Self, F> as *const (),
1390                )),
1391                Box_::into_raw(f),
1392            )
1393        }
1394    }
1395
1396    #[doc(alias = "rise")]
1397    fn connect_rise_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1398        unsafe extern "C" fn notify_rise_trampoline<
1399            P: IsA<CellRendererText>,
1400            F: Fn(&P) + 'static,
1401        >(
1402            this: *mut ffi::GtkCellRendererText,
1403            _param_spec: glib::ffi::gpointer,
1404            f: glib::ffi::gpointer,
1405        ) {
1406            let f: &F = &*(f as *const F);
1407            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1408        }
1409        unsafe {
1410            let f: Box_<F> = Box_::new(f);
1411            connect_raw(
1412                self.as_ptr() as *mut _,
1413                c"notify::rise".as_ptr() as *const _,
1414                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1415                    notify_rise_trampoline::<Self, F> as *const (),
1416                )),
1417                Box_::into_raw(f),
1418            )
1419        }
1420    }
1421
1422    #[doc(alias = "rise-set")]
1423    fn connect_rise_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1424        unsafe extern "C" fn notify_rise_set_trampoline<
1425            P: IsA<CellRendererText>,
1426            F: Fn(&P) + 'static,
1427        >(
1428            this: *mut ffi::GtkCellRendererText,
1429            _param_spec: glib::ffi::gpointer,
1430            f: glib::ffi::gpointer,
1431        ) {
1432            let f: &F = &*(f as *const F);
1433            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1434        }
1435        unsafe {
1436            let f: Box_<F> = Box_::new(f);
1437            connect_raw(
1438                self.as_ptr() as *mut _,
1439                c"notify::rise-set".as_ptr() as *const _,
1440                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1441                    notify_rise_set_trampoline::<Self, F> as *const (),
1442                )),
1443                Box_::into_raw(f),
1444            )
1445        }
1446    }
1447
1448    #[doc(alias = "scale")]
1449    fn connect_scale_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1450        unsafe extern "C" fn notify_scale_trampoline<
1451            P: IsA<CellRendererText>,
1452            F: Fn(&P) + 'static,
1453        >(
1454            this: *mut ffi::GtkCellRendererText,
1455            _param_spec: glib::ffi::gpointer,
1456            f: glib::ffi::gpointer,
1457        ) {
1458            let f: &F = &*(f as *const F);
1459            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1460        }
1461        unsafe {
1462            let f: Box_<F> = Box_::new(f);
1463            connect_raw(
1464                self.as_ptr() as *mut _,
1465                c"notify::scale".as_ptr() as *const _,
1466                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1467                    notify_scale_trampoline::<Self, F> as *const (),
1468                )),
1469                Box_::into_raw(f),
1470            )
1471        }
1472    }
1473
1474    #[doc(alias = "scale-set")]
1475    fn connect_scale_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1476        unsafe extern "C" fn notify_scale_set_trampoline<
1477            P: IsA<CellRendererText>,
1478            F: Fn(&P) + 'static,
1479        >(
1480            this: *mut ffi::GtkCellRendererText,
1481            _param_spec: glib::ffi::gpointer,
1482            f: glib::ffi::gpointer,
1483        ) {
1484            let f: &F = &*(f as *const F);
1485            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1486        }
1487        unsafe {
1488            let f: Box_<F> = Box_::new(f);
1489            connect_raw(
1490                self.as_ptr() as *mut _,
1491                c"notify::scale-set".as_ptr() as *const _,
1492                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1493                    notify_scale_set_trampoline::<Self, F> as *const (),
1494                )),
1495                Box_::into_raw(f),
1496            )
1497        }
1498    }
1499
1500    #[doc(alias = "single-paragraph-mode")]
1501    fn connect_single_paragraph_mode_notify<F: Fn(&Self) + 'static>(
1502        &self,
1503        f: F,
1504    ) -> SignalHandlerId {
1505        unsafe extern "C" fn notify_single_paragraph_mode_trampoline<
1506            P: IsA<CellRendererText>,
1507            F: Fn(&P) + 'static,
1508        >(
1509            this: *mut ffi::GtkCellRendererText,
1510            _param_spec: glib::ffi::gpointer,
1511            f: glib::ffi::gpointer,
1512        ) {
1513            let f: &F = &*(f as *const F);
1514            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1515        }
1516        unsafe {
1517            let f: Box_<F> = Box_::new(f);
1518            connect_raw(
1519                self.as_ptr() as *mut _,
1520                c"notify::single-paragraph-mode".as_ptr() as *const _,
1521                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1522                    notify_single_paragraph_mode_trampoline::<Self, F> as *const (),
1523                )),
1524                Box_::into_raw(f),
1525            )
1526        }
1527    }
1528
1529    #[doc(alias = "size")]
1530    fn connect_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1531        unsafe extern "C" fn notify_size_trampoline<
1532            P: IsA<CellRendererText>,
1533            F: Fn(&P) + 'static,
1534        >(
1535            this: *mut ffi::GtkCellRendererText,
1536            _param_spec: glib::ffi::gpointer,
1537            f: glib::ffi::gpointer,
1538        ) {
1539            let f: &F = &*(f as *const F);
1540            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1541        }
1542        unsafe {
1543            let f: Box_<F> = Box_::new(f);
1544            connect_raw(
1545                self.as_ptr() as *mut _,
1546                c"notify::size".as_ptr() as *const _,
1547                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1548                    notify_size_trampoline::<Self, F> as *const (),
1549                )),
1550                Box_::into_raw(f),
1551            )
1552        }
1553    }
1554
1555    #[doc(alias = "size-points")]
1556    fn connect_size_points_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1557        unsafe extern "C" fn notify_size_points_trampoline<
1558            P: IsA<CellRendererText>,
1559            F: Fn(&P) + 'static,
1560        >(
1561            this: *mut ffi::GtkCellRendererText,
1562            _param_spec: glib::ffi::gpointer,
1563            f: glib::ffi::gpointer,
1564        ) {
1565            let f: &F = &*(f as *const F);
1566            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1567        }
1568        unsafe {
1569            let f: Box_<F> = Box_::new(f);
1570            connect_raw(
1571                self.as_ptr() as *mut _,
1572                c"notify::size-points".as_ptr() as *const _,
1573                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1574                    notify_size_points_trampoline::<Self, F> as *const (),
1575                )),
1576                Box_::into_raw(f),
1577            )
1578        }
1579    }
1580
1581    #[doc(alias = "size-set")]
1582    fn connect_size_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1583        unsafe extern "C" fn notify_size_set_trampoline<
1584            P: IsA<CellRendererText>,
1585            F: Fn(&P) + 'static,
1586        >(
1587            this: *mut ffi::GtkCellRendererText,
1588            _param_spec: glib::ffi::gpointer,
1589            f: glib::ffi::gpointer,
1590        ) {
1591            let f: &F = &*(f as *const F);
1592            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1593        }
1594        unsafe {
1595            let f: Box_<F> = Box_::new(f);
1596            connect_raw(
1597                self.as_ptr() as *mut _,
1598                c"notify::size-set".as_ptr() as *const _,
1599                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1600                    notify_size_set_trampoline::<Self, F> as *const (),
1601                )),
1602                Box_::into_raw(f),
1603            )
1604        }
1605    }
1606
1607    #[doc(alias = "stretch")]
1608    fn connect_stretch_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1609        unsafe extern "C" fn notify_stretch_trampoline<
1610            P: IsA<CellRendererText>,
1611            F: Fn(&P) + 'static,
1612        >(
1613            this: *mut ffi::GtkCellRendererText,
1614            _param_spec: glib::ffi::gpointer,
1615            f: glib::ffi::gpointer,
1616        ) {
1617            let f: &F = &*(f as *const F);
1618            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1619        }
1620        unsafe {
1621            let f: Box_<F> = Box_::new(f);
1622            connect_raw(
1623                self.as_ptr() as *mut _,
1624                c"notify::stretch".as_ptr() as *const _,
1625                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1626                    notify_stretch_trampoline::<Self, F> as *const (),
1627                )),
1628                Box_::into_raw(f),
1629            )
1630        }
1631    }
1632
1633    #[doc(alias = "stretch-set")]
1634    fn connect_stretch_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1635        unsafe extern "C" fn notify_stretch_set_trampoline<
1636            P: IsA<CellRendererText>,
1637            F: Fn(&P) + 'static,
1638        >(
1639            this: *mut ffi::GtkCellRendererText,
1640            _param_spec: glib::ffi::gpointer,
1641            f: glib::ffi::gpointer,
1642        ) {
1643            let f: &F = &*(f as *const F);
1644            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1645        }
1646        unsafe {
1647            let f: Box_<F> = Box_::new(f);
1648            connect_raw(
1649                self.as_ptr() as *mut _,
1650                c"notify::stretch-set".as_ptr() as *const _,
1651                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1652                    notify_stretch_set_trampoline::<Self, F> as *const (),
1653                )),
1654                Box_::into_raw(f),
1655            )
1656        }
1657    }
1658
1659    #[doc(alias = "strikethrough")]
1660    fn connect_strikethrough_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1661        unsafe extern "C" fn notify_strikethrough_trampoline<
1662            P: IsA<CellRendererText>,
1663            F: Fn(&P) + 'static,
1664        >(
1665            this: *mut ffi::GtkCellRendererText,
1666            _param_spec: glib::ffi::gpointer,
1667            f: glib::ffi::gpointer,
1668        ) {
1669            let f: &F = &*(f as *const F);
1670            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1671        }
1672        unsafe {
1673            let f: Box_<F> = Box_::new(f);
1674            connect_raw(
1675                self.as_ptr() as *mut _,
1676                c"notify::strikethrough".as_ptr() as *const _,
1677                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1678                    notify_strikethrough_trampoline::<Self, F> as *const (),
1679                )),
1680                Box_::into_raw(f),
1681            )
1682        }
1683    }
1684
1685    #[doc(alias = "strikethrough-set")]
1686    fn connect_strikethrough_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1687        unsafe extern "C" fn notify_strikethrough_set_trampoline<
1688            P: IsA<CellRendererText>,
1689            F: Fn(&P) + 'static,
1690        >(
1691            this: *mut ffi::GtkCellRendererText,
1692            _param_spec: glib::ffi::gpointer,
1693            f: glib::ffi::gpointer,
1694        ) {
1695            let f: &F = &*(f as *const F);
1696            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1697        }
1698        unsafe {
1699            let f: Box_<F> = Box_::new(f);
1700            connect_raw(
1701                self.as_ptr() as *mut _,
1702                c"notify::strikethrough-set".as_ptr() as *const _,
1703                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1704                    notify_strikethrough_set_trampoline::<Self, F> as *const (),
1705                )),
1706                Box_::into_raw(f),
1707            )
1708        }
1709    }
1710
1711    #[doc(alias = "style")]
1712    fn connect_style_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1713        unsafe extern "C" fn notify_style_trampoline<
1714            P: IsA<CellRendererText>,
1715            F: Fn(&P) + 'static,
1716        >(
1717            this: *mut ffi::GtkCellRendererText,
1718            _param_spec: glib::ffi::gpointer,
1719            f: glib::ffi::gpointer,
1720        ) {
1721            let f: &F = &*(f as *const F);
1722            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1723        }
1724        unsafe {
1725            let f: Box_<F> = Box_::new(f);
1726            connect_raw(
1727                self.as_ptr() as *mut _,
1728                c"notify::style".as_ptr() as *const _,
1729                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1730                    notify_style_trampoline::<Self, F> as *const (),
1731                )),
1732                Box_::into_raw(f),
1733            )
1734        }
1735    }
1736
1737    #[doc(alias = "style-set")]
1738    fn connect_style_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1739        unsafe extern "C" fn notify_style_set_trampoline<
1740            P: IsA<CellRendererText>,
1741            F: Fn(&P) + 'static,
1742        >(
1743            this: *mut ffi::GtkCellRendererText,
1744            _param_spec: glib::ffi::gpointer,
1745            f: glib::ffi::gpointer,
1746        ) {
1747            let f: &F = &*(f as *const F);
1748            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1749        }
1750        unsafe {
1751            let f: Box_<F> = Box_::new(f);
1752            connect_raw(
1753                self.as_ptr() as *mut _,
1754                c"notify::style-set".as_ptr() as *const _,
1755                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1756                    notify_style_set_trampoline::<Self, F> as *const (),
1757                )),
1758                Box_::into_raw(f),
1759            )
1760        }
1761    }
1762
1763    #[doc(alias = "text")]
1764    fn connect_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1765        unsafe extern "C" fn notify_text_trampoline<
1766            P: IsA<CellRendererText>,
1767            F: Fn(&P) + 'static,
1768        >(
1769            this: *mut ffi::GtkCellRendererText,
1770            _param_spec: glib::ffi::gpointer,
1771            f: glib::ffi::gpointer,
1772        ) {
1773            let f: &F = &*(f as *const F);
1774            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1775        }
1776        unsafe {
1777            let f: Box_<F> = Box_::new(f);
1778            connect_raw(
1779                self.as_ptr() as *mut _,
1780                c"notify::text".as_ptr() as *const _,
1781                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1782                    notify_text_trampoline::<Self, F> as *const (),
1783                )),
1784                Box_::into_raw(f),
1785            )
1786        }
1787    }
1788
1789    #[doc(alias = "underline")]
1790    fn connect_underline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1791        unsafe extern "C" fn notify_underline_trampoline<
1792            P: IsA<CellRendererText>,
1793            F: Fn(&P) + 'static,
1794        >(
1795            this: *mut ffi::GtkCellRendererText,
1796            _param_spec: glib::ffi::gpointer,
1797            f: glib::ffi::gpointer,
1798        ) {
1799            let f: &F = &*(f as *const F);
1800            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1801        }
1802        unsafe {
1803            let f: Box_<F> = Box_::new(f);
1804            connect_raw(
1805                self.as_ptr() as *mut _,
1806                c"notify::underline".as_ptr() as *const _,
1807                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1808                    notify_underline_trampoline::<Self, F> as *const (),
1809                )),
1810                Box_::into_raw(f),
1811            )
1812        }
1813    }
1814
1815    #[doc(alias = "underline-set")]
1816    fn connect_underline_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1817        unsafe extern "C" fn notify_underline_set_trampoline<
1818            P: IsA<CellRendererText>,
1819            F: Fn(&P) + 'static,
1820        >(
1821            this: *mut ffi::GtkCellRendererText,
1822            _param_spec: glib::ffi::gpointer,
1823            f: glib::ffi::gpointer,
1824        ) {
1825            let f: &F = &*(f as *const F);
1826            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1827        }
1828        unsafe {
1829            let f: Box_<F> = Box_::new(f);
1830            connect_raw(
1831                self.as_ptr() as *mut _,
1832                c"notify::underline-set".as_ptr() as *const _,
1833                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1834                    notify_underline_set_trampoline::<Self, F> as *const (),
1835                )),
1836                Box_::into_raw(f),
1837            )
1838        }
1839    }
1840
1841    #[doc(alias = "variant")]
1842    fn connect_variant_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1843        unsafe extern "C" fn notify_variant_trampoline<
1844            P: IsA<CellRendererText>,
1845            F: Fn(&P) + 'static,
1846        >(
1847            this: *mut ffi::GtkCellRendererText,
1848            _param_spec: glib::ffi::gpointer,
1849            f: glib::ffi::gpointer,
1850        ) {
1851            let f: &F = &*(f as *const F);
1852            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1853        }
1854        unsafe {
1855            let f: Box_<F> = Box_::new(f);
1856            connect_raw(
1857                self.as_ptr() as *mut _,
1858                c"notify::variant".as_ptr() as *const _,
1859                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1860                    notify_variant_trampoline::<Self, F> as *const (),
1861                )),
1862                Box_::into_raw(f),
1863            )
1864        }
1865    }
1866
1867    #[doc(alias = "variant-set")]
1868    fn connect_variant_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1869        unsafe extern "C" fn notify_variant_set_trampoline<
1870            P: IsA<CellRendererText>,
1871            F: Fn(&P) + 'static,
1872        >(
1873            this: *mut ffi::GtkCellRendererText,
1874            _param_spec: glib::ffi::gpointer,
1875            f: glib::ffi::gpointer,
1876        ) {
1877            let f: &F = &*(f as *const F);
1878            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1879        }
1880        unsafe {
1881            let f: Box_<F> = Box_::new(f);
1882            connect_raw(
1883                self.as_ptr() as *mut _,
1884                c"notify::variant-set".as_ptr() as *const _,
1885                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1886                    notify_variant_set_trampoline::<Self, F> as *const (),
1887                )),
1888                Box_::into_raw(f),
1889            )
1890        }
1891    }
1892
1893    #[doc(alias = "weight")]
1894    fn connect_weight_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1895        unsafe extern "C" fn notify_weight_trampoline<
1896            P: IsA<CellRendererText>,
1897            F: Fn(&P) + 'static,
1898        >(
1899            this: *mut ffi::GtkCellRendererText,
1900            _param_spec: glib::ffi::gpointer,
1901            f: glib::ffi::gpointer,
1902        ) {
1903            let f: &F = &*(f as *const F);
1904            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1905        }
1906        unsafe {
1907            let f: Box_<F> = Box_::new(f);
1908            connect_raw(
1909                self.as_ptr() as *mut _,
1910                c"notify::weight".as_ptr() as *const _,
1911                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1912                    notify_weight_trampoline::<Self, F> as *const (),
1913                )),
1914                Box_::into_raw(f),
1915            )
1916        }
1917    }
1918
1919    #[doc(alias = "weight-set")]
1920    fn connect_weight_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1921        unsafe extern "C" fn notify_weight_set_trampoline<
1922            P: IsA<CellRendererText>,
1923            F: Fn(&P) + 'static,
1924        >(
1925            this: *mut ffi::GtkCellRendererText,
1926            _param_spec: glib::ffi::gpointer,
1927            f: glib::ffi::gpointer,
1928        ) {
1929            let f: &F = &*(f as *const F);
1930            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1931        }
1932        unsafe {
1933            let f: Box_<F> = Box_::new(f);
1934            connect_raw(
1935                self.as_ptr() as *mut _,
1936                c"notify::weight-set".as_ptr() as *const _,
1937                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1938                    notify_weight_set_trampoline::<Self, F> as *const (),
1939                )),
1940                Box_::into_raw(f),
1941            )
1942        }
1943    }
1944
1945    #[doc(alias = "width-chars")]
1946    fn connect_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1947        unsafe extern "C" fn notify_width_chars_trampoline<
1948            P: IsA<CellRendererText>,
1949            F: Fn(&P) + 'static,
1950        >(
1951            this: *mut ffi::GtkCellRendererText,
1952            _param_spec: glib::ffi::gpointer,
1953            f: glib::ffi::gpointer,
1954        ) {
1955            let f: &F = &*(f as *const F);
1956            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1957        }
1958        unsafe {
1959            let f: Box_<F> = Box_::new(f);
1960            connect_raw(
1961                self.as_ptr() as *mut _,
1962                c"notify::width-chars".as_ptr() as *const _,
1963                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1964                    notify_width_chars_trampoline::<Self, F> as *const (),
1965                )),
1966                Box_::into_raw(f),
1967            )
1968        }
1969    }
1970
1971    #[doc(alias = "wrap-mode")]
1972    fn connect_wrap_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1973        unsafe extern "C" fn notify_wrap_mode_trampoline<
1974            P: IsA<CellRendererText>,
1975            F: Fn(&P) + 'static,
1976        >(
1977            this: *mut ffi::GtkCellRendererText,
1978            _param_spec: glib::ffi::gpointer,
1979            f: glib::ffi::gpointer,
1980        ) {
1981            let f: &F = &*(f as *const F);
1982            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
1983        }
1984        unsafe {
1985            let f: Box_<F> = Box_::new(f);
1986            connect_raw(
1987                self.as_ptr() as *mut _,
1988                c"notify::wrap-mode".as_ptr() as *const _,
1989                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
1990                    notify_wrap_mode_trampoline::<Self, F> as *const (),
1991                )),
1992                Box_::into_raw(f),
1993            )
1994        }
1995    }
1996
1997    #[doc(alias = "wrap-width")]
1998    fn connect_wrap_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
1999        unsafe extern "C" fn notify_wrap_width_trampoline<
2000            P: IsA<CellRendererText>,
2001            F: Fn(&P) + 'static,
2002        >(
2003            this: *mut ffi::GtkCellRendererText,
2004            _param_spec: glib::ffi::gpointer,
2005            f: glib::ffi::gpointer,
2006        ) {
2007            let f: &F = &*(f as *const F);
2008            f(CellRendererText::from_glib_borrow(this).unsafe_cast_ref())
2009        }
2010        unsafe {
2011            let f: Box_<F> = Box_::new(f);
2012            connect_raw(
2013                self.as_ptr() as *mut _,
2014                c"notify::wrap-width".as_ptr() as *const _,
2015                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2016                    notify_wrap_width_trampoline::<Self, F> as *const (),
2017                )),
2018                Box_::into_raw(f),
2019            )
2020        }
2021    }
2022}
2023
2024impl<O: IsA<CellRendererText>> CellRendererTextExt for O {}
gtk4/auto/cell_renderer_text.rs

gtk4/auto/
cell_renderer_text.rs
