1use 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(¶graph_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}