pango 3.1.6-x86-mingw32 → 3.1.7-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bb906e738208091972e90dd21e7b56ed355a072
-  data.tar.gz: ab17efdd3701f4bd1ccbc4166dcb88f751d252ab
+  metadata.gz: 09eecf69199095cddb034ce1c78dbff686b0a0b3
+  data.tar.gz: 10943dde994007419aad460e1ab166f2727a367d
 SHA512:
-  metadata.gz: a603764cb18d8421eb9daa7746ab0bd404ed2dd582634195e1510e065e6bee5e72acabb24cc07f8346e4caf9146bf46529c9b434a181a9d9362c00e01fd2d17e
-  data.tar.gz: 0aa869fc410dfc2e9a4a2e754e911e675c6ad334ff4da39ab83a740f1b21ed600620313a19723681e88d886bb7d998631118198063e76d056b93e78efea97448
+  metadata.gz: c045daeeb455464dec62521647d69f8f5d8ad7334a468aaf311ac3101bebc907b25c34d12ee07a740e914143970ac674e3c2738ff33633cbc582d73b9408be77
+  data.tar.gz: 5aff39b28dfab1b6f62a3525f8cd9022366d39cb51ec33528fa328608ca1470ce260942d362fdfe3aa4a370b8f77ca9066745dfb25701fb13ca02c60d325f532

data/Rakefile

@@ -91,7 +91,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "pango",
       :download_site => :gnome,
       :label => "Pango",
-      :version => "1.40.5",
+      :version => "1.40.6",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/pango/pango.def

@@ -1,2 +1,3 @@
 EXPORTS
     Init_pango
+    pango_attr_list_get_type

data/ext/pango/rb-pango-attr-iterator.c

@@ -0,0 +1,60 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2017  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-pango-private.h"
+
+#define RG_TARGET_NAMESPACE cAttrIterator
+#define _SELF(self) (RVAL2PANGOATTRITERATOR(self))
+
+G_DEFINE_BOXED_TYPE(PangoAttrIterator,
+                    pango_attr_iterator,
+                    pango_attr_iterator_copy,
+                    pango_attr_iterator_destroy);
+
+static VALUE
+rg_attrs(VALUE self)
+{
+    GSList *attrs;
+    GSList *node;
+    VALUE rb_attrs;
+
+    attrs = pango_attr_iterator_get_attrs(_SELF(self));
+    rb_attrs = rb_ary_new();
+    for (node = attrs; node; node = g_slist_next(node)) {
+        PangoAttribute *attr = node->data;
+        VALUE rb_attr;
+
+        rb_attr = rbpango_attribute_to_ruby(attr);
+        rb_ary_push(rb_attrs, rb_attr);
+    }
+    g_slist_free(attrs);
+
+    return rb_attrs;
+}
+
+void
+rbpango_attr_iterator_init(VALUE mPango)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+        G_DEF_CLASS(PANGO_TYPE_ATTR_ITERATOR, "AttrIterator", mPango);
+    RG_DEF_METHOD(attrs, 0);
+}

data/ext/pango/rb-pango-attr-list.c

@@ -52,6 +52,15 @@ rg_insert_before(VALUE self, VALUE rb_attribute)
     return self;
 }
 
+static VALUE
+rg_iterator(VALUE self)
+{
+    PangoAttrIterator *iterator;
+
+    iterator = pango_attr_list_get_iterator(RVAL2PANGOATTRLIST(self));
+    return PANGOATTRITERATOR2RVAL(iterator);
+}
+
 void
 rbpango_attr_list_init(VALUE mPango)
 {
@@ -61,4 +70,5 @@ rbpango_attr_list_init(VALUE mPango)
 
     RG_DEF_METHOD(insert, 1);
     RG_DEF_METHOD(insert_before, 1);
+    RG_DEF_METHOD(iterator, 0);
 }

data/ext/pango/rb-pango-attribute.c

@@ -20,12 +20,150 @@
 
 #include "rb-pango-private.h"
 
