pango 3.1.1-x86-mingw32 → 3.1.2-x86-mingw32

data/vendor/local/include/graphene-1.0/graphene-vec3.h

@@ -0,0 +1,155 @@
+/* graphene-vec3.h: 3-coords vector
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_VEC3_H__
+#define __GRAPHENE_VEC3_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-types.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * graphene_vec3_t:
+ *
+ * A structure capable of holding a vector with three dimensions: x, y, and z.
+ *
+ * The contents of the #graphene_vec3_t structure are private and should
+ * never be accessed directly.
+ */
+struct _graphene_vec3_t
+{
+  /*< private >*/
+  GRAPHENE_PRIVATE_FIELD (graphene_simd4f_t, value);
+};
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec3_t *       graphene_vec3_alloc             (void);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_free              (graphene_vec3_t       *v);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec3_t *       graphene_vec3_init              (graphene_vec3_t       *v,
+                                                         float                  x,
+                                                         float                  y,
+                                                         float                  z);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec3_t *       graphene_vec3_init_from_vec3    (graphene_vec3_t       *v,
+                                                         const graphene_vec3_t *src);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec3_t *       graphene_vec3_init_from_float   (graphene_vec3_t       *v,
+                                                         const float           *src);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_to_float          (const graphene_vec3_t *v,
+                                                         float                 *dest);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_add               (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_subtract          (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_multiply          (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_divide            (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_cross             (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec3_dot               (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec3_length            (const graphene_vec3_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_normalize         (const graphene_vec3_t *v,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+void                    graphene_vec3_scale             (const graphene_vec3_t *v,
+                                                         float                  factor,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+void                    graphene_vec3_negate            (const graphene_vec3_t *v,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+bool                    graphene_vec3_equal             (const graphene_vec3_t *v1,
+                                                         const graphene_vec3_t *v2);
+GRAPHENE_AVAILABLE_IN_1_2
+bool                    graphene_vec3_near              (const graphene_vec3_t *v1,
+                                                         const graphene_vec3_t *v2,
+                                                         float                  epsilon);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_min               (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_max               (const graphene_vec3_t *a,
+                                                         const graphene_vec3_t *b,
+                                                         graphene_vec3_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec3_get_x             (const graphene_vec3_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec3_get_y             (const graphene_vec3_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec3_get_z             (const graphene_vec3_t *v);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_get_xy            (const graphene_vec3_t *v,
+                                                         graphene_vec2_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_get_xy0           (const graphene_vec3_t *v,
+                                                         graphene_vec3_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_get_xyz0          (const graphene_vec3_t *v,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_get_xyz1          (const graphene_vec3_t *v,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec3_get_xyzw          (const graphene_vec3_t *v,
+                                                         float                  w,
+                                                         graphene_vec4_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec3_t * graphene_vec3_zero              (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec3_t * graphene_vec3_one               (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec3_t * graphene_vec3_x_axis            (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec3_t * graphene_vec3_y_axis            (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec3_t * graphene_vec3_z_axis            (void);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_VEC3_H__ */

data/vendor/local/include/graphene-1.0/graphene-vec4.h

@@ -0,0 +1,156 @@
+/* graphene-vec4.h: 4-coords vector
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_VEC4_H__
+#define __GRAPHENE_VEC4_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-types.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * graphene_vec4_t:
+ *
+ * A structure capable of holding a vector with four dimensions: x, y, z, and w.
+ *
+ * The contents of the #graphene_vec4_t structure are private and should
+ * never be accessed directly.
+ */
+struct _graphene_vec4_t
+{
+  /*< private >*/
+  GRAPHENE_PRIVATE_FIELD (graphene_simd4f_t, value);
+};
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_alloc             (void);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_free              (graphene_vec4_t       *v);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_init              (graphene_vec4_t       *v,
+                                                         float                  x,
+                                                         float                  y,
+                                                         float                  z,
+                                                         float                  w);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_init_from_vec4    (graphene_vec4_t       *v,
+                                                         const graphene_vec4_t *src);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_init_from_vec3    (graphene_vec4_t       *v,
+                                                         const graphene_vec3_t *src,
+                                                         float                  w);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_init_from_vec2    (graphene_vec4_t       *v,
+                                                         const graphene_vec2_t *src,
+                                                         float                  z,
+                                                         float                  w);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_vec4_t *       graphene_vec4_init_from_float   (graphene_vec4_t       *v,
+                                                         const float           *src);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_to_float          (const graphene_vec4_t *v,
+                                                         float                 *dest);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_add               (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_subtract          (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_multiply          (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_divide            (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_dot               (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_length            (const graphene_vec4_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_normalize         (const graphene_vec4_t *v,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+void                    graphene_vec4_scale             (const graphene_vec4_t *v,
+                                                         float                  factor,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+void                    graphene_vec4_negate            (const graphene_vec4_t *v,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_2
+bool                    graphene_vec4_equal             (const graphene_vec4_t *v1,
+                                                         const graphene_vec4_t *v2);
+GRAPHENE_AVAILABLE_IN_1_2
+bool                    graphene_vec4_near              (const graphene_vec4_t *v1,
+                                                         const graphene_vec4_t *v2,
+                                                         float                  epsilon);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_min               (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_max               (const graphene_vec4_t *a,
+                                                         const graphene_vec4_t *b,
+                                                         graphene_vec4_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_get_x             (const graphene_vec4_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_get_y             (const graphene_vec4_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_get_z             (const graphene_vec4_t *v);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_vec4_get_w             (const graphene_vec4_t *v);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_get_xy            (const graphene_vec4_t *v,
+                                                         graphene_vec2_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_vec4_get_xyz           (const graphene_vec4_t *v,
+                                                         graphene_vec3_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_zero              (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_one               (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_x_axis            (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_y_axis            (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_z_axis            (void);
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_vec4_t * graphene_vec4_w_axis            (void);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_VECTORS_H__ */

data/vendor/local/include/graphene-1.0/graphene-version-macros.h

@@ -0,0 +1,185 @@
+/* graphene-version.h: Versioning macros
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_VERSION_MACROS_H__
+#define __GRAPHENE_VERSION_MACROS_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-version.h"
+
+/**
+ * GRAPHENE_ENCODE_VERSION:
+ * @major: a major version
+ * @minor: a minor version
+ * @micro: a micro version
+ *
+ * Encodes the given components into a value that can be used for
+ * version checks.
+ *
+ * Since: 1.0
+ */
+#define GRAPHENE_ENCODE_VERSION(major,minor,micro) \
+  ((major) << 24 | (minor) << 16 | (micro) << 8)
+
+#define _GRAPHENE_ENCODE_VERSION(maj,min) \
+  ((maj) << 16 | (min) << 8)
+
+#ifdef GRAPHENE_DISABLE_DEPRECATION_WARNINGS
+# define GRAPHENE_DEPRECATED            _GRAPHENE_PUBLIC
+# define GRAPHENE_DEPRECATED_FOR(f)     _GRAPHENE_PUBLIC
+# define GRAPHENE_UNAVAILABLE(maj,min)  _GRAPHENE_PUBLIC
+#else
+# define GRAPHENE_DEPRECATED            _GRAPHENE_DEPRECATED _GRAPHENE_PUBLIC
+# define GRAPHENE_DEPRECATED_FOR(f)     _GRAPHENE_DEPRECATED_FOR(f) _GRAPHENE_PUBLIC
+# define GRAPHENE_UNAVAILABLE(maj,min)  _GRAPHENE_UNAVAILABLE(maj,min) _GRAPHENE_PUBLIC
+#endif
+
+/**
+ * GRAPHENE_VERSION:
+ *
+ * The current version of the library, as encoded through
+ * the %GRAPHENE_ENCODE_VERSION macro. Can be used for version
+ * checking, for instance:
+ *
+ * |[<!-- language="C" -->
+ *   #if GRAPHENE_VERSION >= GRAPHENE_ENCODE_VERSION (1, 2, 3)
+ *     // code that uses API introduced after version 1.2.3
+ *   #endif
+ * ]|
+ *
+ * Since: 1.0
+ */
+#define GRAPHENE_VERSION                \
+  GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION, \
+                           GRAPHENE_MINOR_VERSION, \
+                           GRAPHENE_MICRO_VERSION)
+
+#define GRAPHENE_CHECK_VERSION(major,minor,micro) \
+  ((major) > GRAPHENE_MAJOR_VERSION || \
+   (major) == GRAPHENE_MAJOR_VERSION && (minor) > GRAPHENE_MINOR_VERSION || \
+   (major) == GRAPHENE_MAJOR_VERSION && (minor) == GRAPHENE_MINOR_VERSION && (micro) >= GRAPHENE_MICRO_VERSION)
+
+/* evaluates to the current stable release; for development cycles
+ * this means the next stable target.
+ */
+#if (GRAPHENE_MINOR_VERSION == 99)
+# define GRAPHENE_VERSION_CUR_STABLE    (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION + 1, 0))
+#elif (GRAPHENE_MINOR_VERSION % 2)
+# define GRAPHENE_VERSION_CUR_STABLE    (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION, GRAPHENE_MINOR_VERSION + 1))
+#else
+# define GRAPHENE_VERSION_CUR_STABLE    (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION, GRAPHENE_MINOR_VERSION))
+#endif
+
+/* evaluates to the previous stable version */
+#if (GRAPHENE_MINOR_VERSION == 99)
+# define GRAPHENE_VERSION_PREV_STABLE   (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION + 1, 0))
+#elif (GRAPHENE_MINOR_VERSION % 2)
+# define GRAPHENE_VERSION_PREV_STABLE   (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION, GRAPHENE_MINOR_VERSION - 1))
+#else
+# define GRAPHENE_VERSION_PREV_STABLE   (_GRAPHENE_ENCODE_VERSION (GRAPHENE_MAJOR_VERSION, GRAPHENE_MINOR_VERSION - 2))
+#endif
+
+/* version defines
+ *
+ * remember to add new macros at the beginning of each development cycle
+ */
+
+#define GRAPHENE_VERSION_1_0    (_GRAPHENE_ENCODE_VERSION (1, 0))
+#define GRAPHENE_VERSION_1_2    (_GRAPHENE_ENCODE_VERSION (1, 2))
+#define GRAPHENE_VERSION_1_4    (_GRAPHENE_ENCODE_VERSION (1, 4))
+#define GRAPHENE_VERSION_1_6    (_GRAPHENE_ENCODE_VERSION (1, 6))
+
+#ifndef GRAPHENE_VERSION_MIN_REQUIRED
+# define GRAPHENE_VERSION_MIN_REQUIRED  (GRAPHENE_VERSION_1_0)
+#endif
+
+#ifndef GRAPHENE_VERSION_MAX_ALLOWED
+# if GRAPHENE_VERSION_MIN_REQUIRED > GRAPHENE_VERSION_PREV_STABLE
+#  define GRAPHENE_VERSION_MAX_ALLOWED  (GRAPHENE_VERSION_MIN_REQUIRED)
+# else
+#  define GRAPHENE_VERSION_MAX_ALLOWED  (GRAPHENE_VERSION_CUR_STABLE)
+# endif
+#endif
+
+/* sanity checks */
+#if GRAPHENE_VERSION_MAX_ALLOWED < GRAPHENE_VERSION_MIN_REQUIRED
+# error "GRAPHENE_VERSION_MAX_ALLOWED must be >= GRAPHENE_VERSION_MIN_REQUIRED"
+#endif
+#if GRAPHENE_VERSION_MIN_REQUIRED < GRAPHENE_VERSION_1_0
+# error "GRAPHENE_VERSION_MIN_REQUIRED must be >= GRAPHENE_VERSION_1_0"
+#endif
+
+/* unconditional */
+#define GRAPHENE_DEPRECATED_IN_1_0              GRAPHENE_DEPRECATED
+#define GRAPHENE_DEPRECATED_IN_1_0_FOR(f)       GRAPHENE_DEPRECATED_FOR(f)
+#define GRAPHENE_AVAILABLE_IN_1_0               _GRAPHENE_PUBLIC
+
+/* Graphene 1.2 */
+#if GRAPHENE_VERSION_MIN_REQUIRED >= GRAPHENE_VERSION_1_2
+# define GRAPHENE_DEPRECATED_IN_1_2             GRAPHENE_DEPRECATED
+# define GRAPHENE_DEPRECATED_IN_1_2_FOR(f)      GRAPHENE_DEPRECATED_FOR(f)
+#else
+# define GRAPHENE_DEPRECATED_IN_1_2             _GRAPHENE_PUBLIC
+# define GRAPHENE_DEPRECATED_IN_1_2_FOR(f)      _GRAPHENE_PUBLIC
+#endif
+
+#if GRAPHENE_VERSION_MAX_ALLOWED < GRAPHENE_VERSION_1_2
+# define GRAPHENE_AVAILABLE_IN_1_2              GRAPHENE_UNAVAILABLE(1,2)
+#else
+# define GRAPHENE_AVAILABLE_IN_1_2              _GRAPHENE_PUBLIC
+#endif
+
+/* Graphene 1.4 */
+#if GRAPHENE_VERSION_MIN_REQUIRED >= GRAPHENE_VERSION_1_4
+# define GRAPHENE_DEPRECATED_IN_1_4             GRAPHENE_DEPRECATED
+# define GRAPHENE_DEPRECATED_IN_1_4_FOR(f)      GRAPHENE_DEPRECATED_FOR(f)
+#else
+# define GRAPHENE_DEPRECATED_IN_1_4             _GRAPHENE_PUBLIC
+# define GRAPHENE_DEPRECATED_IN_1_4_FOR(f)      _GRAPHENE_PUBLIC
+#endif
+
+#if GRAPHENE_VERSION_MAX_ALLOWED < GRAPHENE_VERSION_1_4
+# define GRAPHENE_AVAILABLE_IN_1_4              GRAPHENE_UNAVAILABLE(1,4)
+#else
+# define GRAPHENE_AVAILABLE_IN_1_4              _GRAPHENE_PUBLIC
+#endif
+
+/* Graphene 1.6 */
+#if GRAPHENE_VERSION_MIN_REQUIRED >= GRAPHENE_VERSION_1_4
+# define GRAPHENE_DEPRECATED_IN_1_6             GRAPHENE_DEPRECATED
+# define GRAPHENE_DEPRECATED_IN_1_6_FOR(f)      GRAPHENE_DEPRECATED_FOR(f)
+#else
+# define GRAPHENE_DEPRECATED_IN_1_6             _GRAPHENE_PUBLIC
+# define GRAPHENE_DEPRECATED_IN_1_6_FOR(f)      _GRAPHENE_PUBLIC
+#endif
+
+#if GRAPHENE_VERSION_MAX_ALLOWED < GRAPHENE_VERSION_1_4
+# define GRAPHENE_AVAILABLE_IN_1_6              GRAPHENE_UNAVAILABLE(1,6)
+#else
+# define GRAPHENE_AVAILABLE_IN_1_6              _GRAPHENE_PUBLIC
+#endif
+
+#endif /* __GRAPHENE_VERSION_MACROS_H__ */