Merge pull request #212 from sophie-h/pango-new-attributes

Add new pango attributes

Author: sdroege

examples/src/bin/pango_attributes.rs

@@ -18,24 +18,21 @@ fn build_ui(application: &gtk::Application) {
     let label = gtk::Label::new(Some("Some text"));
     let attr_list = pango::AttrList::new();
 
-    let mut attr =
-        pango::Attribute::new_background(65535, 0, 0).expect("Couldn't create new background");
+    let mut attr = pango::Attribute::new_background(65535, 0, 0);
     attr.set_start_index(0);
     attr.set_end_index(2);
     attr_list.insert(attr);
 
-    let mut attr = pango::Attribute::new_underline(pango::Underline::Single)
-        .expect("Couldn't create new underline");
+    let mut attr = pango::Attribute::new_underline(pango::Underline::Single);
     attr.set_start_index(1);
     attr.set_end_index(4);
     attr_list.insert(attr);
 
-    let mut attr =
-        pango::Attribute::new_strikethrough(true).expect("Couldn't create new strikethrough");
+    let mut attr = pango::Attribute::new_strikethrough(true);
     attr.set_start_index(5);
     attr_list.insert(attr);
 
-    let mut attr = pango::Attribute::new_scale(1.2).expect("Couldn't create new scale");
+    let mut attr = pango::Attribute::new_scale(1.2);
     attr.set_start_index(6);
     attr_list.insert(attr);
 

pango/src/attribute.rs

@@ -6,6 +6,12 @@ use crate::AttrClass;
 use crate::Attribute;
 use crate::Gravity;
 use crate::GravityHint;
+#[cfg(any(feature = "v1_46", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))]
+use crate::Overline;
+#[cfg(any(feature = "v1_44", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))]
+use crate::ShowFlags;
 use crate::Stretch;
 use crate::Style;
 use crate::Underline;
@@ -14,97 +20,154 @@ use crate::Weight;
 use glib::translate::*;
 
 impl Attribute {
+    #[cfg(any(feature = "v1_44", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))]
+    #[doc(alias = "pango_attr_allow_breaks_new")]
+    pub fn new_allow_breaks(allow_breaks: bool) -> Attribute {
+        unsafe { from_glib_full(ffi::pango_attr_allow_breaks_new(allow_breaks.to_glib())) }
+    }
+
     #[cfg(any(feature = "v1_38", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_38")))]
-    pub fn new_background_alpha(alpha: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_background_alpha_new")]
+    pub fn new_background_alpha(alpha: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_background_alpha_new(alpha)) }
     }
 
-    pub fn new_background(red: u16, green: u16, blue: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_background_new")]
+    pub fn new_background(red: u16, green: u16, blue: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_background_new(red, green, blue)) }
     }
 
-    pub fn new_fallback(enable_fallback: bool) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_fallback_new")]
+    pub fn new_fallback(enable_fallback: bool) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_fallback_new(enable_fallback.to_glib())) }
     }
 
-    pub fn new_family(family: &str) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_family_new")]
+    pub fn new_family(family: &str) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_family_new(family.to_glib_none().0)) }
     }
 
     #[cfg(any(feature = "v1_38", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_38")))]
-    pub fn new_font_features(features: &str) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_font_features_new")]
+    pub fn new_font_features(features: &str) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_font_features_new(features.to_glib_none().0)) }
     }
 
     #[cfg(any(feature = "v1_38", feature = "dox"))]
     #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_38")))]
-    pub fn new_foreground_alpha(alpha: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_foreground_alpha_new")]
+    pub fn new_foreground_alpha(alpha: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_foreground_alpha_new(alpha)) }
     }
 
-    pub fn new_foreground(red: u16, green: u16, blue: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_foreground_new")]
+    pub fn new_foreground(red: u16, green: u16, blue: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_foreground_new(red, green, blue)) }
     }
 
-    pub fn new_gravity_hint(hint: GravityHint) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_gravity_hint_new")]
+    pub fn new_gravity_hint(hint: GravityHint) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_gravity_hint_new(hint.to_glib())) }
     }
 
