GNOME.org
 

[geglmm] Update to Gegl 0.1.6

commit cb4068655e6424c08d9a847d12dd76ea7acd4a04
Author: Hubert Figuiere <hub figuiere net>
Date:   Sat Feb 19 14:33:05 2011 -0800

    Update to Gegl 0.1.6

 ChangeLog                                  |   24 +-
 configure.in                               |   15 +-
 gegl/src/buffer.hg                         |    3 +
 gegl/src/gegl_enums.defs                   |   12 +-
 gegl/src/gegl_methods.defs                 |  969 +++++++++++++++++++++++++---
 gegl/src/gegl_signals.defs                 |   10 +-
 gegl/src/node.hg                           |    2 +
 gegl/src/operation.hg                      |    2 +-
 gegl/src/path.hg                           |    2 +
 gegl/src/rectangle.hg                      |    2 +-
 tools/extra_defs_gen/generate_defs_gegl.cc |   65 +-
 11 files changed, 980 insertions(+), 126 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 2f88cfd..ef943f3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2011-02-19  Hubert Figuiere  <hub figuiere net>
+
+	* configure.in
+	Prepare 0.1.6. Add silent rules. Bump version requirements.
+
+	* gegl/src/*.defs
+	Updated the definitions to gegl 0.1.6
+
+	* tools/extra_defs_gen/generate_defs_gegl.cc
+	Added 0.1.6 types.
+
+	* gegl/src/*.hg
+	Update to gegl 0.1.6 APIs.
+
 2009-07-06  Hubert Figuiere  <hub figuiere net>
 
 	Prepare 0.1.0 release
@@ -9,17 +23,17 @@
 	Fix the documentation generation.
 
 	Update for gegl 0.1.0 APIs
-	
+
 	* gegl/src/node.{ccg,hg}
 	Implement set() and get() with varargs.
 	Ignore gegl_node_adopt_child()
-	
+
 	* gegl/src/color.hg
 	Minor indent changes.
-	
+
 	* gegl/src/processor.hg
 	Workaround glibmm doc bug.
-	
+
 	* gegl/src/Makefile_list_of_hg.am_fragment
 	* gegl/src/matrix3.{hg,ccg}
 	New Matrix3
@@ -38,7 +52,7 @@
 2009-05-16  Hubert Figuiere  <hub figuiere net>
 
 	Update for gegl master.
-	
+
 	* gegl/src/color.hg
 	* gegl/src/gegl_enums.defs
 	* gegl/src/gegl_methods.defs
diff --git a/configure.in b/configure.in
index 22cd729..b445277 100644
--- a/configure.in
+++ b/configure.in
@@ -18,13 +18,19 @@
 #We use pushdef here because we can't use shell variables before AC_INIT, but we want to use a variable with AC_INIT:
 pushdef([LIBGEGLMM_MAJOR_VERSION],     [0])
 pushdef([LIBGEGLMM_MINOR_VERSION],     [1])
-pushdef([LIBGEGLMM_MICRO_VERSION],     [0])
+pushdef([LIBGEGLMM_MICRO_VERSION],     [6])
 pushdef([LIBGEGLMM_EXTRA_VERSION],     [])
 pushdef([LIBGEGLMM_VERSION], LIBGEGLMM_MAJOR_VERSION.LIBGEGLMM_MINOR_VERSION.LIBGEGLMM_MICRO_VERSION[]LIBGEGLMM_EXTRA_VERSION)
 AC_INIT([geglmm], LIBGEGLMM_VERSION, [gtkmm-list gnome org])
 AC_CONFIG_SRCDIR([gegl/geglmmconfig.h.in])
 #AC_PREREQ(2.59)
 
+# Enable silent build rules by default, requires at least
+# Automake-1.11. Disable by either passing --disable-silent-rules to
+# configure or passing V=1 to make
+m4_ifdef([AM_SILENT_RULES],
+         [AM_SILENT_RULES([yes])],
+         [AC_SUBST([AM_DEFAULT_VERBOSITY], [1])])
 
 #
 # +1 : ? : +1  == new interface that does not break old one
@@ -34,8 +40,9 @@ AC_CONFIG_SRCDIR([gegl/geglmmconfig.h.in])
 #                 better
 # CURRENT : REVISION : AGE
 dnl 0.0.22 is 2:0:0
-dnl 0.10.0 is 3:0:0
-LIBGEGLMM_SO_VERSION=3:0:0
+dnl 0.1.0 is 3:0:0
+dnl 0.1.4 is 3:0:1
+LIBGEGLMM_SO_VERSION=3:0:1
 
 AC_SUBST([LIBGEGLMM_VERSION])
 AC_SUBST(LIBGEGLMM_RELEASE)
@@ -115,7 +122,7 @@ AC_CHECK_PROGS(PERL, perl5 perl)
 #########################################################################
 #  Dependancy checks
 #########################################################################
-PKG_CHECK_MODULES(LIBGEGLMM, glibmm-2.4 >= 2.12.8 gegl >= 0.1)
+PKG_CHECK_MODULES(LIBGEGLMM, glibmm-2.4 >= 2.12.8 gegl >= 0.1.4)
 AC_SUBST(LIBGEGLMM_CFLAGS)
 AC_SUBST(LIBGEGLMM_LIBS)
 
diff --git a/gegl/src/buffer.hg b/gegl/src/buffer.hg
index 16f3d0b..1ddee24 100644
--- a/gegl/src/buffer.hg
+++ b/gegl/src/buffer.hg
@@ -76,11 +76,14 @@ public:
 	_WRAP_METHOD(static Interpolation interpolation_from_string(const Glib::ustring & string), gegl_buffer_interpolation_from_string)
 
 #m4 _CONVERSION(`GeglRectangle*',`const Rectangle&',`Glib::wrap($3)')
+#m4 _CONVERSION(`const GeglRectangle*',`const Rectangle&',`Glib::wrap($3)')
 	_WRAP_SIGNAL(void changed(const Rectangle &r), "changed", no_default_handler)
 
     _WRAP_METHOD(gpointer* linear_open(const Rectangle &r, gint & rowstride, const Babl *format), gegl_buffer_linear_open)
     _WRAP_METHOD(void linear_close(gpointer linear), gegl_buffer_linear_close)
 
+    _WRAP_METHOD(const Rectangle& abyss(), gegl_buffer_get_abyss)
+
 	// Properties
 	_WRAP_PROPERTY("px-size", int)
 	_WRAP_PROPERTY("pixels", int)
diff --git a/gegl/src/gegl_enums.defs b/gegl/src/gegl_enums.defs
index d177896..a980451 100644
--- a/gegl/src/gegl_enums.defs
+++ b/gegl/src/gegl_enums.defs
@@ -1,4 +1,4 @@
-;; From /opt/include/gegl-0.0/gegl-buffer.h
+;; From /opt/hub/include/gegl-0.1/gegl-buffer.h
 
 (define-enum-extended Interpolation
   (in-module "Gegl")
@@ -8,12 +8,16 @@
     '("linear" "GEGL_INTERPOLATION_LINEAR" "1")
     '("cubic" "GEGL_INTERPOLATION_CUBIC" "2")
     '("lanczos" "GEGL_INTERPOLATION_LANCZOS" "3")
-    '("sharp" "GEGL_INTERPOLATION_SHARP" "4")
-    '("yafr" "GEGL_INTERPOLATION_YAFR" "5")
+    '("downsharp" "GEGL_INTERPOLATION_DOWNSHARP" "4")
+    '("downsize" "GEGL_INTERPOLATION_DOWNSIZE" "5")
+    '("downsmooth" "GEGL_INTERPOLATION_DOWNSMOOTH" "6")
+    '("upsharp" "GEGL_INTERPOLATION_UPSHARP" "7")
+    '("upsize" "GEGL_INTERPOLATION_UPSIZE" "8")
+    '("upsmooth" "GEGL_INTERPOLATION_UPSMOOTH" "9")
   )
 )
 
-;; From /opt/include/gegl-0.0/gegl-types.h
+;; From /opt/hub/include/gegl-0.1/gegl-types.h
 
 (define-enum-extended PadType
   (in-module "Gegl")
diff --git a/gegl/src/gegl_methods.defs b/gegl/src/gegl_methods.defs
index ae21a71..22787b0 100644
--- a/gegl/src/gegl_methods.defs
+++ b/gegl/src/gegl_methods.defs
@@ -1,5 +1,26 @@
 ;; -*- scheme -*-
 ; object definitions ...
+(define-object Color
+  (in-module "Gegl")
+  (parent "GObject")
+  (c-name "GeglColor")
+  (gtype-id "GEGL_TYPE_COLOR")
+)
+
+(define-object Curve
+  (in-module "Gegl")
+  (parent "GObject")
+  (c-name "GeglCurve")
+  (gtype-id "GEGL_TYPE_CURVE")
+)
+
+(define-object Operation
+  (in-module "Gegl")
+  (parent "GObject")
+  (c-name "GeglOperation")
+  (gtype-id "GEGL_TYPE_OPERATION")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperation")
@@ -7,23 +28,51 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationComposer
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationComposer")
+  (gtype-id "GEGL_TYPE_OPERATION_COMPOSER")
+)
+
 (define-object Chant
   (in-module "Gegl")
-  (parent "GeglOperationAreaFilter")
+  (parent "GeglOperationComposer")
   (c-name "GeglChant")
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationComposer3
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationComposer3")
+  (gtype-id "GEGL_TYPE_OPERATION_COMPOSER3")
+)
+
 (define-object Chant
   (in-module "Gegl")
-  (parent "GeglOperationComposer")
+  (parent "GeglOperationComposer3")
   (c-name "GeglChant")
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationFilter
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationFilter")
+  (gtype-id "GEGL_TYPE_OPERATION_FILTER")
+)
+
+(define-object OperationAreaFilter
+  (in-module "Gegl")
+  (parent "GeglOperationFilter")
+  (c-name "GeglOperationAreaFilter")
+  (gtype-id "GEGL_TYPE_OPERATION_AREA_FILTER")
+)
+
 (define-object Chant
   (in-module "Gegl")
-  (parent "GeglOperationComposer3")
+  (parent "GeglOperationAreaFilter")
   (c-name "GeglChant")
   (gtype-id "GEGL_TYPE_CHANT")
 )
@@ -35,6 +84,13 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationMeta
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationMeta")
+  (gtype-id "GEGL_TYPE_OPERATION_META")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperationMeta")
@@ -42,6 +98,13 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationPointComposer
+  (in-module "Gegl")
+  (parent "GeglOperationComposer")
+  (c-name "GeglOperationPointComposer")
+  (gtype-id "GEGL_TYPE_OPERATION_POINT_COMPOSER")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperationPointComposer")
@@ -49,6 +112,13 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationPointComposer3
+  (in-module "Gegl")
+  (parent "GeglOperationComposer3")
+  (c-name "GeglOperationPointComposer3")
+  (gtype-id "GEGL_TYPE_OPERATION_POINT_COMPOSER3")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperationPointComposer3")
@@ -56,6 +126,13 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationPointFilter
+  (in-module "Gegl")
+  (parent "GeglOperationFilter")
+  (c-name "GeglOperationPointFilter")
+  (gtype-id "GEGL_TYPE_OPERATION_POINT_FILTER")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperationPointFilter")
@@ -63,16 +140,37 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationSink
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationSink")
+  (gtype-id "GEGL_TYPE_OPERATION_SINK")
+)
+
 (define-object Chant
   (in-module "Gegl")
-  (parent "GeglOperationPointRender")
+  (parent "GeglOperationSink")
   (c-name "GeglChant")
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationSource
+  (in-module "Gegl")
+  (parent "GeglOperation")
+  (c-name "GeglOperationSource")
+  (gtype-id "GEGL_TYPE_OPERATION_SOURCE")
+)
+
+(define-object OperationPointRender
+  (in-module "Gegl")
+  (parent "GeglOperationSource")
+  (c-name "GeglOperationPointRender")
+  (gtype-id "GEGL_TYPE_OPERATION_POINT_RENDER")
+)
+
 (define-object Chant
   (in-module "Gegl")
-  (parent "GeglOperationSink")
+  (parent "GeglOperationPointRender")
   (c-name "GeglChant")
   (gtype-id "GEGL_TYPE_CHANT")
 )
@@ -84,6 +182,13 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
+(define-object OperationTemporal
+  (in-module "Gegl")
+  (parent "GeglOperationFilter")
+  (c-name "GeglOperationTemporal")
+  (gtype-id "GEGL_TYPE_OPERATION_TEMPORAL")
+)
+
 (define-object Chant
   (in-module "Gegl")
   (parent "GeglOperationTemporal")
@@ -91,18 +196,18 @@
   (gtype-id "GEGL_TYPE_CHANT")
 )
 
-(define-object Color
+(define-object TileSource
   (in-module "Gegl")
   (parent "GObject")
-  (c-name "GeglColor")
-  (gtype-id "GEGL_TYPE_COLOR")
+  (c-name "GeglTileSource")
+  (gtype-id "GEGL_TYPE_TILE_SOURCE")
 )
 
-(define-object Curve
+(define-object TileBackend
   (in-module "Gegl")
-  (parent "GObject")
-  (c-name "GeglCurve")
-  (gtype-id "GEGL_TYPE_CURVE")
+  (parent "GeglTileSource")
+  (c-name "GeglTileBackend")
+  (gtype-id "GEGL_TYPE_TILE_BACKEND")
 )
 
 ;; Enumerations and flags ...
@@ -116,8 +221,12 @@
     '("linear" "GEGL_INTERPOLATION_LINEAR")
     '("cubic" "GEGL_INTERPOLATION_CUBIC")
     '("lanczos" "GEGL_INTERPOLATION_LANCZOS")
-    '("sharp" "GEGL_INTERPOLATION_SHARP")
-    '("yafr" "GEGL_INTERPOLATION_YAFR")
+    '("downsharp" "GEGL_INTERPOLATION_DOWNSHARP")
+    '("downsize" "GEGL_INTERPOLATION_DOWNSIZE")
+    '("downsmooth" "GEGL_INTERPOLATION_DOWNSMOOTH")
+    '("upsharp" "GEGL_INTERPOLATION_UPSHARP")
+    '("upsize" "GEGL_INTERPOLATION_UPSIZE")
+    '("upsmooth" "GEGL_INTERPOLATION_UPSMOOTH")
   )
 )
 
@@ -143,6 +252,10 @@
 )
 
 
+;; From gegl-buffer-backend.h
+
+
+
 ;; From gegl-buffer.h
 
 (define-function gegl_buffer_get_type
@@ -160,6 +273,15 @@
   )
 )
 
+(define-function gegl_buffer_new_for_backend
+  (c-name "gegl_buffer_new_for_backend")
+  (return-type "GeglBuffer*")
+  (parameters
+    '("const-GeglRectangle*" "extent")
+    '("void*" "backend")
+  )
+)
+
 (define-function gegl_buffer_open
   (c-name "gegl_buffer_open")
   (return-type "GeglBuffer*")
@@ -350,6 +472,45 @@
   )
 )
 
+(define-method get_abyss
+  (of-object "GeglBuffer")
+  (c-name "gegl_buffer_get_abyss")
+  (return-type "const-GeglRectangle*")
+)
+
+
+
+;; From gegl-buffer-iterator.h
+
+(define-method iterator_new
+  (of-object "GeglBuffer")
+  (c-name "gegl_buffer_iterator_new")
+  (return-type "GeglBufferIterator*")
+  (parameters
+    '("const-GeglRectangle*" "roi")
+    '("const-Babl*" "format")
+    '("guint" "flags")
+  )
+)
+
+(define-method add
+  (of-object "GeglBufferIterator")
+  (c-name "gegl_buffer_iterator_add")
+  (return-type "gint")
+  (parameters
+    '("GeglBuffer*" "buffer")
+    '("const-GeglRectangle*" "roi")
+    '("const-Babl*" "format")
+    '("guint" "flags")
+  )
+)
+
+(define-method next
+  (of-object "GeglBufferIterator")
+  (c-name "gegl_buffer_iterator_next")
+  (return-type "gboolean")
+)
+
 
 
 ;; From gegl-chant.h
@@ -841,6 +1002,15 @@
   )
 )
 
+(define-method has_pad
+  (of-object "GeglNode")
+  (c-name "gegl_node_has_pad")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "pad_name")
+  )
+)
+
 (define-method create_child
   (of-object "GeglNode")
   (c-name "gegl_node_create_child")
@@ -934,6 +1104,64 @@
   (return-type "GeglConfig*")
 )
 
+(define-function gegl_node
+  (c-name "gegl_node")
+  (return-type "GeglNode*")
+  (parameters
+    '("const-gchar*" "op_type")
+    '("const-gchar*" "first_property_name")
+  )
+  (varargs #t)
+)
+
+(define-function gegl_graph
+  (c-name "gegl_graph")
+  (return-type "GeglNode*")
+  (parameters
+    '("GeglNode*" "node")
+  )
+)
+
+
+
+;; From gegl-lookup.h
+
+(define-function gegl_lookup_new_full
+  (c-name "gegl_lookup_new_full")
+  (return-type "GeglLookup*")
+  (parameters
+    '("GeglLookupFunction" "function")
+    '("gpointer" "data")
+    '("gfloat" "start")
+    '("gfloat" "end")
+    '("gfloat" "precision")
+  )
+)
+
+(define-function gegl_lookup_new
+  (c-name "gegl_lookup_new")
+  (is-constructor-of "GeglLookup")
+  (return-type "GeglLookup*")
+  (parameters
+    '("GeglLookupFunction" "function")
+    '("gpointer" "data")
+  )
+)
+
+(define-method free
+  (of-object "GeglLookup")
+  (c-name "gegl_lookup_free")
+  (return-type "none")
+)
+
+(define-function if
+  (c-name "if")
+  (return-type "else")
+  (parameters
+    '("i->-lookup->negative_min&&-i-<" "lookup->negative_max")
+  )
+)
+
 
 
 ;; From gegl-matrix.h
@@ -1286,7 +1514,7 @@
 (define-method calc
   (of-object "GeglPath")
   (c-name "gegl_path_calc")
-  (return-type "none")
+  (return-type "gboolean")
   (parameters
     '("gdouble" "pos")
     '("gdouble*" "x")
@@ -1504,6 +1732,15 @@
   )
 )
 
+(define-method get_object
+  (of-object "GeglOperationContext")
+  (c-name "gegl_operation_context_get_object")
+  (return-type "GObject*")
+  (parameters
+    '("const-gchar*" "padname")
+  )
+)
+
 (define-function gegl_extension_handler_register
   (c-name "gegl_extension_handler_register")
   (return-type "none")
@@ -1513,6 +1750,15 @@
   )
 )
 
+(define-function gegl_extension_handler_register_saver
+  (c-name "gegl_extension_handler_register_saver")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "extension")
+    '("const-gchar*" "handler")
+  )
+)
+
 (define-function gegl_extension_handler_get
   (c-name "gegl_extension_handler_get")
   (return-type "const-gchar*")
@@ -1521,107 +1767,332 @@
   )
 )
 
+(define-function gegl_extension_handler_get_saver
+  (c-name "gegl_extension_handler_get_saver")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "extension")
+  )
+)
+
 
 
 ;; From gegl-simd.h
 
 
 
-;; From gegl-types.h
+;; From gegl-tile-backend.h
 
-(define-function gegl_rectangle_get_type
-  (c-name "gegl_rectangle_get_type")
-  (return-type "GType")
+(define-method get_tile_size
+  (of-object "GeglTileBackend")
+  (c-name "gegl_tile_backend_get_tile_size")
+  (return-type "gint")
 )
 
-(define-function gegl_node_get_type
-  (c-name "gegl_node_get_type")
-  (return-type "GType")
+(define-method get_format
+  (of-object "GeglTileBackend")
+  (c-name "gegl_tile_backend_get_format")
+  (return-type "Babl*")
 )
 
-(define-function gegl_processor_get_type
-  (c-name "gegl_processor_get_type")
+(define-method set_extent
+  (of-object "GeglTileBackend")
+  (c-name "gegl_tile_backend_set_extent")
+  (return-type "none")
+  (parameters
+    '("GeglRectangle*" "rectangle")
+  )
+)
+
+(define-method get_extent
+  (of-object "GeglTileBackend")
+  (c-name "gegl_tile_backend_get_extent")
+  (return-type "GeglRectangle")
+)
+
+(define-function gegl_tile_backend_get_type
+  (c-name "gegl_tile_backend_get_type")
   (return-type "GType")
 )
 
 
 
-;; From gegl-utils.h
+;; From gegl-tile.h
 
-(define-method set
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_set")
-  (return-type "none")
+(define-function gegl_tile_new
+  (c-name "gegl_tile_new")
+  (is-constructor-of "GeglTile")
+  (return-type "GeglTile*")
   (parameters
-    '("gint" "x")
-    '("gint" "y")
-    '("guint" "width")
-    '("guint" "height")
+    '("gint" "size")
   )
 )
 
-(define-method equal
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_equal")
-  (return-type "gboolean")
-  (parameters
-    '("const-GeglRectangle*" "rectangle2")
-  )
+(define-function gegl_tile_new_bare
+  (c-name "gegl_tile_new_bare")
+  (return-type "GeglTile*")
 )
 
-(define-method equal_coords
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_equal_coords")
-  (return-type "gboolean")
-  (parameters
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "width")
-    '("gint" "height")
-  )
+(define-method ref
+  (of-object "GeglTile")
+  (c-name "gegl_tile_ref")
+  (return-type "GeglTile*")
 )
 
-(define-method copy
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_copy")
+(define-method unref
+  (of-object "GeglTile")
+  (c-name "gegl_tile_unref")
   (return-type "none")
-  (parameters
-    '("const-GeglRectangle*" "source")
-  )
 )
 
-(define-method bounding_box
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_bounding_box")
+(define-method lock
+  (of-object "GeglTile")
+  (c-name "gegl_tile_lock")
   (return-type "none")
-  (parameters
-    '("const-GeglRectangle*" "source1")
-    '("const-GeglRectangle*" "source2")
-  )
 )
 
-(define-method intersect
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_intersect")
-  (return-type "gboolean")
-  (parameters
-    '("const-GeglRectangle*" "src1")
-    '("const-GeglRectangle*" "src2")
-  )
+(define-method unlock
+  (of-object "GeglTile")
+  (c-name "gegl_tile_unlock")
+  (return-type "none")
 )
 
-(define-method contains
-  (of-object "GeglRectangle")
-  (c-name "gegl_rectangle_contains")
+(define-method mark_as_stored
+  (of-object "GeglTile")
+  (c-name "gegl_tile_mark_as_stored")
+  (return-type "none")
+)
+
+(define-method is_stored
+  (of-object "GeglTile")
+  (c-name "gegl_tile_is_stored")
   (return-type "gboolean")
-  (parameters
-    '("const-GeglRectangle*" "child")
-  )
 )
 
-(define-function gegl_rectangle_infinite_plane
-  (c-name "gegl_rectangle_infinite_plane")
-  (return-type "GeglRectangle")
+(define-method store
+  (of-object "GeglTile")
+  (c-name "gegl_tile_store")
+  (return-type "gboolean")
+)
+
+(define-method void
+  (of-object "GeglTile")
+  (c-name "gegl_tile_void")
+  (return-type "none")
+)
+
+(define-method dup
+  (of-object "GeglTile")
+  (c-name "gegl_tile_dup")
+  (return-type "GeglTile*")
+)
+
+(define-method set_rev
+  (of-object "GeglTile")
+  (c-name "gegl_tile_set_rev")
+  (return-type "none")
+  (parameters
+    '("guint" "rev")
+  )
+)
+
+(define-method get_rev
+  (of-object "GeglTile")
+  (c-name "gegl_tile_get_rev")
+  (return-type "guint")
+)
+
+(define-method get_data
+  (of-object "GeglTile")
+  (c-name "gegl_tile_get_data")
+  (return-type "guchar*")
+)
+
+
+
+;; From gegl-tile-source.h
+
+(define-function gegl_tile_source_get_type
+  (c-name "gegl_tile_source_get_type")
+  (return-type "GType")
+)
+
+(define-method get_tile
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_get_tile")
+  (return-type "GeglTile*")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
+)
+
+(define-method set_tile
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_set_tile")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+    '("GeglTile*" "tile")
+  )
+)
+
+(define-method is_cached
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_is_cached")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
+)
+
+(define-method exist
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_exist")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
+)
+
+(define-method void
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_void")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
+)
+
+(define-method refetch
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_refetch")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
+)
+
+(define-method idle
+  (of-object "GeglTileSource")
+  (c-name "gegl_tile_source_idle")
+  (return-type "gboolean")
+)
+
+
+
+;; From gegl-types.h
+
+(define-function gegl_rectangle_get_type
+  (c-name "gegl_rectangle_get_type")
+  (return-type "GType")
+)
+
+(define-function gegl_node_get_type
+  (c-name "gegl_node_get_type")
+  (return-type "GType")
+)
+
+(define-function gegl_processor_get_type
+  (c-name "gegl_processor_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-utils.h
+
+(define-method set
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_set")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("guint" "width")
+    '("guint" "height")
+  )
+)
+
+(define-method equal
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_equal")
+  (return-type "gboolean")
+  (parameters
+    '("const-GeglRectangle*" "rectangle2")
+  )
+)
+
+(define-method equal_coords
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_equal_coords")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+  )
+)
+
+(define-method is_empty
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_is_empty")
+  (return-type "gboolean")
+)
+
+(define-method copy
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_copy")
+  (return-type "none")
+  (parameters
+    '("const-GeglRectangle*" "source")
+  )
+)
+
+(define-method bounding_box
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_bounding_box")
+  (return-type "none")
+  (parameters
+    '("const-GeglRectangle*" "source1")
+    '("const-GeglRectangle*" "source2")
+  )
+)
+
+(define-method intersect
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_intersect")
+  (return-type "gboolean")
+  (parameters
+    '("const-GeglRectangle*" "src1")
+    '("const-GeglRectangle*" "src2")
+  )
+)
+
+(define-method contains
+  (of-object "GeglRectangle")
+  (c-name "gegl_rectangle_contains")
+  (return-type "gboolean")
+  (parameters
+    '("const-GeglRectangle*" "child")
+  )
+)
+
+(define-function gegl_rectangle_infinite_plane
+  (c-name "gegl_rectangle_infinite_plane")
+  (return-type "GeglRectangle")
 )
 
 (define-method is_infinite_plane
@@ -1667,3 +2138,341 @@
 )
 
 
+
+;; From gegl-operation-area-filter.h
+
+(define-function gegl_operation_area_filter_get_type
+  (c-name "gegl_operation_area_filter_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-composer3.h
+
+(define-function gegl_operation_composer3_get_type
+  (c-name "gegl_operation_composer3_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-composer.h
+
+(define-function gegl_operation_composer_get_type
+  (c-name "gegl_operation_composer_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-filter.h
+
+(define-function gegl_operation_filter_get_type
+  (c-name "gegl_operation_filter_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation.h
+
+(define-method add_processor
+  (of-object "GeglOperationClass")
+  (c-name "gegl_operation_class_add_processor")
+  (return-type "none")
+  (parameters
+    '("GCallback" "process")
+    '("const-gchar*" "string")
+  )
+)
+
+(define-function gegl_operation_get_type
+  (c-name "gegl_operation_get_type")
+  (return-type "GType")
+)
+
+(define-method get_invalidated_by_change
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_invalidated_by_change")
+  (return-type "GeglRectangle")
+  (parameters
+    '("const-gchar*" "input_pad")
+    '("const-GeglRectangle*" "roi")
+  )
+)
+
+(define-method get_bounding_box
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_bounding_box")
+  (return-type "GeglRectangle")
+)
+
+(define-method source_get_bounding_box
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_source_get_bounding_box")
+  (return-type "GeglRectangle*")
+  (parameters
+    '("const-gchar*" "pad_name")
+  )
+)
+
+(define-method get_cached_region
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_cached_region")
+  (return-type "GeglRectangle")
+  (parameters
+    '("const-GeglRectangle*" "roi")
+  )
+)
+
+(define-method get_required_for_output
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_required_for_output")
+  (return-type "GeglRectangle")
+  (parameters
+    '("const-gchar*" "input_pad")
+    '("const-GeglRectangle*" "roi")
+  )
+)
+
+(define-method detect
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_detect")
+  (return-type "GeglNode*")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method attach
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_attach")
+  (return-type "none")
+  (parameters
+    '("GeglNode*" "node")
+  )
+)
+
+(define-method prepare
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_prepare")
+  (return-type "none")
+)
+
+(define-method process
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_process")
+  (return-type "gboolean")
+  (parameters
+    '("GeglOperationContext*" "context")
+    '("const-gchar*" "output_pad")
+    '("const-GeglRectangle*" "roi")
+  )
+)
+
+(define-method create_pad
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_create_pad")
+  (return-type "none")
+  (parameters
+    '("GParamSpec*" "param_spec")
+  )
+)
+
+(define-method set_format
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_set_format")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "pad_name")
+    '("const-Babl*" "format")
+  )
+)
+
+(define-method get_format
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_format")
+  (return-type "const-Babl*")
+  (parameters
+    '("const-gchar*" "pad_name")
+  )
+)
+
+(define-method get_name
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_source_node
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_get_source_node")
+  (return-type "GeglNode*")
+  (parameters
+    '("const-gchar*" "pad_name")
+  )
+)
+
+(define-function gegl_list_properties
+  (c-name "gegl_list_properties")
+  (return-type "GParamSpec**")
+  (parameters
+    '("const-gchar*" "operation_type")
+    '("guint*" "n_properties_p")
+  )
+)
+
+(define-method invalidate
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_invalidate")
+  (return-type "none")
+  (parameters
+    '("const-GeglRectangle*" "roi")
+    '("gboolean" "clear_cache")
+  )
+)
+
+(define-method calc_need_rects
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_calc_need_rects")
+  (return-type "gboolean")
+  (parameters
+    '("gpointer" "context_id")
+  )
+)
+
+(define-function gegl_operation_path_prop_changed
+  (c-name "gegl_operation_path_prop_changed")
+  (return-type "none")
+  (parameters
+    '("GeglPath*" "path")
+    '("GeglOperation*" "operation")
+  )
+)
+
+
+
+;; From gegl-operation-meta.h
+
+(define-function gegl_operation_meta_get_type
+  (c-name "gegl_operation_meta_get_type")
+  (return-type "GType")
+)
+
+(define-method meta_redirect
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_meta_redirect")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+    '("GeglNode*" "internal")
+    '("const-gchar*" "internal_name")
+  )
+)
+
+(define-method property_changed
+  (of-object "GeglOperationMeta")
+  (c-name "gegl_operation_meta_property_changed")
+  (return-type "none")
+  (parameters
+    '("GParamSpec*" "arg1")
+    '("gpointer" "user_data")
+  )
+)
+
+
+
+;; From gegl-operation-point-composer3.h
+
+(define-function gegl_operation_point_composer3_get_type
+  (c-name "gegl_operation_point_composer3_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-point-composer.h
+
+(define-function gegl_operation_point_composer_get_type
+  (c-name "gegl_operation_point_composer_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-point-filter.h
+
+(define-function gegl_operation_point_filter_get_type
+  (c-name "gegl_operation_point_filter_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-point-render.h
+
+(define-function gegl_operation_point_render_get_type
+  (c-name "gegl_operation_point_render_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-sink.h
+
+(define-function gegl_operation_sink_get_type
+  (c-name "gegl_operation_sink_get_type")
+  (return-type "GType")
+)
+
+(define-method sink_needs_full
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_sink_needs_full")
+  (return-type "gboolean")
+)
+
+
+
+;; From gegl-operation-source.h
+
+(define-function gegl_operation_source_get_type
+  (c-name "gegl_operation_source_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From gegl-operation-temporal.h
+
+(define-function gegl_operation_temporal_get_type
+  (c-name "gegl_operation_temporal_get_type")
+  (return-type "GType")
+)
+
+(define-method temporal_set_history_length
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_temporal_set_history_length")
+  (return-type "none")
+  (parameters
+    '("gint" "history_length")
+  )
+)
+
+(define-method temporal_get_history_length
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_temporal_get_history_length")
+  (return-type "guint")
+)
+
+(define-method temporal_get_frame
+  (of-object "GeglOperation")
+  (c-name "gegl_operation_temporal_get_frame")
+  (return-type "GeglBuffer*")
+  (parameters
+    '("gint" "frame")
+  )
+)
+
+
diff --git a/gegl/src/gegl_signals.defs b/gegl/src/gegl_signals.defs
index 7d77fb9..4cd9d96 100644
--- a/gegl/src/gegl_signals.defs
+++ b/gegl/src/gegl_signals.defs
@@ -233,6 +233,15 @@
   (construct-only #f)
 )
 
+(define-property backend
+  (of-object "GeglBuffer")
+  (prop-type "GParamPointer")
+  (docs "A custom tile-backend instance to use")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
 ;; From GeglCurve
 
 ;; From GeglParamCurve
@@ -557,4 +566,3 @@
   (construct-only #f)
 )
 
-
diff --git a/gegl/src/node.hg b/gegl/src/node.hg
index 7b033f1..fd0e300 100644
--- a/gegl/src/node.hg
+++ b/gegl/src/node.hg
@@ -105,6 +105,8 @@ public:
 	_IGNORE(gegl_node_get_producer)
 	Glib::RefPtr<Node> get_producer(const Glib::ustring & input_pad_name, Glib::ustring * output_pad_name) const;
 
+	_WRAP_METHOD(bool has_pad(const Glib::ustring & pad_name) const, gegl_node_has_pad)
+
 	_WRAP_METHOD(Glib::RefPtr<Node> create_child(const Glib::ustring & operation), gegl_node_create_child)
 
 
diff --git a/gegl/src/operation.hg b/gegl/src/operation.hg
index b934a1d..1d6c5b1 100644
--- a/gegl/src/operation.hg
+++ b/gegl/src/operation.hg
@@ -48,7 +48,7 @@ public:
 	_WRAP_METHOD(Glib::RefPtr<const Node> detect(int x, int y) const, gegl_operation_detect, refreturn, constversion)
 	_WRAP_METHOD(void attach(const Glib::RefPtr<Node> & node), gegl_operation_attach)
 	_WRAP_METHOD(void prepare(), gegl_operation_prepare)
-	_WRAP_METHOD(bool process(GeglNodeContext * context, const Glib::ustring & output_pad, const Rectangle & result_rect), gegl_operation_process)
+	_WRAP_METHOD(bool process(GeglOperationContext * context, const Glib::ustring & output_pad, const Rectangle & result_rect), gegl_operation_process)
 	_WRAP_METHOD(void create_pad(GParamSpec *param_spec), gegl_operation_create_pad)
 	_WRAP_METHOD(void set_format(const Glib::ustring & pad_name, const Babl *format), gegl_operation_set_format)
 	_WRAP_METHOD(const Babl* get_format(const Glib::ustring & pad_name), gegl_operation_get_format) //TODO: Wrap Babl.
diff --git a/gegl/src/path.hg b/gegl/src/path.hg
index 60efa74..be6e992 100644
--- a/gegl/src/path.hg
+++ b/gegl/src/path.hg
@@ -63,8 +63,10 @@ public:
     _WRAP_METHOD(void calc(double pos, double &dest_x, double &dest_y), gegl_path_calc)
     _WRAP_METHOD(void calc_values(guint num_samples, double & dest_xs, double & dest_ys), gegl_path_calc_values)
     _WRAP_METHOD(void get_bounds(double & min_x, double & max_x, double &min_y, double &max_y), gegl_path_get_bounds)
+
     //    _WRAP_METHOD(void foreach(void * each_item, gpointer data), gegl_path_foreach)
     //   gegl_path_foreach_flat
+
     _WRAP_METHOD(void clear(), gegl_path_clear)
     _WRAP_METHOD(void insert_node(int pos, const GeglPathItem *knot), gegl_path_insert_node)
     _WRAP_METHOD(void replace_node(int pos, const GeglPathItem *knot), gegl_path_replace_node)
diff --git a/gegl/src/rectangle.hg b/gegl/src/rectangle.hg
index d89097e..8445b32 100644
--- a/gegl/src/rectangle.hg
+++ b/gegl/src/rectangle.hg
@@ -33,12 +33,12 @@ public:
 	_WRAP_METHOD(void set(int x, int y, guint witdth, guint height), gegl_rectangle_set)
 	_WRAP_METHOD(bool equal(const Rectangle & s) const, gegl_rectangle_equal) //TODO: Rename to operator==() const?
 	_WRAP_METHOD(bool equal_coords(int x, int y, int width, int heght) const, gegl_rectangle_equal_coords)
+  _WRAP_METHOD(bool is_empty() const, gegl_rectangle_is_empty)
 	_WRAP_METHOD(void copy(const Rectangle & from), gegl_rectangle_copy) //Rename to copy constructor?
 	_WRAP_METHOD(void bounding_box(const Rectangle & src1, const Rectangle & src2), gegl_rectangle_bounding_box)
 	_WRAP_METHOD(bool intersect(const Rectangle & src1, const Rectangle & src2), gegl_rectangle_intersect) //TODO: Make this const?
 	_WRAP_METHOD(bool contains(const Rectangle & s) const, gegl_rectangle_contains)
   _WRAP_METHOD(bool is_infinite_plane() const, gegl_rectangle_is_infinite_plane)
-
   _WRAP_METHOD(void dump() const, gegl_rectangle_dump)
 };
 
diff --git a/tools/extra_defs_gen/generate_defs_gegl.cc b/tools/extra_defs_gen/generate_defs_gegl.cc
index 687132c..a802b1d 100644
--- a/tools/extra_defs_gen/generate_defs_gegl.cc
+++ b/tools/extra_defs_gen/generate_defs_gegl.cc
@@ -22,6 +22,8 @@
 #include <iostream>
 #include "glibmm_generate_extra_defs/generate_extra_defs.h"
 #include <gegl.h>
+#include <gegl-tile-backend.h>
+#include <gegl-tile-source.h>
 #undef HAVE_CONFIG_H
 #include <gegl-plugin.h>
 
@@ -30,36 +32,39 @@ int main (int argc, char *argv[])
     gegl_init(&argc, &argv);
 
     std::cout << get_defs(GEGL_TYPE_NODE)
-			  << get_defs(GEGL_TYPE_RECTANGLE)
-			  << get_defs(GEGL_TYPE_COLOR)
-			  << get_defs(GEGL_TYPE_PARAM_COLOR)
-			  << get_defs(GEGL_TYPE_BUFFER)
-			  << get_defs(GEGL_TYPE_CURVE)
-			  << get_defs(GEGL_TYPE_PARAM_CURVE)
-			  << get_defs(GEGL_TYPE_PROCESSOR)
-			  << get_defs(GEGL_TYPE_PATH)
-			  << get_defs(GEGL_TYPE_INT32)
-			  << get_defs(GEGL_TYPE_PARAM_INT32)
-			  << get_defs(GEGL_TYPE_INT16)
-			  << get_defs(GEGL_TYPE_PARAM_INT16)
-			  << get_defs(GEGL_TYPE_INT8)
-			  << get_defs(GEGL_TYPE_PARAM_INT8)
-			  << get_defs(GEGL_TYPE_PARAM_STRING)
-			  << get_defs(GEGL_TYPE_PARAM_PATH)
-			  << get_defs(GEGL_TYPE_PARAM_MULTILINE)
-			  << get_defs(GEGL_TYPE_PARAM_ENUM)
-			  << get_defs(GEGL_TYPE_OPERATION)
-			  << get_defs(GEGL_TYPE_OPERATION_SOURCE)
-			  << get_defs(GEGL_TYPE_OPERATION_SINK)
-			  << get_defs(GEGL_TYPE_OPERATION_FILTER)
-			  << get_defs(GEGL_TYPE_OPERATION_COMPOSER)
-			  << get_defs(GEGL_TYPE_OPERATION_COMPOSER3)
-			  << get_defs(GEGL_TYPE_OPERATION_POINT_COMPOSER)
-			  << get_defs(GEGL_TYPE_OPERATION_POINT_COMPOSER3)
-			  << get_defs(GEGL_TYPE_OPERATION_POINT_FILTER)
-              << get_defs(GEGL_TYPE_OPERATION_POINT_RENDER)
-			  << get_defs(GEGL_TYPE_OPERATION_AREA_FILTER)
-			  << get_defs(GEGL_TYPE_OPERATION_META)
+	      << get_defs(GEGL_TYPE_RECTANGLE)
+	      << get_defs(GEGL_TYPE_COLOR)
+	      << get_defs(GEGL_TYPE_PARAM_COLOR)
+	      << get_defs(GEGL_TYPE_BUFFER)
+	      << get_defs(GEGL_TYPE_CURVE)
+	      << get_defs(GEGL_TYPE_PARAM_CURVE)
+	      << get_defs(GEGL_TYPE_PROCESSOR)
+	      << get_defs(GEGL_TYPE_PATH)
+	      << get_defs(GEGL_TYPE_PARAM_PATH)
+	      << get_defs(GEGL_TYPE_INT32)
+	      << get_defs(GEGL_TYPE_PARAM_INT32)
+	      << get_defs(GEGL_TYPE_INT16)
+	      << get_defs(GEGL_TYPE_PARAM_INT16)
+	      << get_defs(GEGL_TYPE_INT8)
+	      << get_defs(GEGL_TYPE_PARAM_INT8)
+	      << get_defs(GEGL_TYPE_PARAM_STRING)
+	      << get_defs(GEGL_TYPE_PARAM_FILE_PATH)
+	      << get_defs(GEGL_TYPE_PARAM_MULTILINE)
+	      << get_defs(GEGL_TYPE_PARAM_ENUM)
+	      << get_defs(GEGL_TYPE_TILE_BACKEND)
+	      << get_defs(GEGL_TYPE_TILE_SOURCE)
+	      << get_defs(GEGL_TYPE_OPERATION)
+	      << get_defs(GEGL_TYPE_OPERATION_SOURCE)
+	      << get_defs(GEGL_TYPE_OPERATION_SINK)
+	      << get_defs(GEGL_TYPE_OPERATION_FILTER)
+	      << get_defs(GEGL_TYPE_OPERATION_COMPOSER)
+	      << get_defs(GEGL_TYPE_OPERATION_COMPOSER3)
+	      << get_defs(GEGL_TYPE_OPERATION_POINT_COMPOSER)
+	      << get_defs(GEGL_TYPE_OPERATION_POINT_COMPOSER3)
+	      << get_defs(GEGL_TYPE_OPERATION_POINT_FILTER)
+	      << get_defs(GEGL_TYPE_OPERATION_POINT_RENDER)
+	      << get_defs(GEGL_TYPE_OPERATION_AREA_FILTER)
+	      << get_defs(GEGL_TYPE_OPERATION_META)
               << get_defs(GEGL_TYPE_OPERATION_TEMPORAL)
 		;
 	gegl_exit();
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]