gtk/auto/
text_tag.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use gdk;
6use gdk_sys;
7use glib;
8use glib::object::Cast;
9use glib::object::IsA;
10use glib::signal::connect_raw;
11use glib::signal::SignalHandlerId;
12use glib::translate::*;
13use glib::GString;
14use glib::StaticType;
15use glib::ToValue;
16use glib::Value;
17use glib_sys;
18use gobject_sys;
19use gtk_sys;
20use pango;
21use signal::Inhibit;
22use std::boxed::Box as Box_;
23use std::fmt;
24use std::mem::transmute;
25use Justification;
26use TextDirection;
27use TextIter;
28use WrapMode;
29
30glib_wrapper! {
31    pub struct TextTag(Object<gtk_sys::GtkTextTag, gtk_sys::GtkTextTagClass, TextTagClass>);
32
33    match fn {
34        get_type => || gtk_sys::gtk_text_tag_get_type(),
35    }
36}
37
38impl TextTag {
39    pub fn new(name: Option<&str>) -> TextTag {
40        assert_initialized_main_thread!();
41        unsafe { from_glib_full(gtk_sys::gtk_text_tag_new(name.to_glib_none().0)) }
42    }
43}
44
45pub struct TextTagBuilder {
46    accumulative_margin: Option<bool>,
47    background: Option<String>,
48    background_full_height: Option<bool>,
49    background_full_height_set: Option<bool>,
50    background_rgba: Option<gdk::RGBA>,
51    background_set: Option<bool>,
52    direction: Option<TextDirection>,
53    editable: Option<bool>,
54    editable_set: Option<bool>,
55    #[cfg(any(feature = "v3_16", feature = "dox"))]
56    fallback: Option<bool>,
57    fallback_set: Option<bool>,
58    family: Option<String>,
59    family_set: Option<bool>,
60    font: Option<String>,
61    #[cfg(any(feature = "v3_18", feature = "dox"))]
62    font_features: Option<String>,
63    font_features_set: Option<bool>,
64    foreground: Option<String>,
65    foreground_rgba: Option<gdk::RGBA>,
66    foreground_set: Option<bool>,
67    indent: Option<i32>,
68    indent_set: Option<bool>,
69    invisible: Option<bool>,
70    invisible_set: Option<bool>,
71    justification: Option<Justification>,
72    justification_set: Option<bool>,
73    language: Option<String>,
74    language_set: Option<bool>,
75    left_margin: Option<i32>,
76    left_margin_set: Option<bool>,
77    #[cfg(any(feature = "v3_16", feature = "dox"))]
78    letter_spacing: Option<i32>,
79    letter_spacing_set: Option<bool>,
80    name: Option<String>,
81    paragraph_background: Option<String>,
82    paragraph_background_rgba: Option<gdk::RGBA>,
83    paragraph_background_set: Option<bool>,
84    pixels_above_lines: Option<i32>,
85    pixels_above_lines_set: Option<bool>,
86    pixels_below_lines: Option<i32>,
87    pixels_below_lines_set: Option<bool>,
88    pixels_inside_wrap: Option<i32>,
89    pixels_inside_wrap_set: Option<bool>,
90    right_margin: Option<i32>,
91    right_margin_set: Option<bool>,
92    rise: Option<i32>,
93    rise_set: Option<bool>,
94    scale: Option<f64>,
95    scale_set: Option<bool>,
96    size: Option<i32>,
97    size_points: Option<f64>,
98    size_set: Option<bool>,
99    stretch: Option<pango::Stretch>,
100    stretch_set: Option<bool>,
101    strikethrough: Option<bool>,
102    #[cfg(any(feature = "v3_16", feature = "dox"))]
103    strikethrough_rgba: Option<gdk::RGBA>,
104    #[cfg(any(feature = "v3_16", feature = "dox"))]
105    strikethrough_rgba_set: Option<bool>,
106    strikethrough_set: Option<bool>,
107    style: Option<pango::Style>,
108    style_set: Option<bool>,
109    tabs_set: Option<bool>,
110    underline: Option<pango::Underline>,
111    #[cfg(any(feature = "v3_16", feature = "dox"))]
112    underline_rgba: Option<gdk::RGBA>,
113    #[cfg(any(feature = "v3_16", feature = "dox"))]
114    underline_rgba_set: Option<bool>,
115    underline_set: Option<bool>,
116    variant: Option<pango::Variant>,
117    variant_set: Option<bool>,
118    weight: Option<i32>,
119    weight_set: Option<bool>,
120    wrap_mode: Option<WrapMode>,
121    wrap_mode_set: Option<bool>,
122}
123
124impl TextTagBuilder {
125    pub fn new() -> Self {
126        Self {
127            accumulative_margin: None,
128            background: None,
129            background_full_height: None,
130            background_full_height_set: None,
131            background_rgba: None,
132            background_set: None,
133            direction: None,
134            editable: None,
135            editable_set: None,
136            #[cfg(any(feature = "v3_16", feature = "dox"))]
137            fallback: None,
138            fallback_set: None,
139            family: None,
140            family_set: None,
141            font: None,
142            #[cfg(any(feature = "v3_18", feature = "dox"))]
143            font_features: None,
144            font_features_set: None,
145            foreground: None,
146            foreground_rgba: None,
147            foreground_set: None,
148            indent: None,
149            indent_set: None,
150            invisible: None,
151            invisible_set: None,
152            justification: None,
153            justification_set: None,
154            language: None,
155            language_set: None,
156            left_margin: None,
157            left_margin_set: None,
158            #[cfg(any(feature = "v3_16", feature = "dox"))]
159            letter_spacing: None,
160            letter_spacing_set: None,
161            name: None,
162            paragraph_background: None,
163            paragraph_background_rgba: None,
164            paragraph_background_set: None,
165            pixels_above_lines: None,
166            pixels_above_lines_set: None,
167            pixels_below_lines: None,
168            pixels_below_lines_set: None,
169            pixels_inside_wrap: None,
170            pixels_inside_wrap_set: None,
171            right_margin: None,
172            right_margin_set: None,
173            rise: None,
174            rise_set: None,
175            scale: None,
176            scale_set: None,
177            size: None,
178            size_points: None,
179            size_set: None,
180            stretch: None,
181            stretch_set: None,
182            strikethrough: None,
183            #[cfg(any(feature = "v3_16", feature = "dox"))]
184            strikethrough_rgba: None,
185            #[cfg(any(feature = "v3_16", feature = "dox"))]
186            strikethrough_rgba_set: None,
187            strikethrough_set: None,
188            style: None,
189            style_set: None,
190            tabs_set: None,
191            underline: None,
192            #[cfg(any(feature = "v3_16", feature = "dox"))]
193            underline_rgba: None,
194            #[cfg(any(feature = "v3_16", feature = "dox"))]
195            underline_rgba_set: None,
196            underline_set: None,
197            variant: None,
198            variant_set: None,
199            weight: None,
200            weight_set: None,
201            wrap_mode: None,
202            wrap_mode_set: None,
203        }
204    }
205
206    pub fn build(self) -> TextTag {
207        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
208        if let Some(ref accumulative_margin) = self.accumulative_margin {
209            properties.push(("accumulative-margin", accumulative_margin));
210        }
211        if let Some(ref background) = self.background {
212            properties.push(("background", background));
213        }
214        if let Some(ref background_full_height) = self.background_full_height {
215            properties.push(("background-full-height", background_full_height));
216        }
217        if let Some(ref background_full_height_set) = self.background_full_height_set {
218            properties.push(("background-full-height-set", background_full_height_set));
219        }
220        if let Some(ref background_rgba) = self.background_rgba {
221            properties.push(("background-rgba", background_rgba));
222        }
223        if let Some(ref background_set) = self.background_set {
224            properties.push(("background-set", background_set));
225        }
226        if let Some(ref direction) = self.direction {
227            properties.push(("direction", direction));
228        }
229        if let Some(ref editable) = self.editable {
230            properties.push(("editable", editable));
231        }
232        if let Some(ref editable_set) = self.editable_set {
233            properties.push(("editable-set", editable_set));
234        }
235        #[cfg(any(feature = "v3_16", feature = "dox"))]
236        {
237            if let Some(ref fallback) = self.fallback {
238                properties.push(("fallback", fallback));
239            }
240        }
241        if let Some(ref fallback_set) = self.fallback_set {
242            properties.push(("fallback-set", fallback_set));
243        }
244        if let Some(ref family) = self.family {
245            properties.push(("family", family));
246        }
247        if let Some(ref family_set) = self.family_set {
248            properties.push(("family-set", family_set));
249        }
250        if let Some(ref font) = self.font {
251            properties.push(("font", font));
252        }
253        #[cfg(any(feature = "v3_18", feature = "dox"))]
254        {
255            if let Some(ref font_features) = self.font_features {
256                properties.push(("font-features", font_features));
257            }
258        }
259        if let Some(ref font_features_set) = self.font_features_set {
260            properties.push(("font-features-set", font_features_set));
261        }
262        if let Some(ref foreground) = self.foreground {
263            properties.push(("foreground", foreground));
264        }
265        if let Some(ref foreground_rgba) = self.foreground_rgba {
266            properties.push(("foreground-rgba", foreground_rgba));
267        }
268        if let Some(ref foreground_set) = self.foreground_set {
269            properties.push(("foreground-set", foreground_set));
270        }
271        if let Some(ref indent) = self.indent {
272            properties.push(("indent", indent));
273        }
274        if let Some(ref indent_set) = self.indent_set {
275            properties.push(("indent-set", indent_set));
276        }
277        if let Some(ref invisible) = self.invisible {
278            properties.push(("invisible", invisible));
279        }
280        if let Some(ref invisible_set) = self.invisible_set {
281            properties.push(("invisible-set", invisible_set));
282        }
283        if let Some(ref justification) = self.justification {
284            properties.push(("justification", justification));
285        }
286        if let Some(ref justification_set) = self.justification_set {
287            properties.push(("justification-set", justification_set));
288        }
289        if let Some(ref language) = self.language {
290            properties.push(("language", language));
291        }
292        if let Some(ref language_set) = self.language_set {
293            properties.push(("language-set", language_set));
294        }
295        if let Some(ref left_margin) = self.left_margin {
296            properties.push(("left-margin", left_margin));
297        }
298        if let Some(ref left_margin_set) = self.left_margin_set {
299            properties.push(("left-margin-set", left_margin_set));
300        }
301        #[cfg(any(feature = "v3_16", feature = "dox"))]
302        {
303            if let Some(ref letter_spacing) = self.letter_spacing {
304                properties.push(("letter-spacing", letter_spacing));
305            }
306        }
307        if let Some(ref letter_spacing_set) = self.letter_spacing_set {
308            properties.push(("letter-spacing-set", letter_spacing_set));
309        }
310        if let Some(ref name) = self.name {
311            properties.push(("name", name));
312        }
313        if let Some(ref paragraph_background) = self.paragraph_background {
314            properties.push(("paragraph-background", paragraph_background));
315        }
316        if let Some(ref paragraph_background_rgba) = self.paragraph_background_rgba {
317            properties.push(("paragraph-background-rgba", paragraph_background_rgba));
318        }
319        if let Some(ref paragraph_background_set) = self.paragraph_background_set {
320            properties.push(("paragraph-background-set", paragraph_background_set));
321        }
322        if let Some(ref pixels_above_lines) = self.pixels_above_lines {
323            properties.push(("pixels-above-lines", pixels_above_lines));
324        }
325        if let Some(ref pixels_above_lines_set) = self.pixels_above_lines_set {
326            properties.push(("pixels-above-lines-set", pixels_above_lines_set));
327        }
328        if let Some(ref pixels_below_lines) = self.pixels_below_lines {
329            properties.push(("pixels-below-lines", pixels_below_lines));
330        }
331        if let Some(ref pixels_below_lines_set) = self.pixels_below_lines_set {
332            properties.push(("pixels-below-lines-set", pixels_below_lines_set));
333        }
334        if let Some(ref pixels_inside_wrap) = self.pixels_inside_wrap {
335            properties.push(("pixels-inside-wrap", pixels_inside_wrap));
336        }
337        if let Some(ref pixels_inside_wrap_set) = self.pixels_inside_wrap_set {
338            properties.push(("pixels-inside-wrap-set", pixels_inside_wrap_set));
339        }
340        if let Some(ref right_margin) = self.right_margin {
341            properties.push(("right-margin", right_margin));
342        }
343        if let Some(ref right_margin_set) = self.right_margin_set {
344            properties.push(("right-margin-set", right_margin_set));
345        }
346        if let Some(ref rise) = self.rise {
347            properties.push(("rise", rise));
348        }
349        if let Some(ref rise_set) = self.rise_set {
350            properties.push(("rise-set", rise_set));
351        }
352        if let Some(ref scale) = self.scale {
353            properties.push(("scale", scale));
354        }
355        if let Some(ref scale_set) = self.scale_set {
356            properties.push(("scale-set", scale_set));
357        }
358        if let Some(ref size) = self.size {
359            properties.push(("size", size));
360        }
361        if let Some(ref size_points) = self.size_points {
362            properties.push(("size-points", size_points));
363        }
364        if let Some(ref size_set) = self.size_set {
365            properties.push(("size-set", size_set));
366        }
367        if let Some(ref stretch) = self.stretch {
368            properties.push(("stretch", stretch));
369        }
370        if let Some(ref stretch_set) = self.stretch_set {
371            properties.push(("stretch-set", stretch_set));
372        }
373        if let Some(ref strikethrough) = self.strikethrough {
374            properties.push(("strikethrough", strikethrough));
375        }
376        #[cfg(any(feature = "v3_16", feature = "dox"))]
377        {
378            if let Some(ref strikethrough_rgba) = self.strikethrough_rgba {
379                properties.push(("strikethrough-rgba", strikethrough_rgba));
380            }
381        }
382        #[cfg(any(feature = "v3_16", feature = "dox"))]
383        {
384            if let Some(ref strikethrough_rgba_set) = self.strikethrough_rgba_set {
385                properties.push(("strikethrough-rgba-set", strikethrough_rgba_set));
386            }
387        }
388        if let Some(ref strikethrough_set) = self.strikethrough_set {
389            properties.push(("strikethrough-set", strikethrough_set));
390        }
391        if let Some(ref style) = self.style {
392            properties.push(("style", style));
393        }
394        if let Some(ref style_set) = self.style_set {
395            properties.push(("style-set", style_set));
396        }
397        if let Some(ref tabs_set) = self.tabs_set {
398            properties.push(("tabs-set", tabs_set));
399        }
400        if let Some(ref underline) = self.underline {
401            properties.push(("underline", underline));
402        }
403        #[cfg(any(feature = "v3_16", feature = "dox"))]
404        {
405            if let Some(ref underline_rgba) = self.underline_rgba {
406                properties.push(("underline-rgba", underline_rgba));
407            }
408        }
409        #[cfg(any(feature = "v3_16", feature = "dox"))]
410        {
411            if let Some(ref underline_rgba_set) = self.underline_rgba_set {
412                properties.push(("underline-rgba-set", underline_rgba_set));
413            }
414        }
415        if let Some(ref underline_set) = self.underline_set {
416            properties.push(("underline-set", underline_set));
417        }
418        if let Some(ref variant) = self.variant {
419            properties.push(("variant", variant));
420        }
421        if let Some(ref variant_set) = self.variant_set {
422            properties.push(("variant-set", variant_set));
423        }
424        if let Some(ref weight) = self.weight {
425            properties.push(("weight", weight));
426        }
427        if let Some(ref weight_set) = self.weight_set {
428            properties.push(("weight-set", weight_set));
429        }
430        if let Some(ref wrap_mode) = self.wrap_mode {
431            properties.push(("wrap-mode", wrap_mode));
432        }
433        if let Some(ref wrap_mode_set) = self.wrap_mode_set {
434            properties.push(("wrap-mode-set", wrap_mode_set));
435        }
436        glib::Object::new(TextTag::static_type(), &properties)
437            .expect("object new")
438            .downcast()
439            .expect("downcast")
440    }
441
442    pub fn accumulative_margin(mut self, accumulative_margin: bool) -> Self {
443        self.accumulative_margin = Some(accumulative_margin);
444        self
445    }
446
447    pub fn background(mut self, background: &str) -> Self {
448        self.background = Some(background.to_string());
449        self
450    }
451
452    pub fn background_full_height(mut self, background_full_height: bool) -> Self {
453        self.background_full_height = Some(background_full_height);
454        self
455    }
456
457    pub fn background_full_height_set(mut self, background_full_height_set: bool) -> Self {
458        self.background_full_height_set = Some(background_full_height_set);
459        self
460    }
461
462    pub fn background_rgba(mut self, background_rgba: &gdk::RGBA) -> Self {
463        self.background_rgba = Some(background_rgba.clone());
464        self
465    }
466
467    pub fn background_set(mut self, background_set: bool) -> Self {
468        self.background_set = Some(background_set);
469        self
470    }
471
472    pub fn direction(mut self, direction: TextDirection) -> Self {
473        self.direction = Some(direction);
474        self
475    }
476
477    pub fn editable(mut self, editable: bool) -> Self {
478        self.editable = Some(editable);
479        self
480    }
481
482    pub fn editable_set(mut self, editable_set: bool) -> Self {
483        self.editable_set = Some(editable_set);
484        self
485    }
486
487    #[cfg(any(feature = "v3_16", feature = "dox"))]
488    pub fn fallback(mut self, fallback: bool) -> Self {
489        self.fallback = Some(fallback);
490        self
491    }
492
493    pub fn fallback_set(mut self, fallback_set: bool) -> Self {
494        self.fallback_set = Some(fallback_set);
495        self
496    }
497
498    pub fn family(mut self, family: &str) -> Self {
499        self.family = Some(family.to_string());
500        self
501    }
502
503    pub fn family_set(mut self, family_set: bool) -> Self {
504        self.family_set = Some(family_set);
505        self
506    }
507
508    pub fn font(mut self, font: &str) -> Self {
509        self.font = Some(font.to_string());
510        self
511    }
512
513    #[cfg(any(feature = "v3_18", feature = "dox"))]
514    pub fn font_features(mut self, font_features: &str) -> Self {
515        self.font_features = Some(font_features.to_string());
516        self
517    }
518
519    pub fn font_features_set(mut self, font_features_set: bool) -> Self {
520        self.font_features_set = Some(font_features_set);
521        self
522    }
523
524    pub fn foreground(mut self, foreground: &str) -> Self {
525        self.foreground = Some(foreground.to_string());
526        self
527    }
528
529    pub fn foreground_rgba(mut self, foreground_rgba: &gdk::RGBA) -> Self {
530        self.foreground_rgba = Some(foreground_rgba.clone());
531        self
532    }
533
534    pub fn foreground_set(mut self, foreground_set: bool) -> Self {
535        self.foreground_set = Some(foreground_set);
536        self
537    }
538
539    pub fn indent(mut self, indent: i32) -> Self {
540        self.indent = Some(indent);
541        self
542    }
543
544    pub fn indent_set(mut self, indent_set: bool) -> Self {
545        self.indent_set = Some(indent_set);
546        self
547    }
548
549    pub fn invisible(mut self, invisible: bool) -> Self {
550        self.invisible = Some(invisible);
551        self
552    }
553
554    pub fn invisible_set(mut self, invisible_set: bool) -> Self {
555        self.invisible_set = Some(invisible_set);
556        self
557    }
558
559    pub fn justification(mut self, justification: Justification) -> Self {
560        self.justification = Some(justification);
561        self
562    }
563
564    pub fn justification_set(mut self, justification_set: bool) -> Self {
565        self.justification_set = Some(justification_set);
566        self
567    }
568
569    pub fn language(mut self, language: &str) -> Self {
570        self.language = Some(language.to_string());
571        self
572    }
573
574    pub fn language_set(mut self, language_set: bool) -> Self {
575        self.language_set = Some(language_set);
576        self
577    }
578
579    pub fn left_margin(mut self, left_margin: i32) -> Self {
580        self.left_margin = Some(left_margin);
581        self
582    }
583
584    pub fn left_margin_set(mut self, left_margin_set: bool) -> Self {
585        self.left_margin_set = Some(left_margin_set);
586        self
587    }
588
589    #[cfg(any(feature = "v3_16", feature = "dox"))]
590    pub fn letter_spacing(mut self, letter_spacing: i32) -> Self {
591        self.letter_spacing = Some(letter_spacing);
592        self
593    }
594
595    pub fn letter_spacing_set(mut self, letter_spacing_set: bool) -> Self {
596        self.letter_spacing_set = Some(letter_spacing_set);
597        self
598    }
599
600    pub fn name(mut self, name: &str) -> Self {
601        self.name = Some(name.to_string());
602        self
603    }
604
605    pub fn paragraph_background(mut self, paragraph_background: &str) -> Self {
606        self.paragraph_background = Some(paragraph_background.to_string());
607        self
608    }
609
610    pub fn paragraph_background_rgba(mut self, paragraph_background_rgba: &gdk::RGBA) -> Self {
611        self.paragraph_background_rgba = Some(paragraph_background_rgba.clone());
612        self
613    }
614
615    pub fn paragraph_background_set(mut self, paragraph_background_set: bool) -> Self {
616        self.paragraph_background_set = Some(paragraph_background_set);
617        self
618    }
619
620    pub fn pixels_above_lines(mut self, pixels_above_lines: i32) -> Self {
621        self.pixels_above_lines = Some(pixels_above_lines);
622        self
623    }
624
625    pub fn pixels_above_lines_set(mut self, pixels_above_lines_set: bool) -> Self {
626        self.pixels_above_lines_set = Some(pixels_above_lines_set);
627        self
628    }
629
630    pub fn pixels_below_lines(mut self, pixels_below_lines: i32) -> Self {
631        self.pixels_below_lines = Some(pixels_below_lines);
632        self
633    }
634
635    pub fn pixels_below_lines_set(mut self, pixels_below_lines_set: bool) -> Self {
636        self.pixels_below_lines_set = Some(pixels_below_lines_set);
637        self
638    }
639
640    pub fn pixels_inside_wrap(mut self, pixels_inside_wrap: i32) -> Self {
641        self.pixels_inside_wrap = Some(pixels_inside_wrap);
642        self
643    }
644
645    pub fn pixels_inside_wrap_set(mut self, pixels_inside_wrap_set: bool) -> Self {
646        self.pixels_inside_wrap_set = Some(pixels_inside_wrap_set);
647        self
648    }
649
650    pub fn right_margin(mut self, right_margin: i32) -> Self {
651        self.right_margin = Some(right_margin);
652        self
653    }
654
655    pub fn right_margin_set(mut self, right_margin_set: bool) -> Self {
656        self.right_margin_set = Some(right_margin_set);
657        self
658    }
659
660    pub fn rise(mut self, rise: i32) -> Self {
661        self.rise = Some(rise);
662        self
663    }
664
665    pub fn rise_set(mut self, rise_set: bool) -> Self {
666        self.rise_set = Some(rise_set);
667        self
668    }
669
670    pub fn scale(mut self, scale: f64) -> Self {
671        self.scale = Some(scale);
672        self
673    }
674
675    pub fn scale_set(mut self, scale_set: bool) -> Self {
676        self.scale_set = Some(scale_set);
677        self
678    }
679
680    pub fn size(mut self, size: i32) -> Self {
681        self.size = Some(size);
682        self
683    }
684
685    pub fn size_points(mut self, size_points: f64) -> Self {
686        self.size_points = Some(size_points);
687        self
688    }
689
690    pub fn size_set(mut self, size_set: bool) -> Self {
691        self.size_set = Some(size_set);
692        self
693    }
694
695    pub fn stretch(mut self, stretch: pango::Stretch) -> Self {
696        self.stretch = Some(stretch);
697        self
698    }
699
700    pub fn stretch_set(mut self, stretch_set: bool) -> Self {
701        self.stretch_set = Some(stretch_set);
702        self
703    }
704
705    pub fn strikethrough(mut self, strikethrough: bool) -> Self {
706        self.strikethrough = Some(strikethrough);
707        self
708    }
709
710    #[cfg(any(feature = "v3_16", feature = "dox"))]
711    pub fn strikethrough_rgba(mut self, strikethrough_rgba: &gdk::RGBA) -> Self {
712        self.strikethrough_rgba = Some(strikethrough_rgba.clone());
713        self
714    }
715
716    #[cfg(any(feature = "v3_16", feature = "dox"))]
717    pub fn strikethrough_rgba_set(mut self, strikethrough_rgba_set: bool) -> Self {
718        self.strikethrough_rgba_set = Some(strikethrough_rgba_set);
719        self
720    }
721
722    pub fn strikethrough_set(mut self, strikethrough_set: bool) -> Self {
723        self.strikethrough_set = Some(strikethrough_set);
724        self
725    }
726
727    pub fn style(mut self, style: pango::Style) -> Self {
728        self.style = Some(style);
729        self
730    }
731
732    pub fn style_set(mut self, style_set: bool) -> Self {
733        self.style_set = Some(style_set);
734        self
735    }
736
737    pub fn tabs_set(mut self, tabs_set: bool) -> Self {
738        self.tabs_set = Some(tabs_set);
739        self
740    }
741
742    pub fn underline(mut self, underline: pango::Underline) -> Self {
743        self.underline = Some(underline);
744        self
745    }
746
747    #[cfg(any(feature = "v3_16", feature = "dox"))]
748    pub fn underline_rgba(mut self, underline_rgba: &gdk::RGBA) -> Self {
749        self.underline_rgba = Some(underline_rgba.clone());
750        self
751    }
752
753    #[cfg(any(feature = "v3_16", feature = "dox"))]
754    pub fn underline_rgba_set(mut self, underline_rgba_set: bool) -> Self {
755        self.underline_rgba_set = Some(underline_rgba_set);
756        self
757    }
758
759    pub fn underline_set(mut self, underline_set: bool) -> Self {
760        self.underline_set = Some(underline_set);
761        self
762    }
763
764    pub fn variant(mut self, variant: pango::Variant) -> Self {
765        self.variant = Some(variant);
766        self
767    }
768
769    pub fn variant_set(mut self, variant_set: bool) -> Self {
770        self.variant_set = Some(variant_set);
771        self
772    }
773
774    pub fn weight(mut self, weight: i32) -> Self {
775        self.weight = Some(weight);
776        self
777    }
778
779    pub fn weight_set(mut self, weight_set: bool) -> Self {
780        self.weight_set = Some(weight_set);
781        self
782    }
783
784    pub fn wrap_mode(mut self, wrap_mode: WrapMode) -> Self {
785        self.wrap_mode = Some(wrap_mode);
786        self
787    }
788
789    pub fn wrap_mode_set(mut self, wrap_mode_set: bool) -> Self {
790        self.wrap_mode_set = Some(wrap_mode_set);
791        self
792    }
793}
794
795pub const NONE_TEXT_TAG: Option<&TextTag> = None;
796
797pub trait TextTagExt: 'static {
798    #[cfg(any(feature = "v3_20", feature = "dox"))]
799    fn changed(&self, size_changed: bool);
800
801    fn event<P: IsA<glib::Object>>(
802        &self,
803        event_object: &P,
804        event: &gdk::Event,
805        iter: &TextIter,
806    ) -> bool;
807
808    fn get_priority(&self) -> i32;
809
810    fn set_priority(&self, priority: i32);
811
812    fn get_property_accumulative_margin(&self) -> bool;
813
814    fn set_property_accumulative_margin(&self, accumulative_margin: bool);
815
816    fn set_property_background(&self, background: Option<&str>);
817
818    fn get_property_background_full_height(&self) -> bool;
819
820    fn set_property_background_full_height(&self, background_full_height: bool);
821
822    fn get_property_background_full_height_set(&self) -> bool;
823
824    fn set_property_background_full_height_set(&self, background_full_height_set: bool);
825
826    fn get_property_background_rgba(&self) -> Option<gdk::RGBA>;
827
828    fn set_property_background_rgba(&self, background_rgba: Option<&gdk::RGBA>);
829
830    fn get_property_background_set(&self) -> bool;
831
832    fn set_property_background_set(&self, background_set: bool);
833
834    fn get_property_direction(&self) -> TextDirection;
835
836    fn set_property_direction(&self, direction: TextDirection);
837
838    fn get_property_editable(&self) -> bool;
839
840    fn set_property_editable(&self, editable: bool);
841
842    fn get_property_editable_set(&self) -> bool;
843
844    fn set_property_editable_set(&self, editable_set: bool);
845
846    #[cfg(any(feature = "v3_16", feature = "dox"))]
847    fn get_property_fallback(&self) -> bool;
848
849    #[cfg(any(feature = "v3_16", feature = "dox"))]
850    fn set_property_fallback(&self, fallback: bool);
851
852    fn get_property_fallback_set(&self) -> bool;
853
854    fn set_property_fallback_set(&self, fallback_set: bool);
855
856    fn get_property_family(&self) -> Option<GString>;
857
858    fn set_property_family(&self, family: Option<&str>);
859
860    fn get_property_family_set(&self) -> bool;
861
862    fn set_property_family_set(&self, family_set: bool);
863
864    fn get_property_font(&self) -> Option<GString>;
865
866    fn set_property_font(&self, font: Option<&str>);
867
868    #[cfg(any(feature = "v3_18", feature = "dox"))]
869    fn get_property_font_features(&self) -> Option<GString>;
870
871    #[cfg(any(feature = "v3_18", feature = "dox"))]
872    fn set_property_font_features(&self, font_features: Option<&str>);
873
874    fn get_property_font_features_set(&self) -> bool;
875
876    fn set_property_font_features_set(&self, font_features_set: bool);
877
878    fn set_property_foreground(&self, foreground: Option<&str>);
879
880    fn get_property_foreground_rgba(&self) -> Option<gdk::RGBA>;
881
882    fn set_property_foreground_rgba(&self, foreground_rgba: Option<&gdk::RGBA>);
883
884    fn get_property_foreground_set(&self) -> bool;
885
886    fn set_property_foreground_set(&self, foreground_set: bool);
887
888    fn get_property_indent(&self) -> i32;
889
890    fn set_property_indent(&self, indent: i32);
891
892    fn get_property_indent_set(&self) -> bool;
893
894    fn set_property_indent_set(&self, indent_set: bool);
895
896    fn get_property_invisible(&self) -> bool;
897
898    fn set_property_invisible(&self, invisible: bool);
899
900    fn get_property_invisible_set(&self) -> bool;
901
902    fn set_property_invisible_set(&self, invisible_set: bool);
903
904    fn get_property_justification(&self) -> Justification;
905
906    fn set_property_justification(&self, justification: Justification);
907
908    fn get_property_justification_set(&self) -> bool;
909
910    fn set_property_justification_set(&self, justification_set: bool);
911
912    fn get_property_language(&self) -> Option<GString>;
913
914    fn set_property_language(&self, language: Option<&str>);
915
916    fn get_property_language_set(&self) -> bool;
917
918    fn set_property_language_set(&self, language_set: bool);
919
920    fn get_property_left_margin(&self) -> i32;
921
922    fn set_property_left_margin(&self, left_margin: i32);
923
924    fn get_property_left_margin_set(&self) -> bool;
925
926    fn set_property_left_margin_set(&self, left_margin_set: bool);
927
928    #[cfg(any(feature = "v3_16", feature = "dox"))]
929    fn get_property_letter_spacing(&self) -> i32;
930
931    #[cfg(any(feature = "v3_16", feature = "dox"))]
932    fn set_property_letter_spacing(&self, letter_spacing: i32);
933
934    fn get_property_letter_spacing_set(&self) -> bool;
935
936    fn set_property_letter_spacing_set(&self, letter_spacing_set: bool);
937
938    fn get_property_name(&self) -> Option<GString>;
939
940    fn set_property_paragraph_background(&self, paragraph_background: Option<&str>);
941
942    fn get_property_paragraph_background_rgba(&self) -> Option<gdk::RGBA>;
943
944    fn set_property_paragraph_background_rgba(&self, paragraph_background_rgba: Option<&gdk::RGBA>);
945
946    fn get_property_paragraph_background_set(&self) -> bool;
947
948    fn set_property_paragraph_background_set(&self, paragraph_background_set: bool);
949
950    fn get_property_pixels_above_lines(&self) -> i32;
951
952    fn set_property_pixels_above_lines(&self, pixels_above_lines: i32);
953
954    fn get_property_pixels_above_lines_set(&self) -> bool;
955
956    fn set_property_pixels_above_lines_set(&self, pixels_above_lines_set: bool);
957
958    fn get_property_pixels_below_lines(&self) -> i32;
959
960    fn set_property_pixels_below_lines(&self, pixels_below_lines: i32);
961
962    fn get_property_pixels_below_lines_set(&self) -> bool;
963
964    fn set_property_pixels_below_lines_set(&self, pixels_below_lines_set: bool);
965
966    fn get_property_pixels_inside_wrap(&self) -> i32;
967
968    fn set_property_pixels_inside_wrap(&self, pixels_inside_wrap: i32);
969
970    fn get_property_pixels_inside_wrap_set(&self) -> bool;
971
972    fn set_property_pixels_inside_wrap_set(&self, pixels_inside_wrap_set: bool);
973
974    fn get_property_right_margin(&self) -> i32;
975
976    fn set_property_right_margin(&self, right_margin: i32);
977
978    fn get_property_right_margin_set(&self) -> bool;
979
980    fn set_property_right_margin_set(&self, right_margin_set: bool);
981
982    fn get_property_rise(&self) -> i32;
983
984    fn set_property_rise(&self, rise: i32);
985
986    fn get_property_rise_set(&self) -> bool;
987
988    fn set_property_rise_set(&self, rise_set: bool);
989
990    fn get_property_scale(&self) -> f64;
991
992    fn set_property_scale(&self, scale: f64);
993
994    fn get_property_scale_set(&self) -> bool;
995
996    fn set_property_scale_set(&self, scale_set: bool);
997
998    fn get_property_size(&self) -> i32;
999
1000    fn set_property_size(&self, size: i32);
1001
1002    fn get_property_size_points(&self) -> f64;
1003
1004    fn set_property_size_points(&self, size_points: f64);
1005
1006    fn get_property_size_set(&self) -> bool;
1007
1008    fn set_property_size_set(&self, size_set: bool);
1009
1010    fn get_property_stretch(&self) -> pango::Stretch;
1011
1012    fn set_property_stretch(&self, stretch: pango::Stretch);
1013
1014    fn get_property_stretch_set(&self) -> bool;
1015
1016    fn set_property_stretch_set(&self, stretch_set: bool);
1017
1018    fn get_property_strikethrough(&self) -> bool;
1019
1020    fn set_property_strikethrough(&self, strikethrough: bool);
1021
1022    #[cfg(any(feature = "v3_16", feature = "dox"))]
1023    fn get_property_strikethrough_rgba(&self) -> Option<gdk::RGBA>;
1024
1025    #[cfg(any(feature = "v3_16", feature = "dox"))]
1026    fn set_property_strikethrough_rgba(&self, strikethrough_rgba: Option<&gdk::RGBA>);
1027
1028    #[cfg(any(feature = "v3_16", feature = "dox"))]
1029    fn get_property_strikethrough_rgba_set(&self) -> bool;
1030
1031    #[cfg(any(feature = "v3_16", feature = "dox"))]
1032    fn set_property_strikethrough_rgba_set(&self, strikethrough_rgba_set: bool);
1033
1034    fn get_property_strikethrough_set(&self) -> bool;
1035
1036    fn set_property_strikethrough_set(&self, strikethrough_set: bool);
1037
1038    fn get_property_style(&self) -> pango::Style;
1039
1040    fn set_property_style(&self, style: pango::Style);
1041
1042    fn get_property_style_set(&self) -> bool;
1043
1044    fn set_property_style_set(&self, style_set: bool);
1045
1046    fn get_property_tabs_set(&self) -> bool;
1047
1048    fn set_property_tabs_set(&self, tabs_set: bool);
1049
1050    fn get_property_underline(&self) -> pango::Underline;
1051
1052    fn set_property_underline(&self, underline: pango::Underline);
1053
1054    #[cfg(any(feature = "v3_16", feature = "dox"))]
1055    fn get_property_underline_rgba(&self) -> Option<gdk::RGBA>;
1056
1057    #[cfg(any(feature = "v3_16", feature = "dox"))]
1058    fn set_property_underline_rgba(&self, underline_rgba: Option<&gdk::RGBA>);
1059
1060    #[cfg(any(feature = "v3_16", feature = "dox"))]
1061    fn get_property_underline_rgba_set(&self) -> bool;
1062
1063    #[cfg(any(feature = "v3_16", feature = "dox"))]
1064    fn set_property_underline_rgba_set(&self, underline_rgba_set: bool);
1065
1066    fn get_property_underline_set(&self) -> bool;
1067
1068    fn set_property_underline_set(&self, underline_set: bool);
1069
1070    fn get_property_variant(&self) -> pango::Variant;
1071
1072    fn set_property_variant(&self, variant: pango::Variant);
1073
1074    fn get_property_variant_set(&self) -> bool;
1075
1076    fn set_property_variant_set(&self, variant_set: bool);
1077
1078    fn get_property_weight(&self) -> i32;
1079
1080    fn set_property_weight(&self, weight: i32);
1081
1082    fn get_property_weight_set(&self) -> bool;
1083
1084    fn set_property_weight_set(&self, weight_set: bool);
1085
1086    fn get_property_wrap_mode(&self) -> WrapMode;
1087
1088    fn set_property_wrap_mode(&self, wrap_mode: WrapMode);
1089
1090    fn get_property_wrap_mode_set(&self) -> bool;
1091
1092    fn set_property_wrap_mode_set(&self, wrap_mode_set: bool);
1093
1094    fn connect_event<F: Fn(&Self, &glib::Object, &gdk::Event, &TextIter) -> Inhibit + 'static>(
1095        &self,
1096        f: F,
1097    ) -> SignalHandlerId;
1098
1099    fn connect_property_accumulative_margin_notify<F: Fn(&Self) + 'static>(
1100        &self,
1101        f: F,
1102    ) -> SignalHandlerId;
1103
1104    fn connect_property_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1105
1106    fn connect_property_background_full_height_notify<F: Fn(&Self) + 'static>(
1107        &self,
1108        f: F,
1109    ) -> SignalHandlerId;
1110
1111    fn connect_property_background_full_height_set_notify<F: Fn(&Self) + 'static>(
1112        &self,
1113        f: F,
1114    ) -> SignalHandlerId;
1115
1116    fn connect_property_background_rgba_notify<F: Fn(&Self) + 'static>(
1117        &self,
1118        f: F,
1119    ) -> SignalHandlerId;
1120
1121    fn connect_property_background_set_notify<F: Fn(&Self) + 'static>(
1122        &self,
1123        f: F,
1124    ) -> SignalHandlerId;
1125
1126    fn connect_property_direction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1127
1128    fn connect_property_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1129
1130    fn connect_property_editable_set_notify<F: Fn(&Self) + 'static>(&self, f: F)
1131        -> SignalHandlerId;
1132
1133    #[cfg(any(feature = "v3_16", feature = "dox"))]
1134    fn connect_property_fallback_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1135
1136    fn connect_property_fallback_set_notify<F: Fn(&Self) + 'static>(&self, f: F)
1137        -> SignalHandlerId;
1138
1139    fn connect_property_family_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1140
1141    fn connect_property_family_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1142
1143    fn connect_property_font_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1144
1145    #[cfg(any(feature = "v3_18", feature = "dox"))]
1146    fn connect_property_font_features_notify<F: Fn(&Self) + 'static>(
1147        &self,
1148        f: F,
1149    ) -> SignalHandlerId;
1150
1151    fn connect_property_font_features_set_notify<F: Fn(&Self) + 'static>(
1152        &self,
1153        f: F,
1154    ) -> SignalHandlerId;
1155
1156    fn connect_property_foreground_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1157
1158    fn connect_property_foreground_rgba_notify<F: Fn(&Self) + 'static>(
1159        &self,
1160        f: F,
1161    ) -> SignalHandlerId;
1162
1163    fn connect_property_foreground_set_notify<F: Fn(&Self) + 'static>(
1164        &self,
1165        f: F,
1166    ) -> SignalHandlerId;
1167
1168    fn connect_property_indent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1169
1170    fn connect_property_indent_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1171
1172    fn connect_property_invisible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1173
1174    fn connect_property_invisible_set_notify<F: Fn(&Self) + 'static>(
1175        &self,
1176        f: F,
1177    ) -> SignalHandlerId;
1178
1179    fn connect_property_justification_notify<F: Fn(&Self) + 'static>(
1180        &self,
1181        f: F,
1182    ) -> SignalHandlerId;
1183
1184    fn connect_property_justification_set_notify<F: Fn(&Self) + 'static>(
1185        &self,
1186        f: F,
1187    ) -> SignalHandlerId;
1188
1189    fn connect_property_language_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1190
1191    fn connect_property_language_set_notify<F: Fn(&Self) + 'static>(&self, f: F)
1192        -> SignalHandlerId;
1193
1194    fn connect_property_left_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1195
1196    fn connect_property_left_margin_set_notify<F: Fn(&Self) + 'static>(
1197        &self,
1198        f: F,
1199    ) -> SignalHandlerId;
1200
1201    #[cfg(any(feature = "v3_16", feature = "dox"))]
1202    fn connect_property_letter_spacing_notify<F: Fn(&Self) + 'static>(
1203        &self,
1204        f: F,
1205    ) -> SignalHandlerId;
1206
1207    fn connect_property_letter_spacing_set_notify<F: Fn(&Self) + 'static>(
1208        &self,
1209        f: F,
1210    ) -> SignalHandlerId;
1211
1212    fn connect_property_paragraph_background_notify<F: Fn(&Self) + 'static>(
1213        &self,
1214        f: F,
1215    ) -> SignalHandlerId;
1216
1217    fn connect_property_paragraph_background_rgba_notify<F: Fn(&Self) + 'static>(
1218        &self,
1219        f: F,
1220    ) -> SignalHandlerId;
1221
1222    fn connect_property_paragraph_background_set_notify<F: Fn(&Self) + 'static>(
1223        &self,
1224        f: F,
1225    ) -> SignalHandlerId;
1226
1227    fn connect_property_pixels_above_lines_notify<F: Fn(&Self) + 'static>(
1228        &self,
1229        f: F,
1230    ) -> SignalHandlerId;
1231
1232    fn connect_property_pixels_above_lines_set_notify<F: Fn(&Self) + 'static>(
1233        &self,
1234        f: F,
1235    ) -> SignalHandlerId;
1236
1237    fn connect_property_pixels_below_lines_notify<F: Fn(&Self) + 'static>(
1238        &self,
1239        f: F,
1240    ) -> SignalHandlerId;
1241
1242    fn connect_property_pixels_below_lines_set_notify<F: Fn(&Self) + 'static>(
1243        &self,
1244        f: F,
1245    ) -> SignalHandlerId;
1246
1247    fn connect_property_pixels_inside_wrap_notify<F: Fn(&Self) + 'static>(
1248        &self,
1249        f: F,
1250    ) -> SignalHandlerId;
1251
1252    fn connect_property_pixels_inside_wrap_set_notify<F: Fn(&Self) + 'static>(
1253        &self,
1254        f: F,
1255    ) -> SignalHandlerId;
1256
1257    fn connect_property_right_margin_notify<F: Fn(&Self) + 'static>(&self, f: F)
1258        -> SignalHandlerId;
1259
1260    fn connect_property_right_margin_set_notify<F: Fn(&Self) + 'static>(
1261        &self,
1262        f: F,
1263    ) -> SignalHandlerId;
1264
1265    fn connect_property_rise_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1266
1267    fn connect_property_rise_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1268
1269    fn connect_property_scale_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1270
1271    fn connect_property_scale_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1272
1273    fn connect_property_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1274
1275    fn connect_property_size_points_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1276
1277    fn connect_property_size_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1278
1279    fn connect_property_stretch_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1280
1281    fn connect_property_stretch_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1282
1283    fn connect_property_strikethrough_notify<F: Fn(&Self) + 'static>(
1284        &self,
1285        f: F,
1286    ) -> SignalHandlerId;
1287
1288    #[cfg(any(feature = "v3_16", feature = "dox"))]
1289    fn connect_property_strikethrough_rgba_notify<F: Fn(&Self) + 'static>(
1290        &self,
1291        f: F,
1292    ) -> SignalHandlerId;
1293
1294    #[cfg(any(feature = "v3_16", feature = "dox"))]
1295    fn connect_property_strikethrough_rgba_set_notify<F: Fn(&Self) + 'static>(
1296        &self,
1297        f: F,
1298    ) -> SignalHandlerId;
1299
1300    fn connect_property_strikethrough_set_notify<F: Fn(&Self) + 'static>(
1301        &self,
1302        f: F,
1303    ) -> SignalHandlerId;
1304
1305    fn connect_property_style_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1306
1307    fn connect_property_style_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1308
1309    fn connect_property_tabs_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1310
1311    fn connect_property_underline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1312
1313    #[cfg(any(feature = "v3_16", feature = "dox"))]
1314    fn connect_property_underline_rgba_notify<F: Fn(&Self) + 'static>(
1315        &self,
1316        f: F,
1317    ) -> SignalHandlerId;
1318
1319    #[cfg(any(feature = "v3_16", feature = "dox"))]
1320    fn connect_property_underline_rgba_set_notify<F: Fn(&Self) + 'static>(
1321        &self,
1322        f: F,
1323    ) -> SignalHandlerId;
1324
1325    fn connect_property_underline_set_notify<F: Fn(&Self) + 'static>(
1326        &self,
1327        f: F,
1328    ) -> SignalHandlerId;
1329
1330    fn connect_property_variant_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1331
1332    fn connect_property_variant_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1333
1334    fn connect_property_weight_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1335
1336    fn connect_property_weight_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1337
1338    fn connect_property_wrap_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
1339
1340    fn connect_property_wrap_mode_set_notify<F: Fn(&Self) + 'static>(
1341        &self,
1342        f: F,
1343    ) -> SignalHandlerId;
1344}
1345
1346impl<O: IsA<TextTag>> TextTagExt for O {
1347    #[cfg(any(feature = "v3_20", feature = "dox"))]
1348    fn changed(&self, size_changed: bool) {
1349        unsafe {
1350            gtk_sys::gtk_text_tag_changed(self.as_ref().to_glib_none().0, size_changed.to_glib());
1351        }
1352    }
1353
1354    fn event<P: IsA<glib::Object>>(
1355        &self,
1356        event_object: &P,
1357        event: &gdk::Event,
1358        iter: &TextIter,
1359    ) -> bool {
1360        unsafe {
1361            from_glib(gtk_sys::gtk_text_tag_event(
1362                self.as_ref().to_glib_none().0,
1363                event_object.as_ref().to_glib_none().0,
1364                mut_override(event.to_glib_none().0),
1365                iter.to_glib_none().0,
1366            ))
1367        }
1368    }
1369
1370    fn get_priority(&self) -> i32 {
1371        unsafe { gtk_sys::gtk_text_tag_get_priority(self.as_ref().to_glib_none().0) }
1372    }
1373
1374    fn set_priority(&self, priority: i32) {
1375        unsafe {
1376            gtk_sys::gtk_text_tag_set_priority(self.as_ref().to_glib_none().0, priority);
1377        }
1378    }
1379
1380    fn get_property_accumulative_margin(&self) -> bool {
1381        unsafe {
1382            let mut value = Value::from_type(<bool as StaticType>::static_type());
1383            gobject_sys::g_object_get_property(
1384                self.to_glib_none().0 as *mut gobject_sys::GObject,
1385                b"accumulative-margin\0".as_ptr() as *const _,
1386                value.to_glib_none_mut().0,
1387            );
1388            value.get().unwrap()
1389        }
1390    }
1391
1392    fn set_property_accumulative_margin(&self, accumulative_margin: bool) {
1393        unsafe {
1394            gobject_sys::g_object_set_property(
1395                self.to_glib_none().0 as *mut gobject_sys::GObject,
1396                b"accumulative-margin\0".as_ptr() as *const _,
1397                Value::from(&accumulative_margin).to_glib_none().0,
1398            );
1399        }
1400    }
1401
1402    fn set_property_background(&self, background: Option<&str>) {
1403        unsafe {
1404            gobject_sys::g_object_set_property(
1405                self.to_glib_none().0 as *mut gobject_sys::GObject,
1406                b"background\0".as_ptr() as *const _,
1407                Value::from(background).to_glib_none().0,
1408            );
1409        }
1410    }
1411
1412    fn get_property_background_full_height(&self) -> bool {
1413        unsafe {
1414            let mut value = Value::from_type(<bool as StaticType>::static_type());
1415            gobject_sys::g_object_get_property(
1416                self.to_glib_none().0 as *mut gobject_sys::GObject,
1417                b"background-full-height\0".as_ptr() as *const _,
1418                value.to_glib_none_mut().0,
1419            );
1420            value.get().unwrap()
1421        }
1422    }
1423
1424    fn set_property_background_full_height(&self, background_full_height: bool) {
1425        unsafe {
1426            gobject_sys::g_object_set_property(
1427                self.to_glib_none().0 as *mut gobject_sys::GObject,
1428                b"background-full-height\0".as_ptr() as *const _,
1429                Value::from(&background_full_height).to_glib_none().0,
1430            );
1431        }
1432    }
1433
1434    fn get_property_background_full_height_set(&self) -> bool {
1435        unsafe {
1436            let mut value = Value::from_type(<bool as StaticType>::static_type());
1437            gobject_sys::g_object_get_property(
1438                self.to_glib_none().0 as *mut gobject_sys::GObject,
1439                b"background-full-height-set\0".as_ptr() as *const _,
1440                value.to_glib_none_mut().0,
1441            );
1442            value.get().unwrap()
1443        }
1444    }
1445
1446    fn set_property_background_full_height_set(&self, background_full_height_set: bool) {
1447        unsafe {
1448            gobject_sys::g_object_set_property(
1449                self.to_glib_none().0 as *mut gobject_sys::GObject,
1450                b"background-full-height-set\0".as_ptr() as *const _,
1451                Value::from(&background_full_height_set).to_glib_none().0,
1452            );
1453        }
1454    }
1455
1456    fn get_property_background_rgba(&self) -> Option<gdk::RGBA> {
1457        unsafe {
1458            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
1459            gobject_sys::g_object_get_property(
1460                self.to_glib_none().0 as *mut gobject_sys::GObject,
1461                b"background-rgba\0".as_ptr() as *const _,
1462                value.to_glib_none_mut().0,
1463            );
1464            value.get()
1465        }
1466    }
1467
1468    fn set_property_background_rgba(&self, background_rgba: Option<&gdk::RGBA>) {
1469        unsafe {
1470            gobject_sys::g_object_set_property(
1471                self.to_glib_none().0 as *mut gobject_sys::GObject,
1472                b"background-rgba\0".as_ptr() as *const _,
1473                Value::from(background_rgba).to_glib_none().0,
1474            );
1475        }
1476    }
1477
1478    fn get_property_background_set(&self) -> bool {
1479        unsafe {
1480            let mut value = Value::from_type(<bool as StaticType>::static_type());
1481            gobject_sys::g_object_get_property(
1482                self.to_glib_none().0 as *mut gobject_sys::GObject,
1483                b"background-set\0".as_ptr() as *const _,
1484                value.to_glib_none_mut().0,
1485            );
1486            value.get().unwrap()
1487        }
1488    }
1489
1490    fn set_property_background_set(&self, background_set: bool) {
1491        unsafe {
1492            gobject_sys::g_object_set_property(
1493                self.to_glib_none().0 as *mut gobject_sys::GObject,
1494                b"background-set\0".as_ptr() as *const _,
1495                Value::from(&background_set).to_glib_none().0,
1496            );
1497        }
1498    }
1499
1500    fn get_property_direction(&self) -> TextDirection {
1501        unsafe {
1502            let mut value = Value::from_type(<TextDirection as StaticType>::static_type());
1503            gobject_sys::g_object_get_property(
1504                self.to_glib_none().0 as *mut gobject_sys::GObject,
1505                b"direction\0".as_ptr() as *const _,
1506                value.to_glib_none_mut().0,
1507            );
1508            value.get().unwrap()
1509        }
1510    }
1511
1512    fn set_property_direction(&self, direction: TextDirection) {
1513        unsafe {
1514            gobject_sys::g_object_set_property(
1515                self.to_glib_none().0 as *mut gobject_sys::GObject,
1516                b"direction\0".as_ptr() as *const _,
1517                Value::from(&direction).to_glib_none().0,
1518            );
1519        }
1520    }
1521
1522    fn get_property_editable(&self) -> bool {
1523        unsafe {
1524            let mut value = Value::from_type(<bool as StaticType>::static_type());
1525            gobject_sys::g_object_get_property(
1526                self.to_glib_none().0 as *mut gobject_sys::GObject,
1527                b"editable\0".as_ptr() as *const _,
1528                value.to_glib_none_mut().0,
1529            );
1530            value.get().unwrap()
1531        }
1532    }
1533
1534    fn set_property_editable(&self, editable: bool) {
1535        unsafe {
1536            gobject_sys::g_object_set_property(
1537                self.to_glib_none().0 as *mut gobject_sys::GObject,
1538                b"editable\0".as_ptr() as *const _,
1539                Value::from(&editable).to_glib_none().0,
1540            );
1541        }
1542    }
1543
1544    fn get_property_editable_set(&self) -> bool {
1545        unsafe {
1546            let mut value = Value::from_type(<bool as StaticType>::static_type());
1547            gobject_sys::g_object_get_property(
1548                self.to_glib_none().0 as *mut gobject_sys::GObject,
1549                b"editable-set\0".as_ptr() as *const _,
1550                value.to_glib_none_mut().0,
1551            );
1552            value.get().unwrap()
1553        }
1554    }
1555
1556    fn set_property_editable_set(&self, editable_set: bool) {
1557        unsafe {
1558            gobject_sys::g_object_set_property(
1559                self.to_glib_none().0 as *mut gobject_sys::GObject,
1560                b"editable-set\0".as_ptr() as *const _,
1561                Value::from(&editable_set).to_glib_none().0,
1562            );
1563        }
1564    }
1565
1566    #[cfg(any(feature = "v3_16", feature = "dox"))]
1567    fn get_property_fallback(&self) -> bool {
1568        unsafe {
1569            let mut value = Value::from_type(<bool as StaticType>::static_type());
1570            gobject_sys::g_object_get_property(
1571                self.to_glib_none().0 as *mut gobject_sys::GObject,
1572                b"fallback\0".as_ptr() as *const _,
1573                value.to_glib_none_mut().0,
1574            );
1575            value.get().unwrap()
1576        }
1577    }
1578
1579    #[cfg(any(feature = "v3_16", feature = "dox"))]
1580    fn set_property_fallback(&self, fallback: bool) {
1581        unsafe {
1582            gobject_sys::g_object_set_property(
1583                self.to_glib_none().0 as *mut gobject_sys::GObject,
1584                b"fallback\0".as_ptr() as *const _,
1585                Value::from(&fallback).to_glib_none().0,
1586            );
1587        }
1588    }
1589
1590    fn get_property_fallback_set(&self) -> bool {
1591        unsafe {
1592            let mut value = Value::from_type(<bool as StaticType>::static_type());
1593            gobject_sys::g_object_get_property(
1594                self.to_glib_none().0 as *mut gobject_sys::GObject,
1595                b"fallback-set\0".as_ptr() as *const _,
1596                value.to_glib_none_mut().0,
1597            );
1598            value.get().unwrap()
1599        }
1600    }
1601
1602    fn set_property_fallback_set(&self, fallback_set: bool) {
1603        unsafe {
1604            gobject_sys::g_object_set_property(
1605                self.to_glib_none().0 as *mut gobject_sys::GObject,
1606                b"fallback-set\0".as_ptr() as *const _,
1607                Value::from(&fallback_set).to_glib_none().0,
1608            );
1609        }
1610    }
1611
1612    fn get_property_family(&self) -> Option<GString> {
1613        unsafe {
1614            let mut value = Value::from_type(<GString as StaticType>::static_type());
1615            gobject_sys::g_object_get_property(
1616                self.to_glib_none().0 as *mut gobject_sys::GObject,
1617                b"family\0".as_ptr() as *const _,
1618                value.to_glib_none_mut().0,
1619            );
1620            value.get()
1621        }
1622    }
1623
1624    fn set_property_family(&self, family: Option<&str>) {
1625        unsafe {
1626            gobject_sys::g_object_set_property(
1627                self.to_glib_none().0 as *mut gobject_sys::GObject,
1628                b"family\0".as_ptr() as *const _,
1629                Value::from(family).to_glib_none().0,
1630            );
1631        }
1632    }
1633
1634    fn get_property_family_set(&self) -> bool {
1635        unsafe {
1636            let mut value = Value::from_type(<bool as StaticType>::static_type());
1637            gobject_sys::g_object_get_property(
1638                self.to_glib_none().0 as *mut gobject_sys::GObject,
1639                b"family-set\0".as_ptr() as *const _,
1640                value.to_glib_none_mut().0,
1641            );
1642            value.get().unwrap()
1643        }
1644    }
1645
1646    fn set_property_family_set(&self, family_set: bool) {
1647        unsafe {
1648            gobject_sys::g_object_set_property(
1649                self.to_glib_none().0 as *mut gobject_sys::GObject,
1650                b"family-set\0".as_ptr() as *const _,
1651                Value::from(&family_set).to_glib_none().0,
1652            );
1653        }
1654    }
1655
1656    fn get_property_font(&self) -> Option<GString> {
1657        unsafe {
1658            let mut value = Value::from_type(<GString as StaticType>::static_type());
1659            gobject_sys::g_object_get_property(
1660                self.to_glib_none().0 as *mut gobject_sys::GObject,
1661                b"font\0".as_ptr() as *const _,
1662                value.to_glib_none_mut().0,
1663            );
1664            value.get()
1665        }
1666    }
1667
1668    fn set_property_font(&self, font: Option<&str>) {
1669        unsafe {
1670            gobject_sys::g_object_set_property(
1671                self.to_glib_none().0 as *mut gobject_sys::GObject,
1672                b"font\0".as_ptr() as *const _,
1673                Value::from(font).to_glib_none().0,
1674            );
1675        }
1676    }
1677
1678    #[cfg(any(feature = "v3_18", feature = "dox"))]
1679    fn get_property_font_features(&self) -> Option<GString> {
1680        unsafe {
1681            let mut value = Value::from_type(<GString as StaticType>::static_type());
1682            gobject_sys::g_object_get_property(
1683                self.to_glib_none().0 as *mut gobject_sys::GObject,
1684                b"font-features\0".as_ptr() as *const _,
1685                value.to_glib_none_mut().0,
1686            );
1687            value.get()
1688        }
1689    }
1690
1691    #[cfg(any(feature = "v3_18", feature = "dox"))]
1692    fn set_property_font_features(&self, font_features: Option<&str>) {
1693        unsafe {
1694            gobject_sys::g_object_set_property(
1695                self.to_glib_none().0 as *mut gobject_sys::GObject,
1696                b"font-features\0".as_ptr() as *const _,
1697                Value::from(font_features).to_glib_none().0,
1698            );
1699        }
1700    }
1701
1702    fn get_property_font_features_set(&self) -> bool {
1703        unsafe {
1704            let mut value = Value::from_type(<bool as StaticType>::static_type());
1705            gobject_sys::g_object_get_property(
1706                self.to_glib_none().0 as *mut gobject_sys::GObject,
1707                b"font-features-set\0".as_ptr() as *const _,
1708                value.to_glib_none_mut().0,
1709            );
1710            value.get().unwrap()
1711        }
1712    }
1713
1714    fn set_property_font_features_set(&self, font_features_set: bool) {
1715        unsafe {
1716            gobject_sys::g_object_set_property(
1717                self.to_glib_none().0 as *mut gobject_sys::GObject,
1718                b"font-features-set\0".as_ptr() as *const _,
1719                Value::from(&font_features_set).to_glib_none().0,
1720            );
1721        }
1722    }
1723
1724    fn set_property_foreground(&self, foreground: Option<&str>) {
1725        unsafe {
1726            gobject_sys::g_object_set_property(
1727                self.to_glib_none().0 as *mut gobject_sys::GObject,
1728                b"foreground\0".as_ptr() as *const _,
1729                Value::from(foreground).to_glib_none().0,
1730            );
1731        }
1732    }
1733
1734    fn get_property_foreground_rgba(&self) -> Option<gdk::RGBA> {
1735        unsafe {
1736            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
1737            gobject_sys::g_object_get_property(
1738                self.to_glib_none().0 as *mut gobject_sys::GObject,
1739                b"foreground-rgba\0".as_ptr() as *const _,
1740                value.to_glib_none_mut().0,
1741            );
1742            value.get()
1743        }
1744    }
1745
1746    fn set_property_foreground_rgba(&self, foreground_rgba: Option<&gdk::RGBA>) {
1747        unsafe {
1748            gobject_sys::g_object_set_property(
1749                self.to_glib_none().0 as *mut gobject_sys::GObject,
1750                b"foreground-rgba\0".as_ptr() as *const _,
1751                Value::from(foreground_rgba).to_glib_none().0,
1752            );
1753        }
1754    }
1755
1756    fn get_property_foreground_set(&self) -> bool {
1757        unsafe {
1758            let mut value = Value::from_type(<bool as StaticType>::static_type());
1759            gobject_sys::g_object_get_property(
1760                self.to_glib_none().0 as *mut gobject_sys::GObject,
1761                b"foreground-set\0".as_ptr() as *const _,
1762                value.to_glib_none_mut().0,
1763            );
1764            value.get().unwrap()
1765        }
1766    }
1767
1768    fn set_property_foreground_set(&self, foreground_set: bool) {
1769        unsafe {
1770            gobject_sys::g_object_set_property(
1771                self.to_glib_none().0 as *mut gobject_sys::GObject,
1772                b"foreground-set\0".as_ptr() as *const _,
1773                Value::from(&foreground_set).to_glib_none().0,
1774            );
1775        }
1776    }
1777
1778    fn get_property_indent(&self) -> i32 {
1779        unsafe {
1780            let mut value = Value::from_type(<i32 as StaticType>::static_type());
1781            gobject_sys::g_object_get_property(
1782                self.to_glib_none().0 as *mut gobject_sys::GObject,
1783                b"indent\0".as_ptr() as *const _,
1784                value.to_glib_none_mut().0,
1785            );
1786            value.get().unwrap()
1787        }
1788    }
1789
1790    fn set_property_indent(&self, indent: i32) {
1791        unsafe {
1792            gobject_sys::g_object_set_property(
1793                self.to_glib_none().0 as *mut gobject_sys::GObject,
1794                b"indent\0".as_ptr() as *const _,
1795                Value::from(&indent).to_glib_none().0,
1796            );
1797        }
1798    }
1799
1800    fn get_property_indent_set(&self) -> bool {
1801        unsafe {
1802            let mut value = Value::from_type(<bool as StaticType>::static_type());
1803            gobject_sys::g_object_get_property(
1804                self.to_glib_none().0 as *mut gobject_sys::GObject,
1805                b"indent-set\0".as_ptr() as *const _,
1806                value.to_glib_none_mut().0,
1807            );
1808            value.get().unwrap()
1809        }
1810    }
1811
1812    fn set_property_indent_set(&self, indent_set: bool) {
1813        unsafe {
1814            gobject_sys::g_object_set_property(
1815                self.to_glib_none().0 as *mut gobject_sys::GObject,
1816                b"indent-set\0".as_ptr() as *const _,
1817                Value::from(&indent_set).to_glib_none().0,
1818            );
1819        }
1820    }
1821
1822    fn get_property_invisible(&self) -> bool {
1823        unsafe {
1824            let mut value = Value::from_type(<bool as StaticType>::static_type());
1825            gobject_sys::g_object_get_property(
1826                self.to_glib_none().0 as *mut gobject_sys::GObject,
1827                b"invisible\0".as_ptr() as *const _,
1828                value.to_glib_none_mut().0,
1829            );
1830            value.get().unwrap()
1831        }
1832    }
1833
1834    fn set_property_invisible(&self, invisible: bool) {
1835        unsafe {
1836            gobject_sys::g_object_set_property(
1837                self.to_glib_none().0 as *mut gobject_sys::GObject,
1838                b"invisible\0".as_ptr() as *const _,
1839                Value::from(&invisible).to_glib_none().0,
1840            );
1841        }
1842    }
1843
1844    fn get_property_invisible_set(&self) -> bool {
1845        unsafe {
1846            let mut value = Value::from_type(<bool as StaticType>::static_type());
1847            gobject_sys::g_object_get_property(
1848                self.to_glib_none().0 as *mut gobject_sys::GObject,
1849                b"invisible-set\0".as_ptr() as *const _,
1850                value.to_glib_none_mut().0,
1851            );
1852            value.get().unwrap()
1853        }
1854    }
1855
1856    fn set_property_invisible_set(&self, invisible_set: bool) {
1857        unsafe {
1858            gobject_sys::g_object_set_property(
1859                self.to_glib_none().0 as *mut gobject_sys::GObject,
1860                b"invisible-set\0".as_ptr() as *const _,
1861                Value::from(&invisible_set).to_glib_none().0,
1862            );
1863        }
1864    }
1865
1866    fn get_property_justification(&self) -> Justification {
1867        unsafe {
1868            let mut value = Value::from_type(<Justification as StaticType>::static_type());
1869            gobject_sys::g_object_get_property(
1870                self.to_glib_none().0 as *mut gobject_sys::GObject,
1871                b"justification\0".as_ptr() as *const _,
1872                value.to_glib_none_mut().0,
1873            );
1874            value.get().unwrap()
1875        }
1876    }
1877
1878    fn set_property_justification(&self, justification: Justification) {
1879        unsafe {
1880            gobject_sys::g_object_set_property(
1881                self.to_glib_none().0 as *mut gobject_sys::GObject,
1882                b"justification\0".as_ptr() as *const _,
1883                Value::from(&justification).to_glib_none().0,
1884            );
1885        }
1886    }
1887
1888    fn get_property_justification_set(&self) -> bool {
1889        unsafe {
1890            let mut value = Value::from_type(<bool as StaticType>::static_type());
1891            gobject_sys::g_object_get_property(
1892                self.to_glib_none().0 as *mut gobject_sys::GObject,
1893                b"justification-set\0".as_ptr() as *const _,
1894                value.to_glib_none_mut().0,
1895            );
1896            value.get().unwrap()
1897        }
1898    }
1899
1900    fn set_property_justification_set(&self, justification_set: bool) {
1901        unsafe {
1902            gobject_sys::g_object_set_property(
1903                self.to_glib_none().0 as *mut gobject_sys::GObject,
1904                b"justification-set\0".as_ptr() as *const _,
1905                Value::from(&justification_set).to_glib_none().0,
1906            );
1907        }
1908    }
1909
1910    fn get_property_language(&self) -> Option<GString> {
1911        unsafe {
1912            let mut value = Value::from_type(<GString as StaticType>::static_type());
1913            gobject_sys::g_object_get_property(
1914                self.to_glib_none().0 as *mut gobject_sys::GObject,
1915                b"language\0".as_ptr() as *const _,
1916                value.to_glib_none_mut().0,
1917            );
1918            value.get()
1919        }
1920    }
1921
1922    fn set_property_language(&self, language: Option<&str>) {
1923        unsafe {
1924            gobject_sys::g_object_set_property(
1925                self.to_glib_none().0 as *mut gobject_sys::GObject,
1926                b"language\0".as_ptr() as *const _,
1927                Value::from(language).to_glib_none().0,
1928            );
1929        }
1930    }
1931
1932    fn get_property_language_set(&self) -> bool {
1933        unsafe {
1934            let mut value = Value::from_type(<bool as StaticType>::static_type());
1935            gobject_sys::g_object_get_property(
1936                self.to_glib_none().0 as *mut gobject_sys::GObject,
1937                b"language-set\0".as_ptr() as *const _,
1938                value.to_glib_none_mut().0,
1939            );
1940            value.get().unwrap()
1941        }
1942    }
1943
1944    fn set_property_language_set(&self, language_set: bool) {
1945        unsafe {
1946            gobject_sys::g_object_set_property(
1947                self.to_glib_none().0 as *mut gobject_sys::GObject,
1948                b"language-set\0".as_ptr() as *const _,
1949                Value::from(&language_set).to_glib_none().0,
1950            );
1951        }
1952    }
1953
1954    fn get_property_left_margin(&self) -> i32 {
1955        unsafe {
1956            let mut value = Value::from_type(<i32 as StaticType>::static_type());
1957            gobject_sys::g_object_get_property(
1958                self.to_glib_none().0 as *mut gobject_sys::GObject,
1959                b"left-margin\0".as_ptr() as *const _,
1960                value.to_glib_none_mut().0,
1961            );
1962            value.get().unwrap()
1963        }
1964    }
1965
1966    fn set_property_left_margin(&self, left_margin: i32) {
1967        unsafe {
1968            gobject_sys::g_object_set_property(
1969                self.to_glib_none().0 as *mut gobject_sys::GObject,
1970                b"left-margin\0".as_ptr() as *const _,
1971                Value::from(&left_margin).to_glib_none().0,
1972            );
1973        }
1974    }
1975
1976    fn get_property_left_margin_set(&self) -> bool {
1977        unsafe {
1978            let mut value = Value::from_type(<bool as StaticType>::static_type());
1979            gobject_sys::g_object_get_property(
1980                self.to_glib_none().0 as *mut gobject_sys::GObject,
1981                b"left-margin-set\0".as_ptr() as *const _,
1982                value.to_glib_none_mut().0,
1983            );
1984            value.get().unwrap()
1985        }
1986    }
1987
1988    fn set_property_left_margin_set(&self, left_margin_set: bool) {
1989        unsafe {
1990            gobject_sys::g_object_set_property(
1991                self.to_glib_none().0 as *mut gobject_sys::GObject,
1992                b"left-margin-set\0".as_ptr() as *const _,
1993                Value::from(&left_margin_set).to_glib_none().0,
1994            );
1995        }
1996    }
1997
1998    #[cfg(any(feature = "v3_16", feature = "dox"))]
1999    fn get_property_letter_spacing(&self) -> i32 {
2000        unsafe {
2001            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2002            gobject_sys::g_object_get_property(
2003                self.to_glib_none().0 as *mut gobject_sys::GObject,
2004                b"letter-spacing\0".as_ptr() as *const _,
2005                value.to_glib_none_mut().0,
2006            );
2007            value.get().unwrap()
2008        }
2009    }
2010
2011    #[cfg(any(feature = "v3_16", feature = "dox"))]
2012    fn set_property_letter_spacing(&self, letter_spacing: i32) {
2013        unsafe {
2014            gobject_sys::g_object_set_property(
2015                self.to_glib_none().0 as *mut gobject_sys::GObject,
2016                b"letter-spacing\0".as_ptr() as *const _,
2017                Value::from(&letter_spacing).to_glib_none().0,
2018            );
2019        }
2020    }
2021
2022    fn get_property_letter_spacing_set(&self) -> bool {
2023        unsafe {
2024            let mut value = Value::from_type(<bool as StaticType>::static_type());
2025            gobject_sys::g_object_get_property(
2026                self.to_glib_none().0 as *mut gobject_sys::GObject,
2027                b"letter-spacing-set\0".as_ptr() as *const _,
2028                value.to_glib_none_mut().0,
2029            );
2030            value.get().unwrap()
2031        }
2032    }
2033
2034    fn set_property_letter_spacing_set(&self, letter_spacing_set: bool) {
2035        unsafe {
2036            gobject_sys::g_object_set_property(
2037                self.to_glib_none().0 as *mut gobject_sys::GObject,
2038                b"letter-spacing-set\0".as_ptr() as *const _,
2039                Value::from(&letter_spacing_set).to_glib_none().0,
2040            );
2041        }
2042    }
2043
2044    fn get_property_name(&self) -> Option<GString> {
2045        unsafe {
2046            let mut value = Value::from_type(<GString as StaticType>::static_type());
2047            gobject_sys::g_object_get_property(
2048                self.to_glib_none().0 as *mut gobject_sys::GObject,
2049                b"name\0".as_ptr() as *const _,
2050                value.to_glib_none_mut().0,
2051            );
2052            value.get()
2053        }
2054    }
2055
2056    fn set_property_paragraph_background(&self, paragraph_background: Option<&str>) {
2057        unsafe {
2058            gobject_sys::g_object_set_property(
2059                self.to_glib_none().0 as *mut gobject_sys::GObject,
2060                b"paragraph-background\0".as_ptr() as *const _,
2061                Value::from(paragraph_background).to_glib_none().0,
2062            );
2063        }
2064    }
2065
2066    fn get_property_paragraph_background_rgba(&self) -> Option<gdk::RGBA> {
2067        unsafe {
2068            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
2069            gobject_sys::g_object_get_property(
2070                self.to_glib_none().0 as *mut gobject_sys::GObject,
2071                b"paragraph-background-rgba\0".as_ptr() as *const _,
2072                value.to_glib_none_mut().0,
2073            );
2074            value.get()
2075        }
2076    }
2077
2078    fn set_property_paragraph_background_rgba(
2079        &self,
2080        paragraph_background_rgba: Option<&gdk::RGBA>,
2081    ) {
2082        unsafe {
2083            gobject_sys::g_object_set_property(
2084                self.to_glib_none().0 as *mut gobject_sys::GObject,
2085                b"paragraph-background-rgba\0".as_ptr() as *const _,
2086                Value::from(paragraph_background_rgba).to_glib_none().0,
2087            );
2088        }
2089    }
2090
2091    fn get_property_paragraph_background_set(&self) -> bool {
2092        unsafe {
2093            let mut value = Value::from_type(<bool as StaticType>::static_type());
2094            gobject_sys::g_object_get_property(
2095                self.to_glib_none().0 as *mut gobject_sys::GObject,
2096                b"paragraph-background-set\0".as_ptr() as *const _,
2097                value.to_glib_none_mut().0,
2098            );
2099            value.get().unwrap()
2100        }
2101    }
2102
2103    fn set_property_paragraph_background_set(&self, paragraph_background_set: bool) {
2104        unsafe {
2105            gobject_sys::g_object_set_property(
2106                self.to_glib_none().0 as *mut gobject_sys::GObject,
2107                b"paragraph-background-set\0".as_ptr() as *const _,
2108                Value::from(&paragraph_background_set).to_glib_none().0,
2109            );
2110        }
2111    }
2112
2113    fn get_property_pixels_above_lines(&self) -> i32 {
2114        unsafe {
2115            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2116            gobject_sys::g_object_get_property(
2117                self.to_glib_none().0 as *mut gobject_sys::GObject,
2118                b"pixels-above-lines\0".as_ptr() as *const _,
2119                value.to_glib_none_mut().0,
2120            );
2121            value.get().unwrap()
2122        }
2123    }
2124
2125    fn set_property_pixels_above_lines(&self, pixels_above_lines: i32) {
2126        unsafe {
2127            gobject_sys::g_object_set_property(
2128                self.to_glib_none().0 as *mut gobject_sys::GObject,
2129                b"pixels-above-lines\0".as_ptr() as *const _,
2130                Value::from(&pixels_above_lines).to_glib_none().0,
2131            );
2132        }
2133    }
2134
2135    fn get_property_pixels_above_lines_set(&self) -> bool {
2136        unsafe {
2137            let mut value = Value::from_type(<bool as StaticType>::static_type());
2138            gobject_sys::g_object_get_property(
2139                self.to_glib_none().0 as *mut gobject_sys::GObject,
2140                b"pixels-above-lines-set\0".as_ptr() as *const _,
2141                value.to_glib_none_mut().0,
2142            );
2143            value.get().unwrap()
2144        }
2145    }
2146
2147    fn set_property_pixels_above_lines_set(&self, pixels_above_lines_set: bool) {
2148        unsafe {
2149            gobject_sys::g_object_set_property(
2150                self.to_glib_none().0 as *mut gobject_sys::GObject,
2151                b"pixels-above-lines-set\0".as_ptr() as *const _,
2152                Value::from(&pixels_above_lines_set).to_glib_none().0,
2153            );
2154        }
2155    }
2156
2157    fn get_property_pixels_below_lines(&self) -> i32 {
2158        unsafe {
2159            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2160            gobject_sys::g_object_get_property(
2161                self.to_glib_none().0 as *mut gobject_sys::GObject,
2162                b"pixels-below-lines\0".as_ptr() as *const _,
2163                value.to_glib_none_mut().0,
2164            );
2165            value.get().unwrap()
2166        }
2167    }
2168
2169    fn set_property_pixels_below_lines(&self, pixels_below_lines: i32) {
2170        unsafe {
2171            gobject_sys::g_object_set_property(
2172                self.to_glib_none().0 as *mut gobject_sys::GObject,
2173                b"pixels-below-lines\0".as_ptr() as *const _,
2174                Value::from(&pixels_below_lines).to_glib_none().0,
2175            );
2176        }
2177    }
2178
2179    fn get_property_pixels_below_lines_set(&self) -> bool {
2180        unsafe {
2181            let mut value = Value::from_type(<bool as StaticType>::static_type());
2182            gobject_sys::g_object_get_property(
2183                self.to_glib_none().0 as *mut gobject_sys::GObject,
2184                b"pixels-below-lines-set\0".as_ptr() as *const _,
2185                value.to_glib_none_mut().0,
2186            );
2187            value.get().unwrap()
2188        }
2189    }
2190
2191    fn set_property_pixels_below_lines_set(&self, pixels_below_lines_set: bool) {
2192        unsafe {
2193            gobject_sys::g_object_set_property(
2194                self.to_glib_none().0 as *mut gobject_sys::GObject,
2195                b"pixels-below-lines-set\0".as_ptr() as *const _,
2196                Value::from(&pixels_below_lines_set).to_glib_none().0,
2197            );
2198        }
2199    }
2200
2201    fn get_property_pixels_inside_wrap(&self) -> i32 {
2202        unsafe {
2203            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2204            gobject_sys::g_object_get_property(
2205                self.to_glib_none().0 as *mut gobject_sys::GObject,
2206                b"pixels-inside-wrap\0".as_ptr() as *const _,
2207                value.to_glib_none_mut().0,
2208            );
2209            value.get().unwrap()
2210        }
2211    }
2212
2213    fn set_property_pixels_inside_wrap(&self, pixels_inside_wrap: i32) {
2214        unsafe {
2215            gobject_sys::g_object_set_property(
2216                self.to_glib_none().0 as *mut gobject_sys::GObject,
2217                b"pixels-inside-wrap\0".as_ptr() as *const _,
2218                Value::from(&pixels_inside_wrap).to_glib_none().0,
2219            );
2220        }
2221    }
2222
2223    fn get_property_pixels_inside_wrap_set(&self) -> bool {
2224        unsafe {
2225            let mut value = Value::from_type(<bool as StaticType>::static_type());
2226            gobject_sys::g_object_get_property(
2227                self.to_glib_none().0 as *mut gobject_sys::GObject,
2228                b"pixels-inside-wrap-set\0".as_ptr() as *const _,
2229                value.to_glib_none_mut().0,
2230            );
2231            value.get().unwrap()
2232        }
2233    }
2234
2235    fn set_property_pixels_inside_wrap_set(&self, pixels_inside_wrap_set: bool) {
2236        unsafe {
2237            gobject_sys::g_object_set_property(
2238                self.to_glib_none().0 as *mut gobject_sys::GObject,
2239                b"pixels-inside-wrap-set\0".as_ptr() as *const _,
2240                Value::from(&pixels_inside_wrap_set).to_glib_none().0,
2241            );
2242        }
2243    }
2244
2245    fn get_property_right_margin(&self) -> i32 {
2246        unsafe {
2247            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2248            gobject_sys::g_object_get_property(
2249                self.to_glib_none().0 as *mut gobject_sys::GObject,
2250                b"right-margin\0".as_ptr() as *const _,
2251                value.to_glib_none_mut().0,
2252            );
2253            value.get().unwrap()
2254        }
2255    }
2256
2257    fn set_property_right_margin(&self, right_margin: i32) {
2258        unsafe {
2259            gobject_sys::g_object_set_property(
2260                self.to_glib_none().0 as *mut gobject_sys::GObject,
2261                b"right-margin\0".as_ptr() as *const _,
2262                Value::from(&right_margin).to_glib_none().0,
2263            );
2264        }
2265    }
2266
2267    fn get_property_right_margin_set(&self) -> bool {
2268        unsafe {
2269            let mut value = Value::from_type(<bool as StaticType>::static_type());
2270            gobject_sys::g_object_get_property(
2271                self.to_glib_none().0 as *mut gobject_sys::GObject,
2272                b"right-margin-set\0".as_ptr() as *const _,
2273                value.to_glib_none_mut().0,
2274            );
2275            value.get().unwrap()
2276        }
2277    }
2278
2279    fn set_property_right_margin_set(&self, right_margin_set: bool) {
2280        unsafe {
2281            gobject_sys::g_object_set_property(
2282                self.to_glib_none().0 as *mut gobject_sys::GObject,
2283                b"right-margin-set\0".as_ptr() as *const _,
2284                Value::from(&right_margin_set).to_glib_none().0,
2285            );
2286        }
2287    }
2288
2289    fn get_property_rise(&self) -> i32 {
2290        unsafe {
2291            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2292            gobject_sys::g_object_get_property(
2293                self.to_glib_none().0 as *mut gobject_sys::GObject,
2294                b"rise\0".as_ptr() as *const _,
2295                value.to_glib_none_mut().0,
2296            );
2297            value.get().unwrap()
2298        }
2299    }
2300
2301    fn set_property_rise(&self, rise: i32) {
2302        unsafe {
2303            gobject_sys::g_object_set_property(
2304                self.to_glib_none().0 as *mut gobject_sys::GObject,
2305                b"rise\0".as_ptr() as *const _,
2306                Value::from(&rise).to_glib_none().0,
2307            );
2308        }
2309    }
2310
2311    fn get_property_rise_set(&self) -> bool {
2312        unsafe {
2313            let mut value = Value::from_type(<bool as StaticType>::static_type());
2314            gobject_sys::g_object_get_property(
2315                self.to_glib_none().0 as *mut gobject_sys::GObject,
2316                b"rise-set\0".as_ptr() as *const _,
2317                value.to_glib_none_mut().0,
2318            );
2319            value.get().unwrap()
2320        }
2321    }
2322
2323    fn set_property_rise_set(&self, rise_set: bool) {
2324        unsafe {
2325            gobject_sys::g_object_set_property(
2326                self.to_glib_none().0 as *mut gobject_sys::GObject,
2327                b"rise-set\0".as_ptr() as *const _,
2328                Value::from(&rise_set).to_glib_none().0,
2329            );
2330        }
2331    }
2332
2333    fn get_property_scale(&self) -> f64 {
2334        unsafe {
2335            let mut value = Value::from_type(<f64 as StaticType>::static_type());
2336            gobject_sys::g_object_get_property(
2337                self.to_glib_none().0 as *mut gobject_sys::GObject,
2338                b"scale\0".as_ptr() as *const _,
2339                value.to_glib_none_mut().0,
2340            );
2341            value.get().unwrap()
2342        }
2343    }
2344
2345    fn set_property_scale(&self, scale: f64) {
2346        unsafe {
2347            gobject_sys::g_object_set_property(
2348                self.to_glib_none().0 as *mut gobject_sys::GObject,
2349                b"scale\0".as_ptr() as *const _,
2350                Value::from(&scale).to_glib_none().0,
2351            );
2352        }
2353    }
2354
2355    fn get_property_scale_set(&self) -> bool {
2356        unsafe {
2357            let mut value = Value::from_type(<bool as StaticType>::static_type());
2358            gobject_sys::g_object_get_property(
2359                self.to_glib_none().0 as *mut gobject_sys::GObject,
2360                b"scale-set\0".as_ptr() as *const _,
2361                value.to_glib_none_mut().0,
2362            );
2363            value.get().unwrap()
2364        }
2365    }
2366
2367    fn set_property_scale_set(&self, scale_set: bool) {
2368        unsafe {
2369            gobject_sys::g_object_set_property(
2370                self.to_glib_none().0 as *mut gobject_sys::GObject,
2371                b"scale-set\0".as_ptr() as *const _,
2372                Value::from(&scale_set).to_glib_none().0,
2373            );
2374        }
2375    }
2376
2377    fn get_property_size(&self) -> i32 {
2378        unsafe {
2379            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2380            gobject_sys::g_object_get_property(
2381                self.to_glib_none().0 as *mut gobject_sys::GObject,
2382                b"size\0".as_ptr() as *const _,
2383                value.to_glib_none_mut().0,
2384            );
2385            value.get().unwrap()
2386        }
2387    }
2388
2389    fn set_property_size(&self, size: i32) {
2390        unsafe {
2391            gobject_sys::g_object_set_property(
2392                self.to_glib_none().0 as *mut gobject_sys::GObject,
2393                b"size\0".as_ptr() as *const _,
2394                Value::from(&size).to_glib_none().0,
2395            );
2396        }
2397    }
2398
2399    fn get_property_size_points(&self) -> f64 {
2400        unsafe {
2401            let mut value = Value::from_type(<f64 as StaticType>::static_type());
2402            gobject_sys::g_object_get_property(
2403                self.to_glib_none().0 as *mut gobject_sys::GObject,
2404                b"size-points\0".as_ptr() as *const _,
2405                value.to_glib_none_mut().0,
2406            );
2407            value.get().unwrap()
2408        }
2409    }
2410
2411    fn set_property_size_points(&self, size_points: f64) {
2412        unsafe {
2413            gobject_sys::g_object_set_property(
2414                self.to_glib_none().0 as *mut gobject_sys::GObject,
2415                b"size-points\0".as_ptr() as *const _,
2416                Value::from(&size_points).to_glib_none().0,
2417            );
2418        }
2419    }
2420
2421    fn get_property_size_set(&self) -> bool {
2422        unsafe {
2423            let mut value = Value::from_type(<bool as StaticType>::static_type());
2424            gobject_sys::g_object_get_property(
2425                self.to_glib_none().0 as *mut gobject_sys::GObject,
2426                b"size-set\0".as_ptr() as *const _,
2427                value.to_glib_none_mut().0,
2428            );
2429            value.get().unwrap()
2430        }
2431    }
2432
2433    fn set_property_size_set(&self, size_set: bool) {
2434        unsafe {
2435            gobject_sys::g_object_set_property(
2436                self.to_glib_none().0 as *mut gobject_sys::GObject,
2437                b"size-set\0".as_ptr() as *const _,
2438                Value::from(&size_set).to_glib_none().0,
2439            );
2440        }
2441    }
2442
2443    fn get_property_stretch(&self) -> pango::Stretch {
2444        unsafe {
2445            let mut value = Value::from_type(<pango::Stretch as StaticType>::static_type());
2446            gobject_sys::g_object_get_property(
2447                self.to_glib_none().0 as *mut gobject_sys::GObject,
2448                b"stretch\0".as_ptr() as *const _,
2449                value.to_glib_none_mut().0,
2450            );
2451            value.get().unwrap()
2452        }
2453    }
2454
2455    fn set_property_stretch(&self, stretch: pango::Stretch) {
2456        unsafe {
2457            gobject_sys::g_object_set_property(
2458                self.to_glib_none().0 as *mut gobject_sys::GObject,
2459                b"stretch\0".as_ptr() as *const _,
2460                Value::from(&stretch).to_glib_none().0,
2461            );
2462        }
2463    }
2464
2465    fn get_property_stretch_set(&self) -> bool {
2466        unsafe {
2467            let mut value = Value::from_type(<bool as StaticType>::static_type());
2468            gobject_sys::g_object_get_property(
2469                self.to_glib_none().0 as *mut gobject_sys::GObject,
2470                b"stretch-set\0".as_ptr() as *const _,
2471                value.to_glib_none_mut().0,
2472            );
2473            value.get().unwrap()
2474        }
2475    }
2476
2477    fn set_property_stretch_set(&self, stretch_set: bool) {
2478        unsafe {
2479            gobject_sys::g_object_set_property(
2480                self.to_glib_none().0 as *mut gobject_sys::GObject,
2481                b"stretch-set\0".as_ptr() as *const _,
2482                Value::from(&stretch_set).to_glib_none().0,
2483            );
2484        }
2485    }
2486
2487    fn get_property_strikethrough(&self) -> bool {
2488        unsafe {
2489            let mut value = Value::from_type(<bool as StaticType>::static_type());
2490            gobject_sys::g_object_get_property(
2491                self.to_glib_none().0 as *mut gobject_sys::GObject,
2492                b"strikethrough\0".as_ptr() as *const _,
2493                value.to_glib_none_mut().0,
2494            );
2495            value.get().unwrap()
2496        }
2497    }
2498
2499    fn set_property_strikethrough(&self, strikethrough: bool) {
2500        unsafe {
2501            gobject_sys::g_object_set_property(
2502                self.to_glib_none().0 as *mut gobject_sys::GObject,
2503                b"strikethrough\0".as_ptr() as *const _,
2504                Value::from(&strikethrough).to_glib_none().0,
2505            );
2506        }
2507    }
2508
2509    #[cfg(any(feature = "v3_16", feature = "dox"))]
2510    fn get_property_strikethrough_rgba(&self) -> Option<gdk::RGBA> {
2511        unsafe {
2512            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
2513            gobject_sys::g_object_get_property(
2514                self.to_glib_none().0 as *mut gobject_sys::GObject,
2515                b"strikethrough-rgba\0".as_ptr() as *const _,
2516                value.to_glib_none_mut().0,
2517            );
2518            value.get()
2519        }
2520    }
2521
2522    #[cfg(any(feature = "v3_16", feature = "dox"))]
2523    fn set_property_strikethrough_rgba(&self, strikethrough_rgba: Option<&gdk::RGBA>) {
2524        unsafe {
2525            gobject_sys::g_object_set_property(
2526                self.to_glib_none().0 as *mut gobject_sys::GObject,
2527                b"strikethrough-rgba\0".as_ptr() as *const _,
2528                Value::from(strikethrough_rgba).to_glib_none().0,
2529            );
2530        }
2531    }
2532
2533    #[cfg(any(feature = "v3_16", feature = "dox"))]
2534    fn get_property_strikethrough_rgba_set(&self) -> bool {
2535        unsafe {
2536            let mut value = Value::from_type(<bool as StaticType>::static_type());
2537            gobject_sys::g_object_get_property(
2538                self.to_glib_none().0 as *mut gobject_sys::GObject,
2539                b"strikethrough-rgba-set\0".as_ptr() as *const _,
2540                value.to_glib_none_mut().0,
2541            );
2542            value.get().unwrap()
2543        }
2544    }
2545
2546    #[cfg(any(feature = "v3_16", feature = "dox"))]
2547    fn set_property_strikethrough_rgba_set(&self, strikethrough_rgba_set: bool) {
2548        unsafe {
2549            gobject_sys::g_object_set_property(
2550                self.to_glib_none().0 as *mut gobject_sys::GObject,
2551                b"strikethrough-rgba-set\0".as_ptr() as *const _,
2552                Value::from(&strikethrough_rgba_set).to_glib_none().0,
2553            );
2554        }
2555    }
2556
2557    fn get_property_strikethrough_set(&self) -> bool {
2558        unsafe {
2559            let mut value = Value::from_type(<bool as StaticType>::static_type());
2560            gobject_sys::g_object_get_property(
2561                self.to_glib_none().0 as *mut gobject_sys::GObject,
2562                b"strikethrough-set\0".as_ptr() as *const _,
2563                value.to_glib_none_mut().0,
2564            );
2565            value.get().unwrap()
2566        }
2567    }
2568
2569    fn set_property_strikethrough_set(&self, strikethrough_set: bool) {
2570        unsafe {
2571            gobject_sys::g_object_set_property(
2572                self.to_glib_none().0 as *mut gobject_sys::GObject,
2573                b"strikethrough-set\0".as_ptr() as *const _,
2574                Value::from(&strikethrough_set).to_glib_none().0,
2575            );
2576        }
2577    }
2578
2579    fn get_property_style(&self) -> pango::Style {
2580        unsafe {
2581            let mut value = Value::from_type(<pango::Style as StaticType>::static_type());
2582            gobject_sys::g_object_get_property(
2583                self.to_glib_none().0 as *mut gobject_sys::GObject,
2584                b"style\0".as_ptr() as *const _,
2585                value.to_glib_none_mut().0,
2586            );
2587            value.get().unwrap()
2588        }
2589    }
2590
2591    fn set_property_style(&self, style: pango::Style) {
2592        unsafe {
2593            gobject_sys::g_object_set_property(
2594                self.to_glib_none().0 as *mut gobject_sys::GObject,
2595                b"style\0".as_ptr() as *const _,
2596                Value::from(&style).to_glib_none().0,
2597            );
2598        }
2599    }
2600
2601    fn get_property_style_set(&self) -> bool {
2602        unsafe {
2603            let mut value = Value::from_type(<bool as StaticType>::static_type());
2604            gobject_sys::g_object_get_property(
2605                self.to_glib_none().0 as *mut gobject_sys::GObject,
2606                b"style-set\0".as_ptr() as *const _,
2607                value.to_glib_none_mut().0,
2608            );
2609            value.get().unwrap()
2610        }
2611    }
2612
2613    fn set_property_style_set(&self, style_set: bool) {
2614        unsafe {
2615            gobject_sys::g_object_set_property(
2616                self.to_glib_none().0 as *mut gobject_sys::GObject,
2617                b"style-set\0".as_ptr() as *const _,
2618                Value::from(&style_set).to_glib_none().0,
2619            );
2620        }
2621    }
2622
2623    fn get_property_tabs_set(&self) -> bool {
2624        unsafe {
2625            let mut value = Value::from_type(<bool as StaticType>::static_type());
2626            gobject_sys::g_object_get_property(
2627                self.to_glib_none().0 as *mut gobject_sys::GObject,
2628                b"tabs-set\0".as_ptr() as *const _,
2629                value.to_glib_none_mut().0,
2630            );
2631            value.get().unwrap()
2632        }
2633    }
2634
2635    fn set_property_tabs_set(&self, tabs_set: bool) {
2636        unsafe {
2637            gobject_sys::g_object_set_property(
2638                self.to_glib_none().0 as *mut gobject_sys::GObject,
2639                b"tabs-set\0".as_ptr() as *const _,
2640                Value::from(&tabs_set).to_glib_none().0,
2641            );
2642        }
2643    }
2644
2645    fn get_property_underline(&self) -> pango::Underline {
2646        unsafe {
2647            let mut value = Value::from_type(<pango::Underline as StaticType>::static_type());
2648            gobject_sys::g_object_get_property(
2649                self.to_glib_none().0 as *mut gobject_sys::GObject,
2650                b"underline\0".as_ptr() as *const _,
2651                value.to_glib_none_mut().0,
2652            );
2653            value.get().unwrap()
2654        }
2655    }
2656
2657    fn set_property_underline(&self, underline: pango::Underline) {
2658        unsafe {
2659            gobject_sys::g_object_set_property(
2660                self.to_glib_none().0 as *mut gobject_sys::GObject,
2661                b"underline\0".as_ptr() as *const _,
2662                Value::from(&underline).to_glib_none().0,
2663            );
2664        }
2665    }
2666
2667    #[cfg(any(feature = "v3_16", feature = "dox"))]
2668    fn get_property_underline_rgba(&self) -> Option<gdk::RGBA> {
2669        unsafe {
2670            let mut value = Value::from_type(<gdk::RGBA as StaticType>::static_type());
2671            gobject_sys::g_object_get_property(
2672                self.to_glib_none().0 as *mut gobject_sys::GObject,
2673                b"underline-rgba\0".as_ptr() as *const _,
2674                value.to_glib_none_mut().0,
2675            );
2676            value.get()
2677        }
2678    }
2679
2680    #[cfg(any(feature = "v3_16", feature = "dox"))]
2681    fn set_property_underline_rgba(&self, underline_rgba: Option<&gdk::RGBA>) {
2682        unsafe {
2683            gobject_sys::g_object_set_property(
2684                self.to_glib_none().0 as *mut gobject_sys::GObject,
2685                b"underline-rgba\0".as_ptr() as *const _,
2686                Value::from(underline_rgba).to_glib_none().0,
2687            );
2688        }
2689    }
2690
2691    #[cfg(any(feature = "v3_16", feature = "dox"))]
2692    fn get_property_underline_rgba_set(&self) -> bool {
2693        unsafe {
2694            let mut value = Value::from_type(<bool as StaticType>::static_type());
2695            gobject_sys::g_object_get_property(
2696                self.to_glib_none().0 as *mut gobject_sys::GObject,
2697                b"underline-rgba-set\0".as_ptr() as *const _,
2698                value.to_glib_none_mut().0,
2699            );
2700            value.get().unwrap()
2701        }
2702    }
2703
2704    #[cfg(any(feature = "v3_16", feature = "dox"))]
2705    fn set_property_underline_rgba_set(&self, underline_rgba_set: bool) {
2706        unsafe {
2707            gobject_sys::g_object_set_property(
2708                self.to_glib_none().0 as *mut gobject_sys::GObject,
2709                b"underline-rgba-set\0".as_ptr() as *const _,
2710                Value::from(&underline_rgba_set).to_glib_none().0,
2711            );
2712        }
2713    }
2714
2715    fn get_property_underline_set(&self) -> bool {
2716        unsafe {
2717            let mut value = Value::from_type(<bool as StaticType>::static_type());
2718            gobject_sys::g_object_get_property(
2719                self.to_glib_none().0 as *mut gobject_sys::GObject,
2720                b"underline-set\0".as_ptr() as *const _,
2721                value.to_glib_none_mut().0,
2722            );
2723            value.get().unwrap()
2724        }
2725    }
2726
2727    fn set_property_underline_set(&self, underline_set: bool) {
2728        unsafe {
2729            gobject_sys::g_object_set_property(
2730                self.to_glib_none().0 as *mut gobject_sys::GObject,
2731                b"underline-set\0".as_ptr() as *const _,
2732                Value::from(&underline_set).to_glib_none().0,
2733            );
2734        }
2735    }
2736
2737    fn get_property_variant(&self) -> pango::Variant {
2738        unsafe {
2739            let mut value = Value::from_type(<pango::Variant as StaticType>::static_type());
2740            gobject_sys::g_object_get_property(
2741                self.to_glib_none().0 as *mut gobject_sys::GObject,
2742                b"variant\0".as_ptr() as *const _,
2743                value.to_glib_none_mut().0,
2744            );
2745            value.get().unwrap()
2746        }
2747    }
2748
2749    fn set_property_variant(&self, variant: pango::Variant) {
2750        unsafe {
2751            gobject_sys::g_object_set_property(
2752                self.to_glib_none().0 as *mut gobject_sys::GObject,
2753                b"variant\0".as_ptr() as *const _,
2754                Value::from(&variant).to_glib_none().0,
2755            );
2756        }
2757    }
2758
2759    fn get_property_variant_set(&self) -> bool {
2760        unsafe {
2761            let mut value = Value::from_type(<bool as StaticType>::static_type());
2762            gobject_sys::g_object_get_property(
2763                self.to_glib_none().0 as *mut gobject_sys::GObject,
2764                b"variant-set\0".as_ptr() as *const _,
2765                value.to_glib_none_mut().0,
2766            );
2767            value.get().unwrap()
2768        }
2769    }
2770
2771    fn set_property_variant_set(&self, variant_set: bool) {
2772        unsafe {
2773            gobject_sys::g_object_set_property(
2774                self.to_glib_none().0 as *mut gobject_sys::GObject,
2775                b"variant-set\0".as_ptr() as *const _,
2776                Value::from(&variant_set).to_glib_none().0,
2777            );
2778        }
2779    }
2780
2781    fn get_property_weight(&self) -> i32 {
2782        unsafe {
2783            let mut value = Value::from_type(<i32 as StaticType>::static_type());
2784            gobject_sys::g_object_get_property(
2785                self.to_glib_none().0 as *mut gobject_sys::GObject,
2786                b"weight\0".as_ptr() as *const _,
2787                value.to_glib_none_mut().0,
2788            );
2789            value.get().unwrap()
2790        }
2791    }
2792
2793    fn set_property_weight(&self, weight: i32) {
2794        unsafe {
2795            gobject_sys::g_object_set_property(
2796                self.to_glib_none().0 as *mut gobject_sys::GObject,
2797                b"weight\0".as_ptr() as *const _,
2798                Value::from(&weight).to_glib_none().0,
2799            );
2800        }
2801    }
2802
2803    fn get_property_weight_set(&self) -> bool {
2804        unsafe {
2805            let mut value = Value::from_type(<bool as StaticType>::static_type());
2806            gobject_sys::g_object_get_property(
2807                self.to_glib_none().0 as *mut gobject_sys::GObject,
2808                b"weight-set\0".as_ptr() as *const _,
2809                value.to_glib_none_mut().0,
2810            );
2811            value.get().unwrap()
2812        }
2813    }
2814
2815    fn set_property_weight_set(&self, weight_set: bool) {
2816        unsafe {
2817            gobject_sys::g_object_set_property(
2818                self.to_glib_none().0 as *mut gobject_sys::GObject,
2819                b"weight-set\0".as_ptr() as *const _,
2820                Value::from(&weight_set).to_glib_none().0,
2821            );
2822        }
2823    }
2824
2825    fn get_property_wrap_mode(&self) -> WrapMode {
2826        unsafe {
2827            let mut value = Value::from_type(<WrapMode as StaticType>::static_type());
2828            gobject_sys::g_object_get_property(
2829                self.to_glib_none().0 as *mut gobject_sys::GObject,
2830                b"wrap-mode\0".as_ptr() as *const _,
2831                value.to_glib_none_mut().0,
2832            );
2833            value.get().unwrap()
2834        }
2835    }
2836
2837    fn set_property_wrap_mode(&self, wrap_mode: WrapMode) {
2838        unsafe {
2839            gobject_sys::g_object_set_property(
2840                self.to_glib_none().0 as *mut gobject_sys::GObject,
2841                b"wrap-mode\0".as_ptr() as *const _,
2842                Value::from(&wrap_mode).to_glib_none().0,
2843            );
2844        }
2845    }
2846
2847    fn get_property_wrap_mode_set(&self) -> bool {
2848        unsafe {
2849            let mut value = Value::from_type(<bool as StaticType>::static_type());
2850            gobject_sys::g_object_get_property(
2851                self.to_glib_none().0 as *mut gobject_sys::GObject,
2852                b"wrap-mode-set\0".as_ptr() as *const _,
2853                value.to_glib_none_mut().0,
2854            );
2855            value.get().unwrap()
2856        }
2857    }
2858
2859    fn set_property_wrap_mode_set(&self, wrap_mode_set: bool) {
2860        unsafe {
2861            gobject_sys::g_object_set_property(
2862                self.to_glib_none().0 as *mut gobject_sys::GObject,
2863                b"wrap-mode-set\0".as_ptr() as *const _,
2864                Value::from(&wrap_mode_set).to_glib_none().0,
2865            );
2866        }
2867    }
2868
2869    fn connect_event<F: Fn(&Self, &glib::Object, &gdk::Event, &TextIter) -> Inhibit + 'static>(
2870        &self,
2871        f: F,
2872    ) -> SignalHandlerId {
2873        unsafe extern "C" fn event_trampoline<
2874            P,
2875            F: Fn(&P, &glib::Object, &gdk::Event, &TextIter) -> Inhibit + 'static,
2876        >(
2877            this: *mut gtk_sys::GtkTextTag,
2878            object: *mut gobject_sys::GObject,
2879            event: *mut gdk_sys::GdkEvent,
2880            iter: *mut gtk_sys::GtkTextIter,
2881            f: glib_sys::gpointer,
2882        ) -> glib_sys::gboolean
2883        where
2884            P: IsA<TextTag>,
2885        {
2886            let f: &F = &*(f as *const F);
2887            f(
2888                &TextTag::from_glib_borrow(this).unsafe_cast(),
2889                &from_glib_borrow(object),
2890                &from_glib_none(event),
2891                &from_glib_borrow(iter),
2892            )
2893            .to_glib()
2894        }
2895        unsafe {
2896            let f: Box_<F> = Box_::new(f);
2897            connect_raw(
2898                self.as_ptr() as *mut _,
2899                b"event\0".as_ptr() as *const _,
2900                Some(transmute(event_trampoline::<Self, F> as usize)),
2901                Box_::into_raw(f),
2902            )
2903        }
2904    }
2905
2906    fn connect_property_accumulative_margin_notify<F: Fn(&Self) + 'static>(
2907        &self,
2908        f: F,
2909    ) -> SignalHandlerId {
2910        unsafe extern "C" fn notify_accumulative_margin_trampoline<P, F: Fn(&P) + 'static>(
2911            this: *mut gtk_sys::GtkTextTag,
2912            _param_spec: glib_sys::gpointer,
2913            f: glib_sys::gpointer,
2914        ) where
2915            P: IsA<TextTag>,
2916        {
2917            let f: &F = &*(f as *const F);
2918            f(&TextTag::from_glib_borrow(this).unsafe_cast())
2919        }
2920        unsafe {
2921            let f: Box_<F> = Box_::new(f);
2922            connect_raw(
2923                self.as_ptr() as *mut _,
2924                b"notify::accumulative-margin\0".as_ptr() as *const _,
2925                Some(transmute(
2926                    notify_accumulative_margin_trampoline::<Self, F> as usize,
2927                )),
2928                Box_::into_raw(f),
2929            )
2930        }
2931    }
2932
2933    fn connect_property_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2934        unsafe extern "C" fn notify_background_trampoline<P, F: Fn(&P) + 'static>(
2935            this: *mut gtk_sys::GtkTextTag,
2936            _param_spec: glib_sys::gpointer,
2937            f: glib_sys::gpointer,
2938        ) where
2939            P: IsA<TextTag>,
2940        {
2941            let f: &F = &*(f as *const F);
2942            f(&TextTag::from_glib_borrow(this).unsafe_cast())
2943        }
2944        unsafe {
2945            let f: Box_<F> = Box_::new(f);
2946            connect_raw(
2947                self.as_ptr() as *mut _,
2948                b"notify::background\0".as_ptr() as *const _,
2949                Some(transmute(notify_background_trampoline::<Self, F> as usize)),
2950                Box_::into_raw(f),
2951            )
2952        }
2953    }
2954
2955    fn connect_property_background_full_height_notify<F: Fn(&Self) + 'static>(
2956        &self,
2957        f: F,
2958    ) -> SignalHandlerId {
2959        unsafe extern "C" fn notify_background_full_height_trampoline<P, F: Fn(&P) + 'static>(
2960            this: *mut gtk_sys::GtkTextTag,
2961            _param_spec: glib_sys::gpointer,
2962            f: glib_sys::gpointer,
2963        ) where
2964            P: IsA<TextTag>,
2965        {
2966            let f: &F = &*(f as *const F);
2967            f(&TextTag::from_glib_borrow(this).unsafe_cast())
2968        }
2969        unsafe {
2970            let f: Box_<F> = Box_::new(f);
2971            connect_raw(
2972                self.as_ptr() as *mut _,
2973                b"notify::background-full-height\0".as_ptr() as *const _,
2974                Some(transmute(
2975                    notify_background_full_height_trampoline::<Self, F> as usize,
2976                )),
2977                Box_::into_raw(f),
2978            )
2979        }
2980    }
2981
2982    fn connect_property_background_full_height_set_notify<F: Fn(&Self) + 'static>(
2983        &self,
2984        f: F,
2985    ) -> SignalHandlerId {
2986        unsafe extern "C" fn notify_background_full_height_set_trampoline<P, F: Fn(&P) + 'static>(
2987            this: *mut gtk_sys::GtkTextTag,
2988            _param_spec: glib_sys::gpointer,
2989            f: glib_sys::gpointer,
2990        ) where
2991            P: IsA<TextTag>,
2992        {
2993            let f: &F = &*(f as *const F);
2994            f(&TextTag::from_glib_borrow(this).unsafe_cast())
2995        }
2996        unsafe {
2997            let f: Box_<F> = Box_::new(f);
2998            connect_raw(
2999                self.as_ptr() as *mut _,
3000                b"notify::background-full-height-set\0".as_ptr() as *const _,
3001                Some(transmute(
3002                    notify_background_full_height_set_trampoline::<Self, F> as usize,
3003                )),
3004                Box_::into_raw(f),
3005            )
3006        }
3007    }
3008
3009    fn connect_property_background_rgba_notify<F: Fn(&Self) + 'static>(
3010        &self,
3011        f: F,
3012    ) -> SignalHandlerId {
3013        unsafe extern "C" fn notify_background_rgba_trampoline<P, F: Fn(&P) + 'static>(
3014            this: *mut gtk_sys::GtkTextTag,
3015            _param_spec: glib_sys::gpointer,
3016            f: glib_sys::gpointer,
3017        ) where
3018            P: IsA<TextTag>,
3019        {
3020            let f: &F = &*(f as *const F);
3021            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3022        }
3023        unsafe {
3024            let f: Box_<F> = Box_::new(f);
3025            connect_raw(
3026                self.as_ptr() as *mut _,
3027                b"notify::background-rgba\0".as_ptr() as *const _,
3028                Some(transmute(
3029                    notify_background_rgba_trampoline::<Self, F> as usize,
3030                )),
3031                Box_::into_raw(f),
3032            )
3033        }
3034    }
3035
3036    fn connect_property_background_set_notify<F: Fn(&Self) + 'static>(
3037        &self,
3038        f: F,
3039    ) -> SignalHandlerId {
3040        unsafe extern "C" fn notify_background_set_trampoline<P, F: Fn(&P) + 'static>(
3041            this: *mut gtk_sys::GtkTextTag,
3042            _param_spec: glib_sys::gpointer,
3043            f: glib_sys::gpointer,
3044        ) where
3045            P: IsA<TextTag>,
3046        {
3047            let f: &F = &*(f as *const F);
3048            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3049        }
3050        unsafe {
3051            let f: Box_<F> = Box_::new(f);
3052            connect_raw(
3053                self.as_ptr() as *mut _,
3054                b"notify::background-set\0".as_ptr() as *const _,
3055                Some(transmute(
3056                    notify_background_set_trampoline::<Self, F> as usize,
3057                )),
3058                Box_::into_raw(f),
3059            )
3060        }
3061    }
3062
3063    fn connect_property_direction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3064        unsafe extern "C" fn notify_direction_trampoline<P, F: Fn(&P) + 'static>(
3065            this: *mut gtk_sys::GtkTextTag,
3066            _param_spec: glib_sys::gpointer,
3067            f: glib_sys::gpointer,
3068        ) where
3069            P: IsA<TextTag>,
3070        {
3071            let f: &F = &*(f as *const F);
3072            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3073        }
3074        unsafe {
3075            let f: Box_<F> = Box_::new(f);
3076            connect_raw(
3077                self.as_ptr() as *mut _,
3078                b"notify::direction\0".as_ptr() as *const _,
3079                Some(transmute(notify_direction_trampoline::<Self, F> as usize)),
3080                Box_::into_raw(f),
3081            )
3082        }
3083    }
3084
3085    fn connect_property_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3086        unsafe extern "C" fn notify_editable_trampoline<P, F: Fn(&P) + 'static>(
3087            this: *mut gtk_sys::GtkTextTag,
3088            _param_spec: glib_sys::gpointer,
3089            f: glib_sys::gpointer,
3090        ) where
3091            P: IsA<TextTag>,
3092        {
3093            let f: &F = &*(f as *const F);
3094            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3095        }
3096        unsafe {
3097            let f: Box_<F> = Box_::new(f);
3098            connect_raw(
3099                self.as_ptr() as *mut _,
3100                b"notify::editable\0".as_ptr() as *const _,
3101                Some(transmute(notify_editable_trampoline::<Self, F> as usize)),
3102                Box_::into_raw(f),
3103            )
3104        }
3105    }
3106
3107    fn connect_property_editable_set_notify<F: Fn(&Self) + 'static>(
3108        &self,
3109        f: F,
3110    ) -> SignalHandlerId {
3111        unsafe extern "C" fn notify_editable_set_trampoline<P, F: Fn(&P) + 'static>(
3112            this: *mut gtk_sys::GtkTextTag,
3113            _param_spec: glib_sys::gpointer,
3114            f: glib_sys::gpointer,
3115        ) where
3116            P: IsA<TextTag>,
3117        {
3118            let f: &F = &*(f as *const F);
3119            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3120        }
3121        unsafe {
3122            let f: Box_<F> = Box_::new(f);
3123            connect_raw(
3124                self.as_ptr() as *mut _,
3125                b"notify::editable-set\0".as_ptr() as *const _,
3126                Some(transmute(
3127                    notify_editable_set_trampoline::<Self, F> as usize,
3128                )),
3129                Box_::into_raw(f),
3130            )
3131        }
3132    }
3133
3134    #[cfg(any(feature = "v3_16", feature = "dox"))]
3135    fn connect_property_fallback_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3136        unsafe extern "C" fn notify_fallback_trampoline<P, F: Fn(&P) + 'static>(
3137            this: *mut gtk_sys::GtkTextTag,
3138            _param_spec: glib_sys::gpointer,
3139            f: glib_sys::gpointer,
3140        ) where
3141            P: IsA<TextTag>,
3142        {
3143            let f: &F = &*(f as *const F);
3144            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3145        }
3146        unsafe {
3147            let f: Box_<F> = Box_::new(f);
3148            connect_raw(
3149                self.as_ptr() as *mut _,
3150                b"notify::fallback\0".as_ptr() as *const _,
3151                Some(transmute(notify_fallback_trampoline::<Self, F> as usize)),
3152                Box_::into_raw(f),
3153            )
3154        }
3155    }
3156
3157    fn connect_property_fallback_set_notify<F: Fn(&Self) + 'static>(
3158        &self,
3159        f: F,
3160    ) -> SignalHandlerId {
3161        unsafe extern "C" fn notify_fallback_set_trampoline<P, F: Fn(&P) + 'static>(
3162            this: *mut gtk_sys::GtkTextTag,
3163            _param_spec: glib_sys::gpointer,
3164            f: glib_sys::gpointer,
3165        ) where
3166            P: IsA<TextTag>,
3167        {
3168            let f: &F = &*(f as *const F);
3169            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3170        }
3171        unsafe {
3172            let f: Box_<F> = Box_::new(f);
3173            connect_raw(
3174                self.as_ptr() as *mut _,
3175                b"notify::fallback-set\0".as_ptr() as *const _,
3176                Some(transmute(
3177                    notify_fallback_set_trampoline::<Self, F> as usize,
3178                )),
3179                Box_::into_raw(f),
3180            )
3181        }
3182    }
3183
3184    fn connect_property_family_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3185        unsafe extern "C" fn notify_family_trampoline<P, F: Fn(&P) + 'static>(
3186            this: *mut gtk_sys::GtkTextTag,
3187            _param_spec: glib_sys::gpointer,
3188            f: glib_sys::gpointer,
3189        ) where
3190            P: IsA<TextTag>,
3191        {
3192            let f: &F = &*(f as *const F);
3193            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3194        }
3195        unsafe {
3196            let f: Box_<F> = Box_::new(f);
3197            connect_raw(
3198                self.as_ptr() as *mut _,
3199                b"notify::family\0".as_ptr() as *const _,
3200                Some(transmute(notify_family_trampoline::<Self, F> as usize)),
3201                Box_::into_raw(f),
3202            )
3203        }
3204    }
3205
3206    fn connect_property_family_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3207        unsafe extern "C" fn notify_family_set_trampoline<P, F: Fn(&P) + 'static>(
3208            this: *mut gtk_sys::GtkTextTag,
3209            _param_spec: glib_sys::gpointer,
3210            f: glib_sys::gpointer,
3211        ) where
3212            P: IsA<TextTag>,
3213        {
3214            let f: &F = &*(f as *const F);
3215            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3216        }
3217        unsafe {
3218            let f: Box_<F> = Box_::new(f);
3219            connect_raw(
3220                self.as_ptr() as *mut _,
3221                b"notify::family-set\0".as_ptr() as *const _,
3222                Some(transmute(notify_family_set_trampoline::<Self, F> as usize)),
3223                Box_::into_raw(f),
3224            )
3225        }
3226    }
3227
3228    fn connect_property_font_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3229        unsafe extern "C" fn notify_font_trampoline<P, F: Fn(&P) + 'static>(
3230            this: *mut gtk_sys::GtkTextTag,
3231            _param_spec: glib_sys::gpointer,
3232            f: glib_sys::gpointer,
3233        ) where
3234            P: IsA<TextTag>,
3235        {
3236            let f: &F = &*(f as *const F);
3237            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3238        }
3239        unsafe {
3240            let f: Box_<F> = Box_::new(f);
3241            connect_raw(
3242                self.as_ptr() as *mut _,
3243                b"notify::font\0".as_ptr() as *const _,
3244                Some(transmute(notify_font_trampoline::<Self, F> as usize)),
3245                Box_::into_raw(f),
3246            )
3247        }
3248    }
3249
3250    #[cfg(any(feature = "v3_18", feature = "dox"))]
3251    fn connect_property_font_features_notify<F: Fn(&Self) + 'static>(
3252        &self,
3253        f: F,
3254    ) -> SignalHandlerId {
3255        unsafe extern "C" fn notify_font_features_trampoline<P, F: Fn(&P) + 'static>(
3256            this: *mut gtk_sys::GtkTextTag,
3257            _param_spec: glib_sys::gpointer,
3258            f: glib_sys::gpointer,
3259        ) where
3260            P: IsA<TextTag>,
3261        {
3262            let f: &F = &*(f as *const F);
3263            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3264        }
3265        unsafe {
3266            let f: Box_<F> = Box_::new(f);
3267            connect_raw(
3268                self.as_ptr() as *mut _,
3269                b"notify::font-features\0".as_ptr() as *const _,
3270                Some(transmute(
3271                    notify_font_features_trampoline::<Self, F> as usize,
3272                )),
3273                Box_::into_raw(f),
3274            )
3275        }
3276    }
3277
3278    fn connect_property_font_features_set_notify<F: Fn(&Self) + 'static>(
3279        &self,
3280        f: F,
3281    ) -> SignalHandlerId {
3282        unsafe extern "C" fn notify_font_features_set_trampoline<P, F: Fn(&P) + 'static>(
3283            this: *mut gtk_sys::GtkTextTag,
3284            _param_spec: glib_sys::gpointer,
3285            f: glib_sys::gpointer,
3286        ) where
3287            P: IsA<TextTag>,
3288        {
3289            let f: &F = &*(f as *const F);
3290            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3291        }
3292        unsafe {
3293            let f: Box_<F> = Box_::new(f);
3294            connect_raw(
3295                self.as_ptr() as *mut _,
3296                b"notify::font-features-set\0".as_ptr() as *const _,
3297                Some(transmute(
3298                    notify_font_features_set_trampoline::<Self, F> as usize,
3299                )),
3300                Box_::into_raw(f),
3301            )
3302        }
3303    }
3304
3305    fn connect_property_foreground_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3306        unsafe extern "C" fn notify_foreground_trampoline<P, F: Fn(&P) + 'static>(
3307            this: *mut gtk_sys::GtkTextTag,
3308            _param_spec: glib_sys::gpointer,
3309            f: glib_sys::gpointer,
3310        ) where
3311            P: IsA<TextTag>,
3312        {
3313            let f: &F = &*(f as *const F);
3314            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3315        }
3316        unsafe {
3317            let f: Box_<F> = Box_::new(f);
3318            connect_raw(
3319                self.as_ptr() as *mut _,
3320                b"notify::foreground\0".as_ptr() as *const _,
3321                Some(transmute(notify_foreground_trampoline::<Self, F> as usize)),
3322                Box_::into_raw(f),
3323            )
3324        }
3325    }
3326
3327    fn connect_property_foreground_rgba_notify<F: Fn(&Self) + 'static>(
3328        &self,
3329        f: F,
3330    ) -> SignalHandlerId {
3331        unsafe extern "C" fn notify_foreground_rgba_trampoline<P, F: Fn(&P) + 'static>(
3332            this: *mut gtk_sys::GtkTextTag,
3333            _param_spec: glib_sys::gpointer,
3334            f: glib_sys::gpointer,
3335        ) where
3336            P: IsA<TextTag>,
3337        {
3338            let f: &F = &*(f as *const F);
3339            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3340        }
3341        unsafe {
3342            let f: Box_<F> = Box_::new(f);
3343            connect_raw(
3344                self.as_ptr() as *mut _,
3345                b"notify::foreground-rgba\0".as_ptr() as *const _,
3346                Some(transmute(
3347                    notify_foreground_rgba_trampoline::<Self, F> as usize,
3348                )),
3349                Box_::into_raw(f),
3350            )
3351        }
3352    }
3353
3354    fn connect_property_foreground_set_notify<F: Fn(&Self) + 'static>(
3355        &self,
3356        f: F,
3357    ) -> SignalHandlerId {
3358        unsafe extern "C" fn notify_foreground_set_trampoline<P, F: Fn(&P) + 'static>(
3359            this: *mut gtk_sys::GtkTextTag,
3360            _param_spec: glib_sys::gpointer,
3361            f: glib_sys::gpointer,
3362        ) where
3363            P: IsA<TextTag>,
3364        {
3365            let f: &F = &*(f as *const F);
3366            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3367        }
3368        unsafe {
3369            let f: Box_<F> = Box_::new(f);
3370            connect_raw(
3371                self.as_ptr() as *mut _,
3372                b"notify::foreground-set\0".as_ptr() as *const _,
3373                Some(transmute(
3374                    notify_foreground_set_trampoline::<Self, F> as usize,
3375                )),
3376                Box_::into_raw(f),
3377            )
3378        }
3379    }
3380
3381    fn connect_property_indent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3382        unsafe extern "C" fn notify_indent_trampoline<P, F: Fn(&P) + 'static>(
3383            this: *mut gtk_sys::GtkTextTag,
3384            _param_spec: glib_sys::gpointer,
3385            f: glib_sys::gpointer,
3386        ) where
3387            P: IsA<TextTag>,
3388        {
3389            let f: &F = &*(f as *const F);
3390            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3391        }
3392        unsafe {
3393            let f: Box_<F> = Box_::new(f);
3394            connect_raw(
3395                self.as_ptr() as *mut _,
3396                b"notify::indent\0".as_ptr() as *const _,
3397                Some(transmute(notify_indent_trampoline::<Self, F> as usize)),
3398                Box_::into_raw(f),
3399            )
3400        }
3401    }
3402
3403    fn connect_property_indent_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3404        unsafe extern "C" fn notify_indent_set_trampoline<P, F: Fn(&P) + 'static>(
3405            this: *mut gtk_sys::GtkTextTag,
3406            _param_spec: glib_sys::gpointer,
3407            f: glib_sys::gpointer,
3408        ) where
3409            P: IsA<TextTag>,
3410        {
3411            let f: &F = &*(f as *const F);
3412            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3413        }
3414        unsafe {
3415            let f: Box_<F> = Box_::new(f);
3416            connect_raw(
3417                self.as_ptr() as *mut _,
3418                b"notify::indent-set\0".as_ptr() as *const _,
3419                Some(transmute(notify_indent_set_trampoline::<Self, F> as usize)),
3420                Box_::into_raw(f),
3421            )
3422        }
3423    }
3424
3425    fn connect_property_invisible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3426        unsafe extern "C" fn notify_invisible_trampoline<P, F: Fn(&P) + 'static>(
3427            this: *mut gtk_sys::GtkTextTag,
3428            _param_spec: glib_sys::gpointer,
3429            f: glib_sys::gpointer,
3430        ) where
3431            P: IsA<TextTag>,
3432        {
3433            let f: &F = &*(f as *const F);
3434            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3435        }
3436        unsafe {
3437            let f: Box_<F> = Box_::new(f);
3438            connect_raw(
3439                self.as_ptr() as *mut _,
3440                b"notify::invisible\0".as_ptr() as *const _,
3441                Some(transmute(notify_invisible_trampoline::<Self, F> as usize)),
3442                Box_::into_raw(f),
3443            )
3444        }
3445    }
3446
3447    fn connect_property_invisible_set_notify<F: Fn(&Self) + 'static>(
3448        &self,
3449        f: F,
3450    ) -> SignalHandlerId {
3451        unsafe extern "C" fn notify_invisible_set_trampoline<P, F: Fn(&P) + 'static>(
3452            this: *mut gtk_sys::GtkTextTag,
3453            _param_spec: glib_sys::gpointer,
3454            f: glib_sys::gpointer,
3455        ) where
3456            P: IsA<TextTag>,
3457        {
3458            let f: &F = &*(f as *const F);
3459            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3460        }
3461        unsafe {
3462            let f: Box_<F> = Box_::new(f);
3463            connect_raw(
3464                self.as_ptr() as *mut _,
3465                b"notify::invisible-set\0".as_ptr() as *const _,
3466                Some(transmute(
3467                    notify_invisible_set_trampoline::<Self, F> as usize,
3468                )),
3469                Box_::into_raw(f),
3470            )
3471        }
3472    }
3473
3474    fn connect_property_justification_notify<F: Fn(&Self) + 'static>(
3475        &self,
3476        f: F,
3477    ) -> SignalHandlerId {
3478        unsafe extern "C" fn notify_justification_trampoline<P, F: Fn(&P) + 'static>(
3479            this: *mut gtk_sys::GtkTextTag,
3480            _param_spec: glib_sys::gpointer,
3481            f: glib_sys::gpointer,
3482        ) where
3483            P: IsA<TextTag>,
3484        {
3485            let f: &F = &*(f as *const F);
3486            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3487        }
3488        unsafe {
3489            let f: Box_<F> = Box_::new(f);
3490            connect_raw(
3491                self.as_ptr() as *mut _,
3492                b"notify::justification\0".as_ptr() as *const _,
3493                Some(transmute(
3494                    notify_justification_trampoline::<Self, F> as usize,
3495                )),
3496                Box_::into_raw(f),
3497            )
3498        }
3499    }
3500
3501    fn connect_property_justification_set_notify<F: Fn(&Self) + 'static>(
3502        &self,
3503        f: F,
3504    ) -> SignalHandlerId {
3505        unsafe extern "C" fn notify_justification_set_trampoline<P, F: Fn(&P) + 'static>(
3506            this: *mut gtk_sys::GtkTextTag,
3507            _param_spec: glib_sys::gpointer,
3508            f: glib_sys::gpointer,
3509        ) where
3510            P: IsA<TextTag>,
3511        {
3512            let f: &F = &*(f as *const F);
3513            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3514        }
3515        unsafe {
3516            let f: Box_<F> = Box_::new(f);
3517            connect_raw(
3518                self.as_ptr() as *mut _,
3519                b"notify::justification-set\0".as_ptr() as *const _,
3520                Some(transmute(
3521                    notify_justification_set_trampoline::<Self, F> as usize,
3522                )),
3523                Box_::into_raw(f),
3524            )
3525        }
3526    }
3527
3528    fn connect_property_language_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3529        unsafe extern "C" fn notify_language_trampoline<P, F: Fn(&P) + 'static>(
3530            this: *mut gtk_sys::GtkTextTag,
3531            _param_spec: glib_sys::gpointer,
3532            f: glib_sys::gpointer,
3533        ) where
3534            P: IsA<TextTag>,
3535        {
3536            let f: &F = &*(f as *const F);
3537            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3538        }
3539        unsafe {
3540            let f: Box_<F> = Box_::new(f);
3541            connect_raw(
3542                self.as_ptr() as *mut _,
3543                b"notify::language\0".as_ptr() as *const _,
3544                Some(transmute(notify_language_trampoline::<Self, F> as usize)),
3545                Box_::into_raw(f),
3546            )
3547        }
3548    }
3549
3550    fn connect_property_language_set_notify<F: Fn(&Self) + 'static>(
3551        &self,
3552        f: F,
3553    ) -> SignalHandlerId {
3554        unsafe extern "C" fn notify_language_set_trampoline<P, F: Fn(&P) + 'static>(
3555            this: *mut gtk_sys::GtkTextTag,
3556            _param_spec: glib_sys::gpointer,
3557            f: glib_sys::gpointer,
3558        ) where
3559            P: IsA<TextTag>,
3560        {
3561            let f: &F = &*(f as *const F);
3562            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3563        }
3564        unsafe {
3565            let f: Box_<F> = Box_::new(f);
3566            connect_raw(
3567                self.as_ptr() as *mut _,
3568                b"notify::language-set\0".as_ptr() as *const _,
3569                Some(transmute(
3570                    notify_language_set_trampoline::<Self, F> as usize,
3571                )),
3572                Box_::into_raw(f),
3573            )
3574        }
3575    }
3576
3577    fn connect_property_left_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3578        unsafe extern "C" fn notify_left_margin_trampoline<P, F: Fn(&P) + 'static>(
3579            this: *mut gtk_sys::GtkTextTag,
3580            _param_spec: glib_sys::gpointer,
3581            f: glib_sys::gpointer,
3582        ) where
3583            P: IsA<TextTag>,
3584        {
3585            let f: &F = &*(f as *const F);
3586            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3587        }
3588        unsafe {
3589            let f: Box_<F> = Box_::new(f);
3590            connect_raw(
3591                self.as_ptr() as *mut _,
3592                b"notify::left-margin\0".as_ptr() as *const _,
3593                Some(transmute(notify_left_margin_trampoline::<Self, F> as usize)),
3594                Box_::into_raw(f),
3595            )
3596        }
3597    }
3598
3599    fn connect_property_left_margin_set_notify<F: Fn(&Self) + 'static>(
3600        &self,
3601        f: F,
3602    ) -> SignalHandlerId {
3603        unsafe extern "C" fn notify_left_margin_set_trampoline<P, F: Fn(&P) + 'static>(
3604            this: *mut gtk_sys::GtkTextTag,
3605            _param_spec: glib_sys::gpointer,
3606            f: glib_sys::gpointer,
3607        ) where
3608            P: IsA<TextTag>,
3609        {
3610            let f: &F = &*(f as *const F);
3611            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3612        }
3613        unsafe {
3614            let f: Box_<F> = Box_::new(f);
3615            connect_raw(
3616                self.as_ptr() as *mut _,
3617                b"notify::left-margin-set\0".as_ptr() as *const _,
3618                Some(transmute(
3619                    notify_left_margin_set_trampoline::<Self, F> as usize,
3620                )),
3621                Box_::into_raw(f),
3622            )
3623        }
3624    }
3625
3626    #[cfg(any(feature = "v3_16", feature = "dox"))]
3627    fn connect_property_letter_spacing_notify<F: Fn(&Self) + 'static>(
3628        &self,
3629        f: F,
3630    ) -> SignalHandlerId {
3631        unsafe extern "C" fn notify_letter_spacing_trampoline<P, F: Fn(&P) + 'static>(
3632            this: *mut gtk_sys::GtkTextTag,
3633            _param_spec: glib_sys::gpointer,
3634            f: glib_sys::gpointer,
3635        ) where
3636            P: IsA<TextTag>,
3637        {
3638            let f: &F = &*(f as *const F);
3639            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3640        }
3641        unsafe {
3642            let f: Box_<F> = Box_::new(f);
3643            connect_raw(
3644                self.as_ptr() as *mut _,
3645                b"notify::letter-spacing\0".as_ptr() as *const _,
3646                Some(transmute(
3647                    notify_letter_spacing_trampoline::<Self, F> as usize,
3648                )),
3649                Box_::into_raw(f),
3650            )
3651        }
3652    }
3653
3654    fn connect_property_letter_spacing_set_notify<F: Fn(&Self) + 'static>(
3655        &self,
3656        f: F,
3657    ) -> SignalHandlerId {
3658        unsafe extern "C" fn notify_letter_spacing_set_trampoline<P, F: Fn(&P) + 'static>(
3659            this: *mut gtk_sys::GtkTextTag,
3660            _param_spec: glib_sys::gpointer,
3661            f: glib_sys::gpointer,
3662        ) where
3663            P: IsA<TextTag>,
3664        {
3665            let f: &F = &*(f as *const F);
3666            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3667        }
3668        unsafe {
3669            let f: Box_<F> = Box_::new(f);
3670            connect_raw(
3671                self.as_ptr() as *mut _,
3672                b"notify::letter-spacing-set\0".as_ptr() as *const _,
3673                Some(transmute(
3674                    notify_letter_spacing_set_trampoline::<Self, F> as usize,
3675                )),
3676                Box_::into_raw(f),
3677            )
3678        }
3679    }
3680
3681    fn connect_property_paragraph_background_notify<F: Fn(&Self) + 'static>(
3682        &self,
3683        f: F,
3684    ) -> SignalHandlerId {
3685        unsafe extern "C" fn notify_paragraph_background_trampoline<P, F: Fn(&P) + 'static>(
3686            this: *mut gtk_sys::GtkTextTag,
3687            _param_spec: glib_sys::gpointer,
3688            f: glib_sys::gpointer,
3689        ) where
3690            P: IsA<TextTag>,
3691        {
3692            let f: &F = &*(f as *const F);
3693            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3694        }
3695        unsafe {
3696            let f: Box_<F> = Box_::new(f);
3697            connect_raw(
3698                self.as_ptr() as *mut _,
3699                b"notify::paragraph-background\0".as_ptr() as *const _,
3700                Some(transmute(
3701                    notify_paragraph_background_trampoline::<Self, F> as usize,
3702                )),
3703                Box_::into_raw(f),
3704            )
3705        }
3706    }
3707
3708    fn connect_property_paragraph_background_rgba_notify<F: Fn(&Self) + 'static>(
3709        &self,
3710        f: F,
3711    ) -> SignalHandlerId {
3712        unsafe extern "C" fn notify_paragraph_background_rgba_trampoline<P, F: Fn(&P) + 'static>(
3713            this: *mut gtk_sys::GtkTextTag,
3714            _param_spec: glib_sys::gpointer,
3715            f: glib_sys::gpointer,
3716        ) where
3717            P: IsA<TextTag>,
3718        {
3719            let f: &F = &*(f as *const F);
3720            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3721        }
3722        unsafe {
3723            let f: Box_<F> = Box_::new(f);
3724            connect_raw(
3725                self.as_ptr() as *mut _,
3726                b"notify::paragraph-background-rgba\0".as_ptr() as *const _,
3727                Some(transmute(
3728                    notify_paragraph_background_rgba_trampoline::<Self, F> as usize,
3729                )),
3730                Box_::into_raw(f),
3731            )
3732        }
3733    }
3734
3735    fn connect_property_paragraph_background_set_notify<F: Fn(&Self) + 'static>(
3736        &self,
3737        f: F,
3738    ) -> SignalHandlerId {
3739        unsafe extern "C" fn notify_paragraph_background_set_trampoline<P, F: Fn(&P) + 'static>(
3740            this: *mut gtk_sys::GtkTextTag,
3741            _param_spec: glib_sys::gpointer,
3742            f: glib_sys::gpointer,
3743        ) where
3744            P: IsA<TextTag>,
3745        {
3746            let f: &F = &*(f as *const F);
3747            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3748        }
3749        unsafe {
3750            let f: Box_<F> = Box_::new(f);
3751            connect_raw(
3752                self.as_ptr() as *mut _,
3753                b"notify::paragraph-background-set\0".as_ptr() as *const _,
3754                Some(transmute(
3755                    notify_paragraph_background_set_trampoline::<Self, F> as usize,
3756                )),
3757                Box_::into_raw(f),
3758            )
3759        }
3760    }
3761
3762    fn connect_property_pixels_above_lines_notify<F: Fn(&Self) + 'static>(
3763        &self,
3764        f: F,
3765    ) -> SignalHandlerId {
3766        unsafe extern "C" fn notify_pixels_above_lines_trampoline<P, F: Fn(&P) + 'static>(
3767            this: *mut gtk_sys::GtkTextTag,
3768            _param_spec: glib_sys::gpointer,
3769            f: glib_sys::gpointer,
3770        ) where
3771            P: IsA<TextTag>,
3772        {
3773            let f: &F = &*(f as *const F);
3774            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3775        }
3776        unsafe {
3777            let f: Box_<F> = Box_::new(f);
3778            connect_raw(
3779                self.as_ptr() as *mut _,
3780                b"notify::pixels-above-lines\0".as_ptr() as *const _,
3781                Some(transmute(
3782                    notify_pixels_above_lines_trampoline::<Self, F> as usize,
3783                )),
3784                Box_::into_raw(f),
3785            )
3786        }
3787    }
3788
3789    fn connect_property_pixels_above_lines_set_notify<F: Fn(&Self) + 'static>(
3790        &self,
3791        f: F,
3792    ) -> SignalHandlerId {
3793        unsafe extern "C" fn notify_pixels_above_lines_set_trampoline<P, F: Fn(&P) + 'static>(
3794            this: *mut gtk_sys::GtkTextTag,
3795            _param_spec: glib_sys::gpointer,
3796            f: glib_sys::gpointer,
3797        ) where
3798            P: IsA<TextTag>,
3799        {
3800            let f: &F = &*(f as *const F);
3801            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3802        }
3803        unsafe {
3804            let f: Box_<F> = Box_::new(f);
3805            connect_raw(
3806                self.as_ptr() as *mut _,
3807                b"notify::pixels-above-lines-set\0".as_ptr() as *const _,
3808                Some(transmute(
3809                    notify_pixels_above_lines_set_trampoline::<Self, F> as usize,
3810                )),
3811                Box_::into_raw(f),
3812            )
3813        }
3814    }
3815
3816    fn connect_property_pixels_below_lines_notify<F: Fn(&Self) + 'static>(
3817        &self,
3818        f: F,
3819    ) -> SignalHandlerId {
3820        unsafe extern "C" fn notify_pixels_below_lines_trampoline<P, F: Fn(&P) + 'static>(
3821            this: *mut gtk_sys::GtkTextTag,
3822            _param_spec: glib_sys::gpointer,
3823            f: glib_sys::gpointer,
3824        ) where
3825            P: IsA<TextTag>,
3826        {
3827            let f: &F = &*(f as *const F);
3828            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3829        }
3830        unsafe {
3831            let f: Box_<F> = Box_::new(f);
3832            connect_raw(
3833                self.as_ptr() as *mut _,
3834                b"notify::pixels-below-lines\0".as_ptr() as *const _,
3835                Some(transmute(
3836                    notify_pixels_below_lines_trampoline::<Self, F> as usize,
3837                )),
3838                Box_::into_raw(f),
3839            )
3840        }
3841    }
3842
3843    fn connect_property_pixels_below_lines_set_notify<F: Fn(&Self) + 'static>(
3844        &self,
3845        f: F,
3846    ) -> SignalHandlerId {
3847        unsafe extern "C" fn notify_pixels_below_lines_set_trampoline<P, F: Fn(&P) + 'static>(
3848            this: *mut gtk_sys::GtkTextTag,
3849            _param_spec: glib_sys::gpointer,
3850            f: glib_sys::gpointer,
3851        ) where
3852            P: IsA<TextTag>,
3853        {
3854            let f: &F = &*(f as *const F);
3855            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3856        }
3857        unsafe {
3858            let f: Box_<F> = Box_::new(f);
3859            connect_raw(
3860                self.as_ptr() as *mut _,
3861                b"notify::pixels-below-lines-set\0".as_ptr() as *const _,
3862                Some(transmute(
3863                    notify_pixels_below_lines_set_trampoline::<Self, F> as usize,
3864                )),
3865                Box_::into_raw(f),
3866            )
3867        }
3868    }
3869
3870    fn connect_property_pixels_inside_wrap_notify<F: Fn(&Self) + 'static>(
3871        &self,
3872        f: F,
3873    ) -> SignalHandlerId {
3874        unsafe extern "C" fn notify_pixels_inside_wrap_trampoline<P, F: Fn(&P) + 'static>(
3875            this: *mut gtk_sys::GtkTextTag,
3876            _param_spec: glib_sys::gpointer,
3877            f: glib_sys::gpointer,
3878        ) where
3879            P: IsA<TextTag>,
3880        {
3881            let f: &F = &*(f as *const F);
3882            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3883        }
3884        unsafe {
3885            let f: Box_<F> = Box_::new(f);
3886            connect_raw(
3887                self.as_ptr() as *mut _,
3888                b"notify::pixels-inside-wrap\0".as_ptr() as *const _,
3889                Some(transmute(
3890                    notify_pixels_inside_wrap_trampoline::<Self, F> as usize,
3891                )),
3892                Box_::into_raw(f),
3893            )
3894        }
3895    }
3896
3897    fn connect_property_pixels_inside_wrap_set_notify<F: Fn(&Self) + 'static>(
3898        &self,
3899        f: F,
3900    ) -> SignalHandlerId {
3901        unsafe extern "C" fn notify_pixels_inside_wrap_set_trampoline<P, F: Fn(&P) + 'static>(
3902            this: *mut gtk_sys::GtkTextTag,
3903            _param_spec: glib_sys::gpointer,
3904            f: glib_sys::gpointer,
3905        ) where
3906            P: IsA<TextTag>,
3907        {
3908            let f: &F = &*(f as *const F);
3909            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3910        }
3911        unsafe {
3912            let f: Box_<F> = Box_::new(f);
3913            connect_raw(
3914                self.as_ptr() as *mut _,
3915                b"notify::pixels-inside-wrap-set\0".as_ptr() as *const _,
3916                Some(transmute(
3917                    notify_pixels_inside_wrap_set_trampoline::<Self, F> as usize,
3918                )),
3919                Box_::into_raw(f),
3920            )
3921        }
3922    }
3923
3924    fn connect_property_right_margin_notify<F: Fn(&Self) + 'static>(
3925        &self,
3926        f: F,
3927    ) -> SignalHandlerId {
3928        unsafe extern "C" fn notify_right_margin_trampoline<P, F: Fn(&P) + 'static>(
3929            this: *mut gtk_sys::GtkTextTag,
3930            _param_spec: glib_sys::gpointer,
3931            f: glib_sys::gpointer,
3932        ) where
3933            P: IsA<TextTag>,
3934        {
3935            let f: &F = &*(f as *const F);
3936            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3937        }
3938        unsafe {
3939            let f: Box_<F> = Box_::new(f);
3940            connect_raw(
3941                self.as_ptr() as *mut _,
3942                b"notify::right-margin\0".as_ptr() as *const _,
3943                Some(transmute(
3944                    notify_right_margin_trampoline::<Self, F> as usize,
3945                )),
3946                Box_::into_raw(f),
3947            )
3948        }
3949    }
3950
3951    fn connect_property_right_margin_set_notify<F: Fn(&Self) + 'static>(
3952        &self,
3953        f: F,
3954    ) -> SignalHandlerId {
3955        unsafe extern "C" fn notify_right_margin_set_trampoline<P, F: Fn(&P) + 'static>(
3956            this: *mut gtk_sys::GtkTextTag,
3957            _param_spec: glib_sys::gpointer,
3958            f: glib_sys::gpointer,
3959        ) where
3960            P: IsA<TextTag>,
3961        {
3962            let f: &F = &*(f as *const F);
3963            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3964        }
3965        unsafe {
3966            let f: Box_<F> = Box_::new(f);
3967            connect_raw(
3968                self.as_ptr() as *mut _,
3969                b"notify::right-margin-set\0".as_ptr() as *const _,
3970                Some(transmute(
3971                    notify_right_margin_set_trampoline::<Self, F> as usize,
3972                )),
3973                Box_::into_raw(f),
3974            )
3975        }
3976    }
3977
3978    fn connect_property_rise_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3979        unsafe extern "C" fn notify_rise_trampoline<P, F: Fn(&P) + 'static>(
3980            this: *mut gtk_sys::GtkTextTag,
3981            _param_spec: glib_sys::gpointer,
3982            f: glib_sys::gpointer,
3983        ) where
3984            P: IsA<TextTag>,
3985        {
3986            let f: &F = &*(f as *const F);
3987            f(&TextTag::from_glib_borrow(this).unsafe_cast())
3988        }
3989        unsafe {
3990            let f: Box_<F> = Box_::new(f);
3991            connect_raw(
3992                self.as_ptr() as *mut _,
3993                b"notify::rise\0".as_ptr() as *const _,
3994                Some(transmute(notify_rise_trampoline::<Self, F> as usize)),
3995                Box_::into_raw(f),
3996            )
3997        }
3998    }
3999
4000    fn connect_property_rise_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4001        unsafe extern "C" fn notify_rise_set_trampoline<P, F: Fn(&P) + 'static>(
4002            this: *mut gtk_sys::GtkTextTag,
4003            _param_spec: glib_sys::gpointer,
4004            f: glib_sys::gpointer,
4005        ) where
4006            P: IsA<TextTag>,
4007        {
4008            let f: &F = &*(f as *const F);
4009            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4010        }
4011        unsafe {
4012            let f: Box_<F> = Box_::new(f);
4013            connect_raw(
4014                self.as_ptr() as *mut _,
4015                b"notify::rise-set\0".as_ptr() as *const _,
4016                Some(transmute(notify_rise_set_trampoline::<Self, F> as usize)),
4017                Box_::into_raw(f),
4018            )
4019        }
4020    }
4021
4022    fn connect_property_scale_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4023        unsafe extern "C" fn notify_scale_trampoline<P, F: Fn(&P) + 'static>(
4024            this: *mut gtk_sys::GtkTextTag,
4025            _param_spec: glib_sys::gpointer,
4026            f: glib_sys::gpointer,
4027        ) where
4028            P: IsA<TextTag>,
4029        {
4030            let f: &F = &*(f as *const F);
4031            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4032        }
4033        unsafe {
4034            let f: Box_<F> = Box_::new(f);
4035            connect_raw(
4036                self.as_ptr() as *mut _,
4037                b"notify::scale\0".as_ptr() as *const _,
4038                Some(transmute(notify_scale_trampoline::<Self, F> as usize)),
4039                Box_::into_raw(f),
4040            )
4041        }
4042    }
4043
4044    fn connect_property_scale_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4045        unsafe extern "C" fn notify_scale_set_trampoline<P, F: Fn(&P) + 'static>(
4046            this: *mut gtk_sys::GtkTextTag,
4047            _param_spec: glib_sys::gpointer,
4048            f: glib_sys::gpointer,
4049        ) where
4050            P: IsA<TextTag>,
4051        {
4052            let f: &F = &*(f as *const F);
4053            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4054        }
4055        unsafe {
4056            let f: Box_<F> = Box_::new(f);
4057            connect_raw(
4058                self.as_ptr() as *mut _,
4059                b"notify::scale-set\0".as_ptr() as *const _,
4060                Some(transmute(notify_scale_set_trampoline::<Self, F> as usize)),
4061                Box_::into_raw(f),
4062            )
4063        }
4064    }
4065
4066    fn connect_property_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4067        unsafe extern "C" fn notify_size_trampoline<P, F: Fn(&P) + 'static>(
4068            this: *mut gtk_sys::GtkTextTag,
4069            _param_spec: glib_sys::gpointer,
4070            f: glib_sys::gpointer,
4071        ) where
4072            P: IsA<TextTag>,
4073        {
4074            let f: &F = &*(f as *const F);
4075            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4076        }
4077        unsafe {
4078            let f: Box_<F> = Box_::new(f);
4079            connect_raw(
4080                self.as_ptr() as *mut _,
4081                b"notify::size\0".as_ptr() as *const _,
4082                Some(transmute(notify_size_trampoline::<Self, F> as usize)),
4083                Box_::into_raw(f),
4084            )
4085        }
4086    }
4087
4088    fn connect_property_size_points_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4089        unsafe extern "C" fn notify_size_points_trampoline<P, F: Fn(&P) + 'static>(
4090            this: *mut gtk_sys::GtkTextTag,
4091            _param_spec: glib_sys::gpointer,
4092            f: glib_sys::gpointer,
4093        ) where
4094            P: IsA<TextTag>,
4095        {
4096            let f: &F = &*(f as *const F);
4097            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4098        }
4099        unsafe {
4100            let f: Box_<F> = Box_::new(f);
4101            connect_raw(
4102                self.as_ptr() as *mut _,
4103                b"notify::size-points\0".as_ptr() as *const _,
4104                Some(transmute(notify_size_points_trampoline::<Self, F> as usize)),
4105                Box_::into_raw(f),
4106            )
4107        }
4108    }
4109
4110    fn connect_property_size_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4111        unsafe extern "C" fn notify_size_set_trampoline<P, F: Fn(&P) + 'static>(
4112            this: *mut gtk_sys::GtkTextTag,
4113            _param_spec: glib_sys::gpointer,
4114            f: glib_sys::gpointer,
4115        ) where
4116            P: IsA<TextTag>,
4117        {
4118            let f: &F = &*(f as *const F);
4119            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4120        }
4121        unsafe {
4122            let f: Box_<F> = Box_::new(f);
4123            connect_raw(
4124                self.as_ptr() as *mut _,
4125                b"notify::size-set\0".as_ptr() as *const _,
4126                Some(transmute(notify_size_set_trampoline::<Self, F> as usize)),
4127                Box_::into_raw(f),
4128            )
4129        }
4130    }
4131
4132    fn connect_property_stretch_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4133        unsafe extern "C" fn notify_stretch_trampoline<P, F: Fn(&P) + 'static>(
4134            this: *mut gtk_sys::GtkTextTag,
4135            _param_spec: glib_sys::gpointer,
4136            f: glib_sys::gpointer,
4137        ) where
4138            P: IsA<TextTag>,
4139        {
4140            let f: &F = &*(f as *const F);
4141            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4142        }
4143        unsafe {
4144            let f: Box_<F> = Box_::new(f);
4145            connect_raw(
4146                self.as_ptr() as *mut _,
4147                b"notify::stretch\0".as_ptr() as *const _,
4148                Some(transmute(notify_stretch_trampoline::<Self, F> as usize)),
4149                Box_::into_raw(f),
4150            )
4151        }
4152    }
4153
4154    fn connect_property_stretch_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4155        unsafe extern "C" fn notify_stretch_set_trampoline<P, F: Fn(&P) + 'static>(
4156            this: *mut gtk_sys::GtkTextTag,
4157            _param_spec: glib_sys::gpointer,
4158            f: glib_sys::gpointer,
4159        ) where
4160            P: IsA<TextTag>,
4161        {
4162            let f: &F = &*(f as *const F);
4163            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4164        }
4165        unsafe {
4166            let f: Box_<F> = Box_::new(f);
4167            connect_raw(
4168                self.as_ptr() as *mut _,
4169                b"notify::stretch-set\0".as_ptr() as *const _,
4170                Some(transmute(notify_stretch_set_trampoline::<Self, F> as usize)),
4171                Box_::into_raw(f),
4172            )
4173        }
4174    }
4175
4176    fn connect_property_strikethrough_notify<F: Fn(&Self) + 'static>(
4177        &self,
4178        f: F,
4179    ) -> SignalHandlerId {
4180        unsafe extern "C" fn notify_strikethrough_trampoline<P, F: Fn(&P) + 'static>(
4181            this: *mut gtk_sys::GtkTextTag,
4182            _param_spec: glib_sys::gpointer,
4183            f: glib_sys::gpointer,
4184        ) where
4185            P: IsA<TextTag>,
4186        {
4187            let f: &F = &*(f as *const F);
4188            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4189        }
4190        unsafe {
4191            let f: Box_<F> = Box_::new(f);
4192            connect_raw(
4193                self.as_ptr() as *mut _,
4194                b"notify::strikethrough\0".as_ptr() as *const _,
4195                Some(transmute(
4196                    notify_strikethrough_trampoline::<Self, F> as usize,
4197                )),
4198                Box_::into_raw(f),
4199            )
4200        }
4201    }
4202
4203    #[cfg(any(feature = "v3_16", feature = "dox"))]
4204    fn connect_property_strikethrough_rgba_notify<F: Fn(&Self) + 'static>(
4205        &self,
4206        f: F,
4207    ) -> SignalHandlerId {
4208        unsafe extern "C" fn notify_strikethrough_rgba_trampoline<P, F: Fn(&P) + 'static>(
4209            this: *mut gtk_sys::GtkTextTag,
4210            _param_spec: glib_sys::gpointer,
4211            f: glib_sys::gpointer,
4212        ) where
4213            P: IsA<TextTag>,
4214        {
4215            let f: &F = &*(f as *const F);
4216            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4217        }
4218        unsafe {
4219            let f: Box_<F> = Box_::new(f);
4220            connect_raw(
4221                self.as_ptr() as *mut _,
4222                b"notify::strikethrough-rgba\0".as_ptr() as *const _,
4223                Some(transmute(
4224                    notify_strikethrough_rgba_trampoline::<Self, F> as usize,
4225                )),
4226                Box_::into_raw(f),
4227            )
4228        }
4229    }
4230
4231    #[cfg(any(feature = "v3_16", feature = "dox"))]
4232    fn connect_property_strikethrough_rgba_set_notify<F: Fn(&Self) + 'static>(
4233        &self,
4234        f: F,
4235    ) -> SignalHandlerId {
4236        unsafe extern "C" fn notify_strikethrough_rgba_set_trampoline<P, F: Fn(&P) + 'static>(
4237            this: *mut gtk_sys::GtkTextTag,
4238            _param_spec: glib_sys::gpointer,
4239            f: glib_sys::gpointer,
4240        ) where
4241            P: IsA<TextTag>,
4242        {
4243            let f: &F = &*(f as *const F);
4244            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4245        }
4246        unsafe {
4247            let f: Box_<F> = Box_::new(f);
4248            connect_raw(
4249                self.as_ptr() as *mut _,
4250                b"notify::strikethrough-rgba-set\0".as_ptr() as *const _,
4251                Some(transmute(
4252                    notify_strikethrough_rgba_set_trampoline::<Self, F> as usize,
4253                )),
4254                Box_::into_raw(f),
4255            )
4256        }
4257    }
4258
4259    fn connect_property_strikethrough_set_notify<F: Fn(&Self) + 'static>(
4260        &self,
4261        f: F,
4262    ) -> SignalHandlerId {
4263        unsafe extern "C" fn notify_strikethrough_set_trampoline<P, F: Fn(&P) + 'static>(
4264            this: *mut gtk_sys::GtkTextTag,
4265            _param_spec: glib_sys::gpointer,
4266            f: glib_sys::gpointer,
4267        ) where
4268            P: IsA<TextTag>,
4269        {
4270            let f: &F = &*(f as *const F);
4271            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4272        }
4273        unsafe {
4274            let f: Box_<F> = Box_::new(f);
4275            connect_raw(
4276                self.as_ptr() as *mut _,
4277                b"notify::strikethrough-set\0".as_ptr() as *const _,
4278                Some(transmute(
4279                    notify_strikethrough_set_trampoline::<Self, F> as usize,
4280                )),
4281                Box_::into_raw(f),
4282            )
4283        }
4284    }
4285
4286    fn connect_property_style_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4287        unsafe extern "C" fn notify_style_trampoline<P, F: Fn(&P) + 'static>(
4288            this: *mut gtk_sys::GtkTextTag,
4289            _param_spec: glib_sys::gpointer,
4290            f: glib_sys::gpointer,
4291        ) where
4292            P: IsA<TextTag>,
4293        {
4294            let f: &F = &*(f as *const F);
4295            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4296        }
4297        unsafe {
4298            let f: Box_<F> = Box_::new(f);
4299            connect_raw(
4300                self.as_ptr() as *mut _,
4301                b"notify::style\0".as_ptr() as *const _,
4302                Some(transmute(notify_style_trampoline::<Self, F> as usize)),
4303                Box_::into_raw(f),
4304            )
4305        }
4306    }
4307
4308    fn connect_property_style_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4309        unsafe extern "C" fn notify_style_set_trampoline<P, F: Fn(&P) + 'static>(
4310            this: *mut gtk_sys::GtkTextTag,
4311            _param_spec: glib_sys::gpointer,
4312            f: glib_sys::gpointer,
4313        ) where
4314            P: IsA<TextTag>,
4315        {
4316            let f: &F = &*(f as *const F);
4317            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4318        }
4319        unsafe {
4320            let f: Box_<F> = Box_::new(f);
4321            connect_raw(
4322                self.as_ptr() as *mut _,
4323                b"notify::style-set\0".as_ptr() as *const _,
4324                Some(transmute(notify_style_set_trampoline::<Self, F> as usize)),
4325                Box_::into_raw(f),
4326            )
4327        }
4328    }
4329
4330    fn connect_property_tabs_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4331        unsafe extern "C" fn notify_tabs_set_trampoline<P, F: Fn(&P) + 'static>(
4332            this: *mut gtk_sys::GtkTextTag,
4333            _param_spec: glib_sys::gpointer,
4334            f: glib_sys::gpointer,
4335        ) where
4336            P: IsA<TextTag>,
4337        {
4338            let f: &F = &*(f as *const F);
4339            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4340        }
4341        unsafe {
4342            let f: Box_<F> = Box_::new(f);
4343            connect_raw(
4344                self.as_ptr() as *mut _,
4345                b"notify::tabs-set\0".as_ptr() as *const _,
4346                Some(transmute(notify_tabs_set_trampoline::<Self, F> as usize)),
4347                Box_::into_raw(f),
4348            )
4349        }
4350    }
4351
4352    fn connect_property_underline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4353        unsafe extern "C" fn notify_underline_trampoline<P, F: Fn(&P) + 'static>(
4354            this: *mut gtk_sys::GtkTextTag,
4355            _param_spec: glib_sys::gpointer,
4356            f: glib_sys::gpointer,
4357        ) where
4358            P: IsA<TextTag>,
4359        {
4360            let f: &F = &*(f as *const F);
4361            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4362        }
4363        unsafe {
4364            let f: Box_<F> = Box_::new(f);
4365            connect_raw(
4366                self.as_ptr() as *mut _,
4367                b"notify::underline\0".as_ptr() as *const _,
4368                Some(transmute(notify_underline_trampoline::<Self, F> as usize)),
4369                Box_::into_raw(f),
4370            )
4371        }
4372    }
4373
4374    #[cfg(any(feature = "v3_16", feature = "dox"))]
4375    fn connect_property_underline_rgba_notify<F: Fn(&Self) + 'static>(
4376        &self,
4377        f: F,
4378    ) -> SignalHandlerId {
4379        unsafe extern "C" fn notify_underline_rgba_trampoline<P, F: Fn(&P) + 'static>(
4380            this: *mut gtk_sys::GtkTextTag,
4381            _param_spec: glib_sys::gpointer,
4382            f: glib_sys::gpointer,
4383        ) where
4384            P: IsA<TextTag>,
4385        {
4386            let f: &F = &*(f as *const F);
4387            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4388        }
4389        unsafe {
4390            let f: Box_<F> = Box_::new(f);
4391            connect_raw(
4392                self.as_ptr() as *mut _,
4393                b"notify::underline-rgba\0".as_ptr() as *const _,
4394                Some(transmute(
4395                    notify_underline_rgba_trampoline::<Self, F> as usize,
4396                )),
4397                Box_::into_raw(f),
4398            )
4399        }
4400    }
4401
4402    #[cfg(any(feature = "v3_16", feature = "dox"))]
4403    fn connect_property_underline_rgba_set_notify<F: Fn(&Self) + 'static>(
4404        &self,
4405        f: F,
4406    ) -> SignalHandlerId {
4407        unsafe extern "C" fn notify_underline_rgba_set_trampoline<P, F: Fn(&P) + 'static>(
4408            this: *mut gtk_sys::GtkTextTag,
4409            _param_spec: glib_sys::gpointer,
4410            f: glib_sys::gpointer,
4411        ) where
4412            P: IsA<TextTag>,
4413        {
4414            let f: &F = &*(f as *const F);
4415            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4416        }
4417        unsafe {
4418            let f: Box_<F> = Box_::new(f);
4419            connect_raw(
4420                self.as_ptr() as *mut _,
4421                b"notify::underline-rgba-set\0".as_ptr() as *const _,
4422                Some(transmute(
4423                    notify_underline_rgba_set_trampoline::<Self, F> as usize,
4424                )),
4425                Box_::into_raw(f),
4426            )
4427        }
4428    }
4429
4430    fn connect_property_underline_set_notify<F: Fn(&Self) + 'static>(
4431        &self,
4432        f: F,
4433    ) -> SignalHandlerId {
4434        unsafe extern "C" fn notify_underline_set_trampoline<P, F: Fn(&P) + 'static>(
4435            this: *mut gtk_sys::GtkTextTag,
4436            _param_spec: glib_sys::gpointer,
4437            f: glib_sys::gpointer,
4438        ) where
4439            P: IsA<TextTag>,
4440        {
4441            let f: &F = &*(f as *const F);
4442            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4443        }
4444        unsafe {
4445            let f: Box_<F> = Box_::new(f);
4446            connect_raw(
4447                self.as_ptr() as *mut _,
4448                b"notify::underline-set\0".as_ptr() as *const _,
4449                Some(transmute(
4450                    notify_underline_set_trampoline::<Self, F> as usize,
4451                )),
4452                Box_::into_raw(f),
4453            )
4454        }
4455    }
4456
4457    fn connect_property_variant_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4458        unsafe extern "C" fn notify_variant_trampoline<P, F: Fn(&P) + 'static>(
4459            this: *mut gtk_sys::GtkTextTag,
4460            _param_spec: glib_sys::gpointer,
4461            f: glib_sys::gpointer,
4462        ) where
4463            P: IsA<TextTag>,
4464        {
4465            let f: &F = &*(f as *const F);
4466            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4467        }
4468        unsafe {
4469            let f: Box_<F> = Box_::new(f);
4470            connect_raw(
4471                self.as_ptr() as *mut _,
4472                b"notify::variant\0".as_ptr() as *const _,
4473                Some(transmute(notify_variant_trampoline::<Self, F> as usize)),
4474                Box_::into_raw(f),
4475            )
4476        }
4477    }
4478
4479    fn connect_property_variant_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4480        unsafe extern "C" fn notify_variant_set_trampoline<P, F: Fn(&P) + 'static>(
4481            this: *mut gtk_sys::GtkTextTag,
4482            _param_spec: glib_sys::gpointer,
4483            f: glib_sys::gpointer,
4484        ) where
4485            P: IsA<TextTag>,
4486        {
4487            let f: &F = &*(f as *const F);
4488            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4489        }
4490        unsafe {
4491            let f: Box_<F> = Box_::new(f);
4492            connect_raw(
4493                self.as_ptr() as *mut _,
4494                b"notify::variant-set\0".as_ptr() as *const _,
4495                Some(transmute(notify_variant_set_trampoline::<Self, F> as usize)),
4496                Box_::into_raw(f),
4497            )
4498        }
4499    }
4500
4501    fn connect_property_weight_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4502        unsafe extern "C" fn notify_weight_trampoline<P, F: Fn(&P) + 'static>(
4503            this: *mut gtk_sys::GtkTextTag,
4504            _param_spec: glib_sys::gpointer,
4505            f: glib_sys::gpointer,
4506        ) where
4507            P: IsA<TextTag>,
4508        {
4509            let f: &F = &*(f as *const F);
4510            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4511        }
4512        unsafe {
4513            let f: Box_<F> = Box_::new(f);
4514            connect_raw(
4515                self.as_ptr() as *mut _,
4516                b"notify::weight\0".as_ptr() as *const _,
4517                Some(transmute(notify_weight_trampoline::<Self, F> as usize)),
4518                Box_::into_raw(f),
4519            )
4520        }
4521    }
4522
4523    fn connect_property_weight_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4524        unsafe extern "C" fn notify_weight_set_trampoline<P, F: Fn(&P) + 'static>(
4525            this: *mut gtk_sys::GtkTextTag,
4526            _param_spec: glib_sys::gpointer,
4527            f: glib_sys::gpointer,
4528        ) where
4529            P: IsA<TextTag>,
4530        {
4531            let f: &F = &*(f as *const F);
4532            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4533        }
4534        unsafe {
4535            let f: Box_<F> = Box_::new(f);
4536            connect_raw(
4537                self.as_ptr() as *mut _,
4538                b"notify::weight-set\0".as_ptr() as *const _,
4539                Some(transmute(notify_weight_set_trampoline::<Self, F> as usize)),
4540                Box_::into_raw(f),
4541            )
4542        }
4543    }
4544
4545    fn connect_property_wrap_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4546        unsafe extern "C" fn notify_wrap_mode_trampoline<P, F: Fn(&P) + 'static>(
4547            this: *mut gtk_sys::GtkTextTag,
4548            _param_spec: glib_sys::gpointer,
4549            f: glib_sys::gpointer,
4550        ) where
4551            P: IsA<TextTag>,
4552        {
4553            let f: &F = &*(f as *const F);
4554            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4555        }
4556        unsafe {
4557            let f: Box_<F> = Box_::new(f);
4558            connect_raw(
4559                self.as_ptr() as *mut _,
4560                b"notify::wrap-mode\0".as_ptr() as *const _,
4561                Some(transmute(notify_wrap_mode_trampoline::<Self, F> as usize)),
4562                Box_::into_raw(f),
4563            )
4564        }
4565    }
4566
4567    fn connect_property_wrap_mode_set_notify<F: Fn(&Self) + 'static>(
4568        &self,
4569        f: F,
4570    ) -> SignalHandlerId {
4571        unsafe extern "C" fn notify_wrap_mode_set_trampoline<P, F: Fn(&P) + 'static>(
4572            this: *mut gtk_sys::GtkTextTag,
4573            _param_spec: glib_sys::gpointer,
4574            f: glib_sys::gpointer,
4575        ) where
4576            P: IsA<TextTag>,
4577        {
4578            let f: &F = &*(f as *const F);
4579            f(&TextTag::from_glib_borrow(this).unsafe_cast())
4580        }
4581        unsafe {
4582            let f: Box_<F> = Box_::new(f);
4583            connect_raw(
4584                self.as_ptr() as *mut _,
4585                b"notify::wrap-mode-set\0".as_ptr() as *const _,
4586                Some(transmute(
4587                    notify_wrap_mode_set_trampoline::<Self, F> as usize,
4588                )),
4589                Box_::into_raw(f),
4590            )
4591        }
4592    }
4593}
4594
4595impl fmt::Display for TextTag {
4596    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4597        write!(f, "TextTag")
4598    }
4599}