+VALUE
+rbpango_attribute_to_ruby(PangoAttribute *attribute)
+{
+    VALUE rb_attr_type;
+    ID id_to_class;
+    VALUE klass;
+
+    rb_attr_type = GENUM2RVAL(attribute->klass->type, PANGO_TYPE_ATTR_TYPE);
+    CONST_ID(id_to_class, "to_class");
+    klass = rb_funcall(rb_attr_type, id_to_class, 0);
+    return Data_Wrap_Struct(klass,
+                            NULL,
+                            pango_attribute_destroy,
+                            pango_attribute_copy(attribute));
+}
+
+PangoAttribute *
+rbpango_attribute_from_ruby(VALUE rb_attribute)
+{
+    PangoAttribute *attribute;
+
+    Data_Get_Struct(rb_attribute, PangoAttribute, attribute);
+
+    return attribute;
+}
+
 static VALUE
 rbpango_attribute_allocate(VALUE klass)
 {
     return Data_Wrap_Struct(klass, NULL, pango_attribute_destroy, 0);
 }
 
+static VALUE
+rbpango_attr_bool_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return CBOOL2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_language_initialize(VALUE self, VALUE rb_language)
+{
+    PangoLanguage *language;
+
+    language = RVAL2PANGOLANGUAGE(rb_language);
+    DATA_PTR(self) = pango_attr_language_new(language);
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_family_initialize(VALUE self, VALUE rb_family)
+{
+    DATA_PTR(self) = pango_attr_family_new(RVAL2CSTR(rb_family));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_style_initialize(VALUE self, VALUE rb_style)
+{
+    DATA_PTR(self) = pango_attr_style_new(RVAL2PANGOSTYLE(rb_style));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_style_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOSTYLE2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_weight_initialize(VALUE self, VALUE rb_weight)
+{
+    DATA_PTR(self) = pango_attr_weight_new(RVAL2PANGOWEIGHT(rb_weight));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_weight_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOWEIGHT2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_variant_initialize(VALUE self, VALUE rb_variant)
+{
+    DATA_PTR(self) = pango_attr_variant_new(RVAL2PANGOVARIANT(rb_variant));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_variant_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOVARIANT2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_stretch_initialize(VALUE self, VALUE rb_stretch)
+{
+    DATA_PTR(self) = pango_attr_stretch_new(RVAL2PANGOSTRETCH(rb_stretch));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_stretch_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOSTRETCH2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_size_initialize(VALUE self, VALUE rb_size)
+{
+    gint size;
+
+    size = NUM2INT(rb_size);
+    DATA_PTR(self) = pango_attr_size_new(size);
+
+    return Qnil;
+}
+
 static VALUE
 rbpango_attr_font_desc_initialize(VALUE self, VALUE rb_font_desc)
 {
@@ -48,20 +186,61 @@ rbpango_attr_font_desc_initialize(VALUE self, VALUE rb_font_desc)
 }
 
 static VALUE
-rbpango_attr_font_features_initialize(VALUE self, VALUE rb_font_features)
+rbpango_attr_foregound_initialize(VALUE self,
+                                  VALUE rb_red,
+                                  VALUE rb_green,
+                                  VALUE rb_blue)
 {
-    DATA_PTR(self) = pango_attr_font_features_new(RVAL2CSTR(rb_font_features));
+    DATA_PTR(self) = pango_attr_foreground_new(NUM2UINT(rb_red),
+                                               NUM2UINT(rb_green),
+                                               NUM2UINT(rb_blue));
 
     return Qnil;
 }
 
 static VALUE
-rbpango_attr_language_initialize(VALUE self, VALUE rb_language)
+rbpango_attr_background_initialize(VALUE self,
+                                   VALUE rb_red,
+                                   VALUE rb_green,
+                                   VALUE rb_blue)
 {
-    PangoLanguage *language;
+    DATA_PTR(self) = pango_attr_background_new(NUM2UINT(rb_red),
+                                               NUM2UINT(rb_green),
+                                               NUM2UINT(rb_blue));
 
-    language = RVAL2PANGOLANGUAGE(rb_language);
-    DATA_PTR(self) = pango_attr_language_new(language);
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_underline_initialize(VALUE self, VALUE rb_underline)
+{
+    DATA_PTR(self) = pango_attr_underline_new(RVAL2PANGOUNDERLINE(rb_underline));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_underline_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOUNDERLINE2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_strikethrough_initialize(VALUE self, VALUE rb_strikethrough)
+{
+    DATA_PTR(self) = pango_attr_strikethrough_new(RVAL2CBOOL(rb_strikethrough));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_rise_initialize(VALUE self, VALUE rb_rise)
+{
+    DATA_PTR(self) = pango_attr_rise_new(NUM2INT(rb_rise));
 
     return Qnil;
 }
@@ -102,17 +281,126 @@ rbpango_attr_shape_get_data(VALUE self)
 
     Data_Get_Struct(self, PangoAttrShape, attr_shape);
     rb_data = (VALUE)(attr_shape->data);
-    rb_p(rb_data);
     return rb_data;
 }
 
 static VALUE
-rbpango_attr_size_initialize(VALUE self, VALUE rb_size)
+rbpango_attr_scale_initialize(VALUE self, VALUE rb_scale)
 {
-    gint size;
+    DATA_PTR(self) = pango_attr_scale_new(NUM2DBL(rb_scale));
 
-    size = NUM2INT(rb_size);
-    DATA_PTR(self) = pango_attr_size_new(size);
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_fallback_initialize(VALUE self, VALUE rb_enable_fallback)
+{
+    DATA_PTR(self) = pango_attr_fallback_new(RVAL2CBOOL(rb_enable_fallback));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_letter_spacing_initialize(VALUE self, VALUE rb_letter_spacing)
+{
+    DATA_PTR(self) = pango_attr_letter_spacing_new(NUM2INT(rb_letter_spacing));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_underline_color_initialize(VALUE self,
+                                        VALUE rb_red,
+                                        VALUE rb_green,
+                                        VALUE rb_blue)
+{
+    DATA_PTR(self) = pango_attr_underline_color_new(NUM2UINT(rb_red),
+                                                    NUM2UINT(rb_green),
+                                                    NUM2UINT(rb_blue));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_strikethrough_color_initialize(VALUE self,
+                                            VALUE rb_red,
+                                            VALUE rb_green,
+                                            VALUE rb_blue)
+{
+    DATA_PTR(self) = pango_attr_strikethrough_color_new(NUM2UINT(rb_red),
+                                                        NUM2UINT(rb_green),
+                                                        NUM2UINT(rb_blue));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_absolute_size_initialize(VALUE self, VALUE rb_absolute_size)
+{
+    DATA_PTR(self) = pango_attr_size_new_absolute(NUM2INT(rb_absolute_size));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_gravity_initialize(VALUE self, VALUE rb_gravity)
+{
+    DATA_PTR(self) = pango_attr_gravity_new(RVAL2PANGOGRAVITY(rb_gravity));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_gravity_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOGRAVITY2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_gravity_hint_initialize(VALUE self, VALUE rb_gravity_hint)
+{
+    PangoGravityHint hint;
+
+    hint = RVAL2PANGOGRAVITYHINT(rb_gravity_hint);
+    DATA_PTR(self) = pango_attr_gravity_hint_new(hint);
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_gravity_hint_get_value(VALUE self)
+{
+    PangoAttribute *attribute;
+
+    attribute = rbpango_attribute_from_ruby(self);
+
+    return PANGOGRAVITYHINT2RVAL(((PangoAttrInt *)attribute)->value);
+}
+
+static VALUE
+rbpango_attr_font_features_initialize(VALUE self, VALUE rb_font_features)
+{
+    DATA_PTR(self) = pango_attr_font_features_new(RVAL2CSTR(rb_font_features));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_foreground_alpha_initialize(VALUE self, VALUE rb_alpha)
+{
+    DATA_PTR(self) = pango_attr_foreground_alpha_new(NUM2UINT(rb_alpha));
+
+    return Qnil;
+}
+
+static VALUE
+rbpango_attr_background_alpha_initialize(VALUE self, VALUE rb_alpha)
+{
+    DATA_PTR(self) = pango_attr_background_alpha_new(NUM2UINT(rb_alpha));
 
     return Qnil;
 }
@@ -121,45 +409,136 @@ void
 rbpango_attribute_init(VALUE mPango)
 {
     VALUE cAttribute;
+    VALUE cAttrString;
+    VALUE cAttrColor;
+    VALUE cAttrInt;
+    VALUE cAttrBool;
+    VALUE cAttrFloat;
+    VALUE cAttrLanguage;
+    VALUE cAttrFamily;
+    VALUE cAttrStyle;
+    VALUE cAttrWeight;
+    VALUE cAttrVariant;
+    VALUE cAttrStretch;
+    VALUE cAttrSize;
+    VALUE cAttrFontDesc;
+    VALUE cAttrForeground;
+    VALUE cAttrBackground;
+    VALUE cAttrUnderline;
+    VALUE cAttrStrikethrough;
+    VALUE cAttrRise;
+    VALUE cAttrShape;
+    VALUE cAttrScale;
+    VALUE cAttrFallback;
+    VALUE cAttrLetterSpacing;
+    VALUE cAttrUnderlineColor;
+    VALUE cAttrStrikethroughColor;
+    VALUE cAttrAbsoluteSize;
+    VALUE cAttrGravity;
+    VALUE cAttrGravityHint;
+    VALUE cAttrFontFeatures;
+    VALUE cAttrForegroundAlpha;
+    VALUE cAttrBackgroundAlpha;
 
     cAttribute = rb_define_class_under(mPango, "Attribute", rb_cData);
     rb_define_alloc_func(cAttribute, rbpango_attribute_allocate);
 
-#define DEFINE_ABSTRACT_ATTRIBUTE(ClassName)                            \
-    do {                                                                \
-        rb_define_class_under(mPango,                                   \
-                              #ClassName,                               \
-                              cAttribute);                              \
+#define DEFINE_ABSTRACT_ATTRIBUTE_BEGIN(ClassName, parent) do { \
+        c ## ClassName = rb_define_class_under(mPango,          \
+                                               #ClassName,      \
+                                               parent);
+
+#define DEFINE_ABSTRACT_ATTRIBUTE_END()         \
     } while (FALSE)
 
-#define DEFINE_ATTRIBUTE_BEGIN(ClassName, method_name, n_initialize_args)     \
-        VALUE c ## ClassName;                                           \
+#define DEFINE_ABSTRACT_ATTRIBUTE(ClassName, parent)                    \
+    DEFINE_ABSTRACT_ATTRIBUTE_BEGIN(ClassName, parent) {                \
+    } DEFINE_ABSTRACT_ATTRIBUTE_END()
+
+#define DEFINE_ATTRIBUTE_BEGIN(ClassName,                               \
+                               parent,                                  \
+                               method_name,                             \
+                               n_initialize_args) do {                  \
         c ## ClassName = rb_define_class_under(mPango,                  \
                                                #ClassName,              \
-            cAttribute);                                                \
+                                               parent);                 \
         rb_define_method(c ## ClassName, "initialize",                  \
                          rbpango_ ## method_name ## _initialize,        \
                          n_initialize_args);                            \
 
-#define DEFINE_ATTRIBUTE_END                    \
+#define DEFINE_ATTRIBUTE_END()                  \
+    } while (FALSE)
+
+#define DEFINE_ATTRIBUTE(ClassName,             \
+                         parent,                \
+                         method_name,           \
+                         n_initialize_args)     \
+    DEFINE_ATTRIBUTE_BEGIN(ClassName,           \
+                           parent,              \
+                           method_name,         \
+                           n_initialize_args) { \
+    } DEFINE_ATTRIBUTE_END();
 
-#define DEFINE_ATTRIBUTE(ClassName, method_name, n_initialize_args)     \
-    DEFINE_ATTRIBUTE_BEGIN(ClassName, method_name, n_initialize_args) { \
-    } DEFINE_ATTRIBUTE_END;
+    DEFINE_ABSTRACT_ATTRIBUTE(AttrString, cAttribute);
+    DEFINE_ABSTRACT_ATTRIBUTE(AttrColor, cAttribute);
+    DEFINE_ABSTRACT_ATTRIBUTE(AttrInt, cAttribute);
+    DEFINE_ABSTRACT_ATTRIBUTE_BEGIN(AttrBool, cAttrInt) {
+        rb_define_method(cAttrBool, "value", rbpango_attr_bool_get_value, 0);
+    } DEFINE_ABSTRACT_ATTRIBUTE_END();
+    DEFINE_ABSTRACT_ATTRIBUTE(AttrFloat, cAttribute);
 
-    DEFINE_ABSTRACT_ATTRIBUTE(AttrBool);
-    DEFINE_ABSTRACT_ATTRIBUTE(AttrColor);
-    DEFINE_ABSTRACT_ATTRIBUTE(AttrFloat);
-    DEFINE_ATTRIBUTE(AttrFontDesc, attr_font_desc, 1);
-    DEFINE_ATTRIBUTE(AttrFontFeatures, attr_font_features, 1);
-    DEFINE_ABSTRACT_ATTRIBUTE(AttrInt);
-    DEFINE_ATTRIBUTE(AttrLanguage, attr_language, 1);
-    DEFINE_ATTRIBUTE_BEGIN(AttrShape, attr_shape, -1) {
+    DEFINE_ATTRIBUTE(AttrLanguage, cAttribute, attr_language, 1);
+    DEFINE_ATTRIBUTE(AttrFamily, cAttrString, attr_family, 1);
+    DEFINE_ATTRIBUTE_BEGIN(AttrStyle, cAttrInt, attr_style, 1) {
+        rb_define_method(cAttrStyle, "value", rbpango_attr_style_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE_BEGIN(AttrWeight, cAttrInt, attr_weight, 1) {
+        rb_define_method(cAttrWeight, "value", rbpango_attr_weight_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE_BEGIN(AttrVariant, cAttrInt, attr_variant, 1) {
+        rb_define_method(cAttrVariant,
+                         "value", rbpango_attr_variant_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE_BEGIN(AttrStretch, cAttrInt, attr_stretch, 1) {
+        rb_define_method(cAttrStretch,
+                         "value", rbpango_attr_stretch_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE(AttrSize, cAttribute, attr_size, 1);
+    DEFINE_ATTRIBUTE(AttrFontDesc, cAttribute, attr_font_desc, 1);
+    DEFINE_ATTRIBUTE(AttrForeground, cAttrColor, attr_foregound, 3);
+    DEFINE_ATTRIBUTE(AttrBackground, cAttrColor, attr_background, 3);
+    DEFINE_ATTRIBUTE_BEGIN(AttrUnderline, cAttrInt, attr_underline, 1) {
+        rb_define_method(cAttrUnderline,
+                         "value", rbpango_attr_underline_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE(AttrStrikethrough, cAttrBool, attr_strikethrough, 1);
+    DEFINE_ATTRIBUTE(AttrRise, cAttrInt, attr_rise, 1);
+    DEFINE_ATTRIBUTE_BEGIN(AttrShape, cAttribute, attr_shape, -1) {
         rb_define_method(cAttrShape, "data", rbpango_attr_shape_get_data, 0);
-    } DEFINE_ATTRIBUTE_END;
-    DEFINE_ATTRIBUTE(AttrSize, attr_size, 1);
-    DEFINE_ABSTRACT_ATTRIBUTE(AttrString);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE(AttrScale, cAttrFloat, attr_scale, 1);
+    DEFINE_ATTRIBUTE(AttrFallback, cAttrBool, attr_fallback, 1);
+    DEFINE_ATTRIBUTE(AttrLetterSpacing, cAttrInt, attr_letter_spacing, 1);
+    DEFINE_ATTRIBUTE(AttrUnderlineColor, cAttrColor, attr_underline_color, 3);
+    DEFINE_ATTRIBUTE(AttrStrikethroughColor, cAttrColor,
+                     attr_strikethrough_color, 3);
+    DEFINE_ATTRIBUTE(AttrAbsoluteSize, cAttrSize, attr_absolute_size, 1);
+    DEFINE_ATTRIBUTE_BEGIN(AttrGravity, cAttrInt, attr_gravity, 1) {
+        rb_define_method(cAttrGravity,
+                         "value", rbpango_attr_gravity_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE_BEGIN(AttrGravityHint, cAttrInt, attr_gravity_hint, 1) {
+        rb_define_method(cAttrGravityHint,
+                         "value", rbpango_attr_gravity_hint_get_value, 0);
+    } DEFINE_ATTRIBUTE_END();
+    DEFINE_ATTRIBUTE(AttrFontFeatures, cAttrString, attr_font_features, 1);
+    DEFINE_ATTRIBUTE(AttrForegroundAlpha, cAttrInt, attr_foreground_alpha, 1);
+    DEFINE_ATTRIBUTE(AttrBackgroundAlpha, cAttrInt, attr_background_alpha, 1);
 
 #undef DEFINE_ABSTRACT_ATTRIBUTE
+#undef DEFINE_ABSTRACT_ATTRIBUTE_BEGIN
+#undef DEFINE_ABSTRACT_ATTRIBUTE_END
 #undef DEFINE_ATTRIBUTE
+#undef DEFINE_ATTRIBUTE_BEGIN
+#undef DEFINE_ATTRIBUTE_END
 }