1use crate::{ffi, Justification, TextDirection, WrapMode};
6use glib::{
7 prelude::*,
8 signal::{connect_raw, SignalHandlerId},
9 translate::*,
10};
11use std::boxed::Box as Box_;
12
13glib::wrapper! {
14 #[doc(alias = "GtkTextTag")]
620 pub struct TextTag(Object<ffi::GtkTextTag, ffi::GtkTextTagClass>);
621
622 match fn {
623 type_ => || ffi::gtk_text_tag_get_type(),
624 }
625}
626
627impl TextTag {
628 pub const NONE: Option<&'static TextTag> = None;
629
630 #[doc(alias = "gtk_text_tag_new")]
638 pub fn new(name: Option<&str>) -> TextTag {
639 assert_initialized_main_thread!();
640 unsafe { from_glib_full(ffi::gtk_text_tag_new(name.to_glib_none().0)) }
641 }
642
643 pub fn builder() -> TextTagBuilder {
648 TextTagBuilder::new()
649 }
650}
651
652impl Default for TextTag {
653 fn default() -> Self {
654 glib::object::Object::new::<Self>()
655 }
656}
657
658#[must_use = "The builder must be built to be used"]
663pub struct TextTagBuilder {
664 builder: glib::object::ObjectBuilder<'static, TextTag>,
665}
666
667impl TextTagBuilder {
668 fn new() -> Self {
669 Self {
670 builder: glib::object::Object::builder(),
671 }
672 }
673
674 pub fn accumulative_margin(self, accumulative_margin: bool) -> Self {
680 Self {
681 builder: self
682 .builder
683 .property("accumulative-margin", accumulative_margin),
684 }
685 }
686
687 pub fn allow_breaks(self, allow_breaks: bool) -> Self {
689 Self {
690 builder: self.builder.property("allow-breaks", allow_breaks),
691 }
692 }
693
694 pub fn allow_breaks_set(self, allow_breaks_set: bool) -> Self {
696 Self {
697 builder: self.builder.property("allow-breaks-set", allow_breaks_set),
698 }
699 }
700
701 pub fn background(self, background: impl Into<glib::GString>) -> Self {
703 Self {
704 builder: self.builder.property("background", background.into()),
705 }
706 }
707
708 pub fn background_full_height(self, background_full_height: bool) -> Self {
711 Self {
712 builder: self
713 .builder
714 .property("background-full-height", background_full_height),
715 }
716 }
717
718 pub fn background_full_height_set(self, background_full_height_set: bool) -> Self {
720 Self {
721 builder: self
722 .builder
723 .property("background-full-height-set", background_full_height_set),
724 }
725 }
726
727 pub fn background_rgba(self, background_rgba: &gdk::RGBA) -> Self {
729 Self {
730 builder: self.builder.property("background-rgba", background_rgba),
731 }
732 }
733
734 pub fn background_set(self, background_set: bool) -> Self {
736 Self {
737 builder: self.builder.property("background-set", background_set),
738 }
739 }
740
741 pub fn direction(self, direction: TextDirection) -> Self {
743 Self {
744 builder: self.builder.property("direction", direction),
745 }
746 }
747
748 pub fn editable(self, editable: bool) -> Self {
750 Self {
751 builder: self.builder.property("editable", editable),
752 }
753 }
754
755 pub fn editable_set(self, editable_set: bool) -> Self {
757 Self {
758 builder: self.builder.property("editable-set", editable_set),
759 }
760 }
761
762 pub fn fallback(self, fallback: bool) -> Self {
767 Self {
768 builder: self.builder.property("fallback", fallback),
769 }
770 }
771
772 pub fn fallback_set(self, fallback_set: bool) -> Self {
774 Self {
775 builder: self.builder.property("fallback-set", fallback_set),
776 }
777 }
778
779 pub fn family(self, family: impl Into<glib::GString>) -> Self {
781 Self {
782 builder: self.builder.property("family", family.into()),
783 }
784 }
785
786 pub fn family_set(self, family_set: bool) -> Self {
788 Self {
789 builder: self.builder.property("family-set", family_set),
790 }
791 }
792
793 pub fn font(self, font: impl Into<glib::GString>) -> Self {
798 Self {
799 builder: self.builder.property("font", font.into()),
800 }
801 }
802
803 pub fn font_desc(self, font_desc: &pango::FontDescription) -> Self {
805 Self {
806 builder: self.builder.property("font-desc", font_desc),
807 }
808 }
809
810 pub fn font_features(self, font_features: impl Into<glib::GString>) -> Self {
812 Self {
813 builder: self.builder.property("font-features", font_features.into()),
814 }
815 }
816
817 pub fn font_features_set(self, font_features_set: bool) -> Self {
819 Self {
820 builder: self
821 .builder
822 .property("font-features-set", font_features_set),
823 }
824 }
825
826 pub fn foreground(self, foreground: impl Into<glib::GString>) -> Self {
828 Self {
829 builder: self.builder.property("foreground", foreground.into()),
830 }
831 }
832
833 pub fn foreground_rgba(self, foreground_rgba: &gdk::RGBA) -> Self {
835 Self {
836 builder: self.builder.property("foreground-rgba", foreground_rgba),
837 }
838 }
839
840 pub fn foreground_set(self, foreground_set: bool) -> Self {
842 Self {
843 builder: self.builder.property("foreground-set", foreground_set),
844 }
845 }
846
847 pub fn indent(self, indent: i32) -> Self {
853 Self {
854 builder: self.builder.property("indent", indent),
855 }
856 }
857
858 pub fn indent_set(self, indent_set: bool) -> Self {
860 Self {
861 builder: self.builder.property("indent-set", indent_set),
862 }
863 }
864
865 pub fn insert_hyphens(self, insert_hyphens: bool) -> Self {
867 Self {
868 builder: self.builder.property("insert-hyphens", insert_hyphens),
869 }
870 }
871
872 pub fn insert_hyphens_set(self, insert_hyphens_set: bool) -> Self {
874 Self {
875 builder: self
876 .builder
877 .property("insert-hyphens-set", insert_hyphens_set),
878 }
879 }
880
881 pub fn invisible(self, invisible: bool) -> Self {
887 Self {
888 builder: self.builder.property("invisible", invisible),
889 }
890 }
891
892 pub fn invisible_set(self, invisible_set: bool) -> Self {
894 Self {
895 builder: self.builder.property("invisible-set", invisible_set),
896 }
897 }
898
899 pub fn justification(self, justification: Justification) -> Self {
901 Self {
902 builder: self.builder.property("justification", justification),
903 }
904 }
905
906 pub fn justification_set(self, justification_set: bool) -> Self {
908 Self {
909 builder: self
910 .builder
911 .property("justification-set", justification_set),
912 }
913 }
914
915 pub fn language(self, language: impl Into<glib::GString>) -> Self {
923 Self {
924 builder: self.builder.property("language", language.into()),
925 }
926 }
927
928 pub fn language_set(self, language_set: bool) -> Self {
930 Self {
931 builder: self.builder.property("language-set", language_set),
932 }
933 }
934
935 pub fn left_margin(self, left_margin: i32) -> Self {
937 Self {
938 builder: self.builder.property("left-margin", left_margin),
939 }
940 }
941
942 pub fn left_margin_set(self, left_margin_set: bool) -> Self {
944 Self {
945 builder: self.builder.property("left-margin-set", left_margin_set),
946 }
947 }
948
949 pub fn letter_spacing(self, letter_spacing: i32) -> Self {
951 Self {
952 builder: self.builder.property("letter-spacing", letter_spacing),
953 }
954 }
955
956 pub fn letter_spacing_set(self, letter_spacing_set: bool) -> Self {
958 Self {
959 builder: self
960 .builder
961 .property("letter-spacing-set", letter_spacing_set),
962 }
963 }
964
965 #[cfg(feature = "v4_6")]
967 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
968 pub fn line_height(self, line_height: f32) -> Self {
969 Self {
970 builder: self.builder.property("line-height", line_height),
971 }
972 }
973
974 #[cfg(feature = "v4_6")]
976 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
977 pub fn line_height_set(self, line_height_set: bool) -> Self {
978 Self {
979 builder: self.builder.property("line-height-set", line_height_set),
980 }
981 }
982
983 pub fn name(self, name: impl Into<glib::GString>) -> Self {
987 Self {
988 builder: self.builder.property("name", name.into()),
989 }
990 }
991
992 pub fn overline(self, overline: pango::Overline) -> Self {
994 Self {
995 builder: self.builder.property("overline", overline),
996 }
997 }
998
999 pub fn overline_rgba(self, overline_rgba: &gdk::RGBA) -> Self {
1003 Self {
1004 builder: self.builder.property("overline-rgba", overline_rgba),
1005 }
1006 }
1007
1008 pub fn overline_rgba_set(self, overline_rgba_set: bool) -> Self {
1010 Self {
1011 builder: self
1012 .builder
1013 .property("overline-rgba-set", overline_rgba_set),
1014 }
1015 }
1016
1017 pub fn overline_set(self, overline_set: bool) -> Self {
1019 Self {
1020 builder: self.builder.property("overline-set", overline_set),
1021 }
1022 }
1023
1024 pub fn paragraph_background(self, paragraph_background: impl Into<glib::GString>) -> Self {
1026 Self {
1027 builder: self
1028 .builder
1029 .property("paragraph-background", paragraph_background.into()),
1030 }
1031 }
1032
1033 pub fn paragraph_background_rgba(self, paragraph_background_rgba: &gdk::RGBA) -> Self {
1035 Self {
1036 builder: self
1037 .builder
1038 .property("paragraph-background-rgba", paragraph_background_rgba),
1039 }
1040 }
1041
1042 pub fn paragraph_background_set(self, paragraph_background_set: bool) -> Self {
1044 Self {
1045 builder: self
1046 .builder
1047 .property("paragraph-background-set", paragraph_background_set),
1048 }
1049 }
1050
1051 pub fn pixels_above_lines(self, pixels_above_lines: i32) -> Self {
1053 Self {
1054 builder: self
1055 .builder
1056 .property("pixels-above-lines", pixels_above_lines),
1057 }
1058 }
1059
1060 pub fn pixels_above_lines_set(self, pixels_above_lines_set: bool) -> Self {
1062 Self {
1063 builder: self
1064 .builder
1065 .property("pixels-above-lines-set", pixels_above_lines_set),
1066 }
1067 }
1068
1069 pub fn pixels_below_lines(self, pixels_below_lines: i32) -> Self {
1071 Self {
1072 builder: self
1073 .builder
1074 .property("pixels-below-lines", pixels_below_lines),
1075 }
1076 }
1077
1078 pub fn pixels_below_lines_set(self, pixels_below_lines_set: bool) -> Self {
1080 Self {
1081 builder: self
1082 .builder
1083 .property("pixels-below-lines-set", pixels_below_lines_set),
1084 }
1085 }
1086
1087 pub fn pixels_inside_wrap(self, pixels_inside_wrap: i32) -> Self {
1089 Self {
1090 builder: self
1091 .builder
1092 .property("pixels-inside-wrap", pixels_inside_wrap),
1093 }
1094 }
1095
1096 pub fn pixels_inside_wrap_set(self, pixels_inside_wrap_set: bool) -> Self {
1098 Self {
1099 builder: self
1100 .builder
1101 .property("pixels-inside-wrap-set", pixels_inside_wrap_set),
1102 }
1103 }
1104
1105 pub fn right_margin(self, right_margin: i32) -> Self {
1107 Self {
1108 builder: self.builder.property("right-margin", right_margin),
1109 }
1110 }
1111
1112 pub fn right_margin_set(self, right_margin_set: bool) -> Self {
1114 Self {
1115 builder: self.builder.property("right-margin-set", right_margin_set),
1116 }
1117 }
1118
1119 pub fn rise(self, rise: i32) -> Self {
1123 Self {
1124 builder: self.builder.property("rise", rise),
1125 }
1126 }
1127
1128 pub fn rise_set(self, rise_set: bool) -> Self {
1130 Self {
1131 builder: self.builder.property("rise-set", rise_set),
1132 }
1133 }
1134
1135 pub fn scale(self, scale: f64) -> Self {
1140 Self {
1141 builder: self.builder.property("scale", scale),
1142 }
1143 }
1144
1145 pub fn scale_set(self, scale_set: bool) -> Self {
1147 Self {
1148 builder: self.builder.property("scale-set", scale_set),
1149 }
1150 }
1151
1152 #[cfg(feature = "v4_6")]
1156 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1157 pub fn sentence(self, sentence: bool) -> Self {
1158 Self {
1159 builder: self.builder.property("sentence", sentence),
1160 }
1161 }
1162
1163 #[cfg(feature = "v4_6")]
1165 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1166 pub fn sentence_set(self, sentence_set: bool) -> Self {
1167 Self {
1168 builder: self.builder.property("sentence-set", sentence_set),
1169 }
1170 }
1171
1172 pub fn show_spaces(self, show_spaces: pango::ShowFlags) -> Self {
1174 Self {
1175 builder: self.builder.property("show-spaces", show_spaces),
1176 }
1177 }
1178
1179 pub fn show_spaces_set(self, show_spaces_set: bool) -> Self {
1181 Self {
1182 builder: self.builder.property("show-spaces-set", show_spaces_set),
1183 }
1184 }
1185
1186 pub fn size(self, size: i32) -> Self {
1188 Self {
1189 builder: self.builder.property("size", size),
1190 }
1191 }
1192
1193 pub fn size_points(self, size_points: f64) -> Self {
1195 Self {
1196 builder: self.builder.property("size-points", size_points),
1197 }
1198 }
1199
1200 pub fn size_set(self, size_set: bool) -> Self {
1202 Self {
1203 builder: self.builder.property("size-set", size_set),
1204 }
1205 }
1206
1207 pub fn stretch(self, stretch: pango::Stretch) -> Self {
1209 Self {
1210 builder: self.builder.property("stretch", stretch),
1211 }
1212 }
1213
1214 pub fn stretch_set(self, stretch_set: bool) -> Self {
1216 Self {
1217 builder: self.builder.property("stretch-set", stretch_set),
1218 }
1219 }
1220
1221 pub fn strikethrough(self, strikethrough: bool) -> Self {
1223 Self {
1224 builder: self.builder.property("strikethrough", strikethrough),
1225 }
1226 }
1227
1228 pub fn strikethrough_rgba(self, strikethrough_rgba: &gdk::RGBA) -> Self {
1232 Self {
1233 builder: self
1234 .builder
1235 .property("strikethrough-rgba", strikethrough_rgba),
1236 }
1237 }
1238
1239 pub fn strikethrough_rgba_set(self, strikethrough_rgba_set: bool) -> Self {
1241 Self {
1242 builder: self
1243 .builder
1244 .property("strikethrough-rgba-set", strikethrough_rgba_set),
1245 }
1246 }
1247
1248 pub fn strikethrough_set(self, strikethrough_set: bool) -> Self {
1250 Self {
1251 builder: self
1252 .builder
1253 .property("strikethrough-set", strikethrough_set),
1254 }
1255 }
1256
1257 pub fn style(self, style: pango::Style) -> Self {
1259 Self {
1260 builder: self.builder.property("style", style),
1261 }
1262 }
1263
1264 pub fn style_set(self, style_set: bool) -> Self {
1266 Self {
1267 builder: self.builder.property("style-set", style_set),
1268 }
1269 }
1270
1271 pub fn tabs(self, tabs: &pango::TabArray) -> Self {
1273 Self {
1274 builder: self.builder.property("tabs", tabs),
1275 }
1276 }
1277
1278 pub fn tabs_set(self, tabs_set: bool) -> Self {
1280 Self {
1281 builder: self.builder.property("tabs-set", tabs_set),
1282 }
1283 }
1284
1285 #[cfg(feature = "v4_6")]
1287 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1288 pub fn text_transform(self, text_transform: pango::TextTransform) -> Self {
1289 Self {
1290 builder: self.builder.property("text-transform", text_transform),
1291 }
1292 }
1293
1294 #[cfg(feature = "v4_6")]
1296 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1297 pub fn text_transform_set(self, text_transform_set: bool) -> Self {
1298 Self {
1299 builder: self
1300 .builder
1301 .property("text-transform-set", text_transform_set),
1302 }
1303 }
1304
1305 pub fn underline(self, underline: pango::Underline) -> Self {
1307 Self {
1308 builder: self.builder.property("underline", underline),
1309 }
1310 }
1311
1312 pub fn underline_rgba(self, underline_rgba: &gdk::RGBA) -> Self {
1320 Self {
1321 builder: self.builder.property("underline-rgba", underline_rgba),
1322 }
1323 }
1324
1325 pub fn underline_rgba_set(self, underline_rgba_set: bool) -> Self {
1327 Self {
1328 builder: self
1329 .builder
1330 .property("underline-rgba-set", underline_rgba_set),
1331 }
1332 }
1333
1334 pub fn underline_set(self, underline_set: bool) -> Self {
1336 Self {
1337 builder: self.builder.property("underline-set", underline_set),
1338 }
1339 }
1340
1341 pub fn variant(self, variant: pango::Variant) -> Self {
1343 Self {
1344 builder: self.builder.property("variant", variant),
1345 }
1346 }
1347
1348 pub fn variant_set(self, variant_set: bool) -> Self {
1350 Self {
1351 builder: self.builder.property("variant-set", variant_set),
1352 }
1353 }
1354
1355 pub fn weight(self, weight: i32) -> Self {
1357 Self {
1358 builder: self.builder.property("weight", weight),
1359 }
1360 }
1361
1362 pub fn weight_set(self, weight_set: bool) -> Self {
1364 Self {
1365 builder: self.builder.property("weight-set", weight_set),
1366 }
1367 }
1368
1369 #[cfg(feature = "v4_6")]
1373 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1374 pub fn word(self, word: bool) -> Self {
1375 Self {
1376 builder: self.builder.property("word", word),
1377 }
1378 }
1379
1380 #[cfg(feature = "v4_6")]
1382 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1383 pub fn word_set(self, word_set: bool) -> Self {
1384 Self {
1385 builder: self.builder.property("word-set", word_set),
1386 }
1387 }
1388
1389 pub fn wrap_mode(self, wrap_mode: WrapMode) -> Self {
1392 Self {
1393 builder: self.builder.property("wrap-mode", wrap_mode),
1394 }
1395 }
1396
1397 pub fn wrap_mode_set(self, wrap_mode_set: bool) -> Self {
1399 Self {
1400 builder: self.builder.property("wrap-mode-set", wrap_mode_set),
1401 }
1402 }
1403
1404 #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
1407 pub fn build(self) -> TextTag {
1408 assert_initialized_main_thread!();
1409 self.builder.build()
1410 }
1411}
1412
1413mod sealed {
1414 pub trait Sealed {}
1415 impl<T: super::IsA<super::TextTag>> Sealed for T {}
1416}
1417
1418pub trait TextTagExt: IsA<TextTag> + sealed::Sealed + 'static {
1424 #[doc(alias = "gtk_text_tag_changed")]
1432 fn changed(&self, size_changed: bool) {
1433 unsafe {
1434 ffi::gtk_text_tag_changed(self.as_ref().to_glib_none().0, size_changed.into_glib());
1435 }
1436 }
1437
1438 #[doc(alias = "gtk_text_tag_get_priority")]
1444 #[doc(alias = "get_priority")]
1445 fn priority(&self) -> i32 {
1446 unsafe { ffi::gtk_text_tag_get_priority(self.as_ref().to_glib_none().0) }
1447 }
1448
1449 #[doc(alias = "gtk_text_tag_set_priority")]
1466 fn set_priority(&self, priority: i32) {
1467 unsafe {
1468 ffi::gtk_text_tag_set_priority(self.as_ref().to_glib_none().0, priority);
1469 }
1470 }
1471
1472 #[doc(alias = "accumulative-margin")]
1478 fn is_accumulative_margin(&self) -> bool {
1479 ObjectExt::property(self.as_ref(), "accumulative-margin")
1480 }
1481
1482 #[doc(alias = "accumulative-margin")]
1488 fn set_accumulative_margin(&self, accumulative_margin: bool) {
1489 ObjectExt::set_property(self.as_ref(), "accumulative-margin", accumulative_margin)
1490 }
1491
1492 #[doc(alias = "allow-breaks")]
1494 fn allows_breaks(&self) -> bool {
1495 ObjectExt::property(self.as_ref(), "allow-breaks")
1496 }
1497
1498 #[doc(alias = "allow-breaks")]
1500 fn set_allow_breaks(&self, allow_breaks: bool) {
1501 ObjectExt::set_property(self.as_ref(), "allow-breaks", allow_breaks)
1502 }
1503
1504 #[doc(alias = "allow-breaks-set")]
1506 fn allows_breaks_set(&self) -> bool {
1507 ObjectExt::property(self.as_ref(), "allow-breaks-set")
1508 }
1509
1510 fn set_background(&self, background: Option<&str>) {
1512 ObjectExt::set_property(self.as_ref(), "background", background)
1513 }
1514
1515 #[doc(alias = "background-full-height")]
1518 fn is_background_full_height(&self) -> bool {
1519 ObjectExt::property(self.as_ref(), "background-full-height")
1520 }
1521
1522 #[doc(alias = "background-full-height")]
1525 fn set_background_full_height(&self, background_full_height: bool) {
1526 ObjectExt::set_property(
1527 self.as_ref(),
1528 "background-full-height",
1529 background_full_height,
1530 )
1531 }
1532
1533 #[doc(alias = "background-full-height-set")]
1535 fn is_background_full_height_set(&self) -> bool {
1536 ObjectExt::property(self.as_ref(), "background-full-height-set")
1537 }
1538
1539 #[doc(alias = "background-rgba")]
1541 fn background_rgba(&self) -> Option<gdk::RGBA> {
1542 ObjectExt::property(self.as_ref(), "background-rgba")
1543 }
1544
1545 #[doc(alias = "background-rgba")]
1547 fn set_background_rgba(&self, background_rgba: Option<&gdk::RGBA>) {
1548 ObjectExt::set_property(self.as_ref(), "background-rgba", background_rgba)
1549 }
1550
1551 #[doc(alias = "background-set")]
1553 fn is_background_set(&self) -> bool {
1554 ObjectExt::property(self.as_ref(), "background-set")
1555 }
1556
1557 fn direction(&self) -> TextDirection {
1559 ObjectExt::property(self.as_ref(), "direction")
1560 }
1561
1562 fn set_direction(&self, direction: TextDirection) {
1564 ObjectExt::set_property(self.as_ref(), "direction", direction)
1565 }
1566
1567 fn is_editable(&self) -> bool {
1569 ObjectExt::property(self.as_ref(), "editable")
1570 }
1571
1572 fn set_editable(&self, editable: bool) {
1574 ObjectExt::set_property(self.as_ref(), "editable", editable)
1575 }
1576
1577 #[doc(alias = "editable-set")]
1579 fn is_editable_set(&self) -> bool {
1580 ObjectExt::property(self.as_ref(), "editable-set")
1581 }
1582
1583 fn is_fallback(&self) -> bool {
1588 ObjectExt::property(self.as_ref(), "fallback")
1589 }
1590
1591 fn set_fallback(&self, fallback: bool) {
1596 ObjectExt::set_property(self.as_ref(), "fallback", fallback)
1597 }
1598
1599 #[doc(alias = "fallback-set")]
1601 fn is_fallback_set(&self) -> bool {
1602 ObjectExt::property(self.as_ref(), "fallback-set")
1603 }
1604
1605 fn family(&self) -> Option<glib::GString> {
1607 ObjectExt::property(self.as_ref(), "family")
1608 }
1609
1610 fn set_family(&self, family: Option<&str>) {
1612 ObjectExt::set_property(self.as_ref(), "family", family)
1613 }
1614
1615 #[doc(alias = "family-set")]
1617 fn is_family_set(&self) -> bool {
1618 ObjectExt::property(self.as_ref(), "family-set")
1619 }
1620
1621 fn font(&self) -> Option<glib::GString> {
1626 ObjectExt::property(self.as_ref(), "font")
1627 }
1628
1629 fn set_font(&self, font: Option<&str>) {
1634 ObjectExt::set_property(self.as_ref(), "font", font)
1635 }
1636
1637 #[doc(alias = "font-desc")]
1639 fn font_desc(&self) -> Option<pango::FontDescription> {
1640 ObjectExt::property(self.as_ref(), "font-desc")
1641 }
1642
1643 #[doc(alias = "font-desc")]
1645 fn set_font_desc(&self, font_desc: Option<&pango::FontDescription>) {
1646 ObjectExt::set_property(self.as_ref(), "font-desc", font_desc)
1647 }
1648
1649 #[doc(alias = "font-features")]
1651 fn font_features(&self) -> Option<glib::GString> {
1652 ObjectExt::property(self.as_ref(), "font-features")
1653 }
1654
1655 #[doc(alias = "font-features")]
1657 fn set_font_features(&self, font_features: Option<&str>) {
1658 ObjectExt::set_property(self.as_ref(), "font-features", font_features)
1659 }
1660
1661 #[doc(alias = "font-features-set")]
1663 fn is_font_features_set(&self) -> bool {
1664 ObjectExt::property(self.as_ref(), "font-features-set")
1665 }
1666
1667 fn set_foreground(&self, foreground: Option<&str>) {
1669 ObjectExt::set_property(self.as_ref(), "foreground", foreground)
1670 }
1671
1672 #[doc(alias = "foreground-rgba")]
1674 fn foreground_rgba(&self) -> Option<gdk::RGBA> {
1675 ObjectExt::property(self.as_ref(), "foreground-rgba")
1676 }
1677
1678 #[doc(alias = "foreground-rgba")]
1680 fn set_foreground_rgba(&self, foreground_rgba: Option<&gdk::RGBA>) {
1681 ObjectExt::set_property(self.as_ref(), "foreground-rgba", foreground_rgba)
1682 }
1683
1684 #[doc(alias = "foreground-set")]
1686 fn is_foreground_set(&self) -> bool {
1687 ObjectExt::property(self.as_ref(), "foreground-set")
1688 }
1689
1690 fn indent(&self) -> i32 {
1696 ObjectExt::property(self.as_ref(), "indent")
1697 }
1698
1699 fn set_indent(&self, indent: i32) {
1705 ObjectExt::set_property(self.as_ref(), "indent", indent)
1706 }
1707
1708 #[doc(alias = "indent-set")]
1710 fn is_indent_set(&self) -> bool {
1711 ObjectExt::property(self.as_ref(), "indent-set")
1712 }
1713
1714 #[doc(alias = "insert-hyphens")]
1716 fn is_insert_hyphens(&self) -> bool {
1717 ObjectExt::property(self.as_ref(), "insert-hyphens")
1718 }
1719
1720 #[doc(alias = "insert-hyphens")]
1722 fn set_insert_hyphens(&self, insert_hyphens: bool) {
1723 ObjectExt::set_property(self.as_ref(), "insert-hyphens", insert_hyphens)
1724 }
1725
1726 #[doc(alias = "insert-hyphens-set")]
1728 fn is_insert_hyphens_set(&self) -> bool {
1729 ObjectExt::property(self.as_ref(), "insert-hyphens-set")
1730 }
1731
1732 fn is_invisible(&self) -> bool {
1738 ObjectExt::property(self.as_ref(), "invisible")
1739 }
1740
1741 fn set_invisible(&self, invisible: bool) {
1747 ObjectExt::set_property(self.as_ref(), "invisible", invisible)
1748 }
1749
1750 #[doc(alias = "invisible-set")]
1752 fn is_invisible_set(&self) -> bool {
1753 ObjectExt::property(self.as_ref(), "invisible-set")
1754 }
1755
1756 fn justification(&self) -> Justification {
1758 ObjectExt::property(self.as_ref(), "justification")
1759 }
1760
1761 fn set_justification(&self, justification: Justification) {
1763 ObjectExt::set_property(self.as_ref(), "justification", justification)
1764 }
1765
1766 #[doc(alias = "justification-set")]
1768 fn is_justification_set(&self) -> bool {
1769 ObjectExt::property(self.as_ref(), "justification-set")
1770 }
1771
1772 fn language(&self) -> Option<glib::GString> {
1780 ObjectExt::property(self.as_ref(), "language")
1781 }
1782
1783 fn set_language(&self, language: Option<&str>) {
1791 ObjectExt::set_property(self.as_ref(), "language", language)
1792 }
1793
1794 #[doc(alias = "language-set")]
1796 fn is_language_set(&self) -> bool {
1797 ObjectExt::property(self.as_ref(), "language-set")
1798 }
1799
1800 #[doc(alias = "left-margin")]
1802 fn left_margin(&self) -> i32 {
1803 ObjectExt::property(self.as_ref(), "left-margin")
1804 }
1805
1806 #[doc(alias = "left-margin")]
1808 fn set_left_margin(&self, left_margin: i32) {
1809 ObjectExt::set_property(self.as_ref(), "left-margin", left_margin)
1810 }
1811
1812 #[doc(alias = "left-margin-set")]
1814 fn is_left_margin_set(&self) -> bool {
1815 ObjectExt::property(self.as_ref(), "left-margin-set")
1816 }
1817
1818 #[doc(alias = "letter-spacing")]
1820 fn letter_spacing(&self) -> i32 {
1821 ObjectExt::property(self.as_ref(), "letter-spacing")
1822 }
1823
1824 #[doc(alias = "letter-spacing")]
1826 fn set_letter_spacing(&self, letter_spacing: i32) {
1827 ObjectExt::set_property(self.as_ref(), "letter-spacing", letter_spacing)
1828 }
1829
1830 #[doc(alias = "letter-spacing-set")]
1832 fn is_letter_spacing_set(&self) -> bool {
1833 ObjectExt::property(self.as_ref(), "letter-spacing-set")
1834 }
1835
1836 #[cfg(feature = "v4_6")]
1838 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1839 #[doc(alias = "line-height")]
1840 fn line_height(&self) -> f32 {
1841 ObjectExt::property(self.as_ref(), "line-height")
1842 }
1843
1844 #[cfg(feature = "v4_6")]
1846 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1847 #[doc(alias = "line-height")]
1848 fn set_line_height(&self, line_height: f32) {
1849 ObjectExt::set_property(self.as_ref(), "line-height", line_height)
1850 }
1851
1852 #[cfg(feature = "v4_6")]
1854 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1855 #[doc(alias = "line-height-set")]
1856 fn is_line_height_set(&self) -> bool {
1857 ObjectExt::property(self.as_ref(), "line-height-set")
1858 }
1859
1860 fn name(&self) -> Option<glib::GString> {
1864 ObjectExt::property(self.as_ref(), "name")
1865 }
1866
1867 fn overline(&self) -> pango::Overline {
1869 ObjectExt::property(self.as_ref(), "overline")
1870 }
1871
1872 fn set_overline(&self, overline: pango::Overline) {
1874 ObjectExt::set_property(self.as_ref(), "overline", overline)
1875 }
1876
1877 #[doc(alias = "overline-rgba")]
1881 fn overline_rgba(&self) -> Option<gdk::RGBA> {
1882 ObjectExt::property(self.as_ref(), "overline-rgba")
1883 }
1884
1885 #[doc(alias = "overline-rgba")]
1889 fn set_overline_rgba(&self, overline_rgba: Option<&gdk::RGBA>) {
1890 ObjectExt::set_property(self.as_ref(), "overline-rgba", overline_rgba)
1891 }
1892
1893 #[doc(alias = "overline-rgba-set")]
1895 fn is_overline_rgba_set(&self) -> bool {
1896 ObjectExt::property(self.as_ref(), "overline-rgba-set")
1897 }
1898
1899 #[doc(alias = "overline-set")]
1901 fn is_overline_set(&self) -> bool {
1902 ObjectExt::property(self.as_ref(), "overline-set")
1903 }
1904
1905 #[doc(alias = "paragraph-background")]
1907 fn set_paragraph_background(&self, paragraph_background: Option<&str>) {
1908 ObjectExt::set_property(self.as_ref(), "paragraph-background", paragraph_background)
1909 }
1910
1911 #[doc(alias = "paragraph-background-rgba")]
1913 fn paragraph_background_rgba(&self) -> Option<gdk::RGBA> {
1914 ObjectExt::property(self.as_ref(), "paragraph-background-rgba")
1915 }
1916
1917 #[doc(alias = "paragraph-background-rgba")]
1919 fn set_paragraph_background_rgba(&self, paragraph_background_rgba: Option<&gdk::RGBA>) {
1920 ObjectExt::set_property(
1921 self.as_ref(),
1922 "paragraph-background-rgba",
1923 paragraph_background_rgba,
1924 )
1925 }
1926
1927 #[doc(alias = "paragraph-background-set")]
1929 fn is_paragraph_background_set(&self) -> bool {
1930 ObjectExt::property(self.as_ref(), "paragraph-background-set")
1931 }
1932
1933 #[doc(alias = "pixels-above-lines")]
1935 fn pixels_above_lines(&self) -> i32 {
1936 ObjectExt::property(self.as_ref(), "pixels-above-lines")
1937 }
1938
1939 #[doc(alias = "pixels-above-lines")]
1941 fn set_pixels_above_lines(&self, pixels_above_lines: i32) {
1942 ObjectExt::set_property(self.as_ref(), "pixels-above-lines", pixels_above_lines)
1943 }
1944
1945 #[doc(alias = "pixels-above-lines-set")]
1947 fn is_pixels_above_lines_set(&self) -> bool {
1948 ObjectExt::property(self.as_ref(), "pixels-above-lines-set")
1949 }
1950
1951 #[doc(alias = "pixels-below-lines")]
1953 fn pixels_below_lines(&self) -> i32 {
1954 ObjectExt::property(self.as_ref(), "pixels-below-lines")
1955 }
1956
1957 #[doc(alias = "pixels-below-lines")]
1959 fn set_pixels_below_lines(&self, pixels_below_lines: i32) {
1960 ObjectExt::set_property(self.as_ref(), "pixels-below-lines", pixels_below_lines)
1961 }
1962
1963 #[doc(alias = "pixels-below-lines-set")]
1965 fn is_pixels_below_lines_set(&self) -> bool {
1966 ObjectExt::property(self.as_ref(), "pixels-below-lines-set")
1967 }
1968
1969 #[doc(alias = "pixels-inside-wrap")]
1971 fn pixels_inside_wrap(&self) -> i32 {
1972 ObjectExt::property(self.as_ref(), "pixels-inside-wrap")
1973 }
1974
1975 #[doc(alias = "pixels-inside-wrap")]
1977 fn set_pixels_inside_wrap(&self, pixels_inside_wrap: i32) {
1978 ObjectExt::set_property(self.as_ref(), "pixels-inside-wrap", pixels_inside_wrap)
1979 }
1980
1981 #[doc(alias = "pixels-inside-wrap-set")]
1983 fn is_pixels_inside_wrap_set(&self) -> bool {
1984 ObjectExt::property(self.as_ref(), "pixels-inside-wrap-set")
1985 }
1986
1987 #[doc(alias = "right-margin")]
1989 fn right_margin(&self) -> i32 {
1990 ObjectExt::property(self.as_ref(), "right-margin")
1991 }
1992
1993 #[doc(alias = "right-margin")]
1995 fn set_right_margin(&self, right_margin: i32) {
1996 ObjectExt::set_property(self.as_ref(), "right-margin", right_margin)
1997 }
1998
1999 #[doc(alias = "right-margin-set")]
2001 fn is_right_margin_set(&self) -> bool {
2002 ObjectExt::property(self.as_ref(), "right-margin-set")
2003 }
2004
2005 fn rise(&self) -> i32 {
2009 ObjectExt::property(self.as_ref(), "rise")
2010 }
2011
2012 fn set_rise(&self, rise: i32) {
2016 ObjectExt::set_property(self.as_ref(), "rise", rise)
2017 }
2018
2019 #[doc(alias = "rise-set")]
2021 fn is_rise_set(&self) -> bool {
2022 ObjectExt::property(self.as_ref(), "rise-set")
2023 }
2024
2025 fn scale(&self) -> f64 {
2030 ObjectExt::property(self.as_ref(), "scale")
2031 }
2032
2033 fn set_scale(&self, scale: f64) {
2038 ObjectExt::set_property(self.as_ref(), "scale", scale)
2039 }
2040
2041 #[doc(alias = "scale-set")]
2043 fn is_scale_set(&self) -> bool {
2044 ObjectExt::property(self.as_ref(), "scale-set")
2045 }
2046
2047 #[cfg(feature = "v4_6")]
2051 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2052 fn is_sentence(&self) -> bool {
2053 ObjectExt::property(self.as_ref(), "sentence")
2054 }
2055
2056 #[cfg(feature = "v4_6")]
2060 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2061 fn set_sentence(&self, sentence: bool) {
2062 ObjectExt::set_property(self.as_ref(), "sentence", sentence)
2063 }
2064
2065 #[cfg(feature = "v4_6")]
2067 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2068 #[doc(alias = "sentence-set")]
2069 fn is_sentence_set(&self) -> bool {
2070 ObjectExt::property(self.as_ref(), "sentence-set")
2071 }
2072
2073 #[doc(alias = "show-spaces")]
2075 fn show_spaces(&self) -> pango::ShowFlags {
2076 ObjectExt::property(self.as_ref(), "show-spaces")
2077 }
2078
2079 #[doc(alias = "show-spaces")]
2081 fn set_show_spaces(&self, show_spaces: pango::ShowFlags) {
2082 ObjectExt::set_property(self.as_ref(), "show-spaces", show_spaces)
2083 }
2084
2085 #[doc(alias = "show-spaces-set")]
2087 fn shows_spaces_set(&self) -> bool {
2088 ObjectExt::property(self.as_ref(), "show-spaces-set")
2089 }
2090
2091 fn size(&self) -> i32 {
2093 ObjectExt::property(self.as_ref(), "size")
2094 }
2095
2096 fn set_size(&self, size: i32) {
2098 ObjectExt::set_property(self.as_ref(), "size", size)
2099 }
2100
2101 #[doc(alias = "size-points")]
2103 fn size_points(&self) -> f64 {
2104 ObjectExt::property(self.as_ref(), "size-points")
2105 }
2106
2107 #[doc(alias = "size-points")]
2109 fn set_size_points(&self, size_points: f64) {
2110 ObjectExt::set_property(self.as_ref(), "size-points", size_points)
2111 }
2112
2113 #[doc(alias = "size-set")]
2115 fn is_size_set(&self) -> bool {
2116 ObjectExt::property(self.as_ref(), "size-set")
2117 }
2118
2119 fn stretch(&self) -> pango::Stretch {
2121 ObjectExt::property(self.as_ref(), "stretch")
2122 }
2123
2124 fn set_stretch(&self, stretch: pango::Stretch) {
2126 ObjectExt::set_property(self.as_ref(), "stretch", stretch)
2127 }
2128
2129 #[doc(alias = "stretch-set")]
2131 fn is_stretch_set(&self) -> bool {
2132 ObjectExt::property(self.as_ref(), "stretch-set")
2133 }
2134
2135 fn is_strikethrough(&self) -> bool {
2137 ObjectExt::property(self.as_ref(), "strikethrough")
2138 }
2139
2140 fn set_strikethrough(&self, strikethrough: bool) {
2142 ObjectExt::set_property(self.as_ref(), "strikethrough", strikethrough)
2143 }
2144
2145 #[doc(alias = "strikethrough-rgba")]
2149 fn strikethrough_rgba(&self) -> Option<gdk::RGBA> {
2150 ObjectExt::property(self.as_ref(), "strikethrough-rgba")
2151 }
2152
2153 #[doc(alias = "strikethrough-rgba")]
2157 fn set_strikethrough_rgba(&self, strikethrough_rgba: Option<&gdk::RGBA>) {
2158 ObjectExt::set_property(self.as_ref(), "strikethrough-rgba", strikethrough_rgba)
2159 }
2160
2161 #[doc(alias = "strikethrough-rgba-set")]
2163 fn is_strikethrough_rgba_set(&self) -> bool {
2164 ObjectExt::property(self.as_ref(), "strikethrough-rgba-set")
2165 }
2166
2167 #[doc(alias = "strikethrough-set")]
2169 fn is_strikethrough_set(&self) -> bool {
2170 ObjectExt::property(self.as_ref(), "strikethrough-set")
2171 }
2172
2173 fn style(&self) -> pango::Style {
2175 ObjectExt::property(self.as_ref(), "style")
2176 }
2177
2178 fn set_style(&self, style: pango::Style) {
2180 ObjectExt::set_property(self.as_ref(), "style", style)
2181 }
2182
2183 #[doc(alias = "style-set")]
2185 fn is_style_set(&self) -> bool {
2186 ObjectExt::property(self.as_ref(), "style-set")
2187 }
2188
2189 fn tabs(&self) -> Option<pango::TabArray> {
2191 ObjectExt::property(self.as_ref(), "tabs")
2192 }
2193
2194 fn set_tabs(&self, tabs: Option<&pango::TabArray>) {
2196 ObjectExt::set_property(self.as_ref(), "tabs", tabs)
2197 }
2198
2199 #[doc(alias = "tabs-set")]
2201 fn is_tabs_set(&self) -> bool {
2202 ObjectExt::property(self.as_ref(), "tabs-set")
2203 }
2204
2205 #[cfg(feature = "v4_6")]
2207 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2208 #[doc(alias = "text-transform")]
2209 fn text_transform(&self) -> pango::TextTransform {
2210 ObjectExt::property(self.as_ref(), "text-transform")
2211 }
2212
2213 #[cfg(feature = "v4_6")]
2215 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2216 #[doc(alias = "text-transform")]
2217 fn set_text_transform(&self, text_transform: pango::TextTransform) {
2218 ObjectExt::set_property(self.as_ref(), "text-transform", text_transform)
2219 }
2220
2221 #[cfg(feature = "v4_6")]
2223 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2224 #[doc(alias = "text-transform-set")]
2225 fn is_text_transform_set(&self) -> bool {
2226 ObjectExt::property(self.as_ref(), "text-transform-set")
2227 }
2228
2229 fn underline(&self) -> pango::Underline {
2231 ObjectExt::property(self.as_ref(), "underline")
2232 }
2233
2234 fn set_underline(&self, underline: pango::Underline) {
2236 ObjectExt::set_property(self.as_ref(), "underline", underline)
2237 }
2238
2239 #[doc(alias = "underline-rgba")]
2247 fn underline_rgba(&self) -> Option<gdk::RGBA> {
2248 ObjectExt::property(self.as_ref(), "underline-rgba")
2249 }
2250
2251 #[doc(alias = "underline-rgba")]
2259 fn set_underline_rgba(&self, underline_rgba: Option<&gdk::RGBA>) {
2260 ObjectExt::set_property(self.as_ref(), "underline-rgba", underline_rgba)
2261 }
2262
2263 #[doc(alias = "underline-rgba-set")]
2265 fn is_underline_rgba_set(&self) -> bool {
2266 ObjectExt::property(self.as_ref(), "underline-rgba-set")
2267 }
2268
2269 #[doc(alias = "underline-set")]
2271 fn is_underline_set(&self) -> bool {
2272 ObjectExt::property(self.as_ref(), "underline-set")
2273 }
2274
2275 fn variant(&self) -> pango::Variant {
2277 ObjectExt::property(self.as_ref(), "variant")
2278 }
2279
2280 fn set_variant(&self, variant: pango::Variant) {
2282 ObjectExt::set_property(self.as_ref(), "variant", variant)
2283 }
2284
2285 #[doc(alias = "variant-set")]
2287 fn is_variant_set(&self) -> bool {
2288 ObjectExt::property(self.as_ref(), "variant-set")
2289 }
2290
2291 fn weight(&self) -> i32 {
2293 ObjectExt::property(self.as_ref(), "weight")
2294 }
2295
2296 fn set_weight(&self, weight: i32) {
2298 ObjectExt::set_property(self.as_ref(), "weight", weight)
2299 }
2300
2301 #[doc(alias = "weight-set")]
2303 fn is_weight_set(&self) -> bool {
2304 ObjectExt::property(self.as_ref(), "weight-set")
2305 }
2306
2307 #[cfg(feature = "v4_6")]
2311 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2312 fn is_word(&self) -> bool {
2313 ObjectExt::property(self.as_ref(), "word")
2314 }
2315
2316 #[cfg(feature = "v4_6")]
2320 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2321 fn set_word(&self, word: bool) {
2322 ObjectExt::set_property(self.as_ref(), "word", word)
2323 }
2324
2325 #[cfg(feature = "v4_6")]
2327 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2328 #[doc(alias = "word-set")]
2329 fn is_word_set(&self) -> bool {
2330 ObjectExt::property(self.as_ref(), "word-set")
2331 }
2332
2333 #[doc(alias = "wrap-mode")]
2336 fn wrap_mode(&self) -> WrapMode {
2337 ObjectExt::property(self.as_ref(), "wrap-mode")
2338 }
2339
2340 #[doc(alias = "wrap-mode")]
2343 fn set_wrap_mode(&self, wrap_mode: WrapMode) {
2344 ObjectExt::set_property(self.as_ref(), "wrap-mode", wrap_mode)
2345 }
2346
2347 #[doc(alias = "wrap-mode-set")]
2349 fn wraps_mode_set(&self) -> bool {
2350 ObjectExt::property(self.as_ref(), "wrap-mode-set")
2351 }
2352
2353 #[doc(alias = "accumulative-margin")]
2354 fn connect_accumulative_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2355 unsafe extern "C" fn notify_accumulative_margin_trampoline<
2356 P: IsA<TextTag>,
2357 F: Fn(&P) + 'static,
2358 >(
2359 this: *mut ffi::GtkTextTag,
2360 _param_spec: glib::ffi::gpointer,
2361 f: glib::ffi::gpointer,
2362 ) {
2363 let f: &F = &*(f as *const F);
2364 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2365 }
2366 unsafe {
2367 let f: Box_<F> = Box_::new(f);
2368 connect_raw(
2369 self.as_ptr() as *mut _,
2370 b"notify::accumulative-margin\0".as_ptr() as *const _,
2371 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2372 notify_accumulative_margin_trampoline::<Self, F> as *const (),
2373 )),
2374 Box_::into_raw(f),
2375 )
2376 }
2377 }
2378
2379 #[doc(alias = "allow-breaks")]
2380 fn connect_allow_breaks_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2381 unsafe extern "C" fn notify_allow_breaks_trampoline<
2382 P: IsA<TextTag>,
2383 F: Fn(&P) + 'static,
2384 >(
2385 this: *mut ffi::GtkTextTag,
2386 _param_spec: glib::ffi::gpointer,
2387 f: glib::ffi::gpointer,
2388 ) {
2389 let f: &F = &*(f as *const F);
2390 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2391 }
2392 unsafe {
2393 let f: Box_<F> = Box_::new(f);
2394 connect_raw(
2395 self.as_ptr() as *mut _,
2396 b"notify::allow-breaks\0".as_ptr() as *const _,
2397 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2398 notify_allow_breaks_trampoline::<Self, F> as *const (),
2399 )),
2400 Box_::into_raw(f),
2401 )
2402 }
2403 }
2404
2405 #[doc(alias = "allow-breaks-set")]
2406 fn connect_allow_breaks_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2407 unsafe extern "C" fn notify_allow_breaks_set_trampoline<
2408 P: IsA<TextTag>,
2409 F: Fn(&P) + 'static,
2410 >(
2411 this: *mut ffi::GtkTextTag,
2412 _param_spec: glib::ffi::gpointer,
2413 f: glib::ffi::gpointer,
2414 ) {
2415 let f: &F = &*(f as *const F);
2416 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2417 }
2418 unsafe {
2419 let f: Box_<F> = Box_::new(f);
2420 connect_raw(
2421 self.as_ptr() as *mut _,
2422 b"notify::allow-breaks-set\0".as_ptr() as *const _,
2423 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2424 notify_allow_breaks_set_trampoline::<Self, F> as *const (),
2425 )),
2426 Box_::into_raw(f),
2427 )
2428 }
2429 }
2430
2431 #[doc(alias = "background")]
2432 fn connect_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2433 unsafe extern "C" fn notify_background_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2434 this: *mut ffi::GtkTextTag,
2435 _param_spec: glib::ffi::gpointer,
2436 f: glib::ffi::gpointer,
2437 ) {
2438 let f: &F = &*(f as *const F);
2439 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2440 }
2441 unsafe {
2442 let f: Box_<F> = Box_::new(f);
2443 connect_raw(
2444 self.as_ptr() as *mut _,
2445 b"notify::background\0".as_ptr() as *const _,
2446 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2447 notify_background_trampoline::<Self, F> as *const (),
2448 )),
2449 Box_::into_raw(f),
2450 )
2451 }
2452 }
2453
2454 #[doc(alias = "background-full-height")]
2455 fn connect_background_full_height_notify<F: Fn(&Self) + 'static>(
2456 &self,
2457 f: F,
2458 ) -> SignalHandlerId {
2459 unsafe extern "C" fn notify_background_full_height_trampoline<
2460 P: IsA<TextTag>,
2461 F: Fn(&P) + 'static,
2462 >(
2463 this: *mut ffi::GtkTextTag,
2464 _param_spec: glib::ffi::gpointer,
2465 f: glib::ffi::gpointer,
2466 ) {
2467 let f: &F = &*(f as *const F);
2468 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2469 }
2470 unsafe {
2471 let f: Box_<F> = Box_::new(f);
2472 connect_raw(
2473 self.as_ptr() as *mut _,
2474 b"notify::background-full-height\0".as_ptr() as *const _,
2475 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2476 notify_background_full_height_trampoline::<Self, F> as *const (),
2477 )),
2478 Box_::into_raw(f),
2479 )
2480 }
2481 }
2482
2483 #[doc(alias = "background-full-height-set")]
2484 fn connect_background_full_height_set_notify<F: Fn(&Self) + 'static>(
2485 &self,
2486 f: F,
2487 ) -> SignalHandlerId {
2488 unsafe extern "C" fn notify_background_full_height_set_trampoline<
2489 P: IsA<TextTag>,
2490 F: Fn(&P) + 'static,
2491 >(
2492 this: *mut ffi::GtkTextTag,
2493 _param_spec: glib::ffi::gpointer,
2494 f: glib::ffi::gpointer,
2495 ) {
2496 let f: &F = &*(f as *const F);
2497 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2498 }
2499 unsafe {
2500 let f: Box_<F> = Box_::new(f);
2501 connect_raw(
2502 self.as_ptr() as *mut _,
2503 b"notify::background-full-height-set\0".as_ptr() as *const _,
2504 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2505 notify_background_full_height_set_trampoline::<Self, F> as *const (),
2506 )),
2507 Box_::into_raw(f),
2508 )
2509 }
2510 }
2511
2512 #[doc(alias = "background-rgba")]
2513 fn connect_background_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2514 unsafe extern "C" fn notify_background_rgba_trampoline<
2515 P: IsA<TextTag>,
2516 F: Fn(&P) + 'static,
2517 >(
2518 this: *mut ffi::GtkTextTag,
2519 _param_spec: glib::ffi::gpointer,
2520 f: glib::ffi::gpointer,
2521 ) {
2522 let f: &F = &*(f as *const F);
2523 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2524 }
2525 unsafe {
2526 let f: Box_<F> = Box_::new(f);
2527 connect_raw(
2528 self.as_ptr() as *mut _,
2529 b"notify::background-rgba\0".as_ptr() as *const _,
2530 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2531 notify_background_rgba_trampoline::<Self, F> as *const (),
2532 )),
2533 Box_::into_raw(f),
2534 )
2535 }
2536 }
2537
2538 #[doc(alias = "background-set")]
2539 fn connect_background_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2540 unsafe extern "C" fn notify_background_set_trampoline<
2541 P: IsA<TextTag>,
2542 F: Fn(&P) + 'static,
2543 >(
2544 this: *mut ffi::GtkTextTag,
2545 _param_spec: glib::ffi::gpointer,
2546 f: glib::ffi::gpointer,
2547 ) {
2548 let f: &F = &*(f as *const F);
2549 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2550 }
2551 unsafe {
2552 let f: Box_<F> = Box_::new(f);
2553 connect_raw(
2554 self.as_ptr() as *mut _,
2555 b"notify::background-set\0".as_ptr() as *const _,
2556 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2557 notify_background_set_trampoline::<Self, F> as *const (),
2558 )),
2559 Box_::into_raw(f),
2560 )
2561 }
2562 }
2563
2564 #[doc(alias = "direction")]
2565 fn connect_direction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2566 unsafe extern "C" fn notify_direction_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2567 this: *mut ffi::GtkTextTag,
2568 _param_spec: glib::ffi::gpointer,
2569 f: glib::ffi::gpointer,
2570 ) {
2571 let f: &F = &*(f as *const F);
2572 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2573 }
2574 unsafe {
2575 let f: Box_<F> = Box_::new(f);
2576 connect_raw(
2577 self.as_ptr() as *mut _,
2578 b"notify::direction\0".as_ptr() as *const _,
2579 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2580 notify_direction_trampoline::<Self, F> as *const (),
2581 )),
2582 Box_::into_raw(f),
2583 )
2584 }
2585 }
2586
2587 #[doc(alias = "editable")]
2588 fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2589 unsafe extern "C" fn notify_editable_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2590 this: *mut ffi::GtkTextTag,
2591 _param_spec: glib::ffi::gpointer,
2592 f: glib::ffi::gpointer,
2593 ) {
2594 let f: &F = &*(f as *const F);
2595 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2596 }
2597 unsafe {
2598 let f: Box_<F> = Box_::new(f);
2599 connect_raw(
2600 self.as_ptr() as *mut _,
2601 b"notify::editable\0".as_ptr() as *const _,
2602 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2603 notify_editable_trampoline::<Self, F> as *const (),
2604 )),
2605 Box_::into_raw(f),
2606 )
2607 }
2608 }
2609
2610 #[doc(alias = "editable-set")]
2611 fn connect_editable_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2612 unsafe extern "C" fn notify_editable_set_trampoline<
2613 P: IsA<TextTag>,
2614 F: Fn(&P) + 'static,
2615 >(
2616 this: *mut ffi::GtkTextTag,
2617 _param_spec: glib::ffi::gpointer,
2618 f: glib::ffi::gpointer,
2619 ) {
2620 let f: &F = &*(f as *const F);
2621 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2622 }
2623 unsafe {
2624 let f: Box_<F> = Box_::new(f);
2625 connect_raw(
2626 self.as_ptr() as *mut _,
2627 b"notify::editable-set\0".as_ptr() as *const _,
2628 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2629 notify_editable_set_trampoline::<Self, F> as *const (),
2630 )),
2631 Box_::into_raw(f),
2632 )
2633 }
2634 }
2635
2636 #[doc(alias = "fallback")]
2637 fn connect_fallback_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2638 unsafe extern "C" fn notify_fallback_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2639 this: *mut ffi::GtkTextTag,
2640 _param_spec: glib::ffi::gpointer,
2641 f: glib::ffi::gpointer,
2642 ) {
2643 let f: &F = &*(f as *const F);
2644 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2645 }
2646 unsafe {
2647 let f: Box_<F> = Box_::new(f);
2648 connect_raw(
2649 self.as_ptr() as *mut _,
2650 b"notify::fallback\0".as_ptr() as *const _,
2651 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2652 notify_fallback_trampoline::<Self, F> as *const (),
2653 )),
2654 Box_::into_raw(f),
2655 )
2656 }
2657 }
2658
2659 #[doc(alias = "fallback-set")]
2660 fn connect_fallback_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2661 unsafe extern "C" fn notify_fallback_set_trampoline<
2662 P: IsA<TextTag>,
2663 F: Fn(&P) + 'static,
2664 >(
2665 this: *mut ffi::GtkTextTag,
2666 _param_spec: glib::ffi::gpointer,
2667 f: glib::ffi::gpointer,
2668 ) {
2669 let f: &F = &*(f as *const F);
2670 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2671 }
2672 unsafe {
2673 let f: Box_<F> = Box_::new(f);
2674 connect_raw(
2675 self.as_ptr() as *mut _,
2676 b"notify::fallback-set\0".as_ptr() as *const _,
2677 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2678 notify_fallback_set_trampoline::<Self, F> as *const (),
2679 )),
2680 Box_::into_raw(f),
2681 )
2682 }
2683 }
2684
2685 #[doc(alias = "family")]
2686 fn connect_family_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2687 unsafe extern "C" fn notify_family_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2688 this: *mut ffi::GtkTextTag,
2689 _param_spec: glib::ffi::gpointer,
2690 f: glib::ffi::gpointer,
2691 ) {
2692 let f: &F = &*(f as *const F);
2693 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2694 }
2695 unsafe {
2696 let f: Box_<F> = Box_::new(f);
2697 connect_raw(
2698 self.as_ptr() as *mut _,
2699 b"notify::family\0".as_ptr() as *const _,
2700 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2701 notify_family_trampoline::<Self, F> as *const (),
2702 )),
2703 Box_::into_raw(f),
2704 )
2705 }
2706 }
2707
2708 #[doc(alias = "family-set")]
2709 fn connect_family_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2710 unsafe extern "C" fn notify_family_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2711 this: *mut ffi::GtkTextTag,
2712 _param_spec: glib::ffi::gpointer,
2713 f: glib::ffi::gpointer,
2714 ) {
2715 let f: &F = &*(f as *const F);
2716 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2717 }
2718 unsafe {
2719 let f: Box_<F> = Box_::new(f);
2720 connect_raw(
2721 self.as_ptr() as *mut _,
2722 b"notify::family-set\0".as_ptr() as *const _,
2723 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2724 notify_family_set_trampoline::<Self, F> as *const (),
2725 )),
2726 Box_::into_raw(f),
2727 )
2728 }
2729 }
2730
2731 #[doc(alias = "font")]
2732 fn connect_font_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2733 unsafe extern "C" fn notify_font_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2734 this: *mut ffi::GtkTextTag,
2735 _param_spec: glib::ffi::gpointer,
2736 f: glib::ffi::gpointer,
2737 ) {
2738 let f: &F = &*(f as *const F);
2739 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2740 }
2741 unsafe {
2742 let f: Box_<F> = Box_::new(f);
2743 connect_raw(
2744 self.as_ptr() as *mut _,
2745 b"notify::font\0".as_ptr() as *const _,
2746 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2747 notify_font_trampoline::<Self, F> as *const (),
2748 )),
2749 Box_::into_raw(f),
2750 )
2751 }
2752 }
2753
2754 #[doc(alias = "font-desc")]
2755 fn connect_font_desc_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2756 unsafe extern "C" fn notify_font_desc_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2757 this: *mut ffi::GtkTextTag,
2758 _param_spec: glib::ffi::gpointer,
2759 f: glib::ffi::gpointer,
2760 ) {
2761 let f: &F = &*(f as *const F);
2762 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2763 }
2764 unsafe {
2765 let f: Box_<F> = Box_::new(f);
2766 connect_raw(
2767 self.as_ptr() as *mut _,
2768 b"notify::font-desc\0".as_ptr() as *const _,
2769 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2770 notify_font_desc_trampoline::<Self, F> as *const (),
2771 )),
2772 Box_::into_raw(f),
2773 )
2774 }
2775 }
2776
2777 #[doc(alias = "font-features")]
2778 fn connect_font_features_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2779 unsafe extern "C" fn notify_font_features_trampoline<
2780 P: IsA<TextTag>,
2781 F: Fn(&P) + 'static,
2782 >(
2783 this: *mut ffi::GtkTextTag,
2784 _param_spec: glib::ffi::gpointer,
2785 f: glib::ffi::gpointer,
2786 ) {
2787 let f: &F = &*(f as *const F);
2788 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2789 }
2790 unsafe {
2791 let f: Box_<F> = Box_::new(f);
2792 connect_raw(
2793 self.as_ptr() as *mut _,
2794 b"notify::font-features\0".as_ptr() as *const _,
2795 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2796 notify_font_features_trampoline::<Self, F> as *const (),
2797 )),
2798 Box_::into_raw(f),
2799 )
2800 }
2801 }
2802
2803 #[doc(alias = "font-features-set")]
2804 fn connect_font_features_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2805 unsafe extern "C" fn notify_font_features_set_trampoline<
2806 P: IsA<TextTag>,
2807 F: Fn(&P) + 'static,
2808 >(
2809 this: *mut ffi::GtkTextTag,
2810 _param_spec: glib::ffi::gpointer,
2811 f: glib::ffi::gpointer,
2812 ) {
2813 let f: &F = &*(f as *const F);
2814 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2815 }
2816 unsafe {
2817 let f: Box_<F> = Box_::new(f);
2818 connect_raw(
2819 self.as_ptr() as *mut _,
2820 b"notify::font-features-set\0".as_ptr() as *const _,
2821 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2822 notify_font_features_set_trampoline::<Self, F> as *const (),
2823 )),
2824 Box_::into_raw(f),
2825 )
2826 }
2827 }
2828
2829 #[doc(alias = "foreground")]
2830 fn connect_foreground_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2831 unsafe extern "C" fn notify_foreground_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2832 this: *mut ffi::GtkTextTag,
2833 _param_spec: glib::ffi::gpointer,
2834 f: glib::ffi::gpointer,
2835 ) {
2836 let f: &F = &*(f as *const F);
2837 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2838 }
2839 unsafe {
2840 let f: Box_<F> = Box_::new(f);
2841 connect_raw(
2842 self.as_ptr() as *mut _,
2843 b"notify::foreground\0".as_ptr() as *const _,
2844 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2845 notify_foreground_trampoline::<Self, F> as *const (),
2846 )),
2847 Box_::into_raw(f),
2848 )
2849 }
2850 }
2851
2852 #[doc(alias = "foreground-rgba")]
2853 fn connect_foreground_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2854 unsafe extern "C" fn notify_foreground_rgba_trampoline<
2855 P: IsA<TextTag>,
2856 F: Fn(&P) + 'static,
2857 >(
2858 this: *mut ffi::GtkTextTag,
2859 _param_spec: glib::ffi::gpointer,
2860 f: glib::ffi::gpointer,
2861 ) {
2862 let f: &F = &*(f as *const F);
2863 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2864 }
2865 unsafe {
2866 let f: Box_<F> = Box_::new(f);
2867 connect_raw(
2868 self.as_ptr() as *mut _,
2869 b"notify::foreground-rgba\0".as_ptr() as *const _,
2870 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2871 notify_foreground_rgba_trampoline::<Self, F> as *const (),
2872 )),
2873 Box_::into_raw(f),
2874 )
2875 }
2876 }
2877
2878 #[doc(alias = "foreground-set")]
2879 fn connect_foreground_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2880 unsafe extern "C" fn notify_foreground_set_trampoline<
2881 P: IsA<TextTag>,
2882 F: Fn(&P) + 'static,
2883 >(
2884 this: *mut ffi::GtkTextTag,
2885 _param_spec: glib::ffi::gpointer,
2886 f: glib::ffi::gpointer,
2887 ) {
2888 let f: &F = &*(f as *const F);
2889 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2890 }
2891 unsafe {
2892 let f: Box_<F> = Box_::new(f);
2893 connect_raw(
2894 self.as_ptr() as *mut _,
2895 b"notify::foreground-set\0".as_ptr() as *const _,
2896 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2897 notify_foreground_set_trampoline::<Self, F> as *const (),
2898 )),
2899 Box_::into_raw(f),
2900 )
2901 }
2902 }
2903
2904 #[doc(alias = "indent")]
2905 fn connect_indent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2906 unsafe extern "C" fn notify_indent_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2907 this: *mut ffi::GtkTextTag,
2908 _param_spec: glib::ffi::gpointer,
2909 f: glib::ffi::gpointer,
2910 ) {
2911 let f: &F = &*(f as *const F);
2912 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2913 }
2914 unsafe {
2915 let f: Box_<F> = Box_::new(f);
2916 connect_raw(
2917 self.as_ptr() as *mut _,
2918 b"notify::indent\0".as_ptr() as *const _,
2919 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2920 notify_indent_trampoline::<Self, F> as *const (),
2921 )),
2922 Box_::into_raw(f),
2923 )
2924 }
2925 }
2926
2927 #[doc(alias = "indent-set")]
2928 fn connect_indent_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2929 unsafe extern "C" fn notify_indent_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
2930 this: *mut ffi::GtkTextTag,
2931 _param_spec: glib::ffi::gpointer,
2932 f: glib::ffi::gpointer,
2933 ) {
2934 let f: &F = &*(f as *const F);
2935 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2936 }
2937 unsafe {
2938 let f: Box_<F> = Box_::new(f);
2939 connect_raw(
2940 self.as_ptr() as *mut _,
2941 b"notify::indent-set\0".as_ptr() as *const _,
2942 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2943 notify_indent_set_trampoline::<Self, F> as *const (),
2944 )),
2945 Box_::into_raw(f),
2946 )
2947 }
2948 }
2949
2950 #[doc(alias = "insert-hyphens")]
2951 fn connect_insert_hyphens_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2952 unsafe extern "C" fn notify_insert_hyphens_trampoline<
2953 P: IsA<TextTag>,
2954 F: Fn(&P) + 'static,
2955 >(
2956 this: *mut ffi::GtkTextTag,
2957 _param_spec: glib::ffi::gpointer,
2958 f: glib::ffi::gpointer,
2959 ) {
2960 let f: &F = &*(f as *const F);
2961 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2962 }
2963 unsafe {
2964 let f: Box_<F> = Box_::new(f);
2965 connect_raw(
2966 self.as_ptr() as *mut _,
2967 b"notify::insert-hyphens\0".as_ptr() as *const _,
2968 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2969 notify_insert_hyphens_trampoline::<Self, F> as *const (),
2970 )),
2971 Box_::into_raw(f),
2972 )
2973 }
2974 }
2975
2976 #[doc(alias = "insert-hyphens-set")]
2977 fn connect_insert_hyphens_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
2978 unsafe extern "C" fn notify_insert_hyphens_set_trampoline<
2979 P: IsA<TextTag>,
2980 F: Fn(&P) + 'static,
2981 >(
2982 this: *mut ffi::GtkTextTag,
2983 _param_spec: glib::ffi::gpointer,
2984 f: glib::ffi::gpointer,
2985 ) {
2986 let f: &F = &*(f as *const F);
2987 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
2988 }
2989 unsafe {
2990 let f: Box_<F> = Box_::new(f);
2991 connect_raw(
2992 self.as_ptr() as *mut _,
2993 b"notify::insert-hyphens-set\0".as_ptr() as *const _,
2994 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
2995 notify_insert_hyphens_set_trampoline::<Self, F> as *const (),
2996 )),
2997 Box_::into_raw(f),
2998 )
2999 }
3000 }
3001
3002 #[doc(alias = "invisible")]
3003 fn connect_invisible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3004 unsafe extern "C" fn notify_invisible_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3005 this: *mut ffi::GtkTextTag,
3006 _param_spec: glib::ffi::gpointer,
3007 f: glib::ffi::gpointer,
3008 ) {
3009 let f: &F = &*(f as *const F);
3010 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3011 }
3012 unsafe {
3013 let f: Box_<F> = Box_::new(f);
3014 connect_raw(
3015 self.as_ptr() as *mut _,
3016 b"notify::invisible\0".as_ptr() as *const _,
3017 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3018 notify_invisible_trampoline::<Self, F> as *const (),
3019 )),
3020 Box_::into_raw(f),
3021 )
3022 }
3023 }
3024
3025 #[doc(alias = "invisible-set")]
3026 fn connect_invisible_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3027 unsafe extern "C" fn notify_invisible_set_trampoline<
3028 P: IsA<TextTag>,
3029 F: Fn(&P) + 'static,
3030 >(
3031 this: *mut ffi::GtkTextTag,
3032 _param_spec: glib::ffi::gpointer,
3033 f: glib::ffi::gpointer,
3034 ) {
3035 let f: &F = &*(f as *const F);
3036 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3037 }
3038 unsafe {
3039 let f: Box_<F> = Box_::new(f);
3040 connect_raw(
3041 self.as_ptr() as *mut _,
3042 b"notify::invisible-set\0".as_ptr() as *const _,
3043 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3044 notify_invisible_set_trampoline::<Self, F> as *const (),
3045 )),
3046 Box_::into_raw(f),
3047 )
3048 }
3049 }
3050
3051 #[doc(alias = "justification")]
3052 fn connect_justification_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3053 unsafe extern "C" fn notify_justification_trampoline<
3054 P: IsA<TextTag>,
3055 F: Fn(&P) + 'static,
3056 >(
3057 this: *mut ffi::GtkTextTag,
3058 _param_spec: glib::ffi::gpointer,
3059 f: glib::ffi::gpointer,
3060 ) {
3061 let f: &F = &*(f as *const F);
3062 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3063 }
3064 unsafe {
3065 let f: Box_<F> = Box_::new(f);
3066 connect_raw(
3067 self.as_ptr() as *mut _,
3068 b"notify::justification\0".as_ptr() as *const _,
3069 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3070 notify_justification_trampoline::<Self, F> as *const (),
3071 )),
3072 Box_::into_raw(f),
3073 )
3074 }
3075 }
3076
3077 #[doc(alias = "justification-set")]
3078 fn connect_justification_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3079 unsafe extern "C" fn notify_justification_set_trampoline<
3080 P: IsA<TextTag>,
3081 F: Fn(&P) + 'static,
3082 >(
3083 this: *mut ffi::GtkTextTag,
3084 _param_spec: glib::ffi::gpointer,
3085 f: glib::ffi::gpointer,
3086 ) {
3087 let f: &F = &*(f as *const F);
3088 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3089 }
3090 unsafe {
3091 let f: Box_<F> = Box_::new(f);
3092 connect_raw(
3093 self.as_ptr() as *mut _,
3094 b"notify::justification-set\0".as_ptr() as *const _,
3095 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3096 notify_justification_set_trampoline::<Self, F> as *const (),
3097 )),
3098 Box_::into_raw(f),
3099 )
3100 }
3101 }
3102
3103 #[doc(alias = "language")]
3104 fn connect_language_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3105 unsafe extern "C" fn notify_language_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3106 this: *mut ffi::GtkTextTag,
3107 _param_spec: glib::ffi::gpointer,
3108 f: glib::ffi::gpointer,
3109 ) {
3110 let f: &F = &*(f as *const F);
3111 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3112 }
3113 unsafe {
3114 let f: Box_<F> = Box_::new(f);
3115 connect_raw(
3116 self.as_ptr() as *mut _,
3117 b"notify::language\0".as_ptr() as *const _,
3118 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3119 notify_language_trampoline::<Self, F> as *const (),
3120 )),
3121 Box_::into_raw(f),
3122 )
3123 }
3124 }
3125
3126 #[doc(alias = "language-set")]
3127 fn connect_language_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3128 unsafe extern "C" fn notify_language_set_trampoline<
3129 P: IsA<TextTag>,
3130 F: Fn(&P) + 'static,
3131 >(
3132 this: *mut ffi::GtkTextTag,
3133 _param_spec: glib::ffi::gpointer,
3134 f: glib::ffi::gpointer,
3135 ) {
3136 let f: &F = &*(f as *const F);
3137 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3138 }
3139 unsafe {
3140 let f: Box_<F> = Box_::new(f);
3141 connect_raw(
3142 self.as_ptr() as *mut _,
3143 b"notify::language-set\0".as_ptr() as *const _,
3144 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3145 notify_language_set_trampoline::<Self, F> as *const (),
3146 )),
3147 Box_::into_raw(f),
3148 )
3149 }
3150 }
3151
3152 #[doc(alias = "left-margin")]
3153 fn connect_left_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3154 unsafe extern "C" fn notify_left_margin_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3155 this: *mut ffi::GtkTextTag,
3156 _param_spec: glib::ffi::gpointer,
3157 f: glib::ffi::gpointer,
3158 ) {
3159 let f: &F = &*(f as *const F);
3160 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3161 }
3162 unsafe {
3163 let f: Box_<F> = Box_::new(f);
3164 connect_raw(
3165 self.as_ptr() as *mut _,
3166 b"notify::left-margin\0".as_ptr() as *const _,
3167 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3168 notify_left_margin_trampoline::<Self, F> as *const (),
3169 )),
3170 Box_::into_raw(f),
3171 )
3172 }
3173 }
3174
3175 #[doc(alias = "left-margin-set")]
3176 fn connect_left_margin_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3177 unsafe extern "C" fn notify_left_margin_set_trampoline<
3178 P: IsA<TextTag>,
3179 F: Fn(&P) + 'static,
3180 >(
3181 this: *mut ffi::GtkTextTag,
3182 _param_spec: glib::ffi::gpointer,
3183 f: glib::ffi::gpointer,
3184 ) {
3185 let f: &F = &*(f as *const F);
3186 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3187 }
3188 unsafe {
3189 let f: Box_<F> = Box_::new(f);
3190 connect_raw(
3191 self.as_ptr() as *mut _,
3192 b"notify::left-margin-set\0".as_ptr() as *const _,
3193 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3194 notify_left_margin_set_trampoline::<Self, F> as *const (),
3195 )),
3196 Box_::into_raw(f),
3197 )
3198 }
3199 }
3200
3201 #[doc(alias = "letter-spacing")]
3202 fn connect_letter_spacing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3203 unsafe extern "C" fn notify_letter_spacing_trampoline<
3204 P: IsA<TextTag>,
3205 F: Fn(&P) + 'static,
3206 >(
3207 this: *mut ffi::GtkTextTag,
3208 _param_spec: glib::ffi::gpointer,
3209 f: glib::ffi::gpointer,
3210 ) {
3211 let f: &F = &*(f as *const F);
3212 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3213 }
3214 unsafe {
3215 let f: Box_<F> = Box_::new(f);
3216 connect_raw(
3217 self.as_ptr() as *mut _,
3218 b"notify::letter-spacing\0".as_ptr() as *const _,
3219 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3220 notify_letter_spacing_trampoline::<Self, F> as *const (),
3221 )),
3222 Box_::into_raw(f),
3223 )
3224 }
3225 }
3226
3227 #[doc(alias = "letter-spacing-set")]
3228 fn connect_letter_spacing_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3229 unsafe extern "C" fn notify_letter_spacing_set_trampoline<
3230 P: IsA<TextTag>,
3231 F: Fn(&P) + 'static,
3232 >(
3233 this: *mut ffi::GtkTextTag,
3234 _param_spec: glib::ffi::gpointer,
3235 f: glib::ffi::gpointer,
3236 ) {
3237 let f: &F = &*(f as *const F);
3238 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3239 }
3240 unsafe {
3241 let f: Box_<F> = Box_::new(f);
3242 connect_raw(
3243 self.as_ptr() as *mut _,
3244 b"notify::letter-spacing-set\0".as_ptr() as *const _,
3245 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3246 notify_letter_spacing_set_trampoline::<Self, F> as *const (),
3247 )),
3248 Box_::into_raw(f),
3249 )
3250 }
3251 }
3252
3253 #[cfg(feature = "v4_6")]
3254 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3255 #[doc(alias = "line-height")]
3256 fn connect_line_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3257 unsafe extern "C" fn notify_line_height_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3258 this: *mut ffi::GtkTextTag,
3259 _param_spec: glib::ffi::gpointer,
3260 f: glib::ffi::gpointer,
3261 ) {
3262 let f: &F = &*(f as *const F);
3263 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3264 }
3265 unsafe {
3266 let f: Box_<F> = Box_::new(f);
3267 connect_raw(
3268 self.as_ptr() as *mut _,
3269 b"notify::line-height\0".as_ptr() as *const _,
3270 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3271 notify_line_height_trampoline::<Self, F> as *const (),
3272 )),
3273 Box_::into_raw(f),
3274 )
3275 }
3276 }
3277
3278 #[cfg(feature = "v4_6")]
3279 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3280 #[doc(alias = "line-height-set")]
3281 fn connect_line_height_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3282 unsafe extern "C" fn notify_line_height_set_trampoline<
3283 P: IsA<TextTag>,
3284 F: Fn(&P) + 'static,
3285 >(
3286 this: *mut ffi::GtkTextTag,
3287 _param_spec: glib::ffi::gpointer,
3288 f: glib::ffi::gpointer,
3289 ) {
3290 let f: &F = &*(f as *const F);
3291 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3292 }
3293 unsafe {
3294 let f: Box_<F> = Box_::new(f);
3295 connect_raw(
3296 self.as_ptr() as *mut _,
3297 b"notify::line-height-set\0".as_ptr() as *const _,
3298 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3299 notify_line_height_set_trampoline::<Self, F> as *const (),
3300 )),
3301 Box_::into_raw(f),
3302 )
3303 }
3304 }
3305
3306 #[doc(alias = "overline")]
3307 fn connect_overline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3308 unsafe extern "C" fn notify_overline_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3309 this: *mut ffi::GtkTextTag,
3310 _param_spec: glib::ffi::gpointer,
3311 f: glib::ffi::gpointer,
3312 ) {
3313 let f: &F = &*(f as *const F);
3314 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3315 }
3316 unsafe {
3317 let f: Box_<F> = Box_::new(f);
3318 connect_raw(
3319 self.as_ptr() as *mut _,
3320 b"notify::overline\0".as_ptr() as *const _,
3321 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3322 notify_overline_trampoline::<Self, F> as *const (),
3323 )),
3324 Box_::into_raw(f),
3325 )
3326 }
3327 }
3328
3329 #[doc(alias = "overline-rgba")]
3330 fn connect_overline_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3331 unsafe extern "C" fn notify_overline_rgba_trampoline<
3332 P: IsA<TextTag>,
3333 F: Fn(&P) + 'static,
3334 >(
3335 this: *mut ffi::GtkTextTag,
3336 _param_spec: glib::ffi::gpointer,
3337 f: glib::ffi::gpointer,
3338 ) {
3339 let f: &F = &*(f as *const F);
3340 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3341 }
3342 unsafe {
3343 let f: Box_<F> = Box_::new(f);
3344 connect_raw(
3345 self.as_ptr() as *mut _,
3346 b"notify::overline-rgba\0".as_ptr() as *const _,
3347 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3348 notify_overline_rgba_trampoline::<Self, F> as *const (),
3349 )),
3350 Box_::into_raw(f),
3351 )
3352 }
3353 }
3354
3355 #[doc(alias = "overline-rgba-set")]
3356 fn connect_overline_rgba_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3357 unsafe extern "C" fn notify_overline_rgba_set_trampoline<
3358 P: IsA<TextTag>,
3359 F: Fn(&P) + 'static,
3360 >(
3361 this: *mut ffi::GtkTextTag,
3362 _param_spec: glib::ffi::gpointer,
3363 f: glib::ffi::gpointer,
3364 ) {
3365 let f: &F = &*(f as *const F);
3366 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3367 }
3368 unsafe {
3369 let f: Box_<F> = Box_::new(f);
3370 connect_raw(
3371 self.as_ptr() as *mut _,
3372 b"notify::overline-rgba-set\0".as_ptr() as *const _,
3373 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3374 notify_overline_rgba_set_trampoline::<Self, F> as *const (),
3375 )),
3376 Box_::into_raw(f),
3377 )
3378 }
3379 }
3380
3381 #[doc(alias = "overline-set")]
3382 fn connect_overline_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3383 unsafe extern "C" fn notify_overline_set_trampoline<
3384 P: IsA<TextTag>,
3385 F: Fn(&P) + 'static,
3386 >(
3387 this: *mut ffi::GtkTextTag,
3388 _param_spec: glib::ffi::gpointer,
3389 f: glib::ffi::gpointer,
3390 ) {
3391 let f: &F = &*(f as *const F);
3392 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3393 }
3394 unsafe {
3395 let f: Box_<F> = Box_::new(f);
3396 connect_raw(
3397 self.as_ptr() as *mut _,
3398 b"notify::overline-set\0".as_ptr() as *const _,
3399 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3400 notify_overline_set_trampoline::<Self, F> as *const (),
3401 )),
3402 Box_::into_raw(f),
3403 )
3404 }
3405 }
3406
3407 #[doc(alias = "paragraph-background")]
3408 fn connect_paragraph_background_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3409 unsafe extern "C" fn notify_paragraph_background_trampoline<
3410 P: IsA<TextTag>,
3411 F: Fn(&P) + 'static,
3412 >(
3413 this: *mut ffi::GtkTextTag,
3414 _param_spec: glib::ffi::gpointer,
3415 f: glib::ffi::gpointer,
3416 ) {
3417 let f: &F = &*(f as *const F);
3418 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3419 }
3420 unsafe {
3421 let f: Box_<F> = Box_::new(f);
3422 connect_raw(
3423 self.as_ptr() as *mut _,
3424 b"notify::paragraph-background\0".as_ptr() as *const _,
3425 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3426 notify_paragraph_background_trampoline::<Self, F> as *const (),
3427 )),
3428 Box_::into_raw(f),
3429 )
3430 }
3431 }
3432
3433 #[doc(alias = "paragraph-background-rgba")]
3434 fn connect_paragraph_background_rgba_notify<F: Fn(&Self) + 'static>(
3435 &self,
3436 f: F,
3437 ) -> SignalHandlerId {
3438 unsafe extern "C" fn notify_paragraph_background_rgba_trampoline<
3439 P: IsA<TextTag>,
3440 F: Fn(&P) + 'static,
3441 >(
3442 this: *mut ffi::GtkTextTag,
3443 _param_spec: glib::ffi::gpointer,
3444 f: glib::ffi::gpointer,
3445 ) {
3446 let f: &F = &*(f as *const F);
3447 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3448 }
3449 unsafe {
3450 let f: Box_<F> = Box_::new(f);
3451 connect_raw(
3452 self.as_ptr() as *mut _,
3453 b"notify::paragraph-background-rgba\0".as_ptr() as *const _,
3454 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3455 notify_paragraph_background_rgba_trampoline::<Self, F> as *const (),
3456 )),
3457 Box_::into_raw(f),
3458 )
3459 }
3460 }
3461
3462 #[doc(alias = "paragraph-background-set")]
3463 fn connect_paragraph_background_set_notify<F: Fn(&Self) + 'static>(
3464 &self,
3465 f: F,
3466 ) -> SignalHandlerId {
3467 unsafe extern "C" fn notify_paragraph_background_set_trampoline<
3468 P: IsA<TextTag>,
3469 F: Fn(&P) + 'static,
3470 >(
3471 this: *mut ffi::GtkTextTag,
3472 _param_spec: glib::ffi::gpointer,
3473 f: glib::ffi::gpointer,
3474 ) {
3475 let f: &F = &*(f as *const F);
3476 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3477 }
3478 unsafe {
3479 let f: Box_<F> = Box_::new(f);
3480 connect_raw(
3481 self.as_ptr() as *mut _,
3482 b"notify::paragraph-background-set\0".as_ptr() as *const _,
3483 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3484 notify_paragraph_background_set_trampoline::<Self, F> as *const (),
3485 )),
3486 Box_::into_raw(f),
3487 )
3488 }
3489 }
3490
3491 #[doc(alias = "pixels-above-lines")]
3492 fn connect_pixels_above_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3493 unsafe extern "C" fn notify_pixels_above_lines_trampoline<
3494 P: IsA<TextTag>,
3495 F: Fn(&P) + 'static,
3496 >(
3497 this: *mut ffi::GtkTextTag,
3498 _param_spec: glib::ffi::gpointer,
3499 f: glib::ffi::gpointer,
3500 ) {
3501 let f: &F = &*(f as *const F);
3502 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3503 }
3504 unsafe {
3505 let f: Box_<F> = Box_::new(f);
3506 connect_raw(
3507 self.as_ptr() as *mut _,
3508 b"notify::pixels-above-lines\0".as_ptr() as *const _,
3509 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3510 notify_pixels_above_lines_trampoline::<Self, F> as *const (),
3511 )),
3512 Box_::into_raw(f),
3513 )
3514 }
3515 }
3516
3517 #[doc(alias = "pixels-above-lines-set")]
3518 fn connect_pixels_above_lines_set_notify<F: Fn(&Self) + 'static>(
3519 &self,
3520 f: F,
3521 ) -> SignalHandlerId {
3522 unsafe extern "C" fn notify_pixels_above_lines_set_trampoline<
3523 P: IsA<TextTag>,
3524 F: Fn(&P) + 'static,
3525 >(
3526 this: *mut ffi::GtkTextTag,
3527 _param_spec: glib::ffi::gpointer,
3528 f: glib::ffi::gpointer,
3529 ) {
3530 let f: &F = &*(f as *const F);
3531 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3532 }
3533 unsafe {
3534 let f: Box_<F> = Box_::new(f);
3535 connect_raw(
3536 self.as_ptr() as *mut _,
3537 b"notify::pixels-above-lines-set\0".as_ptr() as *const _,
3538 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3539 notify_pixels_above_lines_set_trampoline::<Self, F> as *const (),
3540 )),
3541 Box_::into_raw(f),
3542 )
3543 }
3544 }
3545
3546 #[doc(alias = "pixels-below-lines")]
3547 fn connect_pixels_below_lines_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3548 unsafe extern "C" fn notify_pixels_below_lines_trampoline<
3549 P: IsA<TextTag>,
3550 F: Fn(&P) + 'static,
3551 >(
3552 this: *mut ffi::GtkTextTag,
3553 _param_spec: glib::ffi::gpointer,
3554 f: glib::ffi::gpointer,
3555 ) {
3556 let f: &F = &*(f as *const F);
3557 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3558 }
3559 unsafe {
3560 let f: Box_<F> = Box_::new(f);
3561 connect_raw(
3562 self.as_ptr() as *mut _,
3563 b"notify::pixels-below-lines\0".as_ptr() as *const _,
3564 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3565 notify_pixels_below_lines_trampoline::<Self, F> as *const (),
3566 )),
3567 Box_::into_raw(f),
3568 )
3569 }
3570 }
3571
3572 #[doc(alias = "pixels-below-lines-set")]
3573 fn connect_pixels_below_lines_set_notify<F: Fn(&Self) + 'static>(
3574 &self,
3575 f: F,
3576 ) -> SignalHandlerId {
3577 unsafe extern "C" fn notify_pixels_below_lines_set_trampoline<
3578 P: IsA<TextTag>,
3579 F: Fn(&P) + 'static,
3580 >(
3581 this: *mut ffi::GtkTextTag,
3582 _param_spec: glib::ffi::gpointer,
3583 f: glib::ffi::gpointer,
3584 ) {
3585 let f: &F = &*(f as *const F);
3586 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3587 }
3588 unsafe {
3589 let f: Box_<F> = Box_::new(f);
3590 connect_raw(
3591 self.as_ptr() as *mut _,
3592 b"notify::pixels-below-lines-set\0".as_ptr() as *const _,
3593 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3594 notify_pixels_below_lines_set_trampoline::<Self, F> as *const (),
3595 )),
3596 Box_::into_raw(f),
3597 )
3598 }
3599 }
3600
3601 #[doc(alias = "pixels-inside-wrap")]
3602 fn connect_pixels_inside_wrap_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3603 unsafe extern "C" fn notify_pixels_inside_wrap_trampoline<
3604 P: IsA<TextTag>,
3605 F: Fn(&P) + 'static,
3606 >(
3607 this: *mut ffi::GtkTextTag,
3608 _param_spec: glib::ffi::gpointer,
3609 f: glib::ffi::gpointer,
3610 ) {
3611 let f: &F = &*(f as *const F);
3612 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3613 }
3614 unsafe {
3615 let f: Box_<F> = Box_::new(f);
3616 connect_raw(
3617 self.as_ptr() as *mut _,
3618 b"notify::pixels-inside-wrap\0".as_ptr() as *const _,
3619 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3620 notify_pixels_inside_wrap_trampoline::<Self, F> as *const (),
3621 )),
3622 Box_::into_raw(f),
3623 )
3624 }
3625 }
3626
3627 #[doc(alias = "pixels-inside-wrap-set")]
3628 fn connect_pixels_inside_wrap_set_notify<F: Fn(&Self) + 'static>(
3629 &self,
3630 f: F,
3631 ) -> SignalHandlerId {
3632 unsafe extern "C" fn notify_pixels_inside_wrap_set_trampoline<
3633 P: IsA<TextTag>,
3634 F: Fn(&P) + 'static,
3635 >(
3636 this: *mut ffi::GtkTextTag,
3637 _param_spec: glib::ffi::gpointer,
3638 f: glib::ffi::gpointer,
3639 ) {
3640 let f: &F = &*(f as *const F);
3641 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3642 }
3643 unsafe {
3644 let f: Box_<F> = Box_::new(f);
3645 connect_raw(
3646 self.as_ptr() as *mut _,
3647 b"notify::pixels-inside-wrap-set\0".as_ptr() as *const _,
3648 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3649 notify_pixels_inside_wrap_set_trampoline::<Self, F> as *const (),
3650 )),
3651 Box_::into_raw(f),
3652 )
3653 }
3654 }
3655
3656 #[doc(alias = "right-margin")]
3657 fn connect_right_margin_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3658 unsafe extern "C" fn notify_right_margin_trampoline<
3659 P: IsA<TextTag>,
3660 F: Fn(&P) + 'static,
3661 >(
3662 this: *mut ffi::GtkTextTag,
3663 _param_spec: glib::ffi::gpointer,
3664 f: glib::ffi::gpointer,
3665 ) {
3666 let f: &F = &*(f as *const F);
3667 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3668 }
3669 unsafe {
3670 let f: Box_<F> = Box_::new(f);
3671 connect_raw(
3672 self.as_ptr() as *mut _,
3673 b"notify::right-margin\0".as_ptr() as *const _,
3674 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3675 notify_right_margin_trampoline::<Self, F> as *const (),
3676 )),
3677 Box_::into_raw(f),
3678 )
3679 }
3680 }
3681
3682 #[doc(alias = "right-margin-set")]
3683 fn connect_right_margin_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3684 unsafe extern "C" fn notify_right_margin_set_trampoline<
3685 P: IsA<TextTag>,
3686 F: Fn(&P) + 'static,
3687 >(
3688 this: *mut ffi::GtkTextTag,
3689 _param_spec: glib::ffi::gpointer,
3690 f: glib::ffi::gpointer,
3691 ) {
3692 let f: &F = &*(f as *const F);
3693 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3694 }
3695 unsafe {
3696 let f: Box_<F> = Box_::new(f);
3697 connect_raw(
3698 self.as_ptr() as *mut _,
3699 b"notify::right-margin-set\0".as_ptr() as *const _,
3700 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3701 notify_right_margin_set_trampoline::<Self, F> as *const (),
3702 )),
3703 Box_::into_raw(f),
3704 )
3705 }
3706 }
3707
3708 #[doc(alias = "rise")]
3709 fn connect_rise_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3710 unsafe extern "C" fn notify_rise_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3711 this: *mut ffi::GtkTextTag,
3712 _param_spec: glib::ffi::gpointer,
3713 f: glib::ffi::gpointer,
3714 ) {
3715 let f: &F = &*(f as *const F);
3716 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3717 }
3718 unsafe {
3719 let f: Box_<F> = Box_::new(f);
3720 connect_raw(
3721 self.as_ptr() as *mut _,
3722 b"notify::rise\0".as_ptr() as *const _,
3723 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3724 notify_rise_trampoline::<Self, F> as *const (),
3725 )),
3726 Box_::into_raw(f),
3727 )
3728 }
3729 }
3730
3731 #[doc(alias = "rise-set")]
3732 fn connect_rise_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3733 unsafe extern "C" fn notify_rise_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3734 this: *mut ffi::GtkTextTag,
3735 _param_spec: glib::ffi::gpointer,
3736 f: glib::ffi::gpointer,
3737 ) {
3738 let f: &F = &*(f as *const F);
3739 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3740 }
3741 unsafe {
3742 let f: Box_<F> = Box_::new(f);
3743 connect_raw(
3744 self.as_ptr() as *mut _,
3745 b"notify::rise-set\0".as_ptr() as *const _,
3746 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3747 notify_rise_set_trampoline::<Self, F> as *const (),
3748 )),
3749 Box_::into_raw(f),
3750 )
3751 }
3752 }
3753
3754 #[doc(alias = "scale")]
3755 fn connect_scale_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3756 unsafe extern "C" fn notify_scale_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3757 this: *mut ffi::GtkTextTag,
3758 _param_spec: glib::ffi::gpointer,
3759 f: glib::ffi::gpointer,
3760 ) {
3761 let f: &F = &*(f as *const F);
3762 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3763 }
3764 unsafe {
3765 let f: Box_<F> = Box_::new(f);
3766 connect_raw(
3767 self.as_ptr() as *mut _,
3768 b"notify::scale\0".as_ptr() as *const _,
3769 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3770 notify_scale_trampoline::<Self, F> as *const (),
3771 )),
3772 Box_::into_raw(f),
3773 )
3774 }
3775 }
3776
3777 #[doc(alias = "scale-set")]
3778 fn connect_scale_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3779 unsafe extern "C" fn notify_scale_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3780 this: *mut ffi::GtkTextTag,
3781 _param_spec: glib::ffi::gpointer,
3782 f: glib::ffi::gpointer,
3783 ) {
3784 let f: &F = &*(f as *const F);
3785 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3786 }
3787 unsafe {
3788 let f: Box_<F> = Box_::new(f);
3789 connect_raw(
3790 self.as_ptr() as *mut _,
3791 b"notify::scale-set\0".as_ptr() as *const _,
3792 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3793 notify_scale_set_trampoline::<Self, F> as *const (),
3794 )),
3795 Box_::into_raw(f),
3796 )
3797 }
3798 }
3799
3800 #[cfg(feature = "v4_6")]
3801 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3802 #[doc(alias = "sentence")]
3803 fn connect_sentence_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3804 unsafe extern "C" fn notify_sentence_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3805 this: *mut ffi::GtkTextTag,
3806 _param_spec: glib::ffi::gpointer,
3807 f: glib::ffi::gpointer,
3808 ) {
3809 let f: &F = &*(f as *const F);
3810 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3811 }
3812 unsafe {
3813 let f: Box_<F> = Box_::new(f);
3814 connect_raw(
3815 self.as_ptr() as *mut _,
3816 b"notify::sentence\0".as_ptr() as *const _,
3817 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3818 notify_sentence_trampoline::<Self, F> as *const (),
3819 )),
3820 Box_::into_raw(f),
3821 )
3822 }
3823 }
3824
3825 #[cfg(feature = "v4_6")]
3826 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3827 #[doc(alias = "sentence-set")]
3828 fn connect_sentence_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3829 unsafe extern "C" fn notify_sentence_set_trampoline<
3830 P: IsA<TextTag>,
3831 F: Fn(&P) + 'static,
3832 >(
3833 this: *mut ffi::GtkTextTag,
3834 _param_spec: glib::ffi::gpointer,
3835 f: glib::ffi::gpointer,
3836 ) {
3837 let f: &F = &*(f as *const F);
3838 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3839 }
3840 unsafe {
3841 let f: Box_<F> = Box_::new(f);
3842 connect_raw(
3843 self.as_ptr() as *mut _,
3844 b"notify::sentence-set\0".as_ptr() as *const _,
3845 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3846 notify_sentence_set_trampoline::<Self, F> as *const (),
3847 )),
3848 Box_::into_raw(f),
3849 )
3850 }
3851 }
3852
3853 #[doc(alias = "show-spaces")]
3854 fn connect_show_spaces_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3855 unsafe extern "C" fn notify_show_spaces_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3856 this: *mut ffi::GtkTextTag,
3857 _param_spec: glib::ffi::gpointer,
3858 f: glib::ffi::gpointer,
3859 ) {
3860 let f: &F = &*(f as *const F);
3861 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3862 }
3863 unsafe {
3864 let f: Box_<F> = Box_::new(f);
3865 connect_raw(
3866 self.as_ptr() as *mut _,
3867 b"notify::show-spaces\0".as_ptr() as *const _,
3868 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3869 notify_show_spaces_trampoline::<Self, F> as *const (),
3870 )),
3871 Box_::into_raw(f),
3872 )
3873 }
3874 }
3875
3876 #[doc(alias = "show-spaces-set")]
3877 fn connect_show_spaces_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3878 unsafe extern "C" fn notify_show_spaces_set_trampoline<
3879 P: IsA<TextTag>,
3880 F: Fn(&P) + 'static,
3881 >(
3882 this: *mut ffi::GtkTextTag,
3883 _param_spec: glib::ffi::gpointer,
3884 f: glib::ffi::gpointer,
3885 ) {
3886 let f: &F = &*(f as *const F);
3887 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3888 }
3889 unsafe {
3890 let f: Box_<F> = Box_::new(f);
3891 connect_raw(
3892 self.as_ptr() as *mut _,
3893 b"notify::show-spaces-set\0".as_ptr() as *const _,
3894 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3895 notify_show_spaces_set_trampoline::<Self, F> as *const (),
3896 )),
3897 Box_::into_raw(f),
3898 )
3899 }
3900 }
3901
3902 #[doc(alias = "size")]
3903 fn connect_size_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3904 unsafe extern "C" fn notify_size_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3905 this: *mut ffi::GtkTextTag,
3906 _param_spec: glib::ffi::gpointer,
3907 f: glib::ffi::gpointer,
3908 ) {
3909 let f: &F = &*(f as *const F);
3910 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3911 }
3912 unsafe {
3913 let f: Box_<F> = Box_::new(f);
3914 connect_raw(
3915 self.as_ptr() as *mut _,
3916 b"notify::size\0".as_ptr() as *const _,
3917 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3918 notify_size_trampoline::<Self, F> as *const (),
3919 )),
3920 Box_::into_raw(f),
3921 )
3922 }
3923 }
3924
3925 #[doc(alias = "size-points")]
3926 fn connect_size_points_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3927 unsafe extern "C" fn notify_size_points_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3928 this: *mut ffi::GtkTextTag,
3929 _param_spec: glib::ffi::gpointer,
3930 f: glib::ffi::gpointer,
3931 ) {
3932 let f: &F = &*(f as *const F);
3933 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3934 }
3935 unsafe {
3936 let f: Box_<F> = Box_::new(f);
3937 connect_raw(
3938 self.as_ptr() as *mut _,
3939 b"notify::size-points\0".as_ptr() as *const _,
3940 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3941 notify_size_points_trampoline::<Self, F> as *const (),
3942 )),
3943 Box_::into_raw(f),
3944 )
3945 }
3946 }
3947
3948 #[doc(alias = "size-set")]
3949 fn connect_size_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3950 unsafe extern "C" fn notify_size_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3951 this: *mut ffi::GtkTextTag,
3952 _param_spec: glib::ffi::gpointer,
3953 f: glib::ffi::gpointer,
3954 ) {
3955 let f: &F = &*(f as *const F);
3956 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3957 }
3958 unsafe {
3959 let f: Box_<F> = Box_::new(f);
3960 connect_raw(
3961 self.as_ptr() as *mut _,
3962 b"notify::size-set\0".as_ptr() as *const _,
3963 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3964 notify_size_set_trampoline::<Self, F> as *const (),
3965 )),
3966 Box_::into_raw(f),
3967 )
3968 }
3969 }
3970
3971 #[doc(alias = "stretch")]
3972 fn connect_stretch_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3973 unsafe extern "C" fn notify_stretch_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3974 this: *mut ffi::GtkTextTag,
3975 _param_spec: glib::ffi::gpointer,
3976 f: glib::ffi::gpointer,
3977 ) {
3978 let f: &F = &*(f as *const F);
3979 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
3980 }
3981 unsafe {
3982 let f: Box_<F> = Box_::new(f);
3983 connect_raw(
3984 self.as_ptr() as *mut _,
3985 b"notify::stretch\0".as_ptr() as *const _,
3986 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
3987 notify_stretch_trampoline::<Self, F> as *const (),
3988 )),
3989 Box_::into_raw(f),
3990 )
3991 }
3992 }
3993
3994 #[doc(alias = "stretch-set")]
3995 fn connect_stretch_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
3996 unsafe extern "C" fn notify_stretch_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
3997 this: *mut ffi::GtkTextTag,
3998 _param_spec: glib::ffi::gpointer,
3999 f: glib::ffi::gpointer,
4000 ) {
4001 let f: &F = &*(f as *const F);
4002 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4003 }
4004 unsafe {
4005 let f: Box_<F> = Box_::new(f);
4006 connect_raw(
4007 self.as_ptr() as *mut _,
4008 b"notify::stretch-set\0".as_ptr() as *const _,
4009 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4010 notify_stretch_set_trampoline::<Self, F> as *const (),
4011 )),
4012 Box_::into_raw(f),
4013 )
4014 }
4015 }
4016
4017 #[doc(alias = "strikethrough")]
4018 fn connect_strikethrough_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4019 unsafe extern "C" fn notify_strikethrough_trampoline<
4020 P: IsA<TextTag>,
4021 F: Fn(&P) + 'static,
4022 >(
4023 this: *mut ffi::GtkTextTag,
4024 _param_spec: glib::ffi::gpointer,
4025 f: glib::ffi::gpointer,
4026 ) {
4027 let f: &F = &*(f as *const F);
4028 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4029 }
4030 unsafe {
4031 let f: Box_<F> = Box_::new(f);
4032 connect_raw(
4033 self.as_ptr() as *mut _,
4034 b"notify::strikethrough\0".as_ptr() as *const _,
4035 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4036 notify_strikethrough_trampoline::<Self, F> as *const (),
4037 )),
4038 Box_::into_raw(f),
4039 )
4040 }
4041 }
4042
4043 #[doc(alias = "strikethrough-rgba")]
4044 fn connect_strikethrough_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4045 unsafe extern "C" fn notify_strikethrough_rgba_trampoline<
4046 P: IsA<TextTag>,
4047 F: Fn(&P) + 'static,
4048 >(
4049 this: *mut ffi::GtkTextTag,
4050 _param_spec: glib::ffi::gpointer,
4051 f: glib::ffi::gpointer,
4052 ) {
4053 let f: &F = &*(f as *const F);
4054 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4055 }
4056 unsafe {
4057 let f: Box_<F> = Box_::new(f);
4058 connect_raw(
4059 self.as_ptr() as *mut _,
4060 b"notify::strikethrough-rgba\0".as_ptr() as *const _,
4061 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4062 notify_strikethrough_rgba_trampoline::<Self, F> as *const (),
4063 )),
4064 Box_::into_raw(f),
4065 )
4066 }
4067 }
4068
4069 #[doc(alias = "strikethrough-rgba-set")]
4070 fn connect_strikethrough_rgba_set_notify<F: Fn(&Self) + 'static>(
4071 &self,
4072 f: F,
4073 ) -> SignalHandlerId {
4074 unsafe extern "C" fn notify_strikethrough_rgba_set_trampoline<
4075 P: IsA<TextTag>,
4076 F: Fn(&P) + 'static,
4077 >(
4078 this: *mut ffi::GtkTextTag,
4079 _param_spec: glib::ffi::gpointer,
4080 f: glib::ffi::gpointer,
4081 ) {
4082 let f: &F = &*(f as *const F);
4083 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4084 }
4085 unsafe {
4086 let f: Box_<F> = Box_::new(f);
4087 connect_raw(
4088 self.as_ptr() as *mut _,
4089 b"notify::strikethrough-rgba-set\0".as_ptr() as *const _,
4090 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4091 notify_strikethrough_rgba_set_trampoline::<Self, F> as *const (),
4092 )),
4093 Box_::into_raw(f),
4094 )
4095 }
4096 }
4097
4098 #[doc(alias = "strikethrough-set")]
4099 fn connect_strikethrough_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4100 unsafe extern "C" fn notify_strikethrough_set_trampoline<
4101 P: IsA<TextTag>,
4102 F: Fn(&P) + 'static,
4103 >(
4104 this: *mut ffi::GtkTextTag,
4105 _param_spec: glib::ffi::gpointer,
4106 f: glib::ffi::gpointer,
4107 ) {
4108 let f: &F = &*(f as *const F);
4109 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4110 }
4111 unsafe {
4112 let f: Box_<F> = Box_::new(f);
4113 connect_raw(
4114 self.as_ptr() as *mut _,
4115 b"notify::strikethrough-set\0".as_ptr() as *const _,
4116 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4117 notify_strikethrough_set_trampoline::<Self, F> as *const (),
4118 )),
4119 Box_::into_raw(f),
4120 )
4121 }
4122 }
4123
4124 #[doc(alias = "style")]
4125 fn connect_style_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4126 unsafe extern "C" fn notify_style_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4127 this: *mut ffi::GtkTextTag,
4128 _param_spec: glib::ffi::gpointer,
4129 f: glib::ffi::gpointer,
4130 ) {
4131 let f: &F = &*(f as *const F);
4132 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4133 }
4134 unsafe {
4135 let f: Box_<F> = Box_::new(f);
4136 connect_raw(
4137 self.as_ptr() as *mut _,
4138 b"notify::style\0".as_ptr() as *const _,
4139 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4140 notify_style_trampoline::<Self, F> as *const (),
4141 )),
4142 Box_::into_raw(f),
4143 )
4144 }
4145 }
4146
4147 #[doc(alias = "style-set")]
4148 fn connect_style_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4149 unsafe extern "C" fn notify_style_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4150 this: *mut ffi::GtkTextTag,
4151 _param_spec: glib::ffi::gpointer,
4152 f: glib::ffi::gpointer,
4153 ) {
4154 let f: &F = &*(f as *const F);
4155 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4156 }
4157 unsafe {
4158 let f: Box_<F> = Box_::new(f);
4159 connect_raw(
4160 self.as_ptr() as *mut _,
4161 b"notify::style-set\0".as_ptr() as *const _,
4162 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4163 notify_style_set_trampoline::<Self, F> as *const (),
4164 )),
4165 Box_::into_raw(f),
4166 )
4167 }
4168 }
4169
4170 #[doc(alias = "tabs")]
4171 fn connect_tabs_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4172 unsafe extern "C" fn notify_tabs_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4173 this: *mut ffi::GtkTextTag,
4174 _param_spec: glib::ffi::gpointer,
4175 f: glib::ffi::gpointer,
4176 ) {
4177 let f: &F = &*(f as *const F);
4178 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4179 }
4180 unsafe {
4181 let f: Box_<F> = Box_::new(f);
4182 connect_raw(
4183 self.as_ptr() as *mut _,
4184 b"notify::tabs\0".as_ptr() as *const _,
4185 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4186 notify_tabs_trampoline::<Self, F> as *const (),
4187 )),
4188 Box_::into_raw(f),
4189 )
4190 }
4191 }
4192
4193 #[doc(alias = "tabs-set")]
4194 fn connect_tabs_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4195 unsafe extern "C" fn notify_tabs_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4196 this: *mut ffi::GtkTextTag,
4197 _param_spec: glib::ffi::gpointer,
4198 f: glib::ffi::gpointer,
4199 ) {
4200 let f: &F = &*(f as *const F);
4201 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4202 }
4203 unsafe {
4204 let f: Box_<F> = Box_::new(f);
4205 connect_raw(
4206 self.as_ptr() as *mut _,
4207 b"notify::tabs-set\0".as_ptr() as *const _,
4208 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4209 notify_tabs_set_trampoline::<Self, F> as *const (),
4210 )),
4211 Box_::into_raw(f),
4212 )
4213 }
4214 }
4215
4216 #[cfg(feature = "v4_6")]
4217 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
4218 #[doc(alias = "text-transform")]
4219 fn connect_text_transform_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4220 unsafe extern "C" fn notify_text_transform_trampoline<
4221 P: IsA<TextTag>,
4222 F: Fn(&P) + 'static,
4223 >(
4224 this: *mut ffi::GtkTextTag,
4225 _param_spec: glib::ffi::gpointer,
4226 f: glib::ffi::gpointer,
4227 ) {
4228 let f: &F = &*(f as *const F);
4229 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4230 }
4231 unsafe {
4232 let f: Box_<F> = Box_::new(f);
4233 connect_raw(
4234 self.as_ptr() as *mut _,
4235 b"notify::text-transform\0".as_ptr() as *const _,
4236 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4237 notify_text_transform_trampoline::<Self, F> as *const (),
4238 )),
4239 Box_::into_raw(f),
4240 )
4241 }
4242 }
4243
4244 #[cfg(feature = "v4_6")]
4245 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
4246 #[doc(alias = "text-transform-set")]
4247 fn connect_text_transform_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4248 unsafe extern "C" fn notify_text_transform_set_trampoline<
4249 P: IsA<TextTag>,
4250 F: Fn(&P) + 'static,
4251 >(
4252 this: *mut ffi::GtkTextTag,
4253 _param_spec: glib::ffi::gpointer,
4254 f: glib::ffi::gpointer,
4255 ) {
4256 let f: &F = &*(f as *const F);
4257 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4258 }
4259 unsafe {
4260 let f: Box_<F> = Box_::new(f);
4261 connect_raw(
4262 self.as_ptr() as *mut _,
4263 b"notify::text-transform-set\0".as_ptr() as *const _,
4264 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4265 notify_text_transform_set_trampoline::<Self, F> as *const (),
4266 )),
4267 Box_::into_raw(f),
4268 )
4269 }
4270 }
4271
4272 #[doc(alias = "underline")]
4273 fn connect_underline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4274 unsafe extern "C" fn notify_underline_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4275 this: *mut ffi::GtkTextTag,
4276 _param_spec: glib::ffi::gpointer,
4277 f: glib::ffi::gpointer,
4278 ) {
4279 let f: &F = &*(f as *const F);
4280 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4281 }
4282 unsafe {
4283 let f: Box_<F> = Box_::new(f);
4284 connect_raw(
4285 self.as_ptr() as *mut _,
4286 b"notify::underline\0".as_ptr() as *const _,
4287 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4288 notify_underline_trampoline::<Self, F> as *const (),
4289 )),
4290 Box_::into_raw(f),
4291 )
4292 }
4293 }
4294
4295 #[doc(alias = "underline-rgba")]
4296 fn connect_underline_rgba_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4297 unsafe extern "C" fn notify_underline_rgba_trampoline<
4298 P: IsA<TextTag>,
4299 F: Fn(&P) + 'static,
4300 >(
4301 this: *mut ffi::GtkTextTag,
4302 _param_spec: glib::ffi::gpointer,
4303 f: glib::ffi::gpointer,
4304 ) {
4305 let f: &F = &*(f as *const F);
4306 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4307 }
4308 unsafe {
4309 let f: Box_<F> = Box_::new(f);
4310 connect_raw(
4311 self.as_ptr() as *mut _,
4312 b"notify::underline-rgba\0".as_ptr() as *const _,
4313 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4314 notify_underline_rgba_trampoline::<Self, F> as *const (),
4315 )),
4316 Box_::into_raw(f),
4317 )
4318 }
4319 }
4320
4321 #[doc(alias = "underline-rgba-set")]
4322 fn connect_underline_rgba_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4323 unsafe extern "C" fn notify_underline_rgba_set_trampoline<
4324 P: IsA<TextTag>,
4325 F: Fn(&P) + 'static,
4326 >(
4327 this: *mut ffi::GtkTextTag,
4328 _param_spec: glib::ffi::gpointer,
4329 f: glib::ffi::gpointer,
4330 ) {
4331 let f: &F = &*(f as *const F);
4332 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4333 }
4334 unsafe {
4335 let f: Box_<F> = Box_::new(f);
4336 connect_raw(
4337 self.as_ptr() as *mut _,
4338 b"notify::underline-rgba-set\0".as_ptr() as *const _,
4339 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4340 notify_underline_rgba_set_trampoline::<Self, F> as *const (),
4341 )),
4342 Box_::into_raw(f),
4343 )
4344 }
4345 }
4346
4347 #[doc(alias = "underline-set")]
4348 fn connect_underline_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4349 unsafe extern "C" fn notify_underline_set_trampoline<
4350 P: IsA<TextTag>,
4351 F: Fn(&P) + 'static,
4352 >(
4353 this: *mut ffi::GtkTextTag,
4354 _param_spec: glib::ffi::gpointer,
4355 f: glib::ffi::gpointer,
4356 ) {
4357 let f: &F = &*(f as *const F);
4358 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4359 }
4360 unsafe {
4361 let f: Box_<F> = Box_::new(f);
4362 connect_raw(
4363 self.as_ptr() as *mut _,
4364 b"notify::underline-set\0".as_ptr() as *const _,
4365 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4366 notify_underline_set_trampoline::<Self, F> as *const (),
4367 )),
4368 Box_::into_raw(f),
4369 )
4370 }
4371 }
4372
4373 #[doc(alias = "variant")]
4374 fn connect_variant_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4375 unsafe extern "C" fn notify_variant_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4376 this: *mut ffi::GtkTextTag,
4377 _param_spec: glib::ffi::gpointer,
4378 f: glib::ffi::gpointer,
4379 ) {
4380 let f: &F = &*(f as *const F);
4381 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4382 }
4383 unsafe {
4384 let f: Box_<F> = Box_::new(f);
4385 connect_raw(
4386 self.as_ptr() as *mut _,
4387 b"notify::variant\0".as_ptr() as *const _,
4388 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4389 notify_variant_trampoline::<Self, F> as *const (),
4390 )),
4391 Box_::into_raw(f),
4392 )
4393 }
4394 }
4395
4396 #[doc(alias = "variant-set")]
4397 fn connect_variant_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4398 unsafe extern "C" fn notify_variant_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4399 this: *mut ffi::GtkTextTag,
4400 _param_spec: glib::ffi::gpointer,
4401 f: glib::ffi::gpointer,
4402 ) {
4403 let f: &F = &*(f as *const F);
4404 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4405 }
4406 unsafe {
4407 let f: Box_<F> = Box_::new(f);
4408 connect_raw(
4409 self.as_ptr() as *mut _,
4410 b"notify::variant-set\0".as_ptr() as *const _,
4411 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4412 notify_variant_set_trampoline::<Self, F> as *const (),
4413 )),
4414 Box_::into_raw(f),
4415 )
4416 }
4417 }
4418
4419 #[doc(alias = "weight")]
4420 fn connect_weight_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4421 unsafe extern "C" fn notify_weight_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4422 this: *mut ffi::GtkTextTag,
4423 _param_spec: glib::ffi::gpointer,
4424 f: glib::ffi::gpointer,
4425 ) {
4426 let f: &F = &*(f as *const F);
4427 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4428 }
4429 unsafe {
4430 let f: Box_<F> = Box_::new(f);
4431 connect_raw(
4432 self.as_ptr() as *mut _,
4433 b"notify::weight\0".as_ptr() as *const _,
4434 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4435 notify_weight_trampoline::<Self, F> as *const (),
4436 )),
4437 Box_::into_raw(f),
4438 )
4439 }
4440 }
4441
4442 #[doc(alias = "weight-set")]
4443 fn connect_weight_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4444 unsafe extern "C" fn notify_weight_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4445 this: *mut ffi::GtkTextTag,
4446 _param_spec: glib::ffi::gpointer,
4447 f: glib::ffi::gpointer,
4448 ) {
4449 let f: &F = &*(f as *const F);
4450 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4451 }
4452 unsafe {
4453 let f: Box_<F> = Box_::new(f);
4454 connect_raw(
4455 self.as_ptr() as *mut _,
4456 b"notify::weight-set\0".as_ptr() as *const _,
4457 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4458 notify_weight_set_trampoline::<Self, F> as *const (),
4459 )),
4460 Box_::into_raw(f),
4461 )
4462 }
4463 }
4464
4465 #[cfg(feature = "v4_6")]
4466 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
4467 #[doc(alias = "word")]
4468 fn connect_word_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4469 unsafe extern "C" fn notify_word_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4470 this: *mut ffi::GtkTextTag,
4471 _param_spec: glib::ffi::gpointer,
4472 f: glib::ffi::gpointer,
4473 ) {
4474 let f: &F = &*(f as *const F);
4475 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4476 }
4477 unsafe {
4478 let f: Box_<F> = Box_::new(f);
4479 connect_raw(
4480 self.as_ptr() as *mut _,
4481 b"notify::word\0".as_ptr() as *const _,
4482 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4483 notify_word_trampoline::<Self, F> as *const (),
4484 )),
4485 Box_::into_raw(f),
4486 )
4487 }
4488 }
4489
4490 #[cfg(feature = "v4_6")]
4491 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
4492 #[doc(alias = "word-set")]
4493 fn connect_word_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4494 unsafe extern "C" fn notify_word_set_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4495 this: *mut ffi::GtkTextTag,
4496 _param_spec: glib::ffi::gpointer,
4497 f: glib::ffi::gpointer,
4498 ) {
4499 let f: &F = &*(f as *const F);
4500 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4501 }
4502 unsafe {
4503 let f: Box_<F> = Box_::new(f);
4504 connect_raw(
4505 self.as_ptr() as *mut _,
4506 b"notify::word-set\0".as_ptr() as *const _,
4507 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4508 notify_word_set_trampoline::<Self, F> as *const (),
4509 )),
4510 Box_::into_raw(f),
4511 )
4512 }
4513 }
4514
4515 #[doc(alias = "wrap-mode")]
4516 fn connect_wrap_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4517 unsafe extern "C" fn notify_wrap_mode_trampoline<P: IsA<TextTag>, F: Fn(&P) + 'static>(
4518 this: *mut ffi::GtkTextTag,
4519 _param_spec: glib::ffi::gpointer,
4520 f: glib::ffi::gpointer,
4521 ) {
4522 let f: &F = &*(f as *const F);
4523 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4524 }
4525 unsafe {
4526 let f: Box_<F> = Box_::new(f);
4527 connect_raw(
4528 self.as_ptr() as *mut _,
4529 b"notify::wrap-mode\0".as_ptr() as *const _,
4530 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4531 notify_wrap_mode_trampoline::<Self, F> as *const (),
4532 )),
4533 Box_::into_raw(f),
4534 )
4535 }
4536 }
4537
4538 #[doc(alias = "wrap-mode-set")]
4539 fn connect_wrap_mode_set_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
4540 unsafe extern "C" fn notify_wrap_mode_set_trampoline<
4541 P: IsA<TextTag>,
4542 F: Fn(&P) + 'static,
4543 >(
4544 this: *mut ffi::GtkTextTag,
4545 _param_spec: glib::ffi::gpointer,
4546 f: glib::ffi::gpointer,
4547 ) {
4548 let f: &F = &*(f as *const F);
4549 f(TextTag::from_glib_borrow(this).unsafe_cast_ref())
4550 }
4551 unsafe {
4552 let f: Box_<F> = Box_::new(f);
4553 connect_raw(
4554 self.as_ptr() as *mut _,
4555 b"notify::wrap-mode-set\0".as_ptr() as *const _,
4556 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
4557 notify_wrap_mode_set_trampoline::<Self, F> as *const (),
4558 )),
4559 Box_::into_raw(f),
4560 )
4561 }
4562 }
4563}
4564
4565impl<O: IsA<TextTag>> TextTagExt for O {}