-    pub fn new_gravity(gravity: Gravity) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_gravity_new")]
+    pub fn new_gravity(gravity: Gravity) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_gravity_new(gravity.to_glib())) }
     }
 
-    pub fn new_letter_spacing(letter_spacing: i32) -> Option<Attribute> {
+    #[cfg(any(feature = "v1_44", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))]
+    #[doc(alias = "pango_attr_insert_hyphens_new")]
+    pub fn new_insert_hyphens(insert_hyphens: bool) -> Attribute {
+        unsafe { from_glib_full(ffi::pango_attr_insert_hyphens_new(insert_hyphens.to_glib())) }
+    }
+
+    #[doc(alias = "pango_attr_letter_spacing_new")]
+    pub fn new_letter_spacing(letter_spacing: i32) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_letter_spacing_new(letter_spacing)) }
     }
 
-    pub fn new_rise(rise: i32) -> Option<Attribute> {
+    #[cfg(any(feature = "v1_46", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))]
+    #[doc(alias = "pango_attr_overline_color_new")]
+    pub fn new_overline_color(red: u16, green: u16, blue: u16) -> Attribute {
+        unsafe { from_glib_full(ffi::pango_attr_overline_color_new(red, green, blue)) }
+    }
+
+    #[cfg(any(feature = "v1_46", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))]
+    #[doc(alias = "pango_attr_overline_new")]
+    pub fn new_overline(overline: Overline) -> Attribute {
+        unsafe { from_glib_full(ffi::pango_attr_overline_new(overline.to_glib())) }
+    }
+
+    #[doc(alias = "pango_attr_rise_new")]
+    pub fn new_rise(rise: i32) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_rise_new(rise)) }
     }
 
-    pub fn new_scale(scale_factor: f64) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_scale_new")]
+    pub fn new_scale(scale_factor: f64) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_scale_new(scale_factor)) }
     }
 
-    pub fn new_size(size: i32) -> Option<Attribute> {
+    #[cfg(any(feature = "v1_44", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))]
+    #[doc(alias = "pango_attr_show_new")]
+    pub fn new_show(flags: ShowFlags) -> Attribute {
+        unsafe { from_glib_full(ffi::pango_attr_show_new(flags.to_glib())) }
+    }
+
+    #[doc(alias = "pango_attr_size_new")]
+    pub fn new_size(size: i32) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_size_new(size)) }
     }
 
-    pub fn new_size_absolute(size: i32) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_size_new_absolute")]
+    pub fn new_size_absolute(size: i32) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_size_new_absolute(size)) }
     }
 
-    pub fn new_stretch(stretch: Stretch) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_stretch_new")]
+    pub fn new_stretch(stretch: Stretch) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_stretch_new(stretch.to_glib())) }
     }
 
-    pub fn new_strikethrough_color(red: u16, green: u16, blue: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_strikethrough_color_new")]
+    pub fn new_strikethrough_color(red: u16, green: u16, blue: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_strikethrough_color_new(red, green, blue)) }
     }
 
-    pub fn new_strikethrough(strikethrough: bool) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_strikethrough_new")]
+    pub fn new_strikethrough(strikethrough: bool) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_strikethrough_new(strikethrough.to_glib())) }
     }
 
-    pub fn new_style(style: Style) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_style_new")]
+    pub fn new_style(style: Style) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_style_new(style.to_glib())) }
     }
 
-    pub fn new_underline_color(red: u16, green: u16, blue: u16) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_underline_color_new")]
+    pub fn new_underline_color(red: u16, green: u16, blue: u16) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_underline_color_new(red, green, blue)) }
     }
 
-    pub fn new_underline(underline: Underline) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_underline_new")]
+    pub fn new_underline(underline: Underline) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_underline_new(underline.to_glib())) }
     }
 
-    pub fn new_variant(variant: Variant) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_variant_new")]
+    pub fn new_variant(variant: Variant) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_variant_new(variant.to_glib())) }
     }
 
-    pub fn new_weight(weight: Weight) -> Option<Attribute> {
+    #[doc(alias = "pango_attr_weight_new")]
+    pub fn new_weight(weight: Weight) -> Attribute {
         unsafe { from_glib_full(ffi::pango_attr_weight_new(weight.to_glib())) }
     }