gnomemm r1864 - in cluttermm/trunk: . clutter/src

[daniel svn gnome org]

Author: daniel
Date: Tue Dec 16 19:00:47 2008
New Revision: 1864
URL: http://svn.gnome.org/viewvc/gnomemm?rev=1864&view=rev

Log:
* clutter/src/clutter_enums.defs: Regenerate.
(PathNodeType): Hand-edit definition.
(TokenType): Likewise.
* clutter/src/clutter_methods.defs: Regenerate.
* clutter/src/clutter_signals.defs: Regenerate.
(Actor::*event): Hand-edit signal parameter types.


Modified:
   cluttermm/trunk/ChangeLog
   cluttermm/trunk/clutter/src/clutter_enums.defs
   cluttermm/trunk/clutter/src/clutter_methods.defs
   cluttermm/trunk/clutter/src/clutter_signals.defs

Modified: cluttermm/trunk/clutter/src/clutter_enums.defs
==============================================================================
--- cluttermm/trunk/clutter/src/clutter_enums.defs	(original)
+++ cluttermm/trunk/clutter/src/clutter_enums.defs	Tue Dec 16 19:00:47 2008
@@ -1,4 +1,4 @@
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-actor.h
+;; From clutter/clutter-actor.h
 
 (define-flags-extended ActorFlags
   (in-module "Clutter")
@@ -10,30 +10,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-debug.h
-
-(define-flags-extended DebugFlag
-  (in-module "Clutter")
-  (c-name "ClutterDebugFlag")
-  (values
-    '("misc" "CLUTTER_DEBUG_MISC" "1 << 0")
-    '("actor" "CLUTTER_DEBUG_ACTOR" "1 << 1")
-    '("texture" "CLUTTER_DEBUG_TEXTURE" "1 << 2")
-    '("event" "CLUTTER_DEBUG_EVENT" "1 << 3")
-    '("paint" "CLUTTER_DEBUG_PAINT" "1 << 4")
-    '("gl" "CLUTTER_DEBUG_GL" "1 << 5")
-    '("alpha" "CLUTTER_DEBUG_ALPHA" "1 << 6")
-    '("behaviour" "CLUTTER_DEBUG_BEHAVIOUR" "1 << 7")
-    '("pango" "CLUTTER_DEBUG_PANGO" "1 << 8")
-    '("backend" "CLUTTER_DEBUG_BACKEND" "1 << 9")
-    '("scheduler" "CLUTTER_DEBUG_SCHEDULER" "1 << 10")
-    '("script" "CLUTTER_DEBUG_SCRIPT" "1 << 11")
-    '("shader" "CLUTTER_DEBUG_SHADER" "1 << 12")
-    '("multistage" "CLUTTER_DEBUG_MULTISTAGE" "1 << 13")
-  )
-)
-
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-event.h
+;; From clutter/clutter-event.h
 
 (define-flags-extended ModifierType
   (in-module "Clutter")
@@ -52,6 +29,11 @@
     '("button3-mask" "CLUTTER_BUTTON3_MASK" "1 << 10")
     '("button4-mask" "CLUTTER_BUTTON4_MASK" "1 << 11")
     '("button5-mask" "CLUTTER_BUTTON5_MASK" "1 << 12")
+    '("super-mask" "CLUTTER_SUPER_MASK" "1 << 26")
+    '("hyper-mask" "CLUTTER_HYPER_MASK" "1 << 27")
+    '("meta-mask" "CLUTTER_META_MASK" "1 << 28")
+    '("release-mask" "CLUTTER_RELEASE_MASK" "1 << 30")
+    '("modifier-mask" "CLUTTER_MODIFIER_MASK" "0x5c001fff")
   )
 )
 
@@ -104,7 +86,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-feature.h
+;; From clutter/clutter-feature.h
 
 (define-flags-extended FeatureFlags
   (in-module "Clutter")
@@ -123,7 +105,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-main.h
+;; From clutter/clutter-main.h
 
 (define-enum-extended InitError
   (in-module "Clutter")
@@ -137,32 +119,25 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-private.h
+;; From clutter/clutter-path.h
+;; hand-edited to deal with CLUTTER_PATH_RELATIVE flag
 
-(define-flags-extended PrivateFlags
+(define-flags-extended PathNodeType
   (in-module "Clutter")
-  (c-name "ClutterPrivateFlags")
+  (c-name "ClutterPathNodeType")
   (values
-    '("unused-flag" "CLUTTER_ACTOR_UNUSED_FLAG" "0")
-    '("in-destruction" "CLUTTER_ACTOR_IN_DESTRUCTION" "1 << 0")
-    '("is-toplevel" "CLUTTER_ACTOR_IS_TOPLEVEL" "1 << 1")
-    '("in-reparent" "CLUTTER_ACTOR_IN_REPARENT" "1 << 2")
-    '("in-paint" "CLUTTER_ACTOR_IN_PAINT" "1 << 4")
-    '("in-relayout" "CLUTTER_ACTOR_IN_RELAYOUT" "1 << 5")
+    '("move-to" "CLUTTER_PATH_MOVE_TO" "0")
+    '("line-to" "CLUTTER_PATH_LINE_TO" "1")
+    '("curve-to" "CLUTTER_PATH_CURVE_TO" "2")
+    '("close" "CLUTTER_PATH_CLOSE" "3")
+    '("relative" "CLUTTER_PATH_RELATIVE" "32")
+    '("rel-move-to" "CLUTTER_PATH_REL_MOVE_TO" "PATH_MOVE_TO | PATH_RELATIVE")
+    '("rel-line-to" "CLUTTER_PATH_REL_LINE_TO" "PATH_LINE_TO | PATH_RELATIVE")
+    '("rel-curve-to" "CLUTTER_PATH_REL_CURVE_TO" "PATH_CURVE_TO | PATH_RELATIVE")
   )
 )
 
-(define-enum-extended PickMode
-  (in-module "Clutter")
-  (c-name "ClutterPickMode")
-  (values
-    '("none" "CLUTTER_PICK_NONE" "0")
-    '("reactive" "CLUTTER_PICK_REACTIVE" "1")
-    '("all" "CLUTTER_PICK_ALL" "2")
-  )
-)
-
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-script.h
+;; From clutter/clutter-script.h
 
 (define-enum-extended ScriptError
   (in-module "Clutter")
@@ -174,7 +149,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-shader.h
+;; From clutter/clutter-shader.h
 
 (define-enum-extended ShaderError
   (in-module "Clutter")
@@ -186,7 +161,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-texture.h
+;; From clutter/clutter-texture.h
 
 (define-enum-extended TextureError
   (in-module "Clutter")
@@ -218,7 +193,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-timeline.h
+;; From clutter/clutter-timeline.h
 
 (define-enum-extended TimelineDirection
   (in-module "Clutter")
@@ -229,7 +204,7 @@
   )
 )
 
-;; From /home/ck/devel/clutter/clutter/clutter/clutter-types.h
+;; From clutter/clutter-types.h
 
 (define-enum-extended Gravity
   (in-module "Clutter")
@@ -276,3 +251,94 @@
   )
 )
 
+(define-enum-extended AnimationMode
+  (in-module "Clutter")
+  (c-name "ClutterAnimationMode")
+  (values
+    '("custom-mode" "CLUTTER_CUSTOM_MODE" "0")
+    '("linear" "CLUTTER_LINEAR" "1")
+    '("sine-in" "CLUTTER_SINE_IN" "2")
+    '("sine-out" "CLUTTER_SINE_OUT" "3")
+    '("sine-in-out" "CLUTTER_SINE_IN_OUT" "4")
+    '("ease-in" "CLUTTER_EASE_IN" "5")
+    '("ease-out" "CLUTTER_EASE_OUT" "6")
+    '("ease-in-out" "CLUTTER_EASE_IN_OUT" "7")
+    '("expo-in" "CLUTTER_EXPO_IN" "8")
+    '("expo-out" "CLUTTER_EXPO_OUT" "9")
+    '("expo-in-out" "CLUTTER_EXPO_IN_OUT" "10")
+    '("smooth-in-out" "CLUTTER_SMOOTH_IN_OUT" "11")
+  )
+)
+
+;; From clutter/json/json-parser.h
+
+(define-enum-extended ParserError
+  (in-module "Json")
+  (c-name "JsonParserError")
+  (values
+    '("parse" "JSON_PARSER_ERROR_PARSE" "0")
+    '("unknown" "JSON_PARSER_ERROR_UNKNOWN" "1")
+  )
+)
+
+;; hand-edited to fix reference to G_TOKEN_LAST
+(define-enum-extended TokenType
+  (in-module "Json")
+  (c-name "JsonTokenType")
+  (values
+    '("invalid" "JSON_TOKEN_INVALID" "270")
+    '("true" "JSON_TOKEN_TRUE" "271")
+    '("false" "JSON_TOKEN_FALSE" "272")
+    '("null" "JSON_TOKEN_NULL" "273")
+    '("last" "JSON_TOKEN_LAST" "274")
+  )
+)
+
+;; From clutter/json/json-types.h
+
+(define-enum-extended NodeType
+  (in-module "Json")
+  (c-name "JsonNodeType")
+  (values
+    '("object" "JSON_NODE_OBJECT" "0")
+    '("array" "JSON_NODE_ARRAY" "1")
+    '("value" "JSON_NODE_VALUE" "2")
+    '("null" "JSON_NODE_NULL" "3")
+  )
+)
+
+;; From clutter/x11/clutter-x11.h
+
+(define-enum-extended X11FilterReturn
+  (in-module "Clutter")
+  (c-name "ClutterX11FilterReturn")
+  (values
+    '("continue" "CLUTTER_X11_FILTER_CONTINUE" "0")
+    '("translate" "CLUTTER_X11_FILTER_TRANSLATE" "1")
+    '("remove" "CLUTTER_X11_FILTER_REMOVE" "2")
+  )
+)
+
+(define-enum-extended X11XInputEventTypes
+  (in-module "Clutter")
+  (c-name "ClutterX11XInputEventTypes")
+  (values
+    '("key-press-event" "CLUTTER_X11_XINPUT_KEY_PRESS_EVENT" "0")
+    '("key-release-event" "CLUTTER_X11_XINPUT_KEY_RELEASE_EVENT" "1")
+    '("button-press-event" "CLUTTER_X11_XINPUT_BUTTON_PRESS_EVENT" "2")
+    '("button-release-event" "CLUTTER_X11_XINPUT_BUTTON_RELEASE_EVENT" "3")
+    '("motion-notify-event" "CLUTTER_X11_XINPUT_MOTION_NOTIFY_EVENT" "4")
+    '("last-event" "CLUTTER_X11_XINPUT_LAST_EVENT" "5")
+  )
+)
+
+(define-enum-extended X11InputDeviceType
+  (in-module "Clutter")
+  (c-name "ClutterX11InputDeviceType")
+  (values
+    '("pointer-device" "CLUTTER_X11_XINPUT_POINTER_DEVICE" "0")
+    '("keyboard-device" "CLUTTER_X11_XINPUT_KEYBOARD_DEVICE" "1")
+    '("extension-device" "CLUTTER_X11_XINPUT_EXTENSION_DEVICE" "2")
+  )
+)
+

Modified: cluttermm/trunk/clutter/src/clutter_methods.defs
==============================================================================
--- cluttermm/trunk/clutter/src/clutter_methods.defs	(original)
+++ cluttermm/trunk/clutter/src/clutter_methods.defs	Tue Dec 16 19:00:47 2008
@@ -14,6 +14,13 @@
   (gtype-id "CLUTTER_TYPE_ALPHA")
 )
 
+(define-object Animation
+  (in-module "Clutter")
+  (parent "GInitiallyUnowned")
+  (c-name "ClutterAnimation")
+  (gtype-id "CLUTTER_TYPE_ANIMATION")
+)
+
 (define-object Backend
   (in-module "Clutter")
   (parent "GObject")
@@ -28,13 +35,6 @@
   (gtype-id "CLUTTER_TYPE_BEHAVIOUR")
 )
 
-(define-object BehaviourBspline
-  (in-module "Clutter")
-  (parent "ClutterBehaviour")
-  (c-name "ClutterBehaviourBspline")
-  (gtype-id "CLUTTER_TYPE_BEHAVIOUR_BSPLINE")
-)
-
 (define-object BehaviourDepth
   (in-module "Clutter")
   (parent "ClutterBehaviour")
@@ -118,6 +118,13 @@
   (gtype-id "CLUTTER_TYPE_GROUP")
 )
 
+(define-object Interval
+  (in-module "Clutter")
+  (parent "GInitiallyUnowned")
+  (c-name "ClutterInterval")
+  (gtype-id "CLUTTER_TYPE_INTERVAL")
+)
+
 (define-object Label
   (in-module "Clutter")
   (parent "ClutterActor")
@@ -139,6 +146,13 @@
   (gtype-id "CLUTTER_TYPE_MODEL_ITER")
 )
 
+(define-object Path
+  (in-module "Clutter")
+  (parent "GInitiallyUnowned")
+  (c-name "ClutterPath")
+  (gtype-id "CLUTTER_TYPE_PATH")
+)
+
 (define-object Rectangle
   (in-module "Clutter")
   (parent "ClutterActor")
@@ -180,12 +194,6 @@
   (gtype-id "CLUTTER_TYPE_STAGE")
 )
 
-(define-object StageWindow
-  (in-module "Clutter")
-  (c-name "ClutterStageWindow")
-  (gtype-id "CLUTTER_TYPE_STAGE_WINDOW")
-)
-
 (define-object Texture
   (in-module "Clutter")
   (parent "ClutterActor")
@@ -200,38 +208,72 @@
   (gtype-id "CLUTTER_TYPE_TIMELINE")
 )
 
+(define-object X11TexturePixmap
+  (in-module "Clutter")
+  (parent "ClutterTexture")
+  (c-name "ClutterX11TexturePixmap")
+  (gtype-id "CLUTTER_TYPE_X11_TEXTURE_PIXMAP")
+)
+
+(define-object GLXTexturePixmap
+  (in-module "Clutter")
+  (parent "ClutterX11TexturePixmap")
+  (c-name "ClutterGLXTexturePixmap")
+  (gtype-id "CLUTTER_TYPE_GLX_TEXTURE_PIXMAP")
+)
+
+(define-object Generator
+  (in-module "Json")
+  (parent "GObject")
+  (c-name "JsonGenerator")
+  (gtype-id "JSON_TYPE_GENERATOR")
+)
+
+(define-object Parser
+  (in-module "Json")
+  (parent "GObject")
+  (c-name "JsonParser")
+  (gtype-id "JSON_TYPE_PARSER")
+)
+
 ;; Enumerations and flags ...
 
-(define-flags ActorFlags
+(define-enum InitError
   (in-module "Clutter")
-  (c-name "ClutterActorFlags")
-  (gtype-id "CLUTTER_TYPE_ACTOR_FLAGS")
+  (c-name "ClutterInitError")
+  (gtype-id "CLUTTER_TYPE_INIT_ERROR")
   (values
-    '("mapped" "CLUTTER_ACTOR_MAPPED")
-    '("realized" "CLUTTER_ACTOR_REALIZED")
-    '("reactive" "CLUTTER_ACTOR_REACTIVE")
+    '("success" "CLUTTER_INIT_SUCCESS")
+    '("error-unknown" "CLUTTER_INIT_ERROR_UNKNOWN")
+    '("error-threads" "CLUTTER_INIT_ERROR_THREADS")
+    '("error-backend" "CLUTTER_INIT_ERROR_BACKEND")
+    '("error-internal" "CLUTTER_INIT_ERROR_INTERNAL")
+  )
+)
+
+(define-enum PathNodeType
+  (in-module "Clutter")
+  (c-name "ClutterPathNodeType")
+  (gtype-id "CLUTTER_TYPE_PATH_NODE_TYPE")
+  (values
+    '("move-to" "CLUTTER_PATH_MOVE_TO")
+    '("line-to" "CLUTTER_PATH_LINE_TO")
+    '("curve-to" "CLUTTER_PATH_CURVE_TO")
+    '("close" "CLUTTER_PATH_CLOSE")
+    '("rel-move-to" "CLUTTER_PATH_REL_MOVE_TO")
+    '("rel-line-to" "CLUTTER_PATH_REL_LINE_TO")
+    '("rel-curve-to" "CLUTTER_PATH_REL_CURVE_TO")
   )
 )
 
-(define-flags DebugFlag
+(define-enum ShaderError
   (in-module "Clutter")
-  (c-name "ClutterDebugFlag")
-  (gtype-id "CLUTTER_TYPE_DEBUG_FLAG")
+  (c-name "ClutterShaderError")
+  (gtype-id "CLUTTER_TYPE_SHADER_ERROR")
   (values
-    '("misc" "CLUTTER_DEBUG_MISC")
-    '("actor" "CLUTTER_DEBUG_ACTOR")
-    '("texture" "CLUTTER_DEBUG_TEXTURE")
-    '("event" "CLUTTER_DEBUG_EVENT")
-    '("paint" "CLUTTER_DEBUG_PAINT")
-    '("gl" "CLUTTER_DEBUG_GL")
-    '("alpha" "CLUTTER_DEBUG_ALPHA")
-    '("behaviour" "CLUTTER_DEBUG_BEHAVIOUR")
-    '("pango" "CLUTTER_DEBUG_PANGO")
-    '("backend" "CLUTTER_DEBUG_BACKEND")
-    '("scheduler" "CLUTTER_DEBUG_SCHEDULER")
-    '("script" "CLUTTER_DEBUG_SCRIPT")
-    '("shader" "CLUTTER_DEBUG_SHADER")
-    '("multistage" "CLUTTER_DEBUG_MULTISTAGE")
+    '("no-asm" "CLUTTER_SHADER_ERROR_NO_ASM")
+    '("no-glsl" "CLUTTER_SHADER_ERROR_NO_GLSL")
+    '("compile" "CLUTTER_SHADER_ERROR_COMPILE")
   )
 )
 
@@ -253,6 +295,11 @@
     '("button3-mask" "CLUTTER_BUTTON3_MASK")
     '("button4-mask" "CLUTTER_BUTTON4_MASK")
     '("button5-mask" "CLUTTER_BUTTON5_MASK")
+    '("super-mask" "CLUTTER_SUPER_MASK")
+    '("hyper-mask" "CLUTTER_HYPER_MASK")
+    '("meta-mask" "CLUTTER_META_MASK")
+    '("release-mask" "CLUTTER_RELEASE_MASK")
+    '("modifier-mask" "CLUTTER_MODIFIER_MASK")
   )
 )
 
@@ -261,7 +308,7 @@
   (c-name "ClutterEventFlags")
   (gtype-id "CLUTTER_TYPE_EVENT_FLAGS")
   (values
-    '("c" "CLUTTER_EVENT_FLAG_SYNTHETIC")
+    '("synthetic" "CLUTTER_EVENT_FLAG_SYNTHETIC")
   )
 )
 
@@ -309,85 +356,6 @@
   )
 )
 
-(define-flags FeatureFlags
-  (in-module "Clutter")
-  (c-name "ClutterFeatureFlags")
-  (gtype-id "CLUTTER_TYPE_FEATURE_FLAGS")
-  (values
-    '("texture-npot" "CLUTTER_FEATURE_TEXTURE_NPOT")
-    '("sync-to-vblank" "CLUTTER_FEATURE_SYNC_TO_VBLANK")
-    '("texture-yuv" "CLUTTER_FEATURE_TEXTURE_YUV")
-    '("texture-read-pixels" "CLUTTER_FEATURE_TEXTURE_READ_PIXELS")
-    '("stage-static" "CLUTTER_FEATURE_STAGE_STATIC")
-    '("stage-user-resize" "CLUTTER_FEATURE_STAGE_USER_RESIZE")
-    '("stage-cursor" "CLUTTER_FEATURE_STAGE_CURSOR")
-    '("shaders-glsl" "CLUTTER_FEATURE_SHADERS_GLSL")
-    '("offscreen" "CLUTTER_FEATURE_OFFSCREEN")
-    '("stage-multiple" "CLUTTER_FEATURE_STAGE_MULTIPLE")
-  )
-)
-
-(define-enum InitError
-  (in-module "Clutter")
-  (c-name "ClutterInitError")
-  (gtype-id "CLUTTER_TYPE_INIT_ERROR")
-  (values
-    '("success" "CLUTTER_INIT_SUCCESS")
-    '("error-unknown" "CLUTTER_INIT_ERROR_UNKNOWN")
-    '("error-threads" "CLUTTER_INIT_ERROR_THREADS")
-    '("error-backend" "CLUTTER_INIT_ERROR_BACKEND")
-    '("error-internal" "CLUTTER_INIT_ERROR_INTERNAL")
-  )
-)
-
-(define-flags PrivateFlags
-  (in-module "Clutter")
-  (c-name "ClutterPrivateFlags")
-  (gtype-id "CLUTTER_TYPE_PRIVATE_FLAGS")
-  (values
-    '("unused-flag" "CLUTTER_ACTOR_UNUSED_FLAG")
-    '("in-destruction" "CLUTTER_ACTOR_IN_DESTRUCTION")
-    '("is-toplevel" "CLUTTER_ACTOR_IS_TOPLEVEL")
-    '("in-reparent" "CLUTTER_ACTOR_IN_REPARENT")
-    '("sync-matrices" "CLUTTER_ACTOR_SYNC_MATRICES")
-    '("in-paint" "CLUTTER_ACTOR_IN_PAINT")
-    '("in-relayout" "CLUTTER_ACTOR_IN_RELAYOUT")
-  )
-)
-
-(define-enum PickMode
-  (in-module "Clutter")
-  (c-name "ClutterPickMode")
-  (gtype-id "CLUTTER_TYPE_PICK_MODE")
-  (values
-    '("none" "CLUTTER_PICK_NONE")
-    '("reactive" "CLUTTER_PICK_REACTIVE")
-    '("all" "CLUTTER_PICK_ALL")
-  )
-)
-
-(define-enum ScriptError
-  (in-module "Clutter")
-  (c-name "ClutterScriptError")
-  (gtype-id "CLUTTER_TYPE_SCRIPT_ERROR")
-  (values
-    '("type-function" "CLUTTER_SCRIPT_ERROR_INVALID_TYPE_FUNCTION")
-    '("property" "CLUTTER_SCRIPT_ERROR_INVALID_PROPERTY")
-    '("value" "CLUTTER_SCRIPT_ERROR_INVALID_VALUE")
-  )
-)
-
-(define-enum ShaderError
-  (in-module "Clutter")
-  (c-name "ClutterShaderError")
-  (gtype-id "CLUTTER_TYPE_SHADER_ERROR")
-  (values
-    '("no-asm" "CLUTTER_SHADER_ERROR_NO_ASM")
-    '("no-glsl" "CLUTTER_SHADER_ERROR_NO_GLSL")
-    '("compile" "CLUTTER_SHADER_ERROR_COMPILE")
-  )
-)
-
 (define-enum TextureError
   (in-module "Clutter")
   (c-name "ClutterTextureError")
@@ -421,6 +389,28 @@
   )
 )
 
+(define-enum ScriptError
+  (in-module "Clutter")
+  (c-name "ClutterScriptError")
+  (gtype-id "CLUTTER_TYPE_SCRIPT_ERROR")
+  (values
+    '("type-function" "CLUTTER_SCRIPT_ERROR_INVALID_TYPE_FUNCTION")
+    '("property" "CLUTTER_SCRIPT_ERROR_INVALID_PROPERTY")
+    '("value" "CLUTTER_SCRIPT_ERROR_INVALID_VALUE")
+  )
+)
+
+(define-flags ActorFlags
+  (in-module "Clutter")
+  (c-name "ClutterActorFlags")
+  (gtype-id "CLUTTER_TYPE_ACTOR_FLAGS")
+  (values
+    '("mapped" "CLUTTER_ACTOR_MAPPED")
+    '("realized" "CLUTTER_ACTOR_REALIZED")
+    '("reactive" "CLUTTER_ACTOR_REACTIVE")
+  )
+)
+
 (define-enum TimelineDirection
   (in-module "Clutter")
   (c-name "ClutterTimelineDirection")
@@ -465,8 +455,8 @@
   (c-name "ClutterRotateDirection")
   (gtype-id "CLUTTER_TYPE_ROTATE_DIRECTION")
   (values
-    '("w" "CLUTTER_ROTATE_CW")
-    '("cw" "CLUTTER_ROTATE_CCW")
+    '("cw" "CLUTTER_ROTATE_CW")
+    '("ccw" "CLUTTER_ROTATE_CCW")
   )
 )
 
@@ -480,5646 +470,7125 @@
   )
 )
 
-
-;; From clutter-actor.h
-
-(define-function clutter_actor_box_get_type
-  (c-name "clutter_actor_box_get_type")
-  (return-type "GType")
+(define-enum AnimationMode
+  (in-module "Clutter")
+  (c-name "ClutterAnimationMode")
+  (gtype-id "CLUTTER_TYPE_ANIMATION_MODE")
+  (values
+    '("custom-mode" "CLUTTER_CUSTOM_MODE")
+    '("linear" "CLUTTER_LINEAR")
+    '("sine-in" "CLUTTER_SINE_IN")
+    '("sine-out" "CLUTTER_SINE_OUT")
+    '("sine-in-out" "CLUTTER_SINE_IN_OUT")
+    '("ease-in" "CLUTTER_EASE_IN")
+    '("ease-out" "CLUTTER_EASE_OUT")
+    '("ease-in-out" "CLUTTER_EASE_IN_OUT")
+    '("expo-in" "CLUTTER_EXPO_IN")
+    '("expo-out" "CLUTTER_EXPO_OUT")
+    '("expo-in-out" "CLUTTER_EXPO_IN_OUT")
+    '("smooth-in-out" "CLUTTER_SMOOTH_IN_OUT")
+  )
 )
 
-(define-function clutter_actor_get_type
-  (c-name "clutter_actor_get_type")
-  (return-type "GType")
+(define-flags FeatureFlags
+  (in-module "Clutter")
+  (c-name "ClutterFeatureFlags")
+  (gtype-id "CLUTTER_TYPE_FEATURE_FLAGS")
+  (values
+    '("texture-npot" "CLUTTER_FEATURE_TEXTURE_NPOT")
+    '("sync-to-vblank" "CLUTTER_FEATURE_SYNC_TO_VBLANK")
+    '("texture-yuv" "CLUTTER_FEATURE_TEXTURE_YUV")
+    '("texture-read-pixels" "CLUTTER_FEATURE_TEXTURE_READ_PIXELS")
+    '("stage-static" "CLUTTER_FEATURE_STAGE_STATIC")
+    '("stage-user-resize" "CLUTTER_FEATURE_STAGE_USER_RESIZE")
+    '("stage-cursor" "CLUTTER_FEATURE_STAGE_CURSOR")
+    '("shaders-glsl" "CLUTTER_FEATURE_SHADERS_GLSL")
+    '("offscreen" "CLUTTER_FEATURE_OFFSCREEN")
+    '("stage-multiple" "CLUTTER_FEATURE_STAGE_MULTIPLE")
+  )
 )
 
-(define-method show
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_show")
-  (return-type "none")
+(define-enum NodeType
+  (in-module "Json")
+  (c-name "JsonNodeType")
+  (gtype-id "JSON_TYPE_NODE_TYPE")
+  (values
+    '("object" "JSON_NODE_OBJECT")
+    '("array" "JSON_NODE_ARRAY")
+    '("value" "JSON_NODE_VALUE")
+    '("null" "JSON_NODE_NULL")
+  )
 )
 
-(define-method show_all
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_show_all")
-  (return-type "none")
+(define-enum ParserError
+  (in-module "Json")
+  (c-name "JsonParserError")
+  (gtype-id "JSON_TYPE_PARSER_ERROR")
+  (values
+    '("parse" "JSON_PARSER_ERROR_PARSE")
+    '("unknown" "JSON_PARSER_ERROR_UNKNOWN")
+  )
 )
 
-(define-method hide
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_hide")
-  (return-type "none")
+(define-enum TokenType
+  (in-module "Json")
+  (c-name "JsonTokenType")
+  (gtype-id "JSON_TYPE_TOKEN_TYPE")
+  (values
+    '("invalid" "JSON_TOKEN_INVALID")
+    '("true" "JSON_TOKEN_TRUE")
+    '("false" "JSON_TOKEN_FALSE")
+    '("null" "JSON_TOKEN_NULL")
+    '("last" "JSON_TOKEN_LAST")
+  )
 )
 
-(define-method hide_all
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_hide_all")
-  (return-type "none")
-)
 
-(define-method realize
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_realize")
-  (return-type "none")
-)
+;; From clutter-backend.h
 
-(define-method unrealize
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_unrealize")
-  (return-type "none")
+(define-function clutter_backend_get_type
+  (c-name "clutter_backend_get_type")
+  (return-type "GType")
 )
 
-(define-method paint
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_paint")
-  (return-type "none")
+(define-function clutter_get_default_backend
+  (c-name "clutter_get_default_backend")
+  (return-type "ClutterBackend*")
 )
 
-(define-method pick
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_pick")
+(define-method set_resolution
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_set_resolution")
   (return-type "none")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("gdouble" "dpi")
   )
 )
 
-(define-method queue_redraw
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_queue_redraw")
-  (return-type "none")
+(define-method get_resolution
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_get_resolution")
+  (return-type "gdouble")
 )
 
-(define-method queue_relayout
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_queue_relayout")
+(define-method set_double_click_time
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_set_double_click_time")
   (return-type "none")
+  (parameters
+    '("guint" "msec")
+  )
 )
 
-(define-method destroy
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_destroy")
-  (return-type "none")
+(define-method get_double_click_time
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_get_double_click_time")
+  (return-type "guint")
 )
 
-(define-method get_preferred_width
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_preferred_width")
+(define-method set_double_click_distance
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_set_double_click_distance")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "for_height")
-    '("ClutterUnit*" "min_width_p")
-    '("ClutterUnit*" "natural_width_p")
+    '("guint" "distance")
   )
 )
 
-(define-method get_preferred_height
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_preferred_height")
-  (return-type "none")
+(define-method get_double_click_distance
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_get_double_click_distance")
+  (return-type "guint")
+)
+
+(define-method set_font_options
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_set_font_options")
+  (return-type "none")
+  (parameters
+    '("cairo_font_options_t*" "options")
+  )
+)
+
+(define-method get_font_options
+  (of-object "ClutterBackend")
+  (c-name "clutter_backend_get_font_options")
+  (return-type "cairo_font_options_t*")
+)
+
+
+
+;; From clutter-frame-source.h
+
+(define-function clutter_frame_source_add
+  (c-name "clutter_frame_source_add")
+  (return-type "guint")
+  (parameters
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-function clutter_frame_source_add_full
+  (c-name "clutter_frame_source_add_full")
+  (return-type "guint")
+  (parameters
+    '("gint" "priority")
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
+  )
+)
+
+
+
+;; From clutter-enum-types.h
+
+(define-function clutter_actor_flags_get_type
+  (c-name "clutter_actor_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_modifier_type_get_type
+  (c-name "clutter_modifier_type_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_event_flags_get_type
+  (c-name "clutter_event_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_event_type_get_type
+  (c-name "clutter_event_type_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_scroll_direction_get_type
+  (c-name "clutter_scroll_direction_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_stage_state_get_type
+  (c-name "clutter_stage_state_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_feature_flags_get_type
+  (c-name "clutter_feature_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_init_error_get_type
+  (c-name "clutter_init_error_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_path_node_type_get_type
+  (c-name "clutter_path_node_type_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_script_error_get_type
+  (c-name "clutter_script_error_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_shader_error_get_type
+  (c-name "clutter_shader_error_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_texture_error_get_type
+  (c-name "clutter_texture_error_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_texture_flags_get_type
+  (c-name "clutter_texture_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_texture_quality_get_type
+  (c-name "clutter_texture_quality_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_timeline_direction_get_type
+  (c-name "clutter_timeline_direction_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_gravity_get_type
+  (c-name "clutter_gravity_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_rotate_axis_get_type
+  (c-name "clutter_rotate_axis_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_rotate_direction_get_type
+  (c-name "clutter_rotate_direction_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_request_mode_get_type
+  (c-name "clutter_request_mode_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_animation_mode_get_type
+  (c-name "clutter_animation_mode_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From clutter-fixed.h
+
+(define-function clutter_fixed_get_type
+  (c-name "clutter_fixed_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_param_fixed_get_type
+  (c-name "clutter_param_fixed_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_value_set_fixed
+  (c-name "clutter_value_set_fixed")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("ClutterFixed" "fixed_")
+  )
+)
+
+(define-function clutter_value_get_fixed
+  (c-name "clutter_value_get_fixed")
+  (return-type "ClutterFixed")
+  (parameters
+    '("const-GValue*" "value")
+  )
+)
+
+(define-function clutter_param_spec_fixed
+  (c-name "clutter_param_spec_fixed")
+  (return-type "GParamSpec*")
+  (parameters
+    '("const-gchar*" "name")
+    '("const-gchar*" "nick")
+    '("const-gchar*" "blurb")
+    '("ClutterFixed" "minimum")
+    '("ClutterFixed" "maximum")
+    '("ClutterFixed" "default_value")
+    '("GParamFlags" "flags")
+  )
+)
+
+
+
+;; From clutter-main.h
+
+(define-function clutter_init_error_quark
+  (c-name "clutter_init_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function clutter_base_init
+  (c-name "clutter_base_init")
+  (return-type "none")
+)
+
+(define-function clutter_init
+  (c-name "clutter_init")
+  (return-type "ClutterInitError")
+  (parameters
+    '("int*" "argc")
+    '("char***" "argv")
+  )
+)
+
+(define-function clutter_init_with_args
+  (c-name "clutter_init_with_args")
+  (return-type "ClutterInitError")
+  (parameters
+    '("int*" "argc")
+    '("char***" "argv")
+    '("const-char*" "parameter_string")
+    '("GOptionEntry*" "entries")
+    '("const-char*" "translation_domain")
+    '("GError**" "error")
+  )
+)
+
+(define-function clutter_get_option_group
+  (c-name "clutter_get_option_group")
+  (return-type "GOptionGroup*")
+)
+
+(define-function clutter_get_option_group_without_init
+  (c-name "clutter_get_option_group_without_init")
+  (return-type "GOptionGroup*")
+)
+
+(define-function clutter_main
+  (c-name "clutter_main")
+  (return-type "none")
+)
+
+(define-function clutter_main_quit
+  (c-name "clutter_main_quit")
+  (return-type "none")
+)
+
+(define-function clutter_main_level
+  (c-name "clutter_main_level")
+  (return-type "gint")
+)
+
+(define-function clutter_redraw
+  (c-name "clutter_redraw")
+  (return-type "none")
+  (parameters
+    '("ClutterStage*" "stage")
+  )
+)
+
+(define-function clutter_do_event
+  (c-name "clutter_do_event")
+  (return-type "none")
+  (parameters
+    '("ClutterEvent*" "event")
+  )
+)
+
+(define-function clutter_get_debug_enabled
+  (c-name "clutter_get_debug_enabled")
+  (return-type "gboolean")
+)
+
+(define-function clutter_get_show_fps
+  (c-name "clutter_get_show_fps")
+  (return-type "gboolean")
+)
+
+(define-function clutter_get_timestamp
+  (c-name "clutter_get_timestamp")
+  (return-type "gulong")
+)
+
+(define-function clutter_threads_init
+  (c-name "clutter_threads_init")
+  (return-type "none")
+)
+
+(define-function clutter_threads_enter
+  (c-name "clutter_threads_enter")
+  (return-type "none")
+)
+
+(define-function clutter_threads_leave
+  (c-name "clutter_threads_leave")
+  (return-type "none")
+)
+
+(define-function clutter_threads_set_lock_functions
+  (c-name "clutter_threads_set_lock_functions")
+  (return-type "none")
+  (parameters
+    '("GCallback" "enter_fn")
+    '("GCallback" "leave_fn")
+  )
+)
+
+(define-function clutter_threads_add_idle
+  (c-name "clutter_threads_add_idle")
+  (return-type "guint")
+  (parameters
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-function clutter_threads_add_idle_full
+  (c-name "clutter_threads_add_idle_full")
+  (return-type "guint")
+  (parameters
+    '("gint" "priority")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
+  )
+)
+
+(define-function clutter_threads_add_timeout
+  (c-name "clutter_threads_add_timeout")
+  (return-type "guint")
+  (parameters
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-function clutter_threads_add_timeout_full
+  (c-name "clutter_threads_add_timeout_full")
+  (return-type "guint")
+  (parameters
+    '("gint" "priority")
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
+  )
+)
+
+(define-function clutter_threads_add_frame_source
+  (c-name "clutter_threads_add_frame_source")
+  (return-type "guint")
+  (parameters
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-function clutter_threads_add_frame_source_full
+  (c-name "clutter_threads_add_frame_source_full")
+  (return-type "guint")
+  (parameters
+    '("gint" "priority")
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
+  )
+)
+
+(define-function clutter_set_motion_events_enabled
+  (c-name "clutter_set_motion_events_enabled")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enable")
+  )
+)
+
+(define-function clutter_get_motion_events_enabled
+  (c-name "clutter_get_motion_events_enabled")
+  (return-type "gboolean")
+)
+
+(define-function clutter_set_motion_events_frequency
+  (c-name "clutter_set_motion_events_frequency")
+  (return-type "none")
+  (parameters
+    '("guint" "frequency")
+  )
+)
+
+(define-function clutter_get_motion_events_frequency
+  (c-name "clutter_get_motion_events_frequency")
+  (return-type "guint")
+)
+
+(define-function clutter_set_default_frame_rate
+  (c-name "clutter_set_default_frame_rate")
+  (return-type "none")
+  (parameters
+    '("guint" "frames_per_sec")
+  )
+)
+
+(define-function clutter_get_default_frame_rate
+  (c-name "clutter_get_default_frame_rate")
+  (return-type "guint")
+)
+
+(define-function clutter_grab_pointer
+  (c-name "clutter_grab_pointer")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "actor")
+  )
+)
+
+(define-function clutter_ungrab_pointer
+  (c-name "clutter_ungrab_pointer")
+  (return-type "none")
+)
+
+(define-function clutter_get_pointer_grab
+  (c-name "clutter_get_pointer_grab")
+  (return-type "ClutterActor*")
+)
+
+(define-function clutter_grab_keyboard
+  (c-name "clutter_grab_keyboard")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "actor")
+  )
+)
+
+(define-function clutter_ungrab_keyboard
+  (c-name "clutter_ungrab_keyboard")
+  (return-type "none")
+)
+
+(define-function clutter_get_keyboard_grab
+  (c-name "clutter_get_keyboard_grab")
+  (return-type "ClutterActor*")
+)
+
+(define-function clutter_clear_glyph_cache
+  (c-name "clutter_clear_glyph_cache")
+  (return-type "none")
+)
+
+(define-function clutter_set_use_mipmapped_text
+  (c-name "clutter_set_use_mipmapped_text")
+  (return-type "none")
+  (parameters
+    '("gboolean" "value")
+  )
+)
+
+(define-function clutter_get_use_mipmapped_text
+  (c-name "clutter_get_use_mipmapped_text")
+  (return-type "gboolean")
+)
+
+(define-function clutter_get_input_device_for_id
+  (c-name "clutter_get_input_device_for_id")
+  (return-type "ClutterInputDevice*")
+  (parameters
+    '("gint" "id")
+  )
+)
+
+(define-function clutter_grab_pointer_for_device
+  (c-name "clutter_grab_pointer_for_device")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "actor")
+    '("gint" "id")
+  )
+)
+
+(define-function clutter_ungrab_pointer_for_device
+  (c-name "clutter_ungrab_pointer_for_device")
+  (return-type "none")
+  (parameters
+    '("gint" "id")
+  )
+)
+
+(define-function clutter_get_font_map
+  (c-name "clutter_get_font_map")
+  (return-type "PangoFontMap*")
+)
+
+
+
+;; From clutter-path.h
+
+(define-function clutter_path_get_type
+  (c-name "clutter_path_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_path_new
+  (c-name "clutter_path_new")
+  (is-constructor-of "ClutterPath")
+  (return-type "ClutterPath*")
+)
+
+(define-function clutter_path_new_with_description
+  (c-name "clutter_path_new_with_description")
+  (return-type "ClutterPath*")
+  (parameters
+    '("const-gchar*" "desc")
+  )
+)
+
+(define-method add_move_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_move_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method add_rel_move_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_rel_move_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method add_line_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_line_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method add_rel_line_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_rel_line_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+  )
+)
+
+(define-method add_curve_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_curve_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x1")
+    '("gint" "y1")
+    '("gint" "x2")
+    '("gint" "y2")
+    '("gint" "x3")
+    '("gint" "y3")
+  )
+)
+
+(define-method add_rel_curve_to
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_rel_curve_to")
+  (return-type "none")
+  (parameters
+    '("gint" "x1")
+    '("gint" "y1")
+    '("gint" "x2")
+    '("gint" "y2")
+    '("gint" "x3")
+    '("gint" "y3")
+  )
+)
+
+(define-method add_close
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_close")
+  (return-type "none")
+)
+
+(define-method add_string
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_string")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-method add_node
+  (of-object "ClutterPath")
+  (c-name "clutter_path_add_node")
+  (return-type "none")
+  (parameters
+    '("const-ClutterPathNode*" "node")
+  )
+)
+
+(define-method get_n_nodes
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_n_nodes")
+  (return-type "guint")
+)
+
+(define-method get_node
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_node")
+  (return-type "none")
+  (parameters
+    '("guint" "index")
+    '("ClutterPathNode*" "node")
+  )
+)
+
+(define-method get_nodes
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_nodes")
+  (return-type "GSList*")
+)
+
+(define-method foreach
+  (of-object "ClutterPath")
+  (c-name "clutter_path_foreach")
+  (return-type "none")
+  (parameters
+    '("ClutterPathCallback" "callback")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-method insert_node
+  (of-object "ClutterPath")
+  (c-name "clutter_path_insert_node")
+  (return-type "none")
+  (parameters
+    '("gint" "index")
+    '("const-ClutterPathNode*" "node")
+  )
+)
+
+(define-method remove_node
+  (of-object "ClutterPath")
+  (c-name "clutter_path_remove_node")
+  (return-type "none")
+  (parameters
+    '("guint" "index")
+  )
+)
+
+(define-method replace_node
+  (of-object "ClutterPath")
+  (c-name "clutter_path_replace_node")
+  (return-type "none")
+  (parameters
+    '("guint" "index")
+    '("const-ClutterPathNode*" "node")
+  )
+)
+
+(define-method get_description
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_description")
+  (return-type "gchar*")
+)
+
+(define-method set_description
+  (of-object "ClutterPath")
+  (c-name "clutter_path_set_description")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-method clear
+  (of-object "ClutterPath")
+  (c-name "clutter_path_clear")
+  (return-type "none")
+)
+
+(define-method get_position
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_position")
+  (return-type "guint")
+  (parameters
+    '("guint" "alpha")
+    '("ClutterKnot*" "position")
+  )
+)
+
+(define-method get_length
+  (of-object "ClutterPath")
+  (c-name "clutter_path_get_length")
+  (return-type "guint")
+)
+
+(define-method copy
+  (of-object "ClutterPathNode")
+  (c-name "clutter_path_node_copy")
+  (return-type "ClutterPathNode*")
+)
+
+(define-method free
+  (of-object "ClutterPathNode")
+  (c-name "clutter_path_node_free")
+  (return-type "none")
+)
+
+(define-method equal
+  (of-object "ClutterPathNode")
+  (c-name "clutter_path_node_equal")
+  (return-type "gboolean")
+  (parameters
+    '("const-ClutterPathNode*" "node_b")
+  )
+)
+
+(define-function clutter_path_node_get_type
+  (c-name "clutter_path_node_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From clutter-interval.h
+
+(define-function clutter_interval_get_type
+  (c-name "clutter_interval_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_interval_new
+  (c-name "clutter_interval_new")
+  (is-constructor-of "ClutterInterval")
+  (return-type "ClutterInterval*")
+  (parameters
+    '("GType" "gtype")
+  )
+  (varargs #t)
+)
+
+(define-function clutter_interval_new_with_values
+  (c-name "clutter_interval_new_with_values")
+  (return-type "ClutterInterval*")
+  (parameters
+    '("GType" "gtype")
+    '("const-GValue*" "initial")
+    '("const-GValue*" "final")
+  )
+)
+
+(define-method clone
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_clone")
+  (return-type "ClutterInterval*")
+)
+
+(define-method get_value_type
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_get_value_type")
+  (return-type "GType")
+)
+
+(define-method set_initial_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_set_initial_value")
+  (return-type "none")
+  (parameters
+    '("const-GValue*" "value")
+  )
+)
+
+(define-method get_initial_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_get_initial_value")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+  )
+)
+
+(define-method peek_initial_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_peek_initial_value")
+  (return-type "GValue*")
+)
+
+(define-method set_final_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_set_final_value")
+  (return-type "none")
   (parameters
-    '("ClutterUnit" "for_width")
-    '("ClutterUnit*" "min_height_p")
-    '("ClutterUnit*" "natural_height_p")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method get_preferred_size
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_preferred_size")
+(define-method get_final_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_get_final_value")
   (return-type "none")
   (parameters
-    '("ClutterUnit*" "min_width_p")
-    '("ClutterUnit*" "min_height_p")
-    '("ClutterUnit*" "natural_width_p")
-    '("ClutterUnit*" "natural_height_p")
+    '("GValue*" "value")
   )
 )
 
-(define-method allocate
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_allocate")
+(define-method peek_final_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_peek_final_value")
+  (return-type "GValue*")
+)
+
+(define-method set_interval
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_set_interval")
   (return-type "none")
   (parameters
-    '("const-ClutterActorBox*" "box")
-    '("gboolean" "absolute_origin_changed")
   )
+  (varargs #t)
 )
 
-(define-method get_allocation_coords
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_allocation_coords")
+(define-method get_interval
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_get_interval")
   (return-type "none")
   (parameters
-    '("gint*" "x1")
-    '("gint*" "y1")
-    '("gint*" "x2")
-    '("gint*" "y2")
   )
+  (varargs #t)
 )
 
-(define-method get_allocation_box
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_allocation_box")
+(define-method validate
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_validate")
+  (return-type "gboolean")
+  (parameters
+    '("GParamSpec*" "pspec")
+  )
+)
+
+(define-method compute_value
+  (of-object "ClutterInterval")
+  (c-name "clutter_interval_compute_value")
   (return-type "none")
   (parameters
-    '("ClutterActorBox*" "box")
+    '("gdouble" "factor")
+    '("GValue*" "value")
   )
 )
 
-(define-method get_allocation_geometry
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_allocation_geometry")
+
+
+;; From clutter-color.h
+
+(define-function clutter_color_new
+  (c-name "clutter_color_new")
+  (is-constructor-of "ClutterColor")
+  (return-type "ClutterColor*")
+  (parameters
+    '("guint8" "red")
+    '("guint8" "green")
+    '("guint8" "blue")
+    '("guint8" "alpha")
+  )
+)
+
+(define-method copy
+  (of-object "ClutterColor")
+  (c-name "clutter_color_copy")
+  (return-type "ClutterColor*")
+)
+
+(define-method free
+  (of-object "ClutterColor")
+  (c-name "clutter_color_free")
   (return-type "none")
+)
+
+(define-function clutter_color_parse
+  (c-name "clutter_color_parse")
+  (return-type "gboolean")
   (parameters
-    '("ClutterGeometry*" "geom")
+    '("const-gchar*" "color")
+    '("ClutterColor*" "dest")
   )
 )
 
-(define-method get_allocation_vertices
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_allocation_vertices")
+(define-method equal
+  (of-object "ClutterColor")
+  (c-name "clutter_color_equal")
+  (return-type "gboolean")
+  (parameters
+    '("const-ClutterColor*" "b")
+  )
+)
+
+(define-method to_string
+  (of-object "ClutterColor")
+  (c-name "clutter_color_to_string")
+  (return-type "gchar*")
+)
+
+(define-function clutter_color_get_type
+  (c-name "clutter_color_get_type")
+  (return-type "GType")
+)
+
+(define-method add
+  (of-object "ClutterColor")
+  (c-name "clutter_color_add")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "ancestor")
-    '("ClutterVertex" "verts[4]")
+    '("const-ClutterColor*" "src2")
+    '("ClutterColor*" "dest")
   )
 )
 
-(define-method get_paint_area
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_paint_area")
+(define-method subtract
+  (of-object "ClutterColor")
+  (c-name "clutter_color_subtract")
   (return-type "none")
   (parameters
-    '("ClutterActorBox*" "box")
+    '("const-ClutterColor*" "src2")
+    '("ClutterColor*" "dest")
   )
 )
 
-(define-method set_geometry
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_geometry")
+(define-method lighten
+  (of-object "ClutterColor")
+  (c-name "clutter_color_lighten")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "dest")
+  )
+)
+
+(define-method darken
+  (of-object "ClutterColor")
+  (c-name "clutter_color_darken")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "dest")
+  )
+)
+
+(define-method shade
+  (of-object "ClutterColor")
+  (c-name "clutter_color_shade")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "dest")
+    '("gdouble" "shade")
+  )
+)
+
+(define-method shadex
+  (of-object "ClutterColor")
+  (c-name "clutter_color_shadex")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "dest")
+    '("ClutterFixed" "shade")
+  )
+)
+
+(define-method to_hlsx
+  (of-object "ClutterColor")
+  (c-name "clutter_color_to_hlsx")
+  (return-type "none")
+  (parameters
+    '("ClutterFixed*" "hue")
+    '("ClutterFixed*" "luminance")
+    '("ClutterFixed*" "saturation")
+  )
+)
+
+(define-method from_hlsx
+  (of-object "ClutterColor")
+  (c-name "clutter_color_from_hlsx")
+  (return-type "none")
+  (parameters
+    '("ClutterFixed" "hue")
+    '("ClutterFixed" "luminance")
+    '("ClutterFixed" "saturation")
+  )
+)
+
+(define-method to_hls
+  (of-object "ClutterColor")
+  (c-name "clutter_color_to_hls")
+  (return-type "none")
+  (parameters
+    '("guint8*" "hue")
+    '("guint8*" "luminance")
+    '("guint8*" "saturation")
+  )
+)
+
+(define-method from_hls
+  (of-object "ClutterColor")
+  (c-name "clutter_color_from_hls")
+  (return-type "none")
+  (parameters
+    '("guint8" "hue")
+    '("guint8" "luminance")
+    '("guint8" "saturation")
+  )
+)
+
+(define-method to_pixel
+  (of-object "ClutterColor")
+  (c-name "clutter_color_to_pixel")
+  (return-type "guint32")
+)
+
+(define-method from_pixel
+  (of-object "ClutterColor")
+  (c-name "clutter_color_from_pixel")
+  (return-type "none")
+  (parameters
+    '("guint32" "pixel")
+  )
+)
+
+(define-function clutter_value_set_color
+  (c-name "clutter_value_set_color")
+  (return-type "none")
+  (parameters
+    '("GValue*" "value")
+    '("const-ClutterColor*" "color")
+  )
+)
+
+(define-function clutter_value_get_color
+  (c-name "clutter_value_get_color")
+  (return-type "const-ClutterColor*")
+  (parameters
+    '("const-GValue*" "value")
+  )
+)
+
+(define-function clutter_param_color_get_type
+  (c-name "clutter_param_color_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_param_spec_color
+  (c-name "clutter_param_spec_color")
+  (return-type "GParamSpec*")
+  (parameters
+    '("const-gchar*" "name")
+    '("const-gchar*" "nick")
+    '("const-gchar*" "blurb")
+    '("const-ClutterColor*" "default_value")
+    '("GParamFlags" "flags")
+  )
+)
+
+
+
+;; From clutter-container.h
+
+(define-function clutter_container_get_type
+  (c-name "clutter_container_get_type")
+  (return-type "GType")
+)
+
+(define-method add
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_add")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "first_actor")
+  )
+  (varargs #t)
+)
+
+(define-method add_actor
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_add_actor")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "actor")
+  )
+)
+
+(define-method add_valist
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_add_valist")
   (return-type "none")
   (parameters
-    '("const-ClutterGeometry*" "geometry")
+    '("ClutterActor*" "first_actor")
+    '("va_list" "var_args")
   )
 )
 
-(define-method get_geometry
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_geometry")
+(define-method remove
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_remove")
   (return-type "none")
   (parameters
-    '("ClutterGeometry*" "geometry")
+    '("ClutterActor*" "first_actor")
   )
+  (varargs #t)
 )
 
-(define-method set_size
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_size")
+(define-method remove_actor
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_remove_actor")
   (return-type "none")
   (parameters
-    '("gint" "width")
-    '("gint" "height")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method set_sizeu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_sizeu")
+(define-method remove_valist
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_remove_valist")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "width")
-    '("ClutterUnit" "height")
+    '("ClutterActor*" "first_actor")
+    '("va_list" "var_args")
   )
 )
 
-(define-method get_size
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_size")
+(define-method get_children
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_get_children")
+  (return-type "GList*")
+)
+
+(define-method foreach
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_foreach")
   (return-type "none")
   (parameters
-    '("guint*" "width")
-    '("guint*" "height")
+    '("ClutterCallback" "callback")
+    '("gpointer" "user_data")
   )
 )
 
-(define-method get_sizeu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_sizeu")
-  (return-type "none")
+(define-method find_child_by_name
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_find_child_by_name")
+  (return-type "ClutterActor*")
   (parameters
-    '("ClutterUnit*" "width")
-    '("ClutterUnit*" "height")
+    '("const-gchar*" "child_name")
   )
 )
 
-(define-method get_transformed_size
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_transformed_size")
+(define-method raise_child
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_raise_child")
   (return-type "none")
   (parameters
-    '("guint*" "width")
-    '("guint*" "height")
+    '("ClutterActor*" "actor")
+    '("ClutterActor*" "sibling")
   )
 )
 
-(define-method get_transformed_sizeu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_transformed_sizeu")
+(define-method lower_child
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_lower_child")
   (return-type "none")
   (parameters
-    '("ClutterUnit*" "width")
-    '("ClutterUnit*" "height")
+    '("ClutterActor*" "actor")
+    '("ClutterActor*" "sibling")
   )
 )
 
-(define-method set_position
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_position")
+(define-method sort_depth_order
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_sort_depth_order")
   (return-type "none")
+)
+
+(define-function clutter_container_class_find_child_property
+  (c-name "clutter_container_class_find_child_property")
+  (return-type "GParamSpec*")
   (parameters
-    '("gint" "x")
-    '("gint" "y")
+    '("GObjectClass*" "klass")
+    '("const-gchar*" "property_name")
   )
 )
 
-(define-method set_positionu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_positionu")
-  (return-type "none")
+(define-function clutter_container_class_list_child_properties
+  (c-name "clutter_container_class_list_child_properties")
+  (return-type "GParamSpec**")
   (parameters
-    '("ClutterUnit" "x")
-    '("ClutterUnit" "y")
+    '("GObjectClass*" "klass")
+    '("guint*" "n_properties")
   )
 )
 
-(define-method get_position
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_position")
-  (return-type "none")
+(define-method get_child_meta
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_get_child_meta")
+  (return-type "ClutterChildMeta*")
   (parameters
-    '("gint*" "x")
-    '("gint*" "y")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method get_positionu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_positionu")
+(define-method child_set_property
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_child_set_property")
   (return-type "none")
   (parameters
-    '("ClutterUnit*" "x")
-    '("ClutterUnit*" "y")
+    '("ClutterActor*" "child")
+    '("const-gchar*" "property")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method get_transformed_position
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_transformed_position")
+(define-method child_get_property
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_child_get_property")
   (return-type "none")
   (parameters
-    '("gint*" "x")
-    '("gint*" "y")
+    '("ClutterActor*" "child")
+    '("const-gchar*" "property")
+    '("GValue*" "value")
   )
 )
 
-(define-method get_transformed_positionu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_transformed_positionu")
+(define-method child_set
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_child_set")
   (return-type "none")
   (parameters
-    '("ClutterUnit*" "x")
-    '("ClutterUnit*" "y")
+    '("ClutterActor*" "actor")
+    '("const-gchar*" "first_prop")
   )
+  (varargs #t)
 )
 
-(define-method get_fixed_position_set
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_fixed_position_set")
-  (return-type "gboolean")
-)
-
-(define-method set_fixed_position_set
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_fixed_position_set")
+(define-method child_get
+  (of-object "ClutterContainer")
+  (c-name "clutter_container_child_get")
   (return-type "none")
   (parameters
-    '("gboolean" "is_set")
+    '("ClutterActor*" "actor")
+    '("const-gchar*" "first_prop")
   )
+  (varargs #t)
 )
 
-(define-method get_width
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_width")
-  (return-type "guint")
-)
 
-(define-method get_widthu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_widthu")
-  (return-type "ClutterUnit")
-)
 
-(define-method get_height
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_height")
-  (return-type "guint")
+;; From clutter-json.h
+
+
+
+;; From clutter-animation.h
+
+(define-function clutter_animation_get_type
+  (c-name "clutter_animation_get_type")
+  (return-type "GType")
 )
 
-(define-method get_heightu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_heightu")
-  (return-type "ClutterUnit")
+(define-function clutter_animation_new
+  (c-name "clutter_animation_new")
+  (is-constructor-of "ClutterAnimation")
+  (return-type "ClutterAnimation*")
 )
 
-(define-method set_width
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_width")
+(define-method set_actor
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_actor")
   (return-type "none")
   (parameters
-    '("guint" "width")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method set_widthu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_widthu")
-  (return-type "none")
-  (parameters
-    '("ClutterUnit" "width")
-  )
+(define-method get_actor
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_actor")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_height
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_height")
+(define-method set_mode
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_mode")
   (return-type "none")
   (parameters
-    '("guint" "height")
+    '("ClutterAnimationMode" "mode")
   )
 )
 
-(define-method set_heightu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_heightu")
+(define-method get_mode
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_mode")
+  (return-type "ClutterAnimationMode")
+)
+
+(define-method set_duration
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_duration")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "height")
+    '("gint" "msecs")
   )
 )
 
-(define-method get_x
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_x")
-  (return-type "gint")
-)
-
-(define-method get_xu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_xu")
-  (return-type "ClutterUnit")
+(define-method get_duration
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_duration")
+  (return-type "guint")
 )
 
-(define-method get_y
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_y")
-  (return-type "gint")
+(define-method set_loop
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_loop")
+  (return-type "none")
+  (parameters
+    '("gboolean" "loop")
+  )
 )
 
-(define-method get_yu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_yu")
-  (return-type "ClutterUnit")
+(define-method get_loop
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_loop")
+  (return-type "gboolean")
 )
 
-(define-method set_x
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_x")
+(define-method set_timeline
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_timeline")
   (return-type "none")
   (parameters
-    '("gint" "x")
+    '("ClutterTimeline*" "timeline")
   )
 )
 
-(define-method set_xu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_xu")
+(define-method get_timeline
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_timeline")
+  (return-type "ClutterTimeline*")
+)
+
+(define-method set_alpha
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_set_alpha")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "x")
+    '("ClutterAlpha*" "alpha")
   )
 )
 
-(define-method set_y
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_y")
+(define-method get_alpha
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_alpha")
+  (return-type "ClutterAlpha*")
+)
+
+(define-method bind_property
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_bind_property")
   (return-type "none")
   (parameters
-    '("gint" "y")
+    '("const-gchar*" "property_name")
+    '("ClutterInterval*" "interval")
   )
 )
 
-(define-method set_yu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_yu")
-  (return-type "none")
+(define-method has_property
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_has_property")
+  (return-type "gboolean")
   (parameters
-    '("ClutterUnit" "y")
+    '("const-gchar*" "property_name")
   )
 )
 
-(define-method set_rotation
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_rotation")
+(define-method update_property
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_update_property")
   (return-type "none")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("gdouble" "angle")
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "z")
+    '("const-gchar*" "property_name")
+    '("ClutterInterval*" "interval")
   )
 )
 
-(define-method set_rotationx
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_rotationx")
+(define-method unbind_property
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_unbind_property")
   (return-type "none")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("ClutterFixed" "angle")
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "z")
+    '("const-gchar*" "property_name")
   )
 )
 
-(define-method set_rotationu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_rotationu")
-  (return-type "none")
+(define-method get_interval
+  (of-object "ClutterAnimation")
+  (c-name "clutter_animation_get_interval")
+  (return-type "ClutterInterval*")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("gdouble" "angle")
-    '("ClutterUnit" "x")
-    '("ClutterUnit" "y")
-    '("ClutterUnit" "z")
+    '("const-gchar*" "property_name")
   )
 )
 
-(define-method get_rotation
+(define-method animate
   (of-object "ClutterActor")
-  (c-name "clutter_actor_get_rotation")
-  (return-type "gdouble")
+  (c-name "clutter_actor_animate")
+  (return-type "ClutterAnimation*")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("gint*" "x")
-    '("gint*" "y")
-    '("gint*" "z")
+    '("ClutterAnimationMode" "mode")
+    '("guint" "duration")
+    '("const-gchar*" "first_property_name")
   )
+  (varargs #t)
 )
 
-(define-method get_rotationx
+(define-method animate_with_timeline
   (of-object "ClutterActor")
-  (c-name "clutter_actor_get_rotationx")
-  (return-type "ClutterFixed")
+  (c-name "clutter_actor_animate_with_timeline")
+  (return-type "ClutterAnimation*")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("gint*" "x")
-    '("gint*" "y")
-    '("gint*" "z")
+    '("ClutterAnimationMode" "mode")
+    '("ClutterTimeline*" "timeline")
+    '("const-gchar*" "first_property_name")
   )
+  (varargs #t)
 )
 
-(define-method get_rotationu
+(define-method animate_with_alpha
   (of-object "ClutterActor")
-  (c-name "clutter_actor_get_rotationu")
-  (return-type "gdouble")
+  (c-name "clutter_actor_animate_with_alpha")
+  (return-type "ClutterAnimation*")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("ClutterUnit*" "x")
-    '("ClutterUnit*" "y")
-    '("ClutterUnit*" "z")
+    '("ClutterAlpha*" "alpha")
+    '("const-gchar*" "first_property_name")
   )
+  (varargs #t)
 )
 
-(define-method set_opacity
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_opacity")
+
+
+;; From clutter-stage-manager.h
+
+(define-function clutter_stage_manager_get_type
+  (c-name "clutter_stage_manager_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_stage_manager_get_default
+  (c-name "clutter_stage_manager_get_default")
+  (return-type "ClutterStageManager*")
+)
+
+(define-method set_default_stage
+  (of-object "ClutterStageManager")
+  (c-name "clutter_stage_manager_set_default_stage")
   (return-type "none")
   (parameters
-    '("guint8" "opacity")
+    '("ClutterStage*" "stage")
   )
 )
 
-(define-method get_opacity
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_opacity")
-  (return-type "guint8")
+(define-method get_default_stage
+  (of-object "ClutterStageManager")
+  (c-name "clutter_stage_manager_get_default_stage")
+  (return-type "ClutterStage*")
 )
 
-(define-method get_paint_opacity
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_paint_opacity")
-  (return-type "guint8")
+(define-method list_stages
+  (of-object "ClutterStageManager")
+  (c-name "clutter_stage_manager_list_stages")
+  (return-type "GSList*")
 )
 
-(define-method set_name
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_name")
+
+
+;; From clutter-shader.h
+
+(define-function clutter_shader_error_quark
+  (c-name "clutter_shader_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function clutter_shader_get_type
+  (c-name "clutter_shader_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_shader_new
+  (c-name "clutter_shader_new")
+  (is-constructor-of "ClutterShader")
+  (return-type "ClutterShader*")
+)
+
+(define-method set_is_enabled
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_set_is_enabled")
   (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("gboolean" "enabled")
   )
 )
 
-(define-method get_name
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_name")
-  (return-type "const-gchar*")
+(define-method get_is_enabled
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_is_enabled")
+  (return-type "gboolean")
 )
 
-(define-method get_gid
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_gid")
-  (return-type "guint32")
+(define-method compile
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_compile")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
 )
 
-(define-method set_clip
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_clip")
+(define-method release
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_release")
+  (return-type "none")
+)
+
+(define-method is_compiled
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_is_compiled")
+  (return-type "gboolean")
+)
+
+(define-method set_vertex_source
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_set_vertex_source")
   (return-type "none")
   (parameters
-    '("gint" "xoff")
-    '("gint" "yoff")
-    '("gint" "width")
-    '("gint" "height")
+    '("const-gchar*" "data")
+    '("gssize" "length")
   )
 )
 
-(define-method set_clipu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_clipu")
+(define-method set_fragment_source
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_set_fragment_source")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "xoff")
-    '("ClutterUnit" "yoff")
-    '("ClutterUnit" "width")
-    '("ClutterUnit" "height")
+    '("const-gchar*" "data")
+    '("gssize" "length")
   )
 )
 
-(define-method remove_clip
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_remove_clip")
+(define-method get_vertex_source
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_vertex_source")
+  (return-type "const-gchar*")
+)
+
+(define-method get_fragment_source
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_fragment_source")
+  (return-type "const-gchar*")
+)
+
+(define-method set_uniform
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_set_uniform")
   (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+    '("const-GValue*" "value")
+  )
 )
 
-(define-method has_clip
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_has_clip")
-  (return-type "gboolean")
+(define-method get_cogl_program
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_cogl_program")
+  (return-type "CoglHandle")
 )
 
-(define-method get_clip
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_clip")
+(define-method get_cogl_fragment_shader
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_cogl_fragment_shader")
+  (return-type "CoglHandle")
+)
+
+(define-method get_cogl_vertex_shader
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_get_cogl_vertex_shader")
+  (return-type "CoglHandle")
+)
+
+(define-method set_uniform_1f
+  (of-object "ClutterShader")
+  (c-name "clutter_shader_set_uniform_1f")
   (return-type "none")
   (parameters
-    '("gint*" "xoff")
-    '("gint*" "yoff")
-    '("gint*" "width")
-    '("gint*" "height")
+    '("const-gchar*" "name")
+    '("gfloat" "value")
   )
 )
 
-(define-method get_clipu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_clipu")
-  (return-type "none")
-  (parameters
-    '("ClutterUnit*" "xoff")
-    '("ClutterUnit*" "yoff")
-    '("ClutterUnit*" "width")
-    '("ClutterUnit*" "height")
-  )
+
+
+;; From clutter-event.h
+
+(define-function clutter_event_get_type
+  (c-name "clutter_event_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_events_pending
+  (c-name "clutter_events_pending")
+  (return-type "gboolean")
+)
+
+(define-function clutter_event_get
+  (c-name "clutter_event_get")
+  (return-type "ClutterEvent*")
+)
+
+(define-function clutter_event_peek
+  (c-name "clutter_event_peek")
+  (return-type "ClutterEvent*")
 )
 
-(define-method set_parent
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_parent")
+(define-method put
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_put")
   (return-type "none")
+)
+
+(define-function clutter_event_new
+  (c-name "clutter_event_new")
+  (is-constructor-of "ClutterEvent")
+  (return-type "ClutterEvent*")
   (parameters
-    '("ClutterActor*" "parent")
+    '("ClutterEventType" "type")
   )
 )
 
-(define-method get_parent
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_parent")
-  (return-type "ClutterActor*")
+(define-method copy
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_copy")
+  (return-type "ClutterEvent*")
 )
 
-(define-method reparent
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_reparent")
+(define-method free
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_free")
   (return-type "none")
-  (parameters
-    '("ClutterActor*" "new_parent")
-  )
 )
 
-(define-method unparent
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_unparent")
-  (return-type "none")
+(define-method type
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_type")
+  (return-type "ClutterEventType")
 )
 
-(define-method get_stage
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_stage")
-  (return-type "ClutterActor*")
+(define-method get_time
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_time")
+  (return-type "guint32")
 )
 
-(define-method raise
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_raise")
-  (return-type "none")
-  (parameters
-    '("ClutterActor*" "below")
-  )
+(define-method get_state
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_state")
+  (return-type "ClutterModifierType")
 )
 
-(define-method lower
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_lower")
+(define-method get_coords
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_coords")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "above")
+    '("gint*" "x")
+    '("gint*" "y")
   )
 )
 
-(define-method raise_top
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_raise_top")
-  (return-type "none")
+(define-method get_device_id
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_device_id")
+  (return-type "gint")
 )
 
-(define-method lower_bottom
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_lower_bottom")
-  (return-type "none")
+(define-method get_source
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_source")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_depth
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_depth")
-  (return-type "none")
-  (parameters
-    '("gint" "depth")
-  )
+(define-method symbol
+  (of-object "ClutterKeyEvent")
+  (c-name "clutter_key_event_symbol")
+  (return-type "guint")
 )
 
-(define-method get_depth
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_depth")
-  (return-type "gint")
+(define-method code
+  (of-object "ClutterKeyEvent")
+  (c-name "clutter_key_event_code")
+  (return-type "guint16")
 )
 
-(define-method set_depthu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_depthu")
-  (return-type "none")
-  (parameters
-    '("ClutterUnit" "depth")
-  )
+(define-method unicode
+  (of-object "ClutterKeyEvent")
+  (c-name "clutter_key_event_unicode")
+  (return-type "guint32")
 )
 
-(define-method get_depthu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_depthu")
-  (return-type "ClutterUnit")
+(define-method button
+  (of-object "ClutterButtonEvent")
+  (c-name "clutter_button_event_button")
+  (return-type "guint32")
 )
 
-(define-method set_scalex
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_scalex")
-  (return-type "none")
+(define-function clutter_keysym_to_unicode
+  (c-name "clutter_keysym_to_unicode")
+  (return-type "guint32")
   (parameters
-    '("ClutterFixed" "scale_x")
-    '("ClutterFixed" "scale_y")
+    '("guint" "keyval")
   )
 )
 
-(define-method set_scale
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_scale")
-  (return-type "none")
-  (parameters
-    '("gdouble" "scale_x")
-    '("gdouble" "scale_y")
-  )
+(define-method get_stage
+  (of-object "ClutterEvent")
+  (c-name "clutter_event_get_stage")
+  (return-type "ClutterStage*")
 )
 
-(define-method get_scalex
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_scalex")
-  (return-type "none")
-  (parameters
-    '("ClutterFixed*" "scale_x")
-    '("ClutterFixed*" "scale_y")
-  )
-)
 
-(define-method get_scale
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_scale")
-  (return-type "none")
-  (parameters
-    '("gdouble*" "scale_x")
-    '("gdouble*" "scale_y")
-  )
+
+;; From clutter-behaviour-depth.h
+
+(define-function clutter_behaviour_depth_get_type
+  (c-name "clutter_behaviour_depth_get_type")
+  (return-type "GType")
 )
 
-(define-method move_by
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_move_by")
-  (return-type "none")
+(define-function clutter_behaviour_depth_new
+  (c-name "clutter_behaviour_depth_new")
+  (is-constructor-of "ClutterBehaviourDepth")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("gint" "dx")
-    '("gint" "dy")
+    '("ClutterAlpha*" "alpha")
+    '("gint" "depth_start")
+    '("gint" "depth_end")
   )
 )
 
-(define-method move_byu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_move_byu")
+(define-method set_bounds
+  (of-object "ClutterBehaviourDepth")
+  (c-name "clutter_behaviour_depth_set_bounds")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "dx")
-    '("ClutterUnit" "dy")
+    '("gint" "depth_start")
+    '("gint" "depth_end")
   )
 )
 
-(define-method set_reactive
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_reactive")
+(define-method get_bounds
+  (of-object "ClutterBehaviourDepth")
+  (c-name "clutter_behaviour_depth_get_bounds")
   (return-type "none")
   (parameters
-    '("gboolean" "reactive")
+    '("gint*" "depth_start")
+    '("gint*" "depth_end")
   )
 )
 
-(define-method get_reactive
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_reactive")
-  (return-type "gboolean")
-)
 
-(define-method event
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_event")
-  (return-type "gboolean")
-  (parameters
-    '("ClutterEvent*" "event")
-    '("gboolean" "capture")
-  )
-)
 
-(define-function clutter_get_actor_by_gid
-  (c-name "clutter_get_actor_by_gid")
-  (return-type "ClutterActor*")
-  (parameters
-    '("guint32" "id")
-  )
+;; From clutter-model.h
+
+(define-function clutter_model_get_type
+  (c-name "clutter_model_get_type")
+  (return-type "GType")
 )
 
-(define-method set_shader
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_shader")
-  (return-type "gboolean")
+(define-method set_types
+  (of-object "ClutterModel")
+  (c-name "clutter_model_set_types")
+  (return-type "none")
   (parameters
-    '("ClutterShader*" "shader")
+    '("guint" "n_columns")
+    '("GType*" "types")
   )
 )
 
-(define-method get_shader
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_shader")
-  (return-type "ClutterShader*")
+(define-method set_names
+  (of-object "ClutterModel")
+  (c-name "clutter_model_set_names")
+  (return-type "none")
+  (parameters
+    '("guint" "n_columns")
+    '("const-gchar*-const[]" "names")
+  )
 )
 
-(define-method set_shader_param
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_shader_param")
+(define-method append
+  (of-object "ClutterModel")
+  (c-name "clutter_model_append")
   (return-type "none")
   (parameters
-    '("const-gchar*" "param")
-    '("gfloat" "value")
   )
+  (varargs #t)
 )
 
-(define-method set_anchor_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_anchor_point")
+(define-method appendv
+  (of-object "ClutterModel")
+  (c-name "clutter_model_appendv")
   (return-type "none")
   (parameters
-    '("gint" "anchor_x")
-    '("gint" "anchor_y")
+    '("guint" "n_columns")
+    '("guint*" "columns")
+    '("GValue*" "values")
   )
 )
 
-(define-method move_anchor_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_move_anchor_point")
+(define-method prepend
+  (of-object "ClutterModel")
+  (c-name "clutter_model_prepend")
   (return-type "none")
   (parameters
-    '("gint" "anchor_x")
-    '("gint" "anchor_y")
   )
+  (varargs #t)
 )
 
-(define-method get_anchor_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_anchor_point")
+(define-method prependv
+  (of-object "ClutterModel")
+  (c-name "clutter_model_prependv")
   (return-type "none")
   (parameters
-    '("gint*" "anchor_x")
-    '("gint*" "anchor_y")
+    '("guint" "n_columns")
+    '("guint*" "columns")
+    '("GValue*" "values")
   )
 )
 
-(define-method set_anchor_pointu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_anchor_pointu")
+(define-method insert
+  (of-object "ClutterModel")
+  (c-name "clutter_model_insert")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "anchor_x")
-    '("ClutterUnit" "anchor_y")
+    '("guint" "row")
   )
+  (varargs #t)
 )
 
-(define-method move_anchor_pointu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_move_anchor_pointu")
+(define-method insertv
+  (of-object "ClutterModel")
+  (c-name "clutter_model_insertv")
   (return-type "none")
   (parameters
-    '("ClutterUnit" "anchor_x")
-    '("ClutterUnit" "anchor_y")
+    '("guint" "row")
+    '("guint" "n_columns")
+    '("guint*" "columns")
+    '("GValue*" "values")
   )
 )
 
-(define-method get_anchor_pointu
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_anchor_pointu")
+(define-method insert_value
+  (of-object "ClutterModel")
+  (c-name "clutter_model_insert_value")
   (return-type "none")
   (parameters
-    '("ClutterUnit*" "anchor_x")
-    '("ClutterUnit*" "anchor_y")
+    '("guint" "row")
+    '("guint" "column")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method set_anchor_point_from_gravity
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_set_anchor_point_from_gravity")
+(define-method remove
+  (of-object "ClutterModel")
+  (c-name "clutter_model_remove")
   (return-type "none")
   (parameters
-    '("ClutterGravity" "gravity")
+    '("guint" "row")
   )
 )
 
-(define-method move_anchor_point_from_gravity
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_move_anchor_point_from_gravity")
-  (return-type "none")
+(define-method get_n_rows
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_n_rows")
+  (return-type "guint")
+)
+
+(define-method get_n_columns
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_n_columns")
+  (return-type "guint")
+)
+
+(define-method get_column_name
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_column_name")
+  (return-type "const-gchar*")
   (parameters
-    '("ClutterGravity" "gravity")
+    '("guint" "column")
   )
 )
 
-(define-method transform_stage_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_transform_stage_point")
-  (return-type "gboolean")
+(define-method get_column_type
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_column_type")
+  (return-type "GType")
   (parameters
-    '("ClutterUnit" "x")
-    '("ClutterUnit" "y")
-    '("ClutterUnit*" "x_out")
-    '("ClutterUnit*" "y_out")
+    '("guint" "column")
   )
 )
 
-(define-method is_rotated
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_is_rotated")
-  (return-type "gboolean")
+(define-method get_first_iter
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_first_iter")
+  (return-type "ClutterModelIter*")
 )
 
-(define-method is_scaled
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_is_scaled")
-  (return-type "gboolean")
+(define-method get_last_iter
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_last_iter")
+  (return-type "ClutterModelIter*")
 )
 
-(define-method should_pick_paint
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_should_pick_paint")
-  (return-type "gboolean")
+(define-method get_iter_at_row
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_iter_at_row")
+  (return-type "ClutterModelIter*")
+  (parameters
+    '("guint" "row")
+  )
 )
 
-(define-function clutter_actor_box_get_from_vertices
-  (c-name "clutter_actor_box_get_from_vertices")
+(define-method set_sorting_column
+  (of-object "ClutterModel")
+  (c-name "clutter_model_set_sorting_column")
   (return-type "none")
   (parameters
-    '("ClutterVertex" "vtx[4]")
-    '("ClutterActorBox*" "box")
+    '("gint" "column")
   )
 )
 
-(define-method get_abs_allocation_vertices
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_get_abs_allocation_vertices")
+(define-method get_sorting_column
+  (of-object "ClutterModel")
+  (c-name "clutter_model_get_sorting_column")
+  (return-type "gint")
+)
+
+(define-method foreach
+  (of-object "ClutterModel")
+  (c-name "clutter_model_foreach")
   (return-type "none")
   (parameters
-    '("ClutterVertex" "verts[4]")
+    '("ClutterModelForeachFunc" "func")
+    '("gpointer" "user_data")
   )
 )
 
-(define-method apply_transform_to_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_apply_transform_to_point")
+(define-method set_sort
+  (of-object "ClutterModel")
+  (c-name "clutter_model_set_sort")
   (return-type "none")
   (parameters
-    '("ClutterVertex*" "point")
-    '("ClutterVertex*" "vertex")
+    '("guint" "column")
+    '("ClutterModelSortFunc" "func")
+    '("gpointer" "user_data")
+    '("GDestroyNotify" "notify")
   )
 )
 
-(define-method apply_relative_transform_to_point
-  (of-object "ClutterActor")
-  (c-name "clutter_actor_apply_relative_transform_to_point")
+(define-method set_filter
+  (of-object "ClutterModel")
+  (c-name "clutter_model_set_filter")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "ancestor")
-    '("ClutterVertex*" "point")
-    '("ClutterVertex*" "vertex")
+    '("ClutterModelFilterFunc" "func")
+    '("gpointer" "user_data")
+    '("GDestroyNotify" "notify")
   )
 )
 
+(define-method resort
+  (of-object "ClutterModel")
+  (c-name "clutter_model_resort")
+  (return-type "none")
+)
 
+(define-method filter_row
+  (of-object "ClutterModel")
+  (c-name "clutter_model_filter_row")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "row")
+  )
+)
 
-;; From clutter-alpha.h
+(define-method filter_iter
+  (of-object "ClutterModel")
+  (c-name "clutter_model_filter_iter")
+  (return-type "gboolean")
+  (parameters
+    '("ClutterModelIter*" "iter")
+  )
+)
 
-(define-function clutter_alpha_get_type
-  (c-name "clutter_alpha_get_type")
+(define-function clutter_model_iter_get_type
+  (c-name "clutter_model_iter_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_alpha_new
-  (c-name "clutter_alpha_new")
-  (is-constructor-of "ClutterAlpha")
-  (return-type "ClutterAlpha*")
+(define-method get
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_get")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
 )
 
-(define-function clutter_alpha_new_full
-  (c-name "clutter_alpha_new_full")
-  (return-type "ClutterAlpha*")
+(define-method get_valist
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_get_valist")
+  (return-type "none")
   (parameters
-    '("ClutterTimeline*" "timeline")
-    '("ClutterAlphaFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "destroy")
+    '("va_list" "args")
   )
 )
 
-(define-method get_alpha
-  (of-object "ClutterAlpha")
-  (c-name "clutter_alpha_get_alpha")
-  (return-type "guint32")
+(define-method get_value
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_get_value")
+  (return-type "none")
+  (parameters
+    '("guint" "column")
+    '("GValue*" "value")
+  )
 )
-
-(define-method set_func
-  (of-object "ClutterAlpha")
-  (c-name "clutter_alpha_set_func")
+
+(define-method set
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_set")
   (return-type "none")
   (parameters
-    '("ClutterAlphaFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "destroy")
   )
+  (varargs #t)
 )
 
-(define-method set_closure
-  (of-object "ClutterAlpha")
-  (c-name "clutter_alpha_set_closure")
+(define-method set_valist
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_set_valist")
   (return-type "none")
   (parameters
-    '("GClosure*" "closure")
+    '("va_list" "args")
   )
 )
 
-(define-method set_timeline
-  (of-object "ClutterAlpha")
-  (c-name "clutter_alpha_set_timeline")
+(define-method set_value
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_set_value")
   (return-type "none")
   (parameters
-    '("ClutterTimeline*" "timeline")
+    '("guint" "column")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method get_timeline
-  (of-object "ClutterAlpha")
-  (c-name "clutter_alpha_get_timeline")
-  (return-type "ClutterTimeline*")
+(define-method is_first
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_is_first")
+  (return-type "gboolean")
 )
 
-(define-function clutter_ramp_inc_func
-  (c-name "clutter_ramp_inc_func")
-  (return-type "guint32")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
-  )
+(define-method is_last
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_is_last")
+  (return-type "gboolean")
 )
 
-(define-function clutter_ramp_dec_func
-  (c-name "clutter_ramp_dec_func")
-  (return-type "guint32")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
-  )
+(define-method next
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_next")
+  (return-type "ClutterModelIter*")
 )
 
-(define-function clutter_ramp_func
-  (c-name "clutter_ramp_func")
-  (return-type "guint32")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
-  )
+(define-method prev
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_prev")
+  (return-type "ClutterModelIter*")
 )
 
-(define-function clutter_sine_func
-  (c-name "clutter_sine_func")
-  (return-type "guint32")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
-  )
+(define-method get_model
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_get_model")
+  (return-type "ClutterModel*")
 )
 
-(define-function clutter_sine_inc_func
-  (c-name "clutter_sine_inc_func")
-  (return-type "guint32")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
-  )
+(define-method get_row
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_get_row")
+  (return-type "guint")
 )
 
-(define-function clutter_sine_dec_func
-  (c-name "clutter_sine_dec_func")
-  (return-type "guint32")
+(define-method copy
+  (of-object "ClutterModelIter")
+  (c-name "clutter_model_iter_copy")
+  (return-type "ClutterModelIter*")
+)
+
+
+
+;; From clutter-util.h
+
+(define-function clutter_util_next_p2
+  (c-name "clutter_util_next_p2")
+  (return-type "int")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("int" "a")
   )
 )
 
-(define-function clutter_sine_half_func
-  (c-name "clutter_sine_half_func")
-  (return-type "guint32")
+
+
+;; From clutter-shader-types.h
+
+(define-function clutter_shader_float_get_type
+  (c-name "clutter_shader_float_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_shader_int_get_type
+  (c-name "clutter_shader_int_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_shader_matrix_get_type
+  (c-name "clutter_shader_matrix_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_value_set_shader_float
+  (c-name "clutter_value_set_shader_float")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("GValue*" "value")
+    '("gint" "size")
+    '("const-gfloat*" "floats")
   )
 )
 
-(define-function clutter_square_func
-  (c-name "clutter_square_func")
-  (return-type "guint32")
+(define-function clutter_value_set_shader_int
+  (c-name "clutter_value_set_shader_int")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("GValue*" "value")
+    '("gint" "size")
+    '("const-gint*" "ints")
   )
 )
 
-(define-function clutter_smoothstep_inc_func
-  (c-name "clutter_smoothstep_inc_func")
-  (return-type "guint32")
+(define-function clutter_value_set_shader_matrix
+  (c-name "clutter_value_set_shader_matrix")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("GValue*" "value")
+    '("gint" "size")
+    '("const-gfloat*" "matrix")
   )
 )
 
-(define-function clutter_smoothstep_dec_func
-  (c-name "clutter_smoothstep_dec_func")
-  (return-type "guint32")
+(define-function clutter_value_get_shader_float
+  (c-name "clutter_value_get_shader_float")
+  (return-type "const-gfloat*")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("const-GValue*" "value")
+    '("gsize*" "length")
   )
 )
 
-(define-function clutter_exp_inc_func
-  (c-name "clutter_exp_inc_func")
-  (return-type "guint32")
+(define-function clutter_value_get_shader_int
+  (c-name "clutter_value_get_shader_int")
+  (return-type "const-COGLint*")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("const-GValue*" "value")
+    '("gsize*" "length")
   )
 )
 
-(define-function clutter_exp_dec_func
-  (c-name "clutter_exp_dec_func")
-  (return-type "guint32")
+(define-function clutter_value_get_shader_matrix
+  (c-name "clutter_value_get_shader_matrix")
+  (return-type "const-GLfloat*")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gpointer" "dummy")
+    '("const-GValue*" "value")
+    '("gsize*" "length")
   )
 )
 
 
 
-;; From clutter-backend.h
+;; From clutter-stage.h
 
-(define-function clutter_backend_get_type
-  (c-name "clutter_backend_get_type")
+(define-function clutter_perspective_get_type
+  (c-name "clutter_perspective_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_get_default_backend
-  (c-name "clutter_get_default_backend")
-  (return-type "ClutterBackend*")
+(define-function clutter_fog_get_type
+  (c-name "clutter_fog_get_type")
+  (return-type "GType")
 )
 
-(define-method set_resolution
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_set_resolution")
-  (return-type "none")
-  (parameters
-    '("gdouble" "dpi")
-  )
+(define-function clutter_stage_get_type
+  (c-name "clutter_stage_get_type")
+  (return-type "GType")
 )
 
-(define-method get_resolution
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_get_resolution")
-  (return-type "gdouble")
+(define-function clutter_stage_get_default
+  (c-name "clutter_stage_get_default")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_double_click_time
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_set_double_click_time")
+(define-function clutter_stage_new
+  (c-name "clutter_stage_new")
+  (is-constructor-of "ClutterStage")
+  (return-type "ClutterActor*")
+)
+
+(define-method set_color
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_color")
   (return-type "none")
   (parameters
-    '("guint" "msec")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_double_click_time
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_get_double_click_time")
-  (return-type "guint")
+(define-method get_color
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_color")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "color")
+  )
 )
 
-(define-method set_double_click_distance
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_set_double_click_distance")
+(define-method set_perspectivex
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_perspectivex")
   (return-type "none")
   (parameters
-    '("guint" "distance")
+    '("ClutterPerspective*" "perspective")
   )
 )
 
-(define-method get_double_click_distance
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_get_double_click_distance")
-  (return-type "guint")
+(define-method get_perspectivex
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_perspectivex")
+  (return-type "none")
+  (parameters
+    '("ClutterPerspective*" "perspective")
+  )
 )
 
-(define-method set_font_options
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_set_font_options")
+(define-method set_perspective
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_perspective")
   (return-type "none")
   (parameters
-    '("cairo_font_options_t*" "options")
+    '("gfloat" "fovy")
+    '("gfloat" "aspect")
+    '("gfloat" "z_near")
+    '("gfloat" "z_far")
   )
 )
 
-(define-method get_font_options
-  (of-object "ClutterBackend")
-  (c-name "clutter_backend_get_font_options")
-  (return-type "cairo_font_options_t*")
+(define-method get_perspective
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_perspective")
+  (return-type "none")
+  (parameters
+    '("gfloat*" "fovy")
+    '("gfloat*" "aspect")
+    '("gfloat*" "z_near")
+    '("gfloat*" "z_far")
+  )
 )
 
+(define-method fullscreen
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_fullscreen")
+  (return-type "none")
+)
 
+(define-method unfullscreen
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_unfullscreen")
+  (return-type "none")
+)
 
-;; From clutter-behaviour-bspline.h
+(define-method show_cursor
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_show_cursor")
+  (return-type "none")
+)
 
-(define-function clutter_behaviour_bspline_get_type
-  (c-name "clutter_behaviour_bspline_get_type")
-  (return-type "GType")
+(define-method hide_cursor
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_hide_cursor")
+  (return-type "none")
 )
 
-(define-function clutter_behaviour_bspline_new
-  (c-name "clutter_behaviour_bspline_new")
-  (is-constructor-of "ClutterBehaviourBspline")
-  (return-type "ClutterBehaviour*")
+(define-method get_actor_at_pos
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_actor_at_pos")
+  (return-type "ClutterActor*")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("const-ClutterKnot*" "knots")
-    '("guint" "n_knots")
+    '("gint" "x")
+    '("gint" "y")
   )
 )
 
-(define-method append_knot
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_append_knot")
-  (return-type "none")
+(define-method read_pixels
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_read_pixels")
+  (return-type "guchar*")
   (parameters
-    '("const-ClutterKnot*" "knot")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
   )
 )
 
-(define-method append_knots
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_append_knots")
-  (return-type "none")
+(define-method event
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_event")
+  (return-type "gboolean")
   (parameters
-    '("const-ClutterKnot*" "first_knot")
+    '("ClutterEvent*" "event")
   )
-  (varargs #t)
 )
 
-(define-method truncate
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_truncate")
+(define-method set_title
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_title")
   (return-type "none")
   (parameters
-    '("guint" "offset")
+    '("const-gchar*" "title")
   )
 )
 
-(define-method join
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_join")
-  (return-type "none")
-  (parameters
-    '("ClutterBehaviourBspline*" "bs2")
-  )
+(define-method get_title
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_title")
+  (return-type "const-gchar*")
 )
 
-(define-method split
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_split")
-  (return-type "ClutterBehaviour*")
+(define-method set_user_resizable
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_user_resizable")
+  (return-type "none")
   (parameters
-    '("guint" "offset")
+    '("gboolean" "resizable")
   )
 )
 
-(define-method clear
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_clear")
-  (return-type "none")
+(define-method get_user_resizable
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_user_resizable")
+  (return-type "gboolean")
 )
 
-(define-method adjust
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_adjust")
+(define-method set_use_fog
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_use_fog")
   (return-type "none")
   (parameters
-    '("guint" "offset")
-    '("ClutterKnot*" "knot")
+    '("gboolean" "fog")
   )
 )
 
-(define-method set_origin
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_set_origin")
-  (return-type "none")
-  (parameters
-    '("ClutterKnot*" "knot")
-  )
+(define-method get_use_fog
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_use_fog")
+  (return-type "gboolean")
 )
 
-(define-method get_origin
-  (of-object "ClutterBehaviourBspline")
-  (c-name "clutter_behaviour_bspline_get_origin")
+(define-method set_fog
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_fog")
   (return-type "none")
   (parameters
-    '("ClutterKnot*" "knot")
+    '("gdouble" "density")
+    '("gdouble" "z_near")
+    '("gdouble" "z_far")
   )
 )
 
-
-
-;; From clutter-behaviour-depth.h
-
-(define-function clutter_behaviour_depth_get_type
-  (c-name "clutter_behaviour_depth_get_type")
-  (return-type "GType")
-)
-
-(define-function clutter_behaviour_depth_new
-  (c-name "clutter_behaviour_depth_new")
-  (is-constructor-of "ClutterBehaviourDepth")
-  (return-type "ClutterBehaviour*")
+(define-method get_fog
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_fog")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gint" "depth_start")
-    '("gint" "depth_end")
+    '("gdouble*" "density")
+    '("gdouble*" "z_near")
+    '("gdouble*" "z_far")
   )
 )
 
-(define-method set_bounds
-  (of-object "ClutterBehaviourDepth")
-  (c-name "clutter_behaviour_depth_set_bounds")
+(define-method set_fogx
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_fogx")
   (return-type "none")
   (parameters
-    '("gint" "depth_start")
-    '("gint" "depth_end")
+    '("ClutterFog*" "fog")
   )
 )
 
-(define-method get_bounds
-  (of-object "ClutterBehaviourDepth")
-  (c-name "clutter_behaviour_depth_get_bounds")
+(define-method get_fogx
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_fogx")
   (return-type "none")
   (parameters
-    '("gint*" "depth_start")
-    '("gint*" "depth_end")
+    '("ClutterFog*" "fog")
   )
 )
 
+(define-method get_resolution
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_resolution")
+  (return-type "gdouble")
+)
 
-
-;; From clutter-behaviour-ellipse.h
-
-(define-function clutter_behaviour_ellipse_get_type
-  (c-name "clutter_behaviour_ellipse_get_type")
-  (return-type "GType")
+(define-method get_resolutionx
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_resolutionx")
+  (return-type "ClutterFixed")
 )
 
-(define-function clutter_behaviour_ellipse_new
-  (c-name "clutter_behaviour_ellipse_new")
-  (is-constructor-of "ClutterBehaviourEllipse")
-  (return-type "ClutterBehaviour*")
+(define-method set_key_focus
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_set_key_focus")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "width")
-    '("gint" "height")
-    '("ClutterRotateDirection" "direction")
-    '("gdouble" "start")
-    '("gdouble" "end")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-function clutter_behaviour_ellipse_newx
-  (c-name "clutter_behaviour_ellipse_newx")
-  (return-type "ClutterBehaviour*")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "width")
-    '("gint" "height")
-    '("ClutterRotateDirection" "direction")
-    '("ClutterFixed" "start")
-    '("ClutterFixed" "end")
-  )
+(define-method get_key_focus
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_get_key_focus")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_center
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_center")
+(define-method ensure_current
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_ensure_current")
   (return-type "none")
-  (parameters
-    '("gint" "x")
-    '("gint" "y")
-  )
 )
 
-(define-method get_center
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_center")
+(define-method queue_redraw
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_queue_redraw")
   (return-type "none")
-  (parameters
-    '("gint*" "x")
-    '("gint*" "y")
-  )
 )
 
-(define-method set_width
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_width")
-  (return-type "none")
-  (parameters
-    '("gint" "width")
-  )
+(define-method is_default
+  (of-object "ClutterStage")
+  (c-name "clutter_stage_is_default")
+  (return-type "gboolean")
 )
 
-(define-method get_width
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_width")
-  (return-type "gint")
+
+
+;; From clutter-child-meta.h
+
+(define-function clutter_child_meta_get_type
+  (c-name "clutter_child_meta_get_type")
+  (return-type "GType")
 )
 
-(define-method set_height
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_height")
-  (return-type "none")
-  (parameters
-    '("gint" "height")
-  )
+(define-method get_container
+  (of-object "ClutterChildMeta")
+  (c-name "clutter_child_meta_get_container")
+  (return-type "ClutterContainer*")
 )
 
-(define-method get_height
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_height")
-  (return-type "gint")
+(define-method get_actor
+  (of-object "ClutterChildMeta")
+  (c-name "clutter_child_meta_get_actor")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_angle_start
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_start")
-  (return-type "none")
-  (parameters
-    '("gdouble" "angle_start")
-  )
+
+
+;; From clutter-score.h
+
+(define-function clutter_score_get_type
+  (c-name "clutter_score_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_score_new
+  (c-name "clutter_score_new")
+  (is-constructor-of "ClutterScore")
+  (return-type "ClutterScore*")
 )
 
-(define-method set_angle_startx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_startx")
+(define-method set_loop
+  (of-object "ClutterScore")
+  (c-name "clutter_score_set_loop")
   (return-type "none")
   (parameters
-    '("ClutterFixed" "angle_start")
+    '("gboolean" "loop")
   )
 )
 
-(define-method get_angle_startx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_startx")
-  (return-type "ClutterFixed")
-)
-
-(define-method get_angle_start
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_start")
-  (return-type "gdouble")
+(define-method get_loop
+  (of-object "ClutterScore")
+  (c-name "clutter_score_get_loop")
+  (return-type "gboolean")
 )
 
-(define-method set_angle_endx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_endx")
-  (return-type "none")
+(define-method append
+  (of-object "ClutterScore")
+  (c-name "clutter_score_append")
+  (return-type "gulong")
   (parameters
-    '("ClutterFixed" "angle_end")
+    '("ClutterTimeline*" "parent")
+    '("ClutterTimeline*" "timeline")
   )
 )
 
-(define-method set_angle_end
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_end")
-  (return-type "none")
+(define-method append_at_marker
+  (of-object "ClutterScore")
+  (c-name "clutter_score_append_at_marker")
+  (return-type "gulong")
   (parameters
-    '("gdouble" "angle_end")
+    '("ClutterTimeline*" "parent")
+    '("const-gchar*" "marker_name")
+    '("ClutterTimeline*" "timeline")
   )
 )
 
-(define-method get_angle_endx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_endx")
-  (return-type "ClutterFixed")
-)
-
-(define-method get_angle_end
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_end")
-  (return-type "gdouble")
-)
-
-(define-method set_angle_tiltx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_tiltx")
+(define-method remove
+  (of-object "ClutterScore")
+  (c-name "clutter_score_remove")
   (return-type "none")
   (parameters
-    '("ClutterRotateAxis" "axis")
-    '("ClutterFixed" "angle_tilt")
+    '("gulong" "id")
   )
 )
 
-(define-method set_angle_tilt
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_angle_tilt")
+(define-method remove_all
+  (of-object "ClutterScore")
+  (c-name "clutter_score_remove_all")
   (return-type "none")
-  (parameters
-    '("ClutterRotateAxis" "axis")
-    '("gdouble" "angle_tilt")
-  )
 )
 
-(define-method get_angle_tiltx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_tiltx")
-  (return-type "ClutterFixed")
+(define-method get_timeline
+  (of-object "ClutterScore")
+  (c-name "clutter_score_get_timeline")
+  (return-type "ClutterTimeline*")
   (parameters
-    '("ClutterRotateAxis" "axis")
+    '("gulong" "id")
   )
 )
 
-(define-method get_angle_tilt
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_angle_tilt")
-  (return-type "gdouble")
-  (parameters
-    '("ClutterRotateAxis" "axis")
-  )
+(define-method list_timelines
+  (of-object "ClutterScore")
+  (c-name "clutter_score_list_timelines")
+  (return-type "GSList*")
 )
 
-(define-method set_tilt
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_tilt")
+(define-method start
+  (of-object "ClutterScore")
+  (c-name "clutter_score_start")
   (return-type "none")
-  (parameters
-    '("gdouble" "angle_tilt_x")
-    '("gdouble" "angle_tilt_y")
-    '("gdouble" "angle_tilt_z")
-  )
 )
 
-(define-method set_tiltx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_tiltx")
+(define-method stop
+  (of-object "ClutterScore")
+  (c-name "clutter_score_stop")
   (return-type "none")
-  (parameters
-    '("ClutterFixed" "angle_tilt_x")
-    '("ClutterFixed" "angle_tilt_y")
-    '("ClutterFixed" "angle_tilt_z")
-  )
 )
 
-(define-method get_tilt
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_tilt")
+(define-method pause
+  (of-object "ClutterScore")
+  (c-name "clutter_score_pause")
   (return-type "none")
-  (parameters
-    '("gdouble*" "angle_tilt_x")
-    '("gdouble*" "angle_tilt_y")
-    '("gdouble*" "angle_tilt_z")
-  )
 )
 
-(define-method get_tiltx
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_tiltx")
+(define-method rewind
+  (of-object "ClutterScore")
+  (c-name "clutter_score_rewind")
   (return-type "none")
-  (parameters
-    '("ClutterFixed*" "angle_tilt_x")
-    '("ClutterFixed*" "angle_tilt_y")
-    '("ClutterFixed*" "angle_tilt_z")
-  )
 )
 
-(define-method get_direction
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_get_direction")
-  (return-type "ClutterRotateDirection")
+(define-method is_playing
+  (of-object "ClutterScore")
+  (c-name "clutter_score_is_playing")
+  (return-type "gboolean")
 )
 
-(define-method set_direction
-  (of-object "ClutterBehaviourEllipse")
-  (c-name "clutter_behaviour_ellipse_set_direction")
-  (return-type "none")
+
+
+;; From clutter-effect.h
+
+(define-function clutter_effect_template_get_type
+  (c-name "clutter_effect_template_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_effect_template_new
+  (c-name "clutter_effect_template_new")
+  (is-constructor-of "ClutterEffectTemplate")
+  (return-type "ClutterEffectTemplate*")
   (parameters
-    '("ClutterRotateDirection" "direction")
+    '("ClutterTimeline*" "timeline")
+    '("ClutterAlphaFunc" "alpha_func")
   )
 )
 
+(define-function clutter_effect_template_new_full
+  (c-name "clutter_effect_template_new_full")
+  (return-type "ClutterEffectTemplate*")
+  (parameters
+    '("ClutterTimeline*" "timeline")
+    '("ClutterAlphaFunc" "alpha_func")
+    '("gpointer" "user_data")
+    '("GDestroyNotify" "notify")
+  )
+)
 
-
-;; From clutter-behaviour.h
-
-(define-function clutter_behaviour_get_type
-  (c-name "clutter_behaviour_get_type")
-  (return-type "GType")
+(define-function clutter_effect_template_new_for_duration
+  (c-name "clutter_effect_template_new_for_duration")
+  (return-type "ClutterEffectTemplate*")
+  (parameters
+    '("guint" "msecs")
+    '("ClutterAlphaFunc" "alpha_func")
+  )
 )
 
-(define-method apply
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_apply")
+(define-method construct
+  (of-object "ClutterEffectTemplate")
+  (c-name "clutter_effect_template_construct")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterTimeline*" "timeline")
+    '("ClutterAlphaFunc" "alpha_func")
+    '("gpointer" "user_data")
+    '("GDestroyNotify" "notify")
   )
 )
 
-(define-method remove
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_remove")
+(define-method set_timeline_clone
+  (of-object "ClutterEffectTemplate")
+  (c-name "clutter_effect_template_set_timeline_clone")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("gboolean" "setting")
   )
 )
 
-(define-method remove_all
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_remove_all")
-  (return-type "none")
+(define-method get_timeline_clone
+  (of-object "ClutterEffectTemplate")
+  (c-name "clutter_effect_template_get_timeline_clone")
+  (return-type "gboolean")
 )
 
-(define-method actors_foreach
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_actors_foreach")
-  (return-type "none")
+(define-function clutter_effect_fade
+  (c-name "clutter_effect_fade")
+  (return-type "ClutterTimeline*")
   (parameters
-    '("ClutterBehaviourForeachFunc" "func")
+    '("ClutterEffectTemplate*" "template_")
+    '("ClutterActor*" "actor")
+    '("guint8" "opacity_end")
+    '("ClutterEffectCompleteFunc" "func")
     '("gpointer" "data")
   )
 )
 
-(define-method get_n_actors
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_get_n_actors")
-  (return-type "gint")
+(define-function clutter_effect_depth
+  (c-name "clutter_effect_depth")
+  (return-type "ClutterTimeline*")
+  (parameters
+    '("ClutterEffectTemplate*" "template_")
+    '("ClutterActor*" "actor")
+    '("gint" "depth_end")
+    '("ClutterEffectCompleteFunc" "func")
+    '("gpointer" "data")
+  )
 )
 
-(define-method get_nth_actor
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_get_nth_actor")
-  (return-type "ClutterActor*")
+(define-function clutter_effect_move
+  (c-name "clutter_effect_move")
+  (return-type "ClutterTimeline*")
   (parameters
-    '("gint" "index_")
+    '("ClutterEffectTemplate*" "template_")
+    '("ClutterActor*" "actor")
+    '("gint" "x")
+    '("gint" "y")
+    '("ClutterEffectCompleteFunc" "func")
+    '("gpointer" "data")
   )
 )
 
-(define-method get_actors
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_get_actors")
-  (return-type "GSList*")
-)
-
-(define-method get_alpha
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_get_alpha")
-  (return-type "ClutterAlpha*")
+(define-function clutter_effect_path
+  (c-name "clutter_effect_path")
+  (return-type "ClutterTimeline*")
+  (parameters
+    '("ClutterEffectTemplate*" "template_")
+    '("ClutterActor*" "actor")
+    '("const-ClutterKnot*" "knots")
+    '("guint" "n_knots")
+    '("ClutterEffectCompleteFunc" "func")
+    '("gpointer" "data")
+  )
 )
 
-(define-method set_alpha
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_set_alpha")
-  (return-type "none")
+(define-function clutter_effect_scale
+  (c-name "clutter_effect_scale")
+  (return-type "ClutterTimeline*")
   (parameters
-    '("ClutterAlpha*" "alpha")
+    '("ClutterEffectTemplate*" "template_")
+    '("ClutterActor*" "actor")
+    '("gdouble" "x_scale_end")
+    '("gdouble" "y_scale_end")
+    '("ClutterEffectCompleteFunc" "func")
+    '("gpointer" "data")
   )
 )
 
-(define-method is_applied
-  (of-object "ClutterBehaviour")
-  (c-name "clutter_behaviour_is_applied")
-  (return-type "gboolean")
+(define-function clutter_effect_rotate
+  (c-name "clutter_effect_rotate")
+  (return-type "ClutterTimeline*")
   (parameters
+    '("ClutterEffectTemplate*" "template_")
     '("ClutterActor*" "actor")
+    '("ClutterRotateAxis" "axis")
+    '("gdouble" "angle")
+    '("gint" "center_x")
+    '("gint" "center_y")
+    '("gint" "center_z")
+    '("ClutterRotateDirection" "direction")
+    '("ClutterEffectCompleteFunc" "func")
+    '("gpointer" "data")
   )
 )
 
 
 
-;; From clutter-behaviour-opacity.h
+;; From clutter-group.h
 
-(define-function clutter_behaviour_opacity_get_type
-  (c-name "clutter_behaviour_opacity_get_type")
+(define-function clutter_group_get_type
+  (c-name "clutter_group_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_behaviour_opacity_new
-  (c-name "clutter_behaviour_opacity_new")
-  (is-constructor-of "ClutterBehaviourOpacity")
-  (return-type "ClutterBehaviour*")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("guint8" "opacity_start")
-    '("guint8" "opacity_end")
-  )
+(define-function clutter_group_new
+  (c-name "clutter_group_new")
+  (is-constructor-of "ClutterGroup")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_bounds
-  (of-object "ClutterBehaviourOpacity")
-  (c-name "clutter_behaviour_opacity_set_bounds")
-  (return-type "none")
+(define-method get_nth_child
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_get_nth_child")
+  (return-type "ClutterActor*")
   (parameters
-    '("guint8" "opacity_start")
-    '("guint8" "opacity_end")
+    '("gint" "index_")
   )
 )
 
-(define-method get_bounds
-  (of-object "ClutterBehaviourOpacity")
-  (c-name "clutter_behaviour_opacity_get_bounds")
-  (return-type "none")
-  (parameters
-    '("guint8*" "opacity_start")
-    '("guint8*" "opacity_end")
-  )
+(define-method get_n_children
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_get_n_children")
+  (return-type "gint")
 )
 
-
-
-;; From clutter-behaviour-path.h
-
-(define-function clutter_behaviour_path_get_type
-  (c-name "clutter_behaviour_path_get_type")
-  (return-type "GType")
+(define-method remove_all
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_remove_all")
+  (return-type "none")
 )
 
-(define-function clutter_behaviour_path_new
-  (c-name "clutter_behaviour_path_new")
-  (is-constructor-of "ClutterBehaviourPath")
-  (return-type "ClutterBehaviour*")
+(define-method add_many
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_add_many")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("const-ClutterKnot*" "knots")
-    '("guint" "n_knots")
+    '("ClutterActor*" "first_actor")
   )
+  (varargs #t)
 )
 
-(define-method get_knots
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_get_knots")
-  (return-type "GSList*")
-)
-
-(define-method append_knot
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_append_knot")
+(define-method add_many_valist
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_add_many_valist")
   (return-type "none")
   (parameters
-    '("const-ClutterKnot*" "knot")
+    '("ClutterActor*" "first_actor")
+    '("va_list" "var_args")
   )
 )
 
-(define-method append_knots
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_append_knots")
+(define-method remove
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_remove")
   (return-type "none")
   (parameters
-    '("const-ClutterKnot*" "first_knot")
+    '("ClutterActor*" "actor")
   )
-  (varargs #t)
 )
 
-(define-method insert_knot
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_insert_knot")
+(define-method raise
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_raise")
   (return-type "none")
   (parameters
-    '("guint" "offset")
-    '("const-ClutterKnot*" "knot")
+    '("ClutterActor*" "actor")
+    '("ClutterActor*" "sibling")
   )
 )
 
-(define-method remove_knot
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_remove_knot")
+(define-method lower
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_lower")
   (return-type "none")
   (parameters
-    '("guint" "offset")
+    '("ClutterActor*" "actor")
+    '("ClutterActor*" "sibling")
   )
 )
 
-(define-method clear
-  (of-object "ClutterBehaviourPath")
-  (c-name "clutter_behaviour_path_clear")
+(define-method sort_depth_order
+  (of-object "ClutterGroup")
+  (c-name "clutter_group_sort_depth_order")
   (return-type "none")
 )
 
 
 
-;; From clutter-behaviour-rotate.h
+;; From clutter-units.h
 
-(define-function clutter_behaviour_rotate_get_type
-  (c-name "clutter_behaviour_rotate_get_type")
+(define-function clutter_unit_get_type
+  (c-name "clutter_unit_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_behaviour_rotate_new
-  (c-name "clutter_behaviour_rotate_new")
-  (is-constructor-of "ClutterBehaviourRotate")
-  (return-type "ClutterBehaviour*")
-  (parameters
-    '("ClutterAlpha*" "alpha")
-    '("ClutterRotateAxis" "axis")
-    '("ClutterRotateDirection" "direction")
-    '("gdouble" "angle_start")
-    '("gdouble" "angle_end")
-  )
+(define-function clutter_param_unit_get_type
+  (c-name "clutter_param_unit_get_type")
+  (return-type "GType")
 )
 
-(define-function clutter_behaviour_rotate_newx
-  (c-name "clutter_behaviour_rotate_newx")
-  (return-type "ClutterBehaviour*")
+(define-function clutter_value_set_unit
+  (c-name "clutter_value_set_unit")
+  (return-type "none")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("ClutterRotateAxis" "axis")
-    '("ClutterRotateDirection" "direction")
-    '("ClutterFixed" "angle_start")
-    '("ClutterFixed" "angle_end")
+    '("GValue*" "value")
+    '("ClutterUnit" "units")
   )
 )
 
-(define-method get_center
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_get_center")
-  (return-type "none")
+(define-function clutter_value_get_unit
+  (c-name "clutter_value_get_unit")
+  (return-type "ClutterUnit")
   (parameters
-    '("gint*" "x")
-    '("gint*" "y")
-    '("gint*" "z")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method set_center
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_set_center")
-  (return-type "none")
+(define-function clutter_param_spec_unit
+  (c-name "clutter_param_spec_unit")
+  (return-type "GParamSpec*")
   (parameters
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "z")
+    '("const-gchar*" "name")
+    '("const-gchar*" "nick")
+    '("const-gchar*" "blurb")
+    '("ClutterUnit" "minimum")
+    '("ClutterUnit" "maximum")
+    '("ClutterUnit" "default_value")
+    '("GParamFlags" "flags")
   )
 )
 
-(define-method get_axis
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_get_axis")
-  (return-type "ClutterRotateAxis")
-)
 
-(define-method set_axis
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_set_axis")
-  (return-type "none")
-  (parameters
-    '("ClutterRotateAxis" "axis")
-  )
+
+;; From clutter-texture.h
+
+(define-function clutter_texture_error_quark
+  (c-name "clutter_texture_error_quark")
+  (return-type "GQuark")
 )
 
-(define-method get_direction
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_get_direction")
-  (return-type "ClutterRotateDirection")
+(define-function clutter_texture_get_type
+  (c-name "clutter_texture_get_type")
+  (return-type "GType")
 )
 
-(define-method set_direction
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_set_direction")
-  (return-type "none")
-  (parameters
-    '("ClutterRotateDirection" "direction")
-  )
+(define-function clutter_texture_handle_get_type
+  (c-name "clutter_texture_handle_get_type")
+  (return-type "GType")
 )
 
-(define-method get_bounds
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_get_bounds")
-  (return-type "none")
-  (parameters
-    '("gdouble*" "angle_start")
-    '("gdouble*" "angle_end")
-  )
+(define-function clutter_texture_new
+  (c-name "clutter_texture_new")
+  (is-constructor-of "ClutterTexture")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_bounds
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_set_bounds")
-  (return-type "none")
+(define-function clutter_texture_new_from_file
+  (c-name "clutter_texture_new_from_file")
+  (return-type "ClutterActor*")
   (parameters
-    '("gdouble" "angle_start")
-    '("gdouble" "angle_end")
+    '("const-gchar*" "filename")
+    '("GError**" "error")
   )
 )
 
-(define-method get_boundsx
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_get_boundsx")
-  (return-type "none")
+(define-function clutter_texture_new_from_actor
+  (c-name "clutter_texture_new_from_actor")
+  (return-type "ClutterActor*")
   (parameters
-    '("ClutterFixed*" "angle_start")
-    '("ClutterFixed*" "angle_end")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method set_boundsx
-  (of-object "ClutterBehaviourRotate")
-  (c-name "clutter_behaviour_rotate_set_boundsx")
-  (return-type "none")
+(define-method set_from_file
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_from_file")
+  (return-type "gboolean")
   (parameters
-    '("ClutterFixed" "angle_start")
-    '("ClutterFixed" "angle_end")
+    '("const-gchar*" "filename")
+    '("GError**" "error")
   )
 )
 
-
-
-;; From clutter-behaviour-scale.h
-
-(define-function clutter_behaviour_scale_get_type
-  (c-name "clutter_behaviour_scale_get_type")
-  (return-type "GType")
-)
-
-(define-function clutter_behaviour_scale_new
-  (c-name "clutter_behaviour_scale_new")
-  (is-constructor-of "ClutterBehaviourScale")
-  (return-type "ClutterBehaviour*")
+(define-method set_from_rgb_data
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_from_rgb_data")
+  (return-type "gboolean")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("gdouble" "x_scale_start")
-    '("gdouble" "y_scale_start")
-    '("gdouble" "x_scale_end")
-    '("gdouble" "y_scale_end")
+    '("const-guchar*" "data")
+    '("gboolean" "has_alpha")
+    '("gint" "width")
+    '("gint" "height")
+    '("gint" "rowstride")
+    '("gint" "bpp")
+    '("ClutterTextureFlags" "flags")
+    '("GError**" "error")
   )
 )
 
-(define-function clutter_behaviour_scale_newx
-  (c-name "clutter_behaviour_scale_newx")
-  (return-type "ClutterBehaviour*")
+(define-method set_from_yuv_data
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_from_yuv_data")
+  (return-type "gboolean")
   (parameters
-    '("ClutterAlpha*" "alpha")
-    '("ClutterFixed" "x_scale_start")
-    '("ClutterFixed" "y_scale_start")
-    '("ClutterFixed" "x_scale_end")
-    '("ClutterFixed" "y_scale_end")
+    '("const-guchar*" "data")
+    '("gint" "width")
+    '("gint" "height")
+    '("ClutterTextureFlags" "flags")
+    '("GError**" "error")
   )
 )
 
-(define-method set_bounds
-  (of-object "ClutterBehaviourScale")
-  (c-name "clutter_behaviour_scale_set_bounds")
-  (return-type "none")
+(define-method set_area_from_rgb_data
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_area_from_rgb_data")
+  (return-type "gboolean")
   (parameters
-    '("gdouble" "x_scale_start")
-    '("gdouble" "y_scale_start")
-    '("gdouble" "x_scale_end")
-    '("gdouble" "y_scale_end")
+    '("const-guchar*" "data")
+    '("gboolean" "has_alpha")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("gint" "rowstride")
+    '("gint" "bpp")
+    '("ClutterTextureFlags" "flags")
+    '("GError**" "error")
   )
 )
 
-(define-method set_boundsx
-  (of-object "ClutterBehaviourScale")
-  (c-name "clutter_behaviour_scale_set_boundsx")
+(define-method get_base_size
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_get_base_size")
   (return-type "none")
   (parameters
-    '("ClutterFixed" "x_scale_start")
-    '("ClutterFixed" "y_scale_start")
-    '("ClutterFixed" "x_scale_end")
-    '("ClutterFixed" "y_scale_end")
+    '("gint*" "width")
+    '("gint*" "height")
   )
 )
 
-(define-method get_bounds
-  (of-object "ClutterBehaviourScale")
-  (c-name "clutter_behaviour_scale_get_bounds")
+(define-method set_filter_quality
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_filter_quality")
   (return-type "none")
   (parameters
-    '("gdouble*" "x_scale_start")
-    '("gdouble*" "y_scale_start")
-    '("gdouble*" "x_scale_end")
-    '("gdouble*" "y_scale_end")
+    '("ClutterTextureQuality" "filter_quality")
   )
 )
 
-(define-method get_boundsx
-  (of-object "ClutterBehaviourScale")
-  (c-name "clutter_behaviour_scale_get_boundsx")
+(define-method get_filter_quality
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_get_filter_quality")
+  (return-type "ClutterTextureQuality")
+)
+
+(define-method set_max_tile_waste
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_max_tile_waste")
   (return-type "none")
   (parameters
-    '("ClutterFixed*" "x_scale_start")
-    '("ClutterFixed*" "y_scale_start")
-    '("ClutterFixed*" "x_scale_end")
-    '("ClutterFixed*" "y_scale_end")
+    '("gint" "max_tile_waste")
   )
 )
 
-
-
-;; From clutter-child-meta.h
-
-(define-function clutter_child_meta_get_type
-  (c-name "clutter_child_meta_get_type")
-  (return-type "GType")
+(define-method get_max_tile_waste
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_get_max_tile_waste")
+  (return-type "gint")
 )
 
-(define-method get_container
-  (of-object "ClutterChildMeta")
-  (c-name "clutter_child_meta_get_container")
-  (return-type "ClutterContainer*")
+(define-method get_cogl_texture
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_get_cogl_texture")
+  (return-type "CoglHandle")
 )
 
-(define-method get_actor
-  (of-object "ClutterChildMeta")
-  (c-name "clutter_child_meta_get_actor")
-  (return-type "ClutterActor*")
+(define-method set_cogl_texture
+  (of-object "ClutterTexture")
+  (c-name "clutter_texture_set_cogl_texture")
+  (return-type "none")
+  (parameters
+    '("CoglHandle" "cogl_tex")
+  )
 )
 
 
 
-;; From clutter-clone-texture.h
+;; From clutter-behaviour.h
 
-(define-function clutter_clone_texture_get_type
-  (c-name "clutter_clone_texture_get_type")
+(define-function clutter_behaviour_get_type
+  (c-name "clutter_behaviour_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_clone_texture_new
-  (c-name "clutter_clone_texture_new")
-  (is-constructor-of "ClutterCloneTexture")
-  (return-type "ClutterActor*")
+(define-method apply
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_apply")
+  (return-type "none")
   (parameters
-    '("ClutterTexture*" "texture")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method get_parent_texture
-  (of-object "ClutterCloneTexture")
-  (c-name "clutter_clone_texture_get_parent_texture")
-  (return-type "ClutterTexture*")
+(define-method remove
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_remove")
+  (return-type "none")
+  (parameters
+    '("ClutterActor*" "actor")
+  )
 )
 
-(define-method set_parent_texture
-  (of-object "ClutterCloneTexture")
-  (c-name "clutter_clone_texture_set_parent_texture")
+(define-method remove_all
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_remove_all")
+  (return-type "none")
+)
+
+(define-method actors_foreach
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_actors_foreach")
   (return-type "none")
   (parameters
-    '("ClutterTexture*" "texture")
+    '("ClutterBehaviourForeachFunc" "func")
+    '("gpointer" "data")
   )
 )
 
+(define-method get_n_actors
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_get_n_actors")
+  (return-type "gint")
+)
 
+(define-method get_nth_actor
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_get_nth_actor")
+  (return-type "ClutterActor*")
+  (parameters
+    '("gint" "index_")
+  )
+)
 
-;; From clutter-color.h
-
-(define-method copy
-  (of-object "ClutterColor")
-  (c-name "clutter_color_copy")
-  (return-type "ClutterColor*")
+(define-method get_actors
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_get_actors")
+  (return-type "GSList*")
 )
 
-(define-method free
-  (of-object "ClutterColor")
-  (c-name "clutter_color_free")
-  (return-type "none")
+(define-method get_alpha
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_get_alpha")
+  (return-type "ClutterAlpha*")
 )
 
-(define-function clutter_color_parse
-  (c-name "clutter_color_parse")
-  (return-type "gboolean")
+(define-method set_alpha
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_set_alpha")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "color")
-    '("ClutterColor*" "dest")
+    '("ClutterAlpha*" "alpha")
   )
 )
 
-(define-method equal
-  (of-object "ClutterColor")
-  (c-name "clutter_color_equal")
+(define-method is_applied
+  (of-object "ClutterBehaviour")
+  (c-name "clutter_behaviour_is_applied")
   (return-type "gboolean")
   (parameters
-    '("const-ClutterColor*" "b")
+    '("ClutterActor*" "actor")
   )
 )
 
-(define-method to_string
-  (of-object "ClutterColor")
-  (c-name "clutter_color_to_string")
-  (return-type "gchar*")
-)
 
-(define-function clutter_color_get_type
-  (c-name "clutter_color_get_type")
+
+;; From clutter-media.h
+
+(define-function clutter_media_get_type
+  (c-name "clutter_media_get_type")
   (return-type "GType")
 )
 
-(define-method add
-  (of-object "ClutterColor")
-  (c-name "clutter_color_add")
+(define-method set_uri
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_set_uri")
   (return-type "none")
   (parameters
-    '("const-ClutterColor*" "src2")
-    '("ClutterColor*" "dest")
+    '("const-char*" "uri")
   )
 )
 
-(define-method subtract
-  (of-object "ClutterColor")
-  (c-name "clutter_color_subtract")
-  (return-type "none")
-  (parameters
-    '("const-ClutterColor*" "src2")
-    '("ClutterColor*" "dest")
-  )
+(define-method get_uri
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_uri")
+  (return-type "const-char*")
 )
 
-(define-method lighten
-  (of-object "ClutterColor")
-  (c-name "clutter_color_lighten")
+(define-method set_playing
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_set_playing")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "dest")
+    '("gboolean" "playing")
   )
 )
 
-(define-method darken
-  (of-object "ClutterColor")
-  (c-name "clutter_color_darken")
-  (return-type "none")
-  (parameters
-    '("ClutterColor*" "dest")
-  )
+(define-method get_playing
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_playing")
+  (return-type "gboolean")
 )
 
-(define-method shade
-  (of-object "ClutterColor")
-  (c-name "clutter_color_shade")
+(define-method set_position
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_set_position")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "dest")
-    '("gdouble" "shade")
+    '("int" "position")
   )
 )
 
-(define-method shadex
-  (of-object "ClutterColor")
-  (c-name "clutter_color_shadex")
-  (return-type "none")
-  (parameters
-    '("ClutterColor*" "dest")
-    '("ClutterFixed" "shade")
-  )
+(define-method get_position
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_position")
+  (return-type "int")
 )
 
-(define-method to_hlsx
-  (of-object "ClutterColor")
-  (c-name "clutter_color_to_hlsx")
+(define-method set_volume
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_set_volume")
   (return-type "none")
   (parameters
-    '("ClutterFixed*" "hue")
-    '("ClutterFixed*" "luminance")
-    '("ClutterFixed*" "saturation")
+    '("double" "volume")
   )
 )
 
-(define-method from_hlsx
-  (of-object "ClutterColor")
-  (c-name "clutter_color_from_hlsx")
-  (return-type "none")
-  (parameters
-    '("ClutterFixed" "hue")
-    '("ClutterFixed" "luminance")
-    '("ClutterFixed" "saturation")
-  )
+(define-method get_volume
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_volume")
+  (return-type "double")
 )
 
-(define-method to_hls
-  (of-object "ClutterColor")
-  (c-name "clutter_color_to_hls")
-  (return-type "none")
-  (parameters
-    '("guint8*" "hue")
-    '("guint8*" "luminance")
-    '("guint8*" "saturation")
-  )
+(define-method get_can_seek
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_can_seek")
+  (return-type "gboolean")
 )
 
-(define-method from_hls
-  (of-object "ClutterColor")
-  (c-name "clutter_color_from_hls")
-  (return-type "none")
-  (parameters
-    '("guint8" "hue")
-    '("guint8" "luminance")
-    '("guint8" "saturation")
-  )
+(define-method get_buffer_percent
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_buffer_percent")
+  (return-type "int")
 )
 
-(define-method to_pixel
-  (of-object "ClutterColor")
-  (c-name "clutter_color_to_pixel")
-  (return-type "guint32")
+(define-method get_duration
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_get_duration")
+  (return-type "int")
 )
 
-(define-method from_pixel
-  (of-object "ClutterColor")
-  (c-name "clutter_color_from_pixel")
+(define-method set_filename
+  (of-object "ClutterMedia")
+  (c-name "clutter_media_set_filename")
   (return-type "none")
   (parameters
-    '("guint32" "pixel")
+    '("const-gchar*" "filename")
   )
 )
 
 
 
-;; From clutter-container.h
+;; From clutter-script.h
 
-(define-function clutter_container_get_type
-  (c-name "clutter_container_get_type")
+(define-function clutter_script_error_quark
+  (c-name "clutter_script_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function clutter_script_get_type
+  (c-name "clutter_script_get_type")
   (return-type "GType")
 )
 
-(define-method add
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_add")
-  (return-type "none")
+(define-function clutter_script_new
+  (c-name "clutter_script_new")
+  (is-constructor-of "ClutterScript")
+  (return-type "ClutterScript*")
+)
+
+(define-method load_from_file
+  (of-object "ClutterScript")
+  (c-name "clutter_script_load_from_file")
+  (return-type "guint")
   (parameters
-    '("ClutterActor*" "first_actor")
+    '("const-gchar*" "filename")
+    '("GError**" "error")
   )
-  (varargs #t)
 )
 
-(define-method add_actor
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_add_actor")
-  (return-type "none")
+(define-method load_from_data
+  (of-object "ClutterScript")
+  (c-name "clutter_script_load_from_data")
+  (return-type "guint")
   (parameters
-    '("ClutterActor*" "actor")
+    '("const-gchar*" "data")
+    '("gssize" "length")
+    '("GError**" "error")
   )
 )
 
-(define-method add_valist
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_add_valist")
-  (return-type "none")
+(define-method get_object
+  (of-object "ClutterScript")
+  (c-name "clutter_script_get_object")
+  (return-type "GObject*")
   (parameters
-    '("ClutterActor*" "first_actor")
-    '("va_list" "var_args")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method remove
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_remove")
-  (return-type "none")
+(define-method get_objects
+  (of-object "ClutterScript")
+  (c-name "clutter_script_get_objects")
+  (return-type "gint")
   (parameters
-    '("ClutterActor*" "first_actor")
+    '("const-gchar*" "first_name")
   )
   (varargs #t)
 )
 
-(define-method remove_actor
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_remove_actor")
-  (return-type "none")
-  (parameters
-    '("ClutterActor*" "actor")
-  )
+(define-method list_objects
+  (of-object "ClutterScript")
+  (c-name "clutter_script_list_objects")
+  (return-type "GList*")
 )
 
-(define-method remove_valist
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_remove_valist")
+(define-method unmerge_objects
+  (of-object "ClutterScript")
+  (c-name "clutter_script_unmerge_objects")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "first_actor")
-    '("va_list" "var_args")
+    '("guint" "merge_id")
   )
 )
 
-(define-method get_children
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_get_children")
-  (return-type "GList*")
+(define-method ensure_objects
+  (of-object "ClutterScript")
+  (c-name "clutter_script_ensure_objects")
+  (return-type "none")
 )
 
-(define-method foreach
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_foreach")
-  (return-type "none")
+(define-method get_type_from_name
+  (of-object "ClutterScript")
+  (c-name "clutter_script_get_type_from_name")
+  (return-type "GType")
   (parameters
-    '("ClutterCallback" "callback")
-    '("gpointer" "user_data")
+    '("const-gchar*" "type_name")
   )
 )
 
-(define-method find_child_by_name
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_find_child_by_name")
-  (return-type "ClutterActor*")
+(define-function clutter_get_script_id
+  (c-name "clutter_get_script_id")
+  (return-type "const-gchar*")
   (parameters
-    '("const-gchar*" "child_name")
+    '("GObject*" "gobject")
   )
 )
 
-(define-method raise_child
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_raise_child")
+(define-method connect_signals
+  (of-object "ClutterScript")
+  (c-name "clutter_script_connect_signals")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("ClutterActor*" "sibling")
+    '("gpointer" "user_data")
   )
 )
 
-(define-method lower_child
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_lower_child")
+(define-method connect_signals_full
+  (of-object "ClutterScript")
+  (c-name "clutter_script_connect_signals_full")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("ClutterActor*" "sibling")
+    '("ClutterScriptConnectFunc" "func")
+    '("gpointer" "user_data")
   )
 )
 
-(define-method sort_depth_order
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_sort_depth_order")
+(define-method add_search_paths
+  (of-object "ClutterScript")
+  (c-name "clutter_script_add_search_paths")
   (return-type "none")
-)
-
-(define-function clutter_container_class_find_child_property
-  (c-name "clutter_container_class_find_child_property")
-  (return-type "GParamSpec*")
   (parameters
-    '("GObjectClass*" "klass")
-    '("const-gchar*" "property_name")
+    '("const-gchar*-const[]" "paths")
+    '("gsize" "n_paths")
   )
 )
 
-(define-function clutter_container_class_list_child_properties
-  (c-name "clutter_container_class_list_child_properties")
-  (return-type "GParamSpec**")
+(define-method lookup_filename
+  (of-object "ClutterScript")
+  (c-name "clutter_script_lookup_filename")
+  (return-type "gchar*")
   (parameters
-    '("GObjectClass*" "klass")
-    '("guint*" "n_properties")
+    '("const-gchar*" "filename")
   )
 )
 
-(define-method get_child_meta
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_get_child_meta")
-  (return-type "ClutterChildMeta*")
+
+
+;; From clutter-behaviour-rotate.h
+
+(define-function clutter_behaviour_rotate_get_type
+  (c-name "clutter_behaviour_rotate_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_behaviour_rotate_new
+  (c-name "clutter_behaviour_rotate_new")
+  (is-constructor-of "ClutterBehaviourRotate")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterAlpha*" "alpha")
+    '("ClutterRotateAxis" "axis")
+    '("ClutterRotateDirection" "direction")
+    '("gdouble" "angle_start")
+    '("gdouble" "angle_end")
   )
 )
 
-(define-method child_set_property
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_child_set_property")
-  (return-type "none")
+(define-function clutter_behaviour_rotate_newx
+  (c-name "clutter_behaviour_rotate_newx")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("ClutterActor*" "child")
-    '("const-gchar*" "property")
-    '("const-GValue*" "value")
+    '("ClutterAlpha*" "alpha")
+    '("ClutterRotateAxis" "axis")
+    '("ClutterRotateDirection" "direction")
+    '("ClutterFixed" "angle_start")
+    '("ClutterFixed" "angle_end")
   )
 )
 
-(define-method child_get_property
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_child_get_property")
+(define-method get_center
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_get_center")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "child")
-    '("const-gchar*" "property")
-    '("GValue*" "value")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gint*" "z")
   )
 )
 
-(define-method child_set
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_child_set")
+(define-method set_center
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_set_center")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("const-gchar*" "first_prop")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
   )
-  (varargs #t)
 )
 
-(define-method child_get
-  (of-object "ClutterContainer")
-  (c-name "clutter_container_child_get")
+(define-method get_axis
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_get_axis")
+  (return-type "ClutterRotateAxis")
+)
+
+(define-method set_axis
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_set_axis")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("const-gchar*" "first_prop")
+    '("ClutterRotateAxis" "axis")
   )
-  (varargs #t)
 )
 
-
-
-;; From clutter-debug.h
-
-
-
-;; From clutter-deprecated.h
-
-
-
-;; From clutter-effect.h
-
-(define-function clutter_effect_template_get_type
-  (c-name "clutter_effect_template_get_type")
-  (return-type "GType")
+(define-method get_direction
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_get_direction")
+  (return-type "ClutterRotateDirection")
 )
 
-(define-function clutter_effect_template_new
-  (c-name "clutter_effect_template_new")
-  (is-constructor-of "ClutterEffectTemplate")
-  (return-type "ClutterEffectTemplate*")
+(define-method set_direction
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_set_direction")
+  (return-type "none")
   (parameters
-    '("ClutterTimeline*" "timeline")
-    '("ClutterAlphaFunc" "alpha_func")
+    '("ClutterRotateDirection" "direction")
   )
 )
 
-(define-function clutter_effect_template_new_full
-  (c-name "clutter_effect_template_new_full")
-  (return-type "ClutterEffectTemplate*")
+(define-method get_bounds
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_get_bounds")
+  (return-type "none")
   (parameters
-    '("ClutterTimeline*" "timeline")
-    '("ClutterAlphaFunc" "alpha_func")
-    '("gpointer" "user_data")
-    '("GDestroyNotify" "notify")
+    '("gdouble*" "angle_start")
+    '("gdouble*" "angle_end")
   )
 )
 
-(define-function clutter_effect_template_new_for_duration
-  (c-name "clutter_effect_template_new_for_duration")
-  (return-type "ClutterEffectTemplate*")
+(define-method set_bounds
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_set_bounds")
+  (return-type "none")
   (parameters
-    '("guint" "msecs")
-    '("ClutterAlphaFunc" "alpha_func")
+    '("gdouble" "angle_start")
+    '("gdouble" "angle_end")
   )
 )
 
-(define-method construct
-  (of-object "ClutterEffectTemplate")
-  (c-name "clutter_effect_template_construct")
+(define-method get_boundsx
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_get_boundsx")
   (return-type "none")
   (parameters
-    '("ClutterTimeline*" "timeline")
-    '("ClutterAlphaFunc" "alpha_func")
-    '("gpointer" "user_data")
-    '("GDestroyNotify" "notify")
+    '("ClutterFixed*" "angle_start")
+    '("ClutterFixed*" "angle_end")
   )
 )
 
-(define-method set_timeline_clone
-  (of-object "ClutterEffectTemplate")
-  (c-name "clutter_effect_template_set_timeline_clone")
+(define-method set_boundsx
+  (of-object "ClutterBehaviourRotate")
+  (c-name "clutter_behaviour_rotate_set_boundsx")
   (return-type "none")
   (parameters
-    '("gboolean" "setting")
+    '("ClutterFixed" "angle_start")
+    '("ClutterFixed" "angle_end")
   )
 )
 
-(define-method get_timeline_clone
-  (of-object "ClutterEffectTemplate")
-  (c-name "clutter_effect_template_get_timeline_clone")
-  (return-type "gboolean")
-)
 
-(define-function clutter_effect_fade
-  (c-name "clutter_effect_fade")
-  (return-type "ClutterTimeline*")
-  (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("guint8" "opacity_end")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
-  )
-)
 
-(define-function clutter_effect_depth
-  (c-name "clutter_effect_depth")
-  (return-type "ClutterTimeline*")
-  (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("gint" "depth_end")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
-  )
+;; From clutter-scriptable.h
+
+(define-function clutter_scriptable_get_type
+  (c-name "clutter_scriptable_get_type")
+  (return-type "GType")
 )
 
-(define-function clutter_effect_move
-  (c-name "clutter_effect_move")
-  (return-type "ClutterTimeline*")
+(define-method set_id
+  (of-object "ClutterScriptable")
+  (c-name "clutter_scriptable_set_id")
+  (return-type "none")
   (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("gint" "x")
-    '("gint" "y")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
+    '("const-gchar*" "id")
   )
 )
 
-(define-function clutter_effect_path
-  (c-name "clutter_effect_path")
-  (return-type "ClutterTimeline*")
-  (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("const-ClutterKnot*" "knots")
-    '("guint" "n_knots")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
-  )
+(define-method get_id
+  (of-object "ClutterScriptable")
+  (c-name "clutter_scriptable_get_id")
+  (return-type "const-gchar*")
 )
 
-(define-function clutter_effect_scale
-  (c-name "clutter_effect_scale")
-  (return-type "ClutterTimeline*")
+(define-method parse_custom_node
+  (of-object "ClutterScriptable")
+  (c-name "clutter_scriptable_parse_custom_node")
+  (return-type "gboolean")
   (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("gdouble" "x_scale_end")
-    '("gdouble" "y_scale_end")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
+    '("ClutterScript*" "script")
+    '("GValue*" "value")
+    '("const-gchar*" "name")
+    '("JsonNode*" "node")
   )
 )
 
-(define-function clutter_effect_rotate
-  (c-name "clutter_effect_rotate")
-  (return-type "ClutterTimeline*")
+(define-method set_custom_property
+  (of-object "ClutterScriptable")
+  (c-name "clutter_scriptable_set_custom_property")
+  (return-type "none")
   (parameters
-    '("ClutterEffectTemplate*" "template_")
-    '("ClutterActor*" "actor")
-    '("ClutterRotateAxis" "axis")
-    '("gdouble" "angle")
-    '("gint" "center_x")
-    '("gint" "center_y")
-    '("gint" "center_z")
-    '("ClutterRotateDirection" "direction")
-    '("ClutterEffectCompleteFunc" "func")
-    '("gpointer" "data")
+    '("ClutterScript*" "script")
+    '("const-gchar*" "name")
+    '("const-GValue*" "value")
   )
 )
 
 
 
-;; From clutter-entry.h
+;; From clutter-behaviour-opacity.h
 
-(define-function clutter_entry_get_type
-  (c-name "clutter_entry_get_type")
+(define-function clutter_behaviour_opacity_get_type
+  (c-name "clutter_behaviour_opacity_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_entry_new
-  (c-name "clutter_entry_new")
-  (is-constructor-of "ClutterEntry")
-  (return-type "ClutterActor*")
-)
-
-(define-function clutter_entry_new_full
-  (c-name "clutter_entry_new_full")
-  (return-type "ClutterActor*")
+(define-function clutter_behaviour_opacity_new
+  (c-name "clutter_behaviour_opacity_new")
+  (is-constructor-of "ClutterBehaviourOpacity")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("const-gchar*" "font_name")
-    '("const-gchar*" "text")
-    '("const-ClutterColor*" "color")
+    '("ClutterAlpha*" "alpha")
+    '("guint8" "opacity_start")
+    '("guint8" "opacity_end")
   )
 )
 
-(define-function clutter_entry_new_with_text
-  (c-name "clutter_entry_new_with_text")
-  (return-type "ClutterActor*")
+(define-method set_bounds
+  (of-object "ClutterBehaviourOpacity")
+  (c-name "clutter_behaviour_opacity_set_bounds")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "font_name")
-    '("const-gchar*" "text")
+    '("guint8" "opacity_start")
+    '("guint8" "opacity_end")
   )
 )
 
-(define-method set_text
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_text")
+(define-method get_bounds
+  (of-object "ClutterBehaviourOpacity")
+  (c-name "clutter_behaviour_opacity_get_bounds")
   (return-type "none")
   (parameters
-    '("const-gchar*" "text")
+    '("guint8*" "opacity_start")
+    '("guint8*" "opacity_end")
   )
 )
 
-(define-method get_text
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_text")
-  (return-type "const-gchar*")
+
+
+;; From clutter.h
+
+
+
+;; From clutter-behaviour-path.h
+
+(define-function clutter_behaviour_path_get_type
+  (c-name "clutter_behaviour_path_get_type")
+  (return-type "GType")
 )
 
-(define-method set_font_name
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_font_name")
-  (return-type "none")
+(define-function clutter_behaviour_path_new
+  (c-name "clutter_behaviour_path_new")
+  (is-constructor-of "ClutterBehaviourPath")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("const-gchar*" "font_name")
+    '("ClutterAlpha*" "alpha")
+    '("ClutterPath*" "path")
   )
 )
 
-(define-method get_font_name
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_font_name")
-  (return-type "const-gchar*")
+(define-function clutter_behaviour_path_new_with_description
+  (c-name "clutter_behaviour_path_new_with_description")
+  (return-type "ClutterBehaviour*")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("const-gchar*" "desc")
+  )
 )
 
-(define-method set_color
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_color")
-  (return-type "none")
+(define-function clutter_behaviour_path_new_with_knots
+  (c-name "clutter_behaviour_path_new_with_knots")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("ClutterAlpha*" "alpha")
+    '("const-ClutterKnot*" "knots")
+    '("guint" "n_knots")
   )
 )
 
-(define-method get_color
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_color")
+(define-method set_path
+  (of-object "ClutterBehaviourPath")
+  (c-name "clutter_behaviour_path_set_path")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "color")
+    '("ClutterPath*" "path")
   )
 )
 
-(define-method get_layout
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_layout")
-  (return-type "PangoLayout*")
+(define-method get_path
+  (of-object "ClutterBehaviourPath")
+  (c-name "clutter_behaviour_path_get_path")
+  (return-type "ClutterPath*")
 )
 
-(define-method set_alignment
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_alignment")
-  (return-type "none")
+
+
+;; From clutter-clone-texture.h
+
+(define-function clutter_clone_texture_get_type
+  (c-name "clutter_clone_texture_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_clone_texture_new
+  (c-name "clutter_clone_texture_new")
+  (is-constructor-of "ClutterCloneTexture")
+  (return-type "ClutterActor*")
   (parameters
-    '("PangoAlignment" "alignment")
+    '("ClutterTexture*" "texture")
   )
 )
 
-(define-method get_alignment
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_alignment")
-  (return-type "PangoAlignment")
+(define-method get_parent_texture
+  (of-object "ClutterCloneTexture")
+  (c-name "clutter_clone_texture_get_parent_texture")
+  (return-type "ClutterTexture*")
 )
 
-(define-method set_cursor_position
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_cursor_position")
+(define-method set_parent_texture
+  (of-object "ClutterCloneTexture")
+  (c-name "clutter_clone_texture_set_parent_texture")
   (return-type "none")
   (parameters
-    '("gint" "position")
+    '("ClutterTexture*" "texture")
   )
 )
 
-(define-method get_cursor_position
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_cursor_position")
-  (return-type "gint")
+
+
+;; From clutter-alpha.h
+
+(define-function clutter_alpha_get_type
+  (c-name "clutter_alpha_get_type")
+  (return-type "GType")
 )
 
-(define-method insert_unichar
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_insert_unichar")
-  (return-type "none")
-  (parameters
-    '("gunichar" "wc")
-  )
+(define-function clutter_alpha_new
+  (c-name "clutter_alpha_new")
+  (is-constructor-of "ClutterAlpha")
+  (return-type "ClutterAlpha*")
 )
 
-(define-method delete_chars
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_delete_chars")
-  (return-type "none")
+(define-function clutter_alpha_new_full
+  (c-name "clutter_alpha_new_full")
+  (return-type "ClutterAlpha*")
   (parameters
-    '("guint" "len")
+    '("ClutterTimeline*" "timeline")
+    '("ClutterAlphaFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "destroy")
   )
 )
 
-(define-method insert_text
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_insert_text")
-  (return-type "none")
+(define-function clutter_alpha_new_for_mode
+  (c-name "clutter_alpha_new_for_mode")
+  (return-type "ClutterAlpha*")
   (parameters
-    '("const-gchar*" "text")
-    '("gssize" "position")
+    '("ClutterAnimationMode" "mode")
   )
 )
 
-(define-method delete_text
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_delete_text")
+(define-method get_alpha
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_get_alpha")
+  (return-type "guint32")
+)
+
+(define-method set_func
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_set_func")
   (return-type "none")
   (parameters
-    '("gssize" "start_pos")
-    '("gssize" "end_pos")
+    '("ClutterAlphaFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "destroy")
   )
 )
 
-(define-method set_visible_cursor
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_visible_cursor")
+(define-method set_closure
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_set_closure")
   (return-type "none")
   (parameters
-    '("gboolean" "visible")
+    '("GClosure*" "closure")
   )
 )
 
-(define-method get_visible_cursor
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_visible_cursor")
-  (return-type "gboolean")
-)
-
-(define-method set_visibility
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_visibility")
+(define-method set_timeline
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_set_timeline")
   (return-type "none")
   (parameters
-    '("gboolean" "visible")
+    '("ClutterTimeline*" "timeline")
   )
 )
 
-(define-method get_visibility
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_visibility")
-  (return-type "gboolean")
+(define-method get_timeline
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_get_timeline")
+  (return-type "ClutterTimeline*")
 )
 
-(define-method set_invisible_char
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_invisible_char")
+(define-method set_mode
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_set_mode")
   (return-type "none")
   (parameters
-    '("gunichar" "wc")
+    '("ClutterAnimationMode" "mode")
   )
 )
 
-(define-method get_invisible_char
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_invisible_char")
-  (return-type "gunichar")
+(define-method get_mode
+  (of-object "ClutterAlpha")
+  (c-name "clutter_alpha_get_mode")
+  (return-type "ClutterAnimationMode")
 )
 
-(define-method set_max_length
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_set_max_length")
-  (return-type "none")
+(define-function clutter_ramp_inc_func
+  (c-name "clutter_ramp_inc_func")
+  (return-type "guint32")
   (parameters
-    '("gint" "max")
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
   )
 )
 
-(define-method get_max_length
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_get_max_length")
-  (return-type "gint")
+(define-function clutter_ramp_dec_func
+  (c-name "clutter_ramp_dec_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-method handle_key_event
-  (of-object "ClutterEntry")
-  (c-name "clutter_entry_handle_key_event")
-  (return-type "none")
+(define-function clutter_ramp_func
+  (c-name "clutter_ramp_func")
+  (return-type "guint32")
   (parameters
-    '("ClutterKeyEvent*" "kev")
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
   )
 )
 
-
-
-;; From clutter-enum-types.h
-
-(define-function clutter_actor_flags_get_type
-  (c-name "clutter_actor_flags_get_type")
-  (return-type "GType")
+(define-function clutter_sine_func
+  (c-name "clutter_sine_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_modifier_type_get_type
-  (c-name "clutter_modifier_type_get_type")
-  (return-type "GType")
+(define-function clutter_sine_inc_func
+  (c-name "clutter_sine_inc_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_event_flags_get_type
-  (c-name "clutter_event_flags_get_type")
-  (return-type "GType")
+(define-function clutter_sine_dec_func
+  (c-name "clutter_sine_dec_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_event_type_get_type
-  (c-name "clutter_event_type_get_type")
-  (return-type "GType")
+(define-function clutter_sine_half_func
+  (c-name "clutter_sine_half_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_scroll_direction_get_type
-  (c-name "clutter_scroll_direction_get_type")
-  (return-type "GType")
+(define-function clutter_sine_in_func
+  (c-name "clutter_sine_in_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_stage_state_get_type
-  (c-name "clutter_stage_state_get_type")
-  (return-type "GType")
+(define-function clutter_sine_out_func
+  (c-name "clutter_sine_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_feature_flags_get_type
-  (c-name "clutter_feature_flags_get_type")
-  (return-type "GType")
+(define-function clutter_sine_in_out_func
+  (c-name "clutter_sine_in_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_init_error_get_type
-  (c-name "clutter_init_error_get_type")
-  (return-type "GType")
+(define-function clutter_square_func
+  (c-name "clutter_square_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_script_error_get_type
-  (c-name "clutter_script_error_get_type")
-  (return-type "GType")
+(define-function clutter_smoothstep_inc_func
+  (c-name "clutter_smoothstep_inc_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_shader_error_get_type
-  (c-name "clutter_shader_error_get_type")
-  (return-type "GType")
+(define-function clutter_smoothstep_dec_func
+  (c-name "clutter_smoothstep_dec_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_texture_error_get_type
-  (c-name "clutter_texture_error_get_type")
-  (return-type "GType")
+(define-function clutter_exp_inc_func
+  (c-name "clutter_exp_inc_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_texture_flags_get_type
-  (c-name "clutter_texture_flags_get_type")
-  (return-type "GType")
+(define-function clutter_exp_dec_func
+  (c-name "clutter_exp_dec_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_texture_quality_get_type
-  (c-name "clutter_texture_quality_get_type")
-  (return-type "GType")
+(define-function clutter_ease_in_func
+  (c-name "clutter_ease_in_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_timeline_direction_get_type
-  (c-name "clutter_timeline_direction_get_type")
-  (return-type "GType")
+(define-function clutter_ease_out_func
+  (c-name "clutter_ease_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_gravity_get_type
-  (c-name "clutter_gravity_get_type")
-  (return-type "GType")
+(define-function clutter_ease_in_out_func
+  (c-name "clutter_ease_in_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_rotate_axis_get_type
-  (c-name "clutter_rotate_axis_get_type")
-  (return-type "GType")
+(define-function clutter_exp_in_func
+  (c-name "clutter_exp_in_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_rotate_direction_get_type
-  (c-name "clutter_rotate_direction_get_type")
-  (return-type "GType")
+(define-function clutter_exp_out_func
+  (c-name "clutter_exp_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
-(define-function clutter_request_mode_get_type
-  (c-name "clutter_request_mode_get_type")
-  (return-type "GType")
+(define-function clutter_exp_in_out_func
+  (c-name "clutter_exp_in_out_func")
+  (return-type "guint32")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("gpointer" "dummy")
+  )
 )
 
 
 
-;; From clutter-event.h
+;; From clutter-deprecated.h
 
-(define-function clutter_event_get_type
-  (c-name "clutter_event_get_type")
-  (return-type "GType")
-)
 
-(define-function clutter_events_pending
-  (c-name "clutter_events_pending")
-  (return-type "gboolean")
-)
 
-(define-function clutter_event_get
-  (c-name "clutter_event_get")
-  (return-type "ClutterEvent*")
+;; From clutter-actor.h
+
+(define-function clutter_actor_box_get_type
+  (c-name "clutter_actor_box_get_type")
+  (return-type "GType")
 )
 
-(define-function clutter_event_peek
-  (c-name "clutter_event_peek")
-  (return-type "ClutterEvent*")
+(define-function clutter_actor_get_type
+  (c-name "clutter_actor_get_type")
+  (return-type "GType")
 )
 
-(define-method put
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_put")
+(define-method show
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_show")
   (return-type "none")
 )
 
-(define-function clutter_event_new
-  (c-name "clutter_event_new")
-  (is-constructor-of "ClutterEvent")
-  (return-type "ClutterEvent*")
-  (parameters
-    '("ClutterEventType" "type")
-  )
+(define-method show_all
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_show_all")
+  (return-type "none")
 )
 
-(define-method copy
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_copy")
-  (return-type "ClutterEvent*")
+(define-method hide
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_hide")
+  (return-type "none")
 )
 
-(define-method free
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_free")
+(define-method hide_all
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_hide_all")
   (return-type "none")
 )
 
-(define-method type
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_type")
-  (return-type "ClutterEventType")
+(define-method realize
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_realize")
+  (return-type "none")
 )
 
-(define-method get_time
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_get_time")
-  (return-type "guint32")
+(define-method unrealize
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_unrealize")
+  (return-type "none")
 )
 
-(define-method get_state
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_get_state")
-  (return-type "ClutterModifierType")
+(define-method paint
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_paint")
+  (return-type "none")
 )
 
-(define-method get_coords
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_get_coords")
+(define-method pick
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_pick")
   (return-type "none")
   (parameters
-    '("gint*" "x")
-    '("gint*" "y")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_source
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_get_source")
-  (return-type "ClutterActor*")
-)
-
-(define-method symbol
-  (of-object "ClutterKeyEvent")
-  (c-name "clutter_key_event_symbol")
-  (return-type "guint")
-)
-
-(define-method code
-  (of-object "ClutterKeyEvent")
-  (c-name "clutter_key_event_code")
-  (return-type "guint16")
+(define-method queue_redraw
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_queue_redraw")
+  (return-type "none")
 )
 
-(define-method unicode
-  (of-object "ClutterKeyEvent")
-  (c-name "clutter_key_event_unicode")
-  (return-type "guint32")
+(define-method queue_relayout
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_queue_relayout")
+  (return-type "none")
 )
 
-(define-method button
-  (of-object "ClutterButtonEvent")
-  (c-name "clutter_button_event_button")
-  (return-type "guint32")
+(define-method destroy
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_destroy")
+  (return-type "none")
 )
 
-(define-function clutter_keysym_to_unicode
-  (c-name "clutter_keysym_to_unicode")
-  (return-type "guint32")
+(define-method get_preferred_width
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_preferred_width")
+  (return-type "none")
   (parameters
-    '("guint" "keyval")
+    '("ClutterUnit" "for_height")
+    '("ClutterUnit*" "min_width_p")
+    '("ClutterUnit*" "natural_width_p")
   )
 )
 
-(define-method get_stage
-  (of-object "ClutterEvent")
-  (c-name "clutter_event_get_stage")
-  (return-type "ClutterStage*")
+(define-method get_preferred_height
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_preferred_height")
+  (return-type "none")
+  (parameters
+    '("ClutterUnit" "for_width")
+    '("ClutterUnit*" "min_height_p")
+    '("ClutterUnit*" "natural_height_p")
+  )
 )
 
-
-
-;; From clutter-feature.h
-
-(define-function clutter_feature_available
-  (c-name "clutter_feature_available")
-  (return-type "gboolean")
+(define-method get_preferred_size
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_preferred_size")
+  (return-type "none")
   (parameters
-    '("ClutterFeatureFlags" "feature")
+    '("ClutterUnit*" "min_width_p")
+    '("ClutterUnit*" "min_height_p")
+    '("ClutterUnit*" "natural_width_p")
+    '("ClutterUnit*" "natural_height_p")
   )
 )
 
-(define-function clutter_feature_get_all
-  (c-name "clutter_feature_get_all")
-  (return-type "ClutterFeatureFlags")
+(define-method allocate
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_allocate")
+  (return-type "none")
+  (parameters
+    '("const-ClutterActorBox*" "box")
+    '("gboolean" "absolute_origin_changed")
+  )
 )
 
-
-
-;; From clutter-fixed.h
-
-(define-function clutter_sinx
-  (c-name "clutter_sinx")
-  (return-type "ClutterFixed")
+(define-method allocate_preferred_size
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_allocate_preferred_size")
+  (return-type "none")
   (parameters
-    '("ClutterFixed" "angle")
+    '("gboolean" "absolute_origin_changed")
   )
 )
 
-(define-function clutter_sini
-  (c-name "clutter_sini")
-  (return-type "ClutterFixed")
+(define-method get_allocation_coords
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_allocation_coords")
+  (return-type "none")
   (parameters
-    '("ClutterAngle" "angle")
+    '("gint*" "x_1")
+    '("gint*" "y_1")
+    '("gint*" "x_2")
+    '("gint*" "y_2")
   )
 )
 
-(define-function clutter_tani
-  (c-name "clutter_tani")
-  (return-type "ClutterFixed")
+(define-method get_allocation_box
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_allocation_box")
+  (return-type "none")
   (parameters
-    '("ClutterAngle" "angle")
+    '("ClutterActorBox*" "box")
   )
 )
 
-(define-function clutter_atani
-  (c-name "clutter_atani")
-  (return-type "ClutterFixed")
+(define-method get_allocation_geometry
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_allocation_geometry")
+  (return-type "none")
   (parameters
-    '("ClutterFixed" "x")
+    '("ClutterGeometry*" "geom")
   )
 )
 
-(define-function clutter_atan2i
-  (c-name "clutter_atan2i")
-  (return-type "ClutterFixed")
+(define-method get_allocation_vertices
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_allocation_vertices")
+  (return-type "none")
   (parameters
-    '("ClutterFixed" "y")
-    '("ClutterFixed" "x")
+    '("ClutterActor*" "ancestor")
+    '("ClutterVertex" "verts[4]")
   )
 )
 
-(define-function clutter_sqrtx
-  (c-name "clutter_sqrtx")
-  (return-type "ClutterFixed")
+(define-method set_geometry
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_geometry")
+  (return-type "none")
   (parameters
-    '("ClutterFixed" "x")
+    '("const-ClutterGeometry*" "geometry")
   )
 )
 
-(define-function clutter_sqrti
-  (c-name "clutter_sqrti")
-  (return-type "gint")
+(define-method get_geometry
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_geometry")
+  (return-type "none")
   (parameters
-    '("gint" "x")
+    '("ClutterGeometry*" "geometry")
   )
 )
 
-(define-function clutter_log2x
-  (c-name "clutter_log2x")
-  (return-type "ClutterFixed")
+(define-method set_size
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_size")
+  (return-type "none")
   (parameters
-    '("guint" "x")
+    '("gint" "width")
+    '("gint" "height")
   )
 )
 
-(define-function clutter_pow2x
-  (c-name "clutter_pow2x")
-  (return-type "guint")
+(define-method set_sizeu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_sizeu")
+  (return-type "none")
   (parameters
-    '("ClutterFixed" "x")
+    '("ClutterUnit" "width")
+    '("ClutterUnit" "height")
   )
 )
 
-(define-function clutter_powx
-  (c-name "clutter_powx")
-  (return-type "guint")
+(define-method get_size
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_size")
+  (return-type "none")
   (parameters
-    '("guint" "x")
-    '("ClutterFixed" "y")
+    '("guint*" "width")
+    '("guint*" "height")
   )
 )
 
-(define-function clutter_fixed_get_type
-  (c-name "clutter_fixed_get_type")
-  (return-type "GType")
+(define-method get_sizeu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_sizeu")
+  (return-type "none")
+  (parameters
+    '("ClutterUnit*" "width")
+    '("ClutterUnit*" "height")
+  )
 )
 
-(define-function clutter_param_fixed_get_type
-  (c-name "clutter_param_fixed_get_type")
-  (return-type "GType")
+(define-method get_transformed_size
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_transformed_size")
+  (return-type "none")
+  (parameters
+    '("guint*" "width")
+    '("guint*" "height")
+  )
 )
 
-(define-function clutter_value_set_fixed
-  (c-name "clutter_value_set_fixed")
+(define-method get_transformed_sizeu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_transformed_sizeu")
   (return-type "none")
   (parameters
-    '("GValue*" "value")
-    '("ClutterFixed" "fixed_")
+    '("ClutterUnit*" "width")
+    '("ClutterUnit*" "height")
   )
 )
 
-(define-function clutter_value_get_fixed
-  (c-name "clutter_value_get_fixed")
-  (return-type "ClutterFixed")
+(define-method set_position
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_position")
+  (return-type "none")
   (parameters
-    '("const-GValue*" "value")
+    '("gint" "x")
+    '("gint" "y")
   )
 )
 
-(define-function clutter_param_spec_fixed
-  (c-name "clutter_param_spec_fixed")
-  (return-type "GParamSpec*")
+(define-method set_positionu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_positionu")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
-    '("const-gchar*" "nick")
-    '("const-gchar*" "blurb")
-    '("ClutterFixed" "minimum")
-    '("ClutterFixed" "maximum")
-    '("ClutterFixed" "default_value")
-    '("GParamFlags" "flags")
+    '("ClutterUnit" "x")
+    '("ClutterUnit" "y")
   )
 )
 
-
-
-;; From clutter-frame-source.h
-
-(define-function clutter_frame_source_add
-  (c-name "clutter_frame_source_add")
-  (return-type "guint")
+(define-method get_position
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_position")
+  (return-type "none")
   (parameters
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
+    '("gint*" "x")
+    '("gint*" "y")
   )
 )
 
-(define-function clutter_frame_source_add_full
-  (c-name "clutter_frame_source_add_full")
-  (return-type "guint")
+(define-method get_positionu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_positionu")
+  (return-type "none")
   (parameters
-    '("gint" "priority")
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "notify")
+    '("ClutterUnit*" "x")
+    '("ClutterUnit*" "y")
   )
 )
 
+(define-method get_transformed_position
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_transformed_position")
+  (return-type "none")
+  (parameters
+    '("gint*" "x")
+    '("gint*" "y")
+  )
+)
 
-
-;; From clutter-group.h
-
-(define-function clutter_group_get_type
-  (c-name "clutter_group_get_type")
-  (return-type "GType")
+(define-method get_transformed_positionu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_transformed_positionu")
+  (return-type "none")
+  (parameters
+    '("ClutterUnit*" "x")
+    '("ClutterUnit*" "y")
+  )
 )
 
-(define-function clutter_group_new
-  (c-name "clutter_group_new")
-  (is-constructor-of "ClutterGroup")
-  (return-type "ClutterActor*")
+(define-method get_fixed_position_set
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_fixed_position_set")
+  (return-type "gboolean")
 )
 
-(define-method get_nth_child
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_get_nth_child")
-  (return-type "ClutterActor*")
+(define-method set_fixed_position_set
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_fixed_position_set")
+  (return-type "none")
   (parameters
-    '("gint" "index_")
+    '("gboolean" "is_set")
   )
 )
 
-(define-method get_n_children
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_get_n_children")
-  (return-type "gint")
+(define-method get_width
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_width")
+  (return-type "guint")
 )
 
-(define-method remove_all
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_remove_all")
-  (return-type "none")
+(define-method get_widthu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_widthu")
+  (return-type "ClutterUnit")
 )
 
-(define-method add_many
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_add_many")
-  (return-type "none")
-  (parameters
-    '("ClutterActor*" "first_actor")
-  )
-  (varargs #t)
+(define-method get_height
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_height")
+  (return-type "guint")
 )
 
-(define-method add_many_valist
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_add_many_valist")
+(define-method get_heightu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_heightu")
+  (return-type "ClutterUnit")
+)
+
+(define-method set_width
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_width")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "first_actor")
-    '("va_list" "var_args")
+    '("guint" "width")
   )
 )
 
-(define-method remove
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_remove")
+(define-method set_widthu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_widthu")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterUnit" "width")
   )
 )
 
-(define-method raise
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_raise")
+(define-method set_height
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_height")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("ClutterActor*" "sibling")
+    '("guint" "height")
   )
 )
 
-(define-method lower
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_lower")
+(define-method set_heightu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_heightu")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
-    '("ClutterActor*" "sibling")
+    '("ClutterUnit" "height")
   )
 )
 
-(define-method sort_depth_order
-  (of-object "ClutterGroup")
-  (c-name "clutter_group_sort_depth_order")
-  (return-type "none")
+(define-method get_x
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_x")
+  (return-type "gint")
 )
 
+(define-method get_xu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_xu")
+  (return-type "ClutterUnit")
+)
 
+(define-method get_y
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_y")
+  (return-type "gint")
+)
 
-;; From clutter.h
-
-
-
-;; From clutter-id-pool.h
+(define-method get_yu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_yu")
+  (return-type "ClutterUnit")
+)
 
-(define-function clutter_id_pool_new
-  (c-name "clutter_id_pool_new")
-  (is-constructor-of "ClutterIdPool")
-  (return-type "ClutterIDPool*")
+(define-method set_x
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_x")
+  (return-type "none")
   (parameters
-    '("guint" "initial_size")
+    '("gint" "x")
   )
 )
 
-(define-method free
-  (of-object "ClutterIDPool")
-  (c-name "clutter_id_pool_free")
+(define-method set_xu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_xu")
   (return-type "none")
+  (parameters
+    '("ClutterUnit" "x")
+  )
 )
 
-(define-method add
-  (of-object "ClutterIDPool")
-  (c-name "clutter_id_pool_add")
-  (return-type "guint32")
+(define-method set_y
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_y")
+  (return-type "none")
   (parameters
-    '("gpointer" "ptr")
+    '("gint" "y")
   )
 )
 
-(define-method remove
-  (of-object "ClutterIDPool")
-  (c-name "clutter_id_pool_remove")
+(define-method set_yu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_yu")
   (return-type "none")
   (parameters
-    '("guint32" "id")
+    '("ClutterUnit" "y")
   )
 )
 
-(define-method lookup
-  (of-object "ClutterIDPool")
-  (c-name "clutter_id_pool_lookup")
-  (return-type "gpointer")
+(define-method set_rotation
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_rotation")
+  (return-type "none")
   (parameters
-    '("guint32" "id")
+    '("ClutterRotateAxis" "axis")
+    '("gdouble" "angle")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
   )
 )
 
-
-
-;; From clutter-json.h
-
-
-
-;; From clutter-keysyms.h
-
-
-
-;; From clutter-keysyms-table.h
-
-
-
-;; From clutter-label.h
-
-(define-function clutter_label_get_type
-  (c-name "clutter_label_get_type")
-  (return-type "GType")
+(define-method set_rotationx
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_rotationx")
+  (return-type "none")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+    '("ClutterFixed" "angle")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "z")
+  )
 )
 
-(define-function clutter_label_new
-  (c-name "clutter_label_new")
-  (is-constructor-of "ClutterLabel")
-  (return-type "ClutterActor*")
+(define-method set_rotationu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_rotationu")
+  (return-type "none")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+    '("gdouble" "angle")
+    '("ClutterUnit" "x")
+    '("ClutterUnit" "y")
+    '("ClutterUnit" "z")
+  )
 )
 
-(define-function clutter_label_new_full
-  (c-name "clutter_label_new_full")
-  (return-type "ClutterActor*")
+(define-method get_rotation
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_rotation")
+  (return-type "gdouble")
   (parameters
-    '("const-gchar*" "font_name")
-    '("const-gchar*" "text")
-    '("const-ClutterColor*" "color")
+    '("ClutterRotateAxis" "axis")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gint*" "z")
+  )
+)
+
+(define-method get_rotationx
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_rotationx")
+  (return-type "ClutterFixed")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gint*" "z")
   )
 )
 
-(define-function clutter_label_new_with_text
-  (c-name "clutter_label_new_with_text")
-  (return-type "ClutterActor*")
+(define-method get_rotationu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_rotationu")
+  (return-type "gdouble")
   (parameters
-    '("const-gchar*" "font_name")
-    '("const-gchar*" "text")
+    '("ClutterRotateAxis" "axis")
+    '("ClutterUnit*" "x")
+    '("ClutterUnit*" "y")
+    '("ClutterUnit*" "z")
   )
 )
 
-(define-method set_text
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_text")
+(define-method set_opacity
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_opacity")
   (return-type "none")
   (parameters
-    '("const-gchar*" "text")
+    '("guint8" "opacity")
   )
 )
 
-(define-method get_text
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_text")
-  (return-type "const-gchar*")
+(define-method get_opacity
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_opacity")
+  (return-type "guint8")
 )
 
-(define-method set_font_name
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_font_name")
+(define-method get_paint_opacity
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_paint_opacity")
+  (return-type "guint8")
+)
+
+(define-method set_name
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_name")
   (return-type "none")
   (parameters
-    '("const-gchar*" "font_name")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_font_name
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_font_name")
+(define-method get_name
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_name")
   (return-type "const-gchar*")
 )
 
-(define-method set_color
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_color")
-  (return-type "none")
-  (parameters
-    '("const-ClutterColor*" "color")
-  )
+(define-method get_gid
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_gid")
+  (return-type "guint32")
 )
 
-(define-method get_color
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_color")
+(define-method set_clip
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_clip")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "color")
+    '("gint" "xoff")
+    '("gint" "yoff")
+    '("gint" "width")
+    '("gint" "height")
   )
 )
 
-(define-method set_ellipsize
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_ellipsize")
+(define-method set_clipu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_clipu")
   (return-type "none")
   (parameters
-    '("PangoEllipsizeMode" "mode")
+    '("ClutterUnit" "xoff")
+    '("ClutterUnit" "yoff")
+    '("ClutterUnit" "width")
+    '("ClutterUnit" "height")
   )
 )
 
-(define-method get_ellipsize
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_ellipsize")
-  (return-type "PangoEllipsizeMode")
-)
-
-(define-method set_line_wrap
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_line_wrap")
+(define-method remove_clip
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_remove_clip")
   (return-type "none")
-  (parameters
-    '("gboolean" "wrap")
-  )
 )
 
-(define-method get_line_wrap
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_line_wrap")
+(define-method has_clip
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_has_clip")
   (return-type "gboolean")
 )
 
-(define-method set_line_wrap_mode
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_line_wrap_mode")
+(define-method get_clip
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_clip")
   (return-type "none")
   (parameters
-    '("PangoWrapMode" "wrap_mode")
+    '("gint*" "xoff")
+    '("gint*" "yoff")
+    '("gint*" "width")
+    '("gint*" "height")
   )
 )
 
-(define-method get_line_wrap_mode
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_line_wrap_mode")
-  (return-type "PangoWrapMode")
-)
-
-(define-method get_layout
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_layout")
-  (return-type "PangoLayout*")
+(define-method get_clipu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_clipu")
+  (return-type "none")
+  (parameters
+    '("ClutterUnit*" "xoff")
+    '("ClutterUnit*" "yoff")
+    '("ClutterUnit*" "width")
+    '("ClutterUnit*" "height")
+  )
 )
 
-(define-method set_attributes
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_attributes")
+(define-method set_parent
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_parent")
   (return-type "none")
   (parameters
-    '("PangoAttrList*" "attrs")
+    '("ClutterActor*" "parent")
   )
 )
 
-(define-method get_attributes
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_attributes")
-  (return-type "PangoAttrList*")
+(define-method get_parent
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_parent")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_use_markup
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_use_markup")
+(define-method reparent
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_reparent")
   (return-type "none")
   (parameters
-    '("gboolean" "setting")
+    '("ClutterActor*" "new_parent")
   )
 )
 
-(define-method get_use_markup
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_use_markup")
-  (return-type "gboolean")
+(define-method unparent
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_unparent")
+  (return-type "none")
 )
 
-(define-method set_alignment
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_alignment")
+(define-method get_stage
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_stage")
+  (return-type "ClutterActor*")
+)
+
+(define-method raise
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_raise")
   (return-type "none")
   (parameters
-    '("PangoAlignment" "alignment")
+    '("ClutterActor*" "below")
   )
 )
 
-(define-method get_alignment
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_alignment")
-  (return-type "PangoAlignment")
-)
-
-(define-method set_justify
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_set_justify")
+(define-method lower
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_lower")
   (return-type "none")
   (parameters
-    '("gboolean" "justify")
+    '("ClutterActor*" "above")
   )
 )
 
-(define-method get_justify
-  (of-object "ClutterLabel")
-  (c-name "clutter_label_get_justify")
-  (return-type "gboolean")
+(define-method raise_top
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_raise_top")
+  (return-type "none")
 )
 
-
-
-;; From clutter-list-model.h
-
-(define-function clutter_list_model_get_type
-  (c-name "clutter_list_model_get_type")
-  (return-type "GType")
+(define-method lower_bottom
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_lower_bottom")
+  (return-type "none")
 )
 
-(define-function clutter_list_model_new
-  (c-name "clutter_list_model_new")
-  (is-constructor-of "ClutterListModel")
-  (return-type "ClutterModel*")
+(define-method set_depth
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_depth")
+  (return-type "none")
   (parameters
-    '("guint" "n_columns")
+    '("gint" "depth")
   )
-  (varargs #t)
 )
 
-(define-function clutter_list_model_newv
-  (c-name "clutter_list_model_newv")
-  (return-type "ClutterModel*")
-  (parameters
-    '("guint" "n_columns")
-    '("GType*" "types")
-    '("const-gchar*-const[]" "names")
-  )
+(define-method get_depth
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_depth")
+  (return-type "gint")
 )
 
-
-
-;; From clutter-main.h
-
-(define-function clutter_init_error_quark
-  (c-name "clutter_init_error_quark")
-  (return-type "GQuark")
+(define-method set_depthu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_depthu")
+  (return-type "none")
+  (parameters
+    '("ClutterUnit" "depth")
+  )
 )
 
-(define-function clutter_base_init
-  (c-name "clutter_base_init")
-  (return-type "none")
+(define-method get_depthu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_depthu")
+  (return-type "ClutterUnit")
 )
 
-(define-function clutter_init
-  (c-name "clutter_init")
-  (return-type "ClutterInitError")
+(define-method set_scalex
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_scalex")
+  (return-type "none")
   (parameters
-    '("int*" "argc")
-    '("char***" "argv")
+    '("ClutterFixed" "scale_x")
+    '("ClutterFixed" "scale_y")
   )
 )
 
-(define-function clutter_init_with_args
-  (c-name "clutter_init_with_args")
-  (return-type "ClutterInitError")
+(define-method set_scale
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_scale")
+  (return-type "none")
   (parameters
-    '("int*" "argc")
-    '("char***" "argv")
-    '("char*" "parameter_string")
-    '("GOptionEntry*" "entries")
-    '("char*" "translation_domain")
-    '("GError**" "error")
+    '("gdouble" "scale_x")
+    '("gdouble" "scale_y")
   )
 )
 
-(define-function clutter_get_option_group
-  (c-name "clutter_get_option_group")
-  (return-type "GOptionGroup*")
-)
-
-(define-function clutter_main
-  (c-name "clutter_main")
+(define-method get_scalex
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_scalex")
   (return-type "none")
+  (parameters
+    '("ClutterFixed*" "scale_x")
+    '("ClutterFixed*" "scale_y")
+  )
 )
 
-(define-function clutter_main_quit
-  (c-name "clutter_main_quit")
+(define-method get_scale
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_scale")
   (return-type "none")
+  (parameters
+    '("gdouble*" "scale_x")
+    '("gdouble*" "scale_y")
+  )
 )
 
-(define-function clutter_main_level
-  (c-name "clutter_main_level")
-  (return-type "gint")
+(define-method move_by
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_move_by")
+  (return-type "none")
+  (parameters
+    '("gint" "dx")
+    '("gint" "dy")
+  )
 )
 
-(define-function clutter_redraw
-  (c-name "clutter_redraw")
+(define-method move_byu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_move_byu")
   (return-type "none")
   (parameters
-    '("ClutterStage*" "stage")
+    '("ClutterUnit" "dx")
+    '("ClutterUnit" "dy")
   )
 )
 
-(define-function clutter_do_event
-  (c-name "clutter_do_event")
+(define-method set_reactive
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_reactive")
   (return-type "none")
   (parameters
-    '("ClutterEvent*" "event")
+    '("gboolean" "reactive")
   )
 )
 
-(define-function clutter_get_debug_enabled
-  (c-name "clutter_get_debug_enabled")
+(define-method get_reactive
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_reactive")
   (return-type "gboolean")
 )
 
-(define-function clutter_get_show_fps
-  (c-name "clutter_get_show_fps")
+(define-method event
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_event")
   (return-type "gboolean")
+  (parameters
+    '("ClutterEvent*" "event")
+    '("gboolean" "capture")
+  )
 )
 
-(define-function clutter_get_timestamp
-  (c-name "clutter_get_timestamp")
-  (return-type "gulong")
+(define-function clutter_get_actor_by_gid
+  (c-name "clutter_get_actor_by_gid")
+  (return-type "ClutterActor*")
+  (parameters
+    '("guint32" "id")
+  )
 )
 
-(define-function clutter_threads_init
-  (c-name "clutter_threads_init")
-  (return-type "none")
+(define-method set_shader
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_shader")
+  (return-type "gboolean")
+  (parameters
+    '("ClutterShader*" "shader")
+  )
 )
 
-(define-function clutter_threads_enter
-  (c-name "clutter_threads_enter")
-  (return-type "none")
+(define-method get_shader
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_shader")
+  (return-type "ClutterShader*")
 )
 
-(define-function clutter_threads_leave
-  (c-name "clutter_threads_leave")
+(define-method set_shader_param
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_shader_param")
   (return-type "none")
+  (parameters
+    '("const-gchar*" "param")
+    '("const-GValue*" "value")
+  )
 )
 
-(define-function clutter_threads_set_lock_functions
-  (c-name "clutter_threads_set_lock_functions")
+(define-method set_shader_param_int
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_shader_param_int")
   (return-type "none")
   (parameters
-    '("GCallback" "enter_fn")
-    '("GCallback" "leave_fn")
+    '("const-gchar*" "param")
+    '("gint" "value")
   )
 )
 
-(define-function clutter_threads_add_idle
-  (c-name "clutter_threads_add_idle")
-  (return-type "guint")
+(define-method set_shader_param_float
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_shader_param_float")
+  (return-type "none")
   (parameters
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
+    '("const-gchar*" "param")
+    '("gfloat" "value")
   )
 )
 
-(define-function clutter_threads_add_idle_full
-  (c-name "clutter_threads_add_idle_full")
-  (return-type "guint")
+(define-method set_anchor_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_anchor_point")
+  (return-type "none")
   (parameters
-    '("gint" "priority")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "notify")
+    '("gint" "anchor_x")
+    '("gint" "anchor_y")
   )
 )
 
-(define-function clutter_threads_add_timeout
-  (c-name "clutter_threads_add_timeout")
-  (return-type "guint")
+(define-method move_anchor_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_move_anchor_point")
+  (return-type "none")
   (parameters
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
+    '("gint" "anchor_x")
+    '("gint" "anchor_y")
   )
 )
 
-(define-function clutter_threads_add_timeout_full
-  (c-name "clutter_threads_add_timeout_full")
-  (return-type "guint")
+(define-method get_anchor_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_anchor_point")
+  (return-type "none")
   (parameters
-    '("gint" "priority")
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "notify")
+    '("gint*" "anchor_x")
+    '("gint*" "anchor_y")
   )
 )
 
-(define-function clutter_threads_add_frame_source
-  (c-name "clutter_threads_add_frame_source")
-  (return-type "guint")
+(define-method set_anchor_pointu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_anchor_pointu")
+  (return-type "none")
   (parameters
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
+    '("ClutterUnit" "anchor_x")
+    '("ClutterUnit" "anchor_y")
   )
 )
 
-(define-function clutter_threads_add_frame_source_full
-  (c-name "clutter_threads_add_frame_source_full")
-  (return-type "guint")
+(define-method move_anchor_pointu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_move_anchor_pointu")
+  (return-type "none")
   (parameters
-    '("gint" "priority")
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "notify")
+    '("ClutterUnit" "anchor_x")
+    '("ClutterUnit" "anchor_y")
   )
 )
 
-(define-function clutter_set_motion_events_enabled
-  (c-name "clutter_set_motion_events_enabled")
+(define-method get_anchor_pointu
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_anchor_pointu")
   (return-type "none")
   (parameters
-    '("gboolean" "enable")
+    '("ClutterUnit*" "anchor_x")
+    '("ClutterUnit*" "anchor_y")
   )
 )
 
-(define-function clutter_get_motion_events_enabled
-  (c-name "clutter_get_motion_events_enabled")
-  (return-type "gboolean")
-)
-
-(define-function clutter_set_motion_events_frequency
-  (c-name "clutter_set_motion_events_frequency")
+(define-method set_anchor_point_from_gravity
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_set_anchor_point_from_gravity")
   (return-type "none")
   (parameters
-    '("guint" "frequency")
+    '("ClutterGravity" "gravity")
   )
 )
 
-(define-function clutter_get_motion_events_frequency
-  (c-name "clutter_get_motion_events_frequency")
-  (return-type "guint")
-)
-
-(define-function clutter_set_default_frame_rate
-  (c-name "clutter_set_default_frame_rate")
+(define-method move_anchor_point_from_gravity
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_move_anchor_point_from_gravity")
   (return-type "none")
   (parameters
-    '("guint" "frames_per_sec")
+    '("ClutterGravity" "gravity")
   )
 )
 
-(define-function clutter_get_default_frame_rate
-  (c-name "clutter_get_default_frame_rate")
-  (return-type "guint")
-)
-
-(define-function clutter_grab_pointer
-  (c-name "clutter_grab_pointer")
-  (return-type "none")
+(define-method transform_stage_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_transform_stage_point")
+  (return-type "gboolean")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterUnit" "x")
+    '("ClutterUnit" "y")
+    '("ClutterUnit*" "x_out")
+    '("ClutterUnit*" "y_out")
   )
 )
 
-(define-function clutter_ungrab_pointer
-  (c-name "clutter_ungrab_pointer")
-  (return-type "none")
+(define-method is_rotated
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_is_rotated")
+  (return-type "gboolean")
 )
 
-(define-function clutter_get_pointer_grab
-  (c-name "clutter_get_pointer_grab")
-  (return-type "ClutterActor*")
+(define-method is_scaled
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_is_scaled")
+  (return-type "gboolean")
 )
 
-(define-function clutter_grab_keyboard
-  (c-name "clutter_grab_keyboard")
+(define-method should_pick_paint
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_should_pick_paint")
+  (return-type "gboolean")
+)
+
+(define-function clutter_actor_box_get_from_vertices
+  (c-name "clutter_actor_box_get_from_vertices")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterVertex" "vtx[4]")
+    '("ClutterActorBox*" "box")
   )
 )
 
-(define-function clutter_ungrab_keyboard
-  (c-name "clutter_ungrab_keyboard")
+(define-method get_abs_allocation_vertices
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_abs_allocation_vertices")
   (return-type "none")
+  (parameters
+    '("ClutterVertex" "verts[4]")
+  )
 )
 
-(define-function clutter_get_keyboard_grab
-  (c-name "clutter_get_keyboard_grab")
-  (return-type "ClutterActor*")
-)
-
-(define-function clutter_clear_glyph_cache
-  (c-name "clutter_clear_glyph_cache")
+(define-method apply_transform_to_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_apply_transform_to_point")
   (return-type "none")
+  (parameters
+    '("const-ClutterVertex*" "point")
+    '("ClutterVertex*" "vertex")
+  )
 )
 
-(define-function clutter_set_use_mipmapped_text
-  (c-name "clutter_set_use_mipmapped_text")
+(define-method apply_relative_transform_to_point
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_apply_relative_transform_to_point")
   (return-type "none")
   (parameters
-    '("gboolean" "value")
+    '("ClutterActor*" "ancestor")
+    '("const-ClutterVertex*" "point")
+    '("ClutterVertex*" "vertex")
   )
 )
 
-(define-function clutter_get_use_mipmapped_text
-  (c-name "clutter_get_use_mipmapped_text")
+(define-method get_paint_visibility
+  (of-object "ClutterActor")
+  (c-name "clutter_actor_get_paint_visibility")
   (return-type "gboolean")
 )
 
 
 
-;; From clutter-marshal.h
+;; From clutter-keysyms.h
 
 
 
-;; From clutter-media.h
+;; From clutter-rectangle.h
 
-(define-function clutter_media_get_type
-  (c-name "clutter_media_get_type")
+(define-function clutter_rectangle_get_type
+  (c-name "clutter_rectangle_get_type")
   (return-type "GType")
 )
 
-(define-method set_uri
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_set_uri")
-  (return-type "none")
+(define-function clutter_rectangle_new
+  (c-name "clutter_rectangle_new")
+  (is-constructor-of "ClutterRectangle")
+  (return-type "ClutterActor*")
+)
+
+(define-function clutter_rectangle_new_with_color
+  (c-name "clutter_rectangle_new_with_color")
+  (return-type "ClutterActor*")
   (parameters
-    '("const-char*" "uri")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_uri
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_uri")
-  (return-type "const-char*")
+(define-method get_color
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_get_color")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "color")
+  )
 )
 
-(define-method set_playing
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_set_playing")
+(define-method set_color
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_set_color")
   (return-type "none")
   (parameters
-    '("gboolean" "playing")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_playing
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_playing")
-  (return-type "gboolean")
+(define-method get_border_width
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_get_border_width")
+  (return-type "guint")
 )
 
-(define-method set_position
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_set_position")
+(define-method set_border_width
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_set_border_width")
   (return-type "none")
   (parameters
-    '("int" "position")
+    '("guint" "width")
   )
 )
 
-(define-method get_position
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_position")
-  (return-type "int")
+(define-method get_border_color
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_get_border_color")
+  (return-type "none")
+  (parameters
+    '("ClutterColor*" "color")
+  )
 )
 
-(define-method set_volume
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_set_volume")
+(define-method set_border_color
+  (of-object "ClutterRectangle")
+  (c-name "clutter_rectangle_set_border_color")
   (return-type "none")
   (parameters
-    '("double" "volume")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_volume
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_volume")
-  (return-type "double")
-)
 
-(define-method get_can_seek
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_can_seek")
-  (return-type "gboolean")
-)
 
-(define-method get_buffer_percent
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_buffer_percent")
-  (return-type "int")
-)
+;; From clutter-behaviour-scale.h
 
-(define-method get_duration
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_get_duration")
-  (return-type "int")
+(define-function clutter_behaviour_scale_get_type
+  (c-name "clutter_behaviour_scale_get_type")
+  (return-type "GType")
 )
 
-(define-method set_filename
-  (of-object "ClutterMedia")
-  (c-name "clutter_media_set_filename")
-  (return-type "none")
+(define-function clutter_behaviour_scale_new
+  (c-name "clutter_behaviour_scale_new")
+  (is-constructor-of "ClutterBehaviourScale")
+  (return-type "ClutterBehaviour*")
   (parameters
-    '("const-gchar*" "filename")
+    '("ClutterAlpha*" "alpha")
+    '("gdouble" "x_scale_start")
+    '("gdouble" "y_scale_start")
+    '("gdouble" "x_scale_end")
+    '("gdouble" "y_scale_end")
   )
 )
 
-
-
-;; From clutter-model.h
-
-(define-function clutter_model_get_type
-  (c-name "clutter_model_get_type")
-  (return-type "GType")
+(define-function clutter_behaviour_scale_newx
+  (c-name "clutter_behaviour_scale_newx")
+  (return-type "ClutterBehaviour*")
+  (parameters
+    '("ClutterAlpha*" "alpha")
+    '("ClutterFixed" "x_scale_start")
+    '("ClutterFixed" "y_scale_start")
+    '("ClutterFixed" "x_scale_end")
+    '("ClutterFixed" "y_scale_end")
+  )
 )
 
-(define-method set_types
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_types")
+(define-method set_bounds
+  (of-object "ClutterBehaviourScale")
+  (c-name "clutter_behaviour_scale_set_bounds")
   (return-type "none")
   (parameters
-    '("guint" "n_columns")
-    '("GType*" "types")
+    '("gdouble" "x_scale_start")
+    '("gdouble" "y_scale_start")
+    '("gdouble" "x_scale_end")
+    '("gdouble" "y_scale_end")
   )
 )
 
-(define-method set_names
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_names")
+(define-method set_boundsx
+  (of-object "ClutterBehaviourScale")
+  (c-name "clutter_behaviour_scale_set_boundsx")
   (return-type "none")
   (parameters
-    '("guint" "n_columns")
-    '("const-gchar*-const[]" "names")
+    '("ClutterFixed" "x_scale_start")
+    '("ClutterFixed" "y_scale_start")
+    '("ClutterFixed" "x_scale_end")
+    '("ClutterFixed" "y_scale_end")
   )
 )
 
-(define-method append
-  (of-object "ClutterModel")
-  (c-name "clutter_model_append")
+(define-method get_bounds
+  (of-object "ClutterBehaviourScale")
+  (c-name "clutter_behaviour_scale_get_bounds")
   (return-type "none")
   (parameters
+    '("gdouble*" "x_scale_start")
+    '("gdouble*" "y_scale_start")
+    '("gdouble*" "x_scale_end")
+    '("gdouble*" "y_scale_end")
   )
-  (varargs #t)
 )
 
-(define-method appendv
-  (of-object "ClutterModel")
-  (c-name "clutter_model_appendv")
+(define-method get_boundsx
+  (of-object "ClutterBehaviourScale")
+  (c-name "clutter_behaviour_scale_get_boundsx")
   (return-type "none")
   (parameters
-    '("guint" "n_columns")
-    '("guint*" "columns")
-    '("GValue*" "values")
+    '("ClutterFixed*" "x_scale_start")
+    '("ClutterFixed*" "y_scale_start")
+    '("ClutterFixed*" "x_scale_end")
+    '("ClutterFixed*" "y_scale_end")
   )
 )
 
-(define-method prepend
-  (of-object "ClutterModel")
-  (c-name "clutter_model_prepend")
-  (return-type "none")
+
+
+;; From clutter-timeline.h
+
+(define-function clutter_timeline_get_type
+  (c-name "clutter_timeline_get_type")
+  (return-type "GType")
+)
+
+(define-function clutter_timeline_new
+  (c-name "clutter_timeline_new")
+  (is-constructor-of "ClutterTimeline")
+  (return-type "ClutterTimeline*")
   (parameters
+    '("guint" "n_frames")
+    '("guint" "fps")
   )
-  (varargs #t)
 )
 
-(define-method prependv
-  (of-object "ClutterModel")
-  (c-name "clutter_model_prependv")
-  (return-type "none")
+(define-function clutter_timeline_new_for_duration
+  (c-name "clutter_timeline_new_for_duration")
+  (return-type "ClutterTimeline*")
   (parameters
-    '("guint" "n_columns")
-    '("guint*" "columns")
-    '("GValue*" "values")
+    '("guint" "msecs")
   )
 )
 
-(define-method insert
-  (of-object "ClutterModel")
-  (c-name "clutter_model_insert")
-  (return-type "none")
-  (parameters
-    '("guint" "row")
-  )
-  (varargs #t)
+(define-method clone
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_clone")
+  (return-type "ClutterTimeline*")
 )
 
-(define-method insertv
-  (of-object "ClutterModel")
-  (c-name "clutter_model_insertv")
+(define-method get_duration
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_duration")
+  (return-type "guint")
+)
+
+(define-method set_duration
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_duration")
   (return-type "none")
   (parameters
-    '("guint" "row")
-    '("guint" "n_columns")
-    '("guint*" "columns")
-    '("GValue*" "values")
+    '("guint" "msecs")
   )
 )
 
-(define-method insert_value
-  (of-object "ClutterModel")
-  (c-name "clutter_model_insert_value")
+(define-method get_speed
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_speed")
+  (return-type "guint")
+)
+
+(define-method set_speed
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_speed")
   (return-type "none")
   (parameters
-    '("guint" "row")
-    '("guint" "column")
-    '("const-GValue*" "value")
+    '("guint" "fps")
   )
 )
 
-(define-method remove
-  (of-object "ClutterModel")
-  (c-name "clutter_model_remove")
+(define-method get_direction
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_direction")
+  (return-type "ClutterTimelineDirection")
+)
+
+(define-method set_direction
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_direction")
   (return-type "none")
   (parameters
-    '("guint" "row")
+    '("ClutterTimelineDirection" "direction")
   )
 )
 
-(define-method get_n_rows
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_n_rows")
-  (return-type "guint")
+(define-method start
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_start")
+  (return-type "none")
 )
 
-(define-method get_n_columns
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_n_columns")
-  (return-type "guint")
+(define-method pause
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_pause")
+  (return-type "none")
 )
 
-(define-method get_column_name
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_column_name")
-  (return-type "const-gchar*")
-  (parameters
-    '("guint" "column")
-  )
+(define-method stop
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_stop")
+  (return-type "none")
 )
 
-(define-method get_column_type
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_column_type")
-  (return-type "GType")
+(define-method set_loop
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_loop")
+  (return-type "none")
   (parameters
-    '("guint" "column")
+    '("gboolean" "loop")
   )
 )
 
-(define-method get_first_iter
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_first_iter")
-  (return-type "ClutterModelIter*")
+(define-method get_loop
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_loop")
+  (return-type "gboolean")
 )
 
-(define-method get_last_iter
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_last_iter")
-  (return-type "ClutterModelIter*")
+(define-method rewind
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_rewind")
+  (return-type "none")
 )
 
-(define-method get_iter_at_row
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_iter_at_row")
-  (return-type "ClutterModelIter*")
+(define-method skip
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_skip")
+  (return-type "none")
   (parameters
-    '("guint" "row")
+    '("guint" "n_frames")
   )
 )
 
-(define-method set_sorting_column
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_sorting_column")
+(define-method advance
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_advance")
   (return-type "none")
   (parameters
-    '("gint" "column")
+    '("guint" "frame_num")
   )
 )
 
-(define-method get_sorting_column
-  (of-object "ClutterModel")
-  (c-name "clutter_model_get_sorting_column")
+(define-method get_current_frame
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_current_frame")
   (return-type "gint")
 )
 
-(define-method foreach
-  (of-object "ClutterModel")
-  (c-name "clutter_model_foreach")
-  (return-type "none")
-  (parameters
-    '("ClutterModelForeachFunc" "func")
-    '("gpointer" "user_data")
-  )
+(define-method get_progress
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_progress")
+  (return-type "gdouble")
 )
 
-(define-method set_sort
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_sort")
-  (return-type "none")
-  (parameters
-    '("guint" "column")
-    '("ClutterModelSortFunc" "func")
-    '("gpointer" "user_data")
-    '("GDestroyNotify" "notify")
-  )
+(define-method get_progressx
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_progressx")
+  (return-type "ClutterFixed")
 )
 
-(define-method set_filter
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_filter")
+(define-method set_n_frames
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_n_frames")
   (return-type "none")
   (parameters
-    '("ClutterModelFilterFunc" "func")
-    '("gpointer" "user_data")
-    '("GDestroyNotify" "notify")
+    '("guint" "n_frames")
   )
 )
 
-(define-method resort
-  (of-object "ClutterModel")
-  (c-name "clutter_model_resort")
-  (return-type "none")
+(define-method get_n_frames
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_n_frames")
+  (return-type "guint")
 )
 
-(define-method filter_row
-  (of-object "ClutterModel")
-  (c-name "clutter_model_filter_row")
+(define-method is_playing
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_is_playing")
   (return-type "gboolean")
-  (parameters
-    '("guint" "row")
-  )
 )
 
-(define-method filter_iter
-  (of-object "ClutterModel")
-  (c-name "clutter_model_filter_iter")
-  (return-type "gboolean")
+(define-method set_delay
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_set_delay")
+  (return-type "none")
   (parameters
-    '("ClutterModelIter*" "iter")
+    '("guint" "msecs")
   )
 )
 
-(define-function clutter_model_iter_get_type
-  (c-name "clutter_model_iter_get_type")
-  (return-type "GType")
+(define-method get_delay
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_delay")
+  (return-type "guint")
 )
 
-(define-method get
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_get")
+(define-method get_delta
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_get_delta")
+  (return-type "guint")
+  (parameters
+    '("guint*" "msecs")
+  )
+)
+
+(define-method add_marker_at_frame
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_add_marker_at_frame")
   (return-type "none")
   (parameters
+    '("const-gchar*" "marker_name")
+    '("guint" "frame_num")
   )
-  (varargs #t)
 )
 
-(define-method get_valist
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_get_valist")
+(define-method add_marker_at_time
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_add_marker_at_time")
   (return-type "none")
   (parameters
-    '("va_list" "args")
+    '("const-gchar*" "marker_name")
+    '("guint" "msecs")
   )
 )
 
-(define-method get_value
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_get_value")
+(define-method remove_marker
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_remove_marker")
   (return-type "none")
   (parameters
-    '("guint" "column")
-    '("GValue*" "value")
+    '("const-gchar*" "marker_name")
   )
 )
 
-(define-method set
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_set")
-  (return-type "none")
+(define-method list_markers
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_list_markers")
+  (return-type "gchar**")
   (parameters
+    '("gint" "frame_num")
+    '("gsize*" "n_markers")
   )
-  (varargs #t)
 )
 
-(define-method set_valist
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_set_valist")
-  (return-type "none")
+(define-method has_marker
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_has_marker")
+  (return-type "gboolean")
   (parameters
-    '("va_list" "args")
+    '("const-gchar*" "marker_name")
   )
 )
 
-(define-method set_value
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_set_value")
+(define-method advance_to_marker
+  (of-object "ClutterTimeline")
+  (c-name "clutter_timeline_advance_to_marker")
   (return-type "none")
   (parameters
-    '("guint" "column")
-    '("const-GValue*" "value")
+    '("const-gchar*" "marker_name")
   )
 )
 
-(define-method is_first
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_is_first")
-  (return-type "gboolean")
-)
 
-(define-method is_last
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_is_last")
-  (return-type "gboolean")
-)
 
-(define-method next
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_next")
-  (return-type "ClutterModelIter*")
-)
+;; From clutter-types.h
 
-(define-method prev
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_prev")
-  (return-type "ClutterModelIter*")
+(define-function clutter_geometry_get_type
+  (c-name "clutter_geometry_get_type")
+  (return-type "GType")
 )
 
-(define-method get_model
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_get_model")
-  (return-type "ClutterModel*")
+(define-function clutter_vertex_get_type
+  (c-name "clutter_vertex_get_type")
+  (return-type "GType")
 )
 
-(define-method get_row
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_get_row")
-  (return-type "guint")
+(define-function clutter_knot_get_type
+  (c-name "clutter_knot_get_type")
+  (return-type "GType")
 )
 
 (define-method copy
-  (of-object "ClutterModelIter")
-  (c-name "clutter_model_iter_copy")
-  (return-type "ClutterModelIter*")
+  (of-object "ClutterKnot")
+  (c-name "clutter_knot_copy")
+  (return-type "ClutterKnot*")
 )
 
-
-
-;; From clutter-model-private.h
-
-(define-method set_n_columns
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_n_columns")
+(define-method free
+  (of-object "ClutterKnot")
+  (c-name "clutter_knot_free")
   (return-type "none")
-  (parameters
-    '("gint" "n_columns")
-    '("gboolean" "set_types")
-    '("gboolean" "set_names")
-  )
 )
 
-(define-function clutter_model_check_type
-  (c-name "clutter_model_check_type")
+(define-method equal
+  (of-object "ClutterKnot")
+  (c-name "clutter_knot_equal")
   (return-type "gboolean")
   (parameters
-    '("GType" "gtype")
+    '("const-ClutterKnot*" "knot_b")
   )
 )
 
-(define-method set_column_type
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_column_type")
-  (return-type "none")
-  (parameters
-    '("gint" "column")
-    '("GType" "gtype")
-  )
+
+
+;; From clutter-list-model.h
+
+(define-function clutter_list_model_get_type
+  (c-name "clutter_list_model_get_type")
+  (return-type "GType")
 )
 
-(define-method set_column_name
-  (of-object "ClutterModel")
-  (c-name "clutter_model_set_column_name")
-  (return-type "none")
+(define-function clutter_list_model_new
+  (c-name "clutter_list_model_new")
+  (is-constructor-of "ClutterListModel")
+  (return-type "ClutterModel*")
   (parameters
-    '("gint" "column")
-    '("const-gchar*" "name")
+    '("guint" "n_columns")
   )
+  (varargs #t)
 )
 
-
-
-;; From clutter-private.h
-
-(define-function clutter_context_get_default
-  (c-name "clutter_context_get_default")
-  (return-type "ClutterMainContext*")
+(define-function clutter_list_model_newv
+  (c-name "clutter_list_model_newv")
+  (return-type "ClutterModel*")
+  (parameters
+    '("guint" "n_columns")
+    '("GType*" "types")
+    '("const-gchar*-const[]" "names")
+  )
 )
 
 
 
-;; From clutter-rectangle.h
+;; From clutter-binding-pool.h
 
-(define-function clutter_rectangle_get_type
-  (c-name "clutter_rectangle_get_type")
-  (return-type "GType")
+(define-function clutter_binding_pool_new
+  (c-name "clutter_binding_pool_new")
+  (is-constructor-of "ClutterBindingPool")
+  (return-type "ClutterBindingPool*")
+  (parameters
+    '("const-gchar*" "name")
+  )
 )
 
-(define-function clutter_rectangle_new
-  (c-name "clutter_rectangle_new")
-  (is-constructor-of "ClutterRectangle")
-  (return-type "ClutterActor*")
+(define-function clutter_binding_pool_get_for_class
+  (c-name "clutter_binding_pool_get_for_class")
+  (return-type "ClutterBindingPool*")
+  (parameters
+    '("gpointer" "klass")
+  )
 )
 
-(define-function clutter_rectangle_new_with_color
-  (c-name "clutter_rectangle_new_with_color")
-  (return-type "ClutterActor*")
+(define-function clutter_binding_pool_find
+  (c-name "clutter_binding_pool_find")
+  (return-type "ClutterBindingPool*")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("const-gchar*" "name")
   )
 )
 
-(define-method get_color
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_get_color")
+(define-method install_action
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_install_action")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "color")
+    '("const-gchar*" "action_name")
+    '("guint" "key_val")
+    '("ClutterModifierType" "modifiers")
+    '("GCallback" "callback")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
   )
 )
 
-(define-method set_color
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_set_color")
+(define-method install_closure
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_install_closure")
   (return-type "none")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("const-gchar*" "action_name")
+    '("guint" "key_val")
+    '("ClutterModifierType" "modifiers")
+    '("GClosure*" "closure")
   )
 )
 
-(define-method get_border_width
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_get_border_width")
-  (return-type "guint")
+(define-method list_actions
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_list_actions")
+  (return-type "gchar**")
 )
 
-(define-method set_border_width
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_set_border_width")
+(define-method find_action
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_find_action")
+  (return-type "const-gchar*")
+  (parameters
+    '("guint" "key_val")
+    '("ClutterModifierType" "modifiers")
+  )
+)
+
+(define-method remove_action
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_remove_action")
   (return-type "none")
   (parameters
-    '("guint" "width")
+    '("guint" "key_val")
+    '("ClutterModifierType" "modifiers")
   )
 )
 
-(define-method get_border_color
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_get_border_color")
+(define-method activate
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_activate")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "key_val")
+    '("ClutterModifierType" "modifiers")
+    '("GObject*" "gobject")
+  )
+)
+
+(define-method block_action
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_block_action")
   (return-type "none")
   (parameters
-    '("ClutterColor*" "color")
+    '("const-gchar*" "action_name")
   )
 )
 
-(define-method set_border_color
-  (of-object "ClutterRectangle")
-  (c-name "clutter_rectangle_set_border_color")
+(define-method unblock_action
+  (of-object "ClutterBindingPool")
+  (c-name "clutter_binding_pool_unblock_action")
   (return-type "none")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("const-gchar*" "action_name")
   )
 )
 
 
 
-;; From clutter-score.h
+;; From clutter-entry.h
 
-(define-function clutter_score_get_type
-  (c-name "clutter_score_get_type")
+(define-function clutter_entry_get_type
+  (c-name "clutter_entry_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_score_new
-  (c-name "clutter_score_new")
-  (is-constructor-of "ClutterScore")
-  (return-type "ClutterScore*")
-)
-
-(define-method set_loop
-  (of-object "ClutterScore")
-  (c-name "clutter_score_set_loop")
-  (return-type "none")
-  (parameters
-    '("gboolean" "loop")
-  )
-)
-
-(define-method get_loop
-  (of-object "ClutterScore")
-  (c-name "clutter_score_get_loop")
-  (return-type "gboolean")
+(define-function clutter_entry_new
+  (c-name "clutter_entry_new")
+  (is-constructor-of "ClutterEntry")
+  (return-type "ClutterActor*")
 )
 
-(define-method append
-  (of-object "ClutterScore")
-  (c-name "clutter_score_append")
-  (return-type "guint")
+(define-function clutter_entry_new_full
+  (c-name "clutter_entry_new_full")
+  (return-type "ClutterActor*")
   (parameters
-    '("ClutterTimeline*" "parent")
-    '("ClutterTimeline*" "timeline")
+    '("const-gchar*" "font_name")
+    '("const-gchar*" "text")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method append_at_marker
-  (of-object "ClutterScore")
-  (c-name "clutter_score_append_at_marker")
-  (return-type "guint")
+(define-function clutter_entry_new_with_text
+  (c-name "clutter_entry_new_with_text")
+  (return-type "ClutterActor*")
   (parameters
-    '("ClutterTimeline*" "parent")
-    '("const-gchar*" "marker_name")
-    '("ClutterTimeline*" "timeline")
+    '("const-gchar*" "font_name")
+    '("const-gchar*" "text")
   )
 )
 
-(define-method remove
-  (of-object "ClutterScore")
-  (c-name "clutter_score_remove")
+(define-method set_text
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_text")
   (return-type "none")
   (parameters
-    '("guint" "id")
+    '("const-gchar*" "text")
   )
 )
 
-(define-method remove_all
-  (of-object "ClutterScore")
-  (c-name "clutter_score_remove_all")
-  (return-type "none")
+(define-method get_text
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_text")
+  (return-type "const-gchar*")
 )
 
-(define-method get_timeline
-  (of-object "ClutterScore")
-  (c-name "clutter_score_get_timeline")
-  (return-type "ClutterTimeline*")
+(define-method set_font_name
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_font_name")
+  (return-type "none")
   (parameters
-    '("guint" "id")
+    '("const-gchar*" "font_name")
   )
 )
 
-(define-method list_timelines
-  (of-object "ClutterScore")
-  (c-name "clutter_score_list_timelines")
-  (return-type "GSList*")
+(define-method get_font_name
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_font_name")
+  (return-type "const-gchar*")
 )
 
-(define-method start
-  (of-object "ClutterScore")
-  (c-name "clutter_score_start")
+(define-method set_color
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_color")
   (return-type "none")
+  (parameters
+    '("const-ClutterColor*" "color")
+  )
 )
 
-(define-method stop
-  (of-object "ClutterScore")
-  (c-name "clutter_score_stop")
+(define-method get_color
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_color")
   (return-type "none")
+  (parameters
+    '("ClutterColor*" "color")
+  )
 )
 
-(define-method pause
-  (of-object "ClutterScore")
-  (c-name "clutter_score_pause")
-  (return-type "none")
+(define-method get_layout
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_layout")
+  (return-type "PangoLayout*")
 )
 
-(define-method rewind
-  (of-object "ClutterScore")
-  (c-name "clutter_score_rewind")
+(define-method set_alignment
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_alignment")
   (return-type "none")
+  (parameters
+    '("PangoAlignment" "alignment")
+  )
 )
 
-(define-method is_playing
-  (of-object "ClutterScore")
-  (c-name "clutter_score_is_playing")
-  (return-type "gboolean")
+(define-method get_alignment
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_alignment")
+  (return-type "PangoAlignment")
 )
 
+(define-method set_cursor_position
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_cursor_position")
+  (return-type "none")
+  (parameters
+    '("gint" "position")
+  )
+)
 
-
-;; From clutter-scriptable.h
-
-(define-function clutter_scriptable_get_type
-  (c-name "clutter_scriptable_get_type")
-  (return-type "GType")
+(define-method get_cursor_position
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_cursor_position")
+  (return-type "gint")
 )
 
-(define-method set_id
-  (of-object "ClutterScriptable")
-  (c-name "clutter_scriptable_set_id")
+(define-method insert_unichar
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_insert_unichar")
   (return-type "none")
   (parameters
-    '("const-gchar*" "id")
+    '("gunichar" "wc")
   )
 )
 
-(define-method get_id
-  (of-object "ClutterScriptable")
-  (c-name "clutter_scriptable_get_id")
-  (return-type "const-gchar*")
+(define-method delete_chars
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_delete_chars")
+  (return-type "none")
+  (parameters
+    '("guint" "len")
+  )
 )
 
-(define-method parse_custom_node
-  (of-object "ClutterScriptable")
-  (c-name "clutter_scriptable_parse_custom_node")
-  (return-type "gboolean")
+(define-method insert_text
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_insert_text")
+  (return-type "none")
   (parameters
-    '("ClutterScript*" "script")
-    '("GValue*" "value")
-    '("const-gchar*" "name")
-    '("JsonNode*" "node")
+    '("const-gchar*" "text")
+    '("gssize" "position")
   )
 )
 
-(define-method set_custom_property
-  (of-object "ClutterScriptable")
-  (c-name "clutter_scriptable_set_custom_property")
+(define-method delete_text
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_delete_text")
   (return-type "none")
   (parameters
-    '("ClutterScript*" "script")
-    '("const-gchar*" "name")
-    '("const-GValue*" "value")
+    '("gssize" "start_pos")
+    '("gssize" "end_pos")
   )
 )
 
+(define-method set_visible_cursor
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_visible_cursor")
+  (return-type "none")
+  (parameters
+    '("gboolean" "visible")
+  )
+)
 
-
-;; From clutter-script.h
-
-(define-function clutter_script_error_quark
-  (c-name "clutter_script_error_quark")
-  (return-type "GQuark")
+(define-method get_visible_cursor
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_visible_cursor")
+  (return-type "gboolean")
 )
 
-(define-function clutter_script_get_type
-  (c-name "clutter_script_get_type")
-  (return-type "GType")
+(define-method set_visibility
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_visibility")
+  (return-type "none")
+  (parameters
+    '("gboolean" "visible")
+  )
 )
 
-(define-function clutter_script_new
-  (c-name "clutter_script_new")
-  (is-constructor-of "ClutterScript")
-  (return-type "ClutterScript*")
+(define-method get_visibility
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_visibility")
+  (return-type "gboolean")
 )
 
-(define-method load_from_file
-  (of-object "ClutterScript")
-  (c-name "clutter_script_load_from_file")
-  (return-type "guint")
+(define-method set_invisible_char
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_invisible_char")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "filename")
-    '("GError**" "error")
+    '("gunichar" "wc")
   )
 )
 
-(define-method load_from_data
-  (of-object "ClutterScript")
-  (c-name "clutter_script_load_from_data")
-  (return-type "guint")
-  (parameters
-    '("const-gchar*" "data")
-    '("gssize" "length")
-    '("GError**" "error")
-  )
+(define-method get_invisible_char
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_invisible_char")
+  (return-type "gunichar")
 )
 
-(define-method get_object
-  (of-object "ClutterScript")
-  (c-name "clutter_script_get_object")
-  (return-type "GObject*")
+(define-method set_max_length
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_set_max_length")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
+    '("gint" "max")
   )
 )
 
-(define-method get_objects
-  (of-object "ClutterScript")
-  (c-name "clutter_script_get_objects")
+(define-method get_max_length
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_get_max_length")
   (return-type "gint")
-  (parameters
-    '("const-gchar*" "first_name")
-  )
-  (varargs #t)
 )
 
-(define-method unmerge_objects
-  (of-object "ClutterScript")
-  (c-name "clutter_script_unmerge_objects")
+(define-method handle_key_event
+  (of-object "ClutterEntry")
+  (c-name "clutter_entry_handle_key_event")
   (return-type "none")
   (parameters
-    '("guint" "merge_id")
+    '("ClutterKeyEvent*" "kev")
   )
 )
 
-(define-method ensure_objects
-  (of-object "ClutterScript")
-  (c-name "clutter_script_ensure_objects")
-  (return-type "none")
-)
 
-(define-method get_type_from_name
-  (of-object "ClutterScript")
-  (c-name "clutter_script_get_type_from_name")
-  (return-type "GType")
+
+;; From clutter-timeout-pool.h
+
+(define-function clutter_timeout_pool_new
+  (c-name "clutter_timeout_pool_new")
+  (is-constructor-of "ClutterTimeoutPool")
+  (return-type "ClutterTimeoutPool*")
   (parameters
-    '("const-gchar*" "type_name")
+    '("gint" "priority")
   )
 )
 
-(define-function clutter_get_script_id
-  (c-name "clutter_get_script_id")
-  (return-type "const-gchar*")
+(define-method add
+  (of-object "ClutterTimeoutPool")
+  (c-name "clutter_timeout_pool_add")
+  (return-type "guint")
   (parameters
-    '("GObject*" "gobject")
+    '("guint" "interval")
+    '("GSourceFunc" "func")
+    '("gpointer" "data")
+    '("GDestroyNotify" "notify")
   )
 )
 
-(define-method connect_signals
-  (of-object "ClutterScript")
-  (c-name "clutter_script_connect_signals")
+(define-method remove
+  (of-object "ClutterTimeoutPool")
+  (c-name "clutter_timeout_pool_remove")
   (return-type "none")
   (parameters
-    '("gpointer" "user_data")
+    '("guint" "id")
   )
 )
 
-(define-method connect_signals_full
-  (of-object "ClutterScript")
-  (c-name "clutter_script_connect_signals_full")
-  (return-type "none")
+
+
+;; From clutter-feature.h
+
+(define-function clutter_feature_available
+  (c-name "clutter_feature_available")
+  (return-type "gboolean")
   (parameters
-    '("ClutterScriptConnectFunc" "func")
-    '("gpointer" "user_data")
+    '("ClutterFeatureFlags" "feature")
   )
 )
 
+(define-function clutter_feature_get_all
+  (c-name "clutter_feature_get_all")
+  (return-type "ClutterFeatureFlags")
+)
+
 
-;; From clutter-shader.h
 
-(define-function clutter_shader_error_quark
-  (c-name "clutter_shader_error_quark")
-  (return-type "GQuark")
-)
+;; From clutter-label.h
 
-(define-function clutter_shader_get_type
-  (c-name "clutter_shader_get_type")
+(define-function clutter_label_get_type
+  (c-name "clutter_label_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_shader_new
-  (c-name "clutter_shader_new")
-  (is-constructor-of "ClutterShader")
-  (return-type "ClutterShader*")
+(define-function clutter_label_new
+  (c-name "clutter_label_new")
+  (is-constructor-of "ClutterLabel")
+  (return-type "ClutterActor*")
 )
 
-(define-method set_is_enabled
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_set_is_enabled")
-  (return-type "none")
+(define-function clutter_label_new_full
+  (c-name "clutter_label_new_full")
+  (return-type "ClutterActor*")
   (parameters
-    '("gboolean" "enabled")
+    '("const-gchar*" "font_name")
+    '("const-gchar*" "text")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method get_is_enabled
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_get_is_enabled")
-  (return-type "gboolean")
+(define-function clutter_label_new_with_text
+  (c-name "clutter_label_new_with_text")
+  (return-type "ClutterActor*")
+  (parameters
+    '("const-gchar*" "font_name")
+    '("const-gchar*" "text")
+  )
 )
 
-(define-method compile
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_compile")
-  (return-type "gboolean")
+(define-method set_text
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_text")
+  (return-type "none")
   (parameters
-    '("GError**" "error")
+    '("const-gchar*" "text")
   )
 )
 
-(define-method release
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_release")
+(define-method get_text
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_text")
+  (return-type "const-gchar*")
+)
+
+(define-method set_font_name
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_font_name")
   (return-type "none")
+  (parameters
+    '("const-gchar*" "font_name")
+  )
 )
 
-(define-method is_compiled
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_is_compiled")
-  (return-type "gboolean")
+(define-method get_font_name
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_font_name")
+  (return-type "const-gchar*")
 )
 
-(define-method set_vertex_source
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_set_vertex_source")
+(define-method set_color
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_color")
   (return-type "none")
   (parameters
-    '("const-gchar*" "data")
-    '("gssize" "length")
+    '("const-ClutterColor*" "color")
   )
 )
 
-(define-method set_fragment_source
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_set_fragment_source")
+(define-method get_color
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_color")
   (return-type "none")
   (parameters
-    '("const-gchar*" "data")
-    '("gssize" "length")
+    '("ClutterColor*" "color")
   )
 )
 
-(define-method get_vertex_source
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_get_vertex_source")
-  (return-type "const-gchar*")
+(define-method set_ellipsize
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_ellipsize")
+  (return-type "none")
+  (parameters
+    '("PangoEllipsizeMode" "mode")
+  )
 )
 
-(define-method get_fragment_source
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_get_fragment_source")
-  (return-type "const-gchar*")
+(define-method get_ellipsize
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_ellipsize")
+  (return-type "PangoEllipsizeMode")
 )
 
-(define-method set_uniform_1f
-  (of-object "ClutterShader")
-  (c-name "clutter_shader_set_uniform_1f")
+(define-method set_line_wrap
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_line_wrap")
   (return-type "none")
   (parameters
-    '("const-gchar*" "name")
-    '("gfloat" "value")
+    '("gboolean" "wrap")
   )
 )
 
-
-
-;; From clutter-stage.h
-
-(define-function clutter_perspective_get_type
-  (c-name "clutter_perspective_get_type")
-  (return-type "GType")
-)
-
-(define-function clutter_fog_get_type
-  (c-name "clutter_fog_get_type")
-  (return-type "GType")
+(define-method get_line_wrap
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_line_wrap")
+  (return-type "gboolean")
 )
 
-(define-function clutter_stage_get_type
-  (c-name "clutter_stage_get_type")
-  (return-type "GType")
+(define-method set_line_wrap_mode
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_line_wrap_mode")
+  (return-type "none")
+  (parameters
+    '("PangoWrapMode" "wrap_mode")
+  )
 )
 
-(define-function clutter_stage_get_default
-  (c-name "clutter_stage_get_default")
-  (return-type "ClutterActor*")
+(define-method get_line_wrap_mode
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_line_wrap_mode")
+  (return-type "PangoWrapMode")
 )
 
-(define-function clutter_stage_new
-  (c-name "clutter_stage_new")
-  (is-constructor-of "ClutterStage")
-  (return-type "ClutterActor*")
+(define-method get_layout
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_layout")
+  (return-type "PangoLayout*")
 )
 
-(define-method set_color
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_color")
+(define-method set_attributes
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_attributes")
   (return-type "none")
   (parameters
-    '("const-ClutterColor*" "color")
+    '("PangoAttrList*" "attrs")
   )
 )
 
-(define-method get_color
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_color")
-  (return-type "none")
-  (parameters
-    '("ClutterColor*" "color")
-  )
+(define-method get_attributes
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_attributes")
+  (return-type "PangoAttrList*")
 )
 
-(define-method set_perspectivex
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_perspectivex")
+(define-method set_use_markup
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_use_markup")
   (return-type "none")
   (parameters
-    '("ClutterPerspective*" "perspective")
+    '("gboolean" "setting")
   )
 )
 
-(define-method get_perspectivex
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_perspectivex")
-  (return-type "none")
-  (parameters
-    '("ClutterPerspective*" "perspective")
-  )
+(define-method get_use_markup
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_use_markup")
+  (return-type "gboolean")
 )
 
-(define-method set_perspective
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_perspective")
+(define-method set_alignment
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_alignment")
   (return-type "none")
   (parameters
-    '("gfloat" "fovy")
-    '("gfloat" "aspect")
-    '("gfloat" "z_near")
-    '("gfloat" "z_far")
+    '("PangoAlignment" "alignment")
   )
 )
 
-(define-method get_perspective
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_perspective")
+(define-method get_alignment
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_alignment")
+  (return-type "PangoAlignment")
+)
+
+(define-method set_justify
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_set_justify")
   (return-type "none")
   (parameters
-    '("gfloat*" "fovy")
-    '("gfloat*" "aspect")
-    '("gfloat*" "z_near")
-    '("gfloat*" "z_far")
+    '("gboolean" "justify")
   )
 )
 
-(define-method fullscreen
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_fullscreen")
-  (return-type "none")
+(define-method get_justify
+  (of-object "ClutterLabel")
+  (c-name "clutter_label_get_justify")
+  (return-type "gboolean")
 )
 
-(define-method unfullscreen
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_unfullscreen")
-  (return-type "none")
-)
 
-(define-method show_cursor
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_show_cursor")
-  (return-type "none")
-)
 
-(define-method hide_cursor
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_hide_cursor")
-  (return-type "none")
+;; From clutter-version.h
+
+
+
+;; From clutter-behaviour-ellipse.h
+
+(define-function clutter_behaviour_ellipse_get_type
+  (c-name "clutter_behaviour_ellipse_get_type")
+  (return-type "GType")
 )
 
-(define-method get_actor_at_pos
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_actor_at_pos")
-  (return-type "ClutterActor*")
+(define-function clutter_behaviour_ellipse_new
+  (c-name "clutter_behaviour_ellipse_new")
+  (is-constructor-of "ClutterBehaviourEllipse")
+  (return-type "ClutterBehaviour*")
   (parameters
+    '("ClutterAlpha*" "alpha")
     '("gint" "x")
     '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
+    '("ClutterRotateDirection" "direction")
+    '("gdouble" "start")
+    '("gdouble" "end")
   )
 )
 
-(define-method read_pixels
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_read_pixels")
-  (return-type "guchar*")
+(define-function clutter_behaviour_ellipse_newx
+  (c-name "clutter_behaviour_ellipse_newx")
+  (return-type "ClutterBehaviour*")
   (parameters
+    '("ClutterAlpha*" "alpha")
     '("gint" "x")
     '("gint" "y")
     '("gint" "width")
     '("gint" "height")
+    '("ClutterRotateDirection" "direction")
+    '("ClutterFixed" "start")
+    '("ClutterFixed" "end")
   )
 )
 
-(define-method event
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_event")
-  (return-type "gboolean")
+(define-method set_center
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_center")
+  (return-type "none")
   (parameters
-    '("ClutterEvent*" "event")
+    '("gint" "x")
+    '("gint" "y")
   )
 )
 
-(define-method set_title
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_title")
+(define-method get_center
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_center")
   (return-type "none")
   (parameters
-    '("const-gchar*" "title")
+    '("gint*" "x")
+    '("gint*" "y")
   )
 )
 
-(define-method get_title
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_title")
-  (return-type "const-gchar*")
-)
-
-(define-method set_user_resizable
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_user_resizable")
+(define-method set_width
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_width")
   (return-type "none")
   (parameters
-    '("gboolean" "resizable")
+    '("gint" "width")
   )
 )
 
-(define-method get_user_resizable
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_user_resizable")
-  (return-type "gboolean")
+(define-method get_width
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_width")
+  (return-type "gint")
 )
 
-(define-method set_use_fog
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_use_fog")
+(define-method set_height
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_height")
   (return-type "none")
   (parameters
-    '("gboolean" "fog")
+    '("gint" "height")
   )
 )
 
-(define-method get_use_fog
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_use_fog")
-  (return-type "gboolean")
+(define-method get_height
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_height")
+  (return-type "gint")
 )
 
-(define-method set_fog
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_fog")
+(define-method set_angle_start
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_start")
   (return-type "none")
   (parameters
-    '("gdouble" "density")
-    '("gdouble" "z_near")
-    '("gdouble" "z_far")
+    '("gdouble" "angle_start")
   )
 )
 
-(define-method get_fog
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_fog")
+(define-method set_angle_startx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_startx")
   (return-type "none")
   (parameters
-    '("gdouble*" "density")
-    '("gdouble*" "z_near")
-    '("gdouble*" "z_far")
+    '("ClutterFixed" "angle_start")
   )
 )
 
-(define-method set_fogx
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_fogx")
+(define-method get_angle_startx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_startx")
+  (return-type "ClutterFixed")
+)
+
+(define-method get_angle_start
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_start")
+  (return-type "gdouble")
+)
+
+(define-method set_angle_endx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_endx")
   (return-type "none")
   (parameters
-    '("ClutterFog*" "fog")
+    '("ClutterFixed" "angle_end")
   )
 )
 
-(define-method get_fogx
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_fogx")
+(define-method set_angle_end
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_end")
   (return-type "none")
   (parameters
-    '("ClutterFog*" "fog")
+    '("gdouble" "angle_end")
   )
 )
 
-(define-method get_resolution
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_resolution")
-  (return-type "gdouble")
+(define-method get_angle_endx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_endx")
+  (return-type "ClutterFixed")
 )
 
-(define-method get_resolutionx
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_resolutionx")
-  (return-type "ClutterFixed")
+(define-method get_angle_end
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_end")
+  (return-type "gdouble")
 )
 
-(define-method set_key_focus
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_set_key_focus")
+(define-method set_angle_tiltx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_tiltx")
   (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("ClutterRotateAxis" "axis")
+    '("ClutterFixed" "angle_tilt")
   )
 )
 
-(define-method get_key_focus
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_get_key_focus")
-  (return-type "ClutterActor*")
-)
-
-(define-method ensure_current
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_ensure_current")
+(define-method set_angle_tilt
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_angle_tilt")
   (return-type "none")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+    '("gdouble" "angle_tilt")
+  )
 )
 
-(define-method queue_redraw
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_queue_redraw")
-  (return-type "none")
+(define-method get_angle_tiltx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_tiltx")
+  (return-type "ClutterFixed")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+  )
 )
 
-(define-method is_default
-  (of-object "ClutterStage")
-  (c-name "clutter_stage_is_default")
-  (return-type "gboolean")
+(define-method get_angle_tilt
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_angle_tilt")
+  (return-type "gdouble")
+  (parameters
+    '("ClutterRotateAxis" "axis")
+  )
 )
 
-
-
-;; From clutter-stage-manager.h
-
-(define-function clutter_stage_manager_get_type
-  (c-name "clutter_stage_manager_get_type")
-  (return-type "GType")
+(define-method set_tilt
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_tilt")
+  (return-type "none")
+  (parameters
+    '("gdouble" "angle_tilt_x")
+    '("gdouble" "angle_tilt_y")
+    '("gdouble" "angle_tilt_z")
+  )
 )
 
-(define-function clutter_stage_manager_get_default
-  (c-name "clutter_stage_manager_get_default")
-  (return-type "ClutterStageManager*")
+(define-method set_tiltx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_tiltx")
+  (return-type "none")
+  (parameters
+    '("ClutterFixed" "angle_tilt_x")
+    '("ClutterFixed" "angle_tilt_y")
+    '("ClutterFixed" "angle_tilt_z")
+  )
 )
 
-(define-method set_default_stage
-  (of-object "ClutterStageManager")
-  (c-name "clutter_stage_manager_set_default_stage")
+(define-method get_tilt
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_tilt")
   (return-type "none")
   (parameters
-    '("ClutterStage*" "stage")
+    '("gdouble*" "angle_tilt_x")
+    '("gdouble*" "angle_tilt_y")
+    '("gdouble*" "angle_tilt_z")
   )
 )
 
-(define-method get_default_stage
-  (of-object "ClutterStageManager")
-  (c-name "clutter_stage_manager_get_default_stage")
-  (return-type "ClutterStage*")
+(define-method get_tiltx
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_tiltx")
+  (return-type "none")
+  (parameters
+    '("ClutterFixed*" "angle_tilt_x")
+    '("ClutterFixed*" "angle_tilt_y")
+    '("ClutterFixed*" "angle_tilt_z")
+  )
 )
 
-(define-method list_stages
-  (of-object "ClutterStageManager")
-  (c-name "clutter_stage_manager_list_stages")
-  (return-type "GSList*")
+(define-method get_direction
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_get_direction")
+  (return-type "ClutterRotateDirection")
 )
 
+(define-method set_direction
+  (of-object "ClutterBehaviourEllipse")
+  (c-name "clutter_behaviour_ellipse_set_direction")
+  (return-type "none")
+  (parameters
+    '("ClutterRotateDirection" "direction")
+  )
+)
 
 
-;; From clutter-stage-window.h
-
-(define-function clutter_stage_window_get_type
-  (c-name "clutter_stage_window_get_type")
-  (return-type "GType")
-)
 
+;; From clutter-glx.h
 
 
-;; From clutter-texture.h
 
-(define-function clutter_texture_error_quark
-  (c-name "clutter_texture_error_quark")
-  (return-type "GQuark")
-)
+;; From clutter-glx-texture-pixmap.h
 
-(define-function clutter_texture_get_type
-  (c-name "clutter_texture_get_type")
+(define-function clutter_glx_texture_pixmap_get_type
+  (c-name "clutter_glx_texture_pixmap_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_texture_handle_get_type
-  (c-name "clutter_texture_handle_get_type")
-  (return-type "GType")
+(define-function clutter_glx_texture_pixmap_new
+  (c-name "clutter_glx_texture_pixmap_new")
+  (is-constructor-of "ClutterGlxTexturePixmap")
+  (return-type "ClutterActor*")
 )
 
-(define-function clutter_texture_new
-  (c-name "clutter_texture_new")
-  (is-constructor-of "ClutterTexture")
+(define-function clutter_glx_texture_pixmap_new_with_pixmap
+  (c-name "clutter_glx_texture_pixmap_new_with_pixmap")
   (return-type "ClutterActor*")
+  (parameters
+    '("Pixmap" "pixmap")
+  )
 )
 
-(define-function clutter_texture_new_from_file
-  (c-name "clutter_texture_new_from_file")
+(define-function clutter_glx_texture_pixmap_new_with_window
+  (c-name "clutter_glx_texture_pixmap_new_with_window")
   (return-type "ClutterActor*")
   (parameters
-    '("const-gchar*" "filename")
-    '("GError**" "error")
+    '("Window" "window")
   )
 )
 
-(define-method set_from_file
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_from_file")
+(define-method using_extension
+  (of-object "ClutterGLXTexturePixmap")
+  (c-name "clutter_glx_texture_pixmap_using_extension")
   (return-type "gboolean")
+)
+
+
+
+;; From json-types.h
+
+(define-function json_node_new
+  (c-name "json_node_new")
+  (is-constructor-of "JsonNode")
+  (return-type "JsonNode*")
   (parameters
-    '("const-gchar*" "filename")
-    '("GError**" "error")
+    '("JsonNodeType" "type")
   )
 )
 
-(define-method set_from_rgb_data
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_from_rgb_data")
-  (return-type "gboolean")
+(define-method copy
+  (of-object "JsonNode")
+  (c-name "json_node_copy")
+  (return-type "JsonNode*")
+)
+
+(define-method free
+  (of-object "JsonNode")
+  (c-name "json_node_free")
+  (return-type "none")
+)
+
+(define-method set_object
+  (of-object "JsonNode")
+  (c-name "json_node_set_object")
+  (return-type "none")
   (parameters
-    '("const-guchar*" "data")
-    '("gboolean" "has_alpha")
-    '("gint" "width")
-    '("gint" "height")
-    '("gint" "rowstride")
-    '("gint" "bpp")
-    '("ClutterTextureFlags" "flags")
-    '("GError**" "error")
+    '("JsonObject*" "object")
   )
 )
 
-(define-function clutter_texture_new_from_actor
-  (c-name "clutter_texture_new_from_actor")
-  (return-type "ClutterActor*")
+(define-method take_object
+  (of-object "JsonNode")
+  (c-name "json_node_take_object")
+  (return-type "none")
   (parameters
-    '("ClutterActor*" "actor")
+    '("JsonObject*" "object")
   )
 )
 
-(define-method set_area_from_rgb_data
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_area_from_rgb_data")
-  (return-type "gboolean")
+(define-method get_object
+  (of-object "JsonNode")
+  (c-name "json_node_get_object")
+  (return-type "JsonObject*")
+)
+
+(define-method dup_object
+  (of-object "JsonNode")
+  (c-name "json_node_dup_object")
+  (return-type "JsonObject*")
+)
+
+(define-method set_array
+  (of-object "JsonNode")
+  (c-name "json_node_set_array")
+  (return-type "none")
   (parameters
-    '("const-guchar*" "data")
-    '("gboolean" "has_alpha")
-    '("gint" "x")
-    '("gint" "y")
-    '("gint" "width")
-    '("gint" "height")
-    '("gint" "rowstride")
-    '("gint" "bpp")
-    '("ClutterTextureFlags" "flags")
-    '("GError**" "error")
+    '("JsonArray*" "array")
   )
 )
 
-(define-method set_from_yuv_data
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_from_yuv_data")
-  (return-type "gboolean")
+(define-method take_array
+  (of-object "JsonNode")
+  (c-name "json_node_take_array")
+  (return-type "none")
   (parameters
-    '("const-guchar*" "data")
-    '("gint" "width")
-    '("gint" "height")
-    '("ClutterTextureFlags" "flags")
-    '("GError**" "error")
+    '("JsonArray*" "array")
   )
 )
 
-(define-method get_base_size
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_get_base_size")
+(define-method get_array
+  (of-object "JsonNode")
+  (c-name "json_node_get_array")
+  (return-type "JsonArray*")
+)
+
+(define-method dup_array
+  (of-object "JsonNode")
+  (c-name "json_node_dup_array")
+  (return-type "JsonArray*")
+)
+
+(define-method set_value
+  (of-object "JsonNode")
+  (c-name "json_node_set_value")
   (return-type "none")
   (parameters
-    '("gint*" "width")
-    '("gint*" "height")
+    '("const-GValue*" "value")
   )
 )
 
-(define-method set_filter_quality
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_filter_quality")
+(define-method get_value
+  (of-object "JsonNode")
+  (c-name "json_node_get_value")
   (return-type "none")
   (parameters
-    '("ClutterTextureQuality" "filter_quality")
+    '("GValue*" "value")
   )
 )
 
-(define-method get_filter_quality
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_get_filter_quality")
-  (return-type "ClutterTextureQuality")
+(define-method set_string
+  (of-object "JsonNode")
+  (c-name "json_node_set_string")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "value")
+  )
 )
 
-(define-method set_max_tile_waste
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_max_tile_waste")
+(define-method get_string
+  (of-object "JsonNode")
+  (c-name "json_node_get_string")
+  (return-type "const-gchar*")
+)
+
+(define-method dup_string
+  (of-object "JsonNode")
+  (c-name "json_node_dup_string")
+  (return-type "gchar*")
+)
+
+(define-method set_int
+  (of-object "JsonNode")
+  (c-name "json_node_set_int")
   (return-type "none")
   (parameters
-    '("gint" "max_tile_waste")
+    '("gint" "value")
   )
 )
 
-(define-method get_max_tile_waste
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_get_max_tile_waste")
+(define-method get_int
+  (of-object "JsonNode")
+  (c-name "json_node_get_int")
   (return-type "gint")
 )
 
-(define-method get_cogl_texture
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_get_cogl_texture")
-  (return-type "CoglHandle")
+(define-method set_double
+  (of-object "JsonNode")
+  (c-name "json_node_set_double")
+  (return-type "none")
+  (parameters
+    '("gdouble" "value")
+  )
 )
 
-(define-method set_cogl_texture
-  (of-object "ClutterTexture")
-  (c-name "clutter_texture_set_cogl_texture")
+(define-method get_double
+  (of-object "JsonNode")
+  (c-name "json_node_get_double")
+  (return-type "gdouble")
+)
+
+(define-method set_boolean
+  (of-object "JsonNode")
+  (c-name "json_node_set_boolean")
   (return-type "none")
   (parameters
-    '("CoglHandle" "cogl_tex")
+    '("gboolean" "value")
   )
 )
 
+(define-method get_boolean
+  (of-object "JsonNode")
+  (c-name "json_node_get_boolean")
+  (return-type "gboolean")
+)
 
+(define-method get_parent
+  (of-object "JsonNode")
+  (c-name "json_node_get_parent")
+  (return-type "JsonNode*")
+)
 
-;; From clutter-timeline.h
+(define-method type_name
+  (of-object "JsonNode")
+  (c-name "json_node_type_name")
+  (return-type "const-gchar*")
+)
 
-(define-function clutter_timeline_get_type
-  (c-name "clutter_timeline_get_type")
+(define-function json_object_get_type
+  (c-name "json_object_get_type")
   (return-type "GType")
 )
 
-(define-function clutter_timeline_new
-  (c-name "clutter_timeline_new")
-  (is-constructor-of "ClutterTimeline")
-  (return-type "ClutterTimeline*")
-  (parameters
-    '("guint" "n_frames")
-    '("guint" "fps")
-  )
+(define-function json_object_new
+  (c-name "json_object_new")
+  (is-constructor-of "JsonObject")
+  (return-type "JsonObject*")
 )
 
-(define-function clutter_timeline_new_for_duration
-  (c-name "clutter_timeline_new_for_duration")
-  (return-type "ClutterTimeline*")
+(define-method ref
+  (of-object "JsonObject")
+  (c-name "json_object_ref")
+  (return-type "JsonObject*")
+)
+
+(define-method unref
+  (of-object "JsonObject")
+  (c-name "json_object_unref")
+  (return-type "none")
+)
+
+(define-method add_member
+  (of-object "JsonObject")
+  (c-name "json_object_add_member")
+  (return-type "none")
   (parameters
-    '("guint" "msecs")
+    '("const-gchar*" "member_name")
+    '("JsonNode*" "node")
   )
 )
 
-(define-method clone
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_clone")
-  (return-type "ClutterTimeline*")
+(define-method get_members
+  (of-object "JsonObject")
+  (c-name "json_object_get_members")
+  (return-type "GList*")
 )
 
-(define-method get_duration
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_duration")
-  (return-type "guint")
+(define-method get_member
+  (of-object "JsonObject")
+  (c-name "json_object_get_member")
+  (return-type "JsonNode*")
+  (parameters
+    '("const-gchar*" "member_name")
+  )
 )
 
-(define-method set_duration
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_duration")
+(define-method has_member
+  (of-object "JsonObject")
+  (c-name "json_object_has_member")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "member_name")
+  )
+)
+
+(define-method remove_member
+  (of-object "JsonObject")
+  (c-name "json_object_remove_member")
   (return-type "none")
   (parameters
-    '("guint" "msecs")
+    '("const-gchar*" "member_name")
   )
 )
 
-(define-method get_speed
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_speed")
+(define-method get_size
+  (of-object "JsonObject")
+  (c-name "json_object_get_size")
   (return-type "guint")
 )
 
-(define-method set_speed
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_speed")
-  (return-type "none")
-  (parameters
-    '("guint" "fps")
-  )
+(define-function json_array_get_type
+  (c-name "json_array_get_type")
+  (return-type "GType")
 )
 
-(define-method get_direction
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_direction")
-  (return-type "ClutterTimelineDirection")
+(define-function json_array_new
+  (c-name "json_array_new")
+  (is-constructor-of "JsonArray")
+  (return-type "JsonArray*")
 )
 
-(define-method set_direction
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_direction")
-  (return-type "none")
+(define-function json_array_sized_new
+  (c-name "json_array_sized_new")
+  (is-constructor-of "JsonArraySized")
+  (return-type "JsonArray*")
   (parameters
-    '("ClutterTimelineDirection" "direction")
+    '("guint" "n_elements")
   )
 )
 
-(define-method start
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_start")
-  (return-type "none")
+(define-method ref
+  (of-object "JsonArray")
+  (c-name "json_array_ref")
+  (return-type "JsonArray*")
 )
 
-(define-method pause
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_pause")
+(define-method unref
+  (of-object "JsonArray")
+  (c-name "json_array_unref")
   (return-type "none")
 )
 
-(define-method stop
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_stop")
+(define-method add_element
+  (of-object "JsonArray")
+  (c-name "json_array_add_element")
   (return-type "none")
+  (parameters
+    '("JsonNode*" "node")
+  )
 )
 
-(define-method set_loop
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_loop")
+(define-method get_elements
+  (of-object "JsonArray")
+  (c-name "json_array_get_elements")
+  (return-type "GList*")
+)
+
+(define-method get_element
+  (of-object "JsonArray")
+  (c-name "json_array_get_element")
+  (return-type "JsonNode*")
+  (parameters
+    '("guint" "index_")
+  )
+)
+
+(define-method remove_element
+  (of-object "JsonArray")
+  (c-name "json_array_remove_element")
   (return-type "none")
   (parameters
-    '("gboolean" "loop")
+    '("guint" "index_")
   )
 )
 
-(define-method get_loop
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_loop")
-  (return-type "gboolean")
+(define-method get_length
+  (of-object "JsonArray")
+  (c-name "json_array_get_length")
+  (return-type "guint")
 )
 
-(define-method rewind
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_rewind")
-  (return-type "none")
+
+
+;; From json-generator.h
+
+(define-function json_generator_get_type
+  (c-name "json_generator_get_type")
+  (return-type "GType")
+)
+
+(define-function json_generator_new
+  (c-name "json_generator_new")
+  (is-constructor-of "JsonGenerator")
+  (return-type "JsonGenerator*")
 )
 
-(define-method skip
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_skip")
-  (return-type "none")
+(define-method to_data
+  (of-object "JsonGenerator")
+  (c-name "json_generator_to_data")
+  (return-type "gchar*")
   (parameters
-    '("guint" "n_frames")
+    '("gsize*" "length")
   )
 )
 
-(define-method advance
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_advance")
-  (return-type "none")
+(define-method to_file
+  (of-object "JsonGenerator")
+  (c-name "json_generator_to_file")
+  (return-type "gboolean")
   (parameters
-    '("guint" "frame_num")
+    '("const-gchar*" "filename")
+    '("GError**" "error")
   )
 )
 
-(define-method get_current_frame
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_current_frame")
-  (return-type "gint")
+(define-method set_root
+  (of-object "JsonGenerator")
+  (c-name "json_generator_set_root")
+  (return-type "none")
+  (parameters
+    '("JsonNode*" "node")
+  )
 )
 
-(define-method get_progress
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_progress")
-  (return-type "gdouble")
-)
 
-(define-method get_progressx
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_progressx")
-  (return-type "ClutterFixed")
+
+;; From json-glib.h
+
+
+
+;; From json-marshal.h
+
+
+
+;; From json-parser.h
+
+(define-function json_parser_error_quark
+  (c-name "json_parser_error_quark")
+  (return-type "GQuark")
 )
 
-(define-method set_n_frames
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_n_frames")
-  (return-type "none")
-  (parameters
-    '("guint" "n_frames")
-  )
+(define-function json_parser_get_type
+  (c-name "json_parser_get_type")
+  (return-type "GType")
 )
 
-(define-method get_n_frames
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_n_frames")
-  (return-type "guint")
+(define-function json_parser_new
+  (c-name "json_parser_new")
+  (is-constructor-of "JsonParser")
+  (return-type "JsonParser*")
 )
 
-(define-method is_playing
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_is_playing")
+(define-method load_from_file
+  (of-object "JsonParser")
+  (c-name "json_parser_load_from_file")
   (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("GError**" "error")
+  )
 )
 
-(define-method set_delay
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_set_delay")
-  (return-type "none")
+(define-method load_from_data
+  (of-object "JsonParser")
+  (c-name "json_parser_load_from_data")
+  (return-type "gboolean")
   (parameters
-    '("guint" "msecs")
+    '("const-gchar*" "data")
+    '("gssize" "length")
+    '("GError**" "error")
   )
 )
 
-(define-method get_delay
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_delay")
+(define-method get_root
+  (of-object "JsonParser")
+  (c-name "json_parser_get_root")
+  (return-type "JsonNode*")
+)
+
+(define-method get_current_line
+  (of-object "JsonParser")
+  (c-name "json_parser_get_current_line")
   (return-type "guint")
 )
 
-(define-method get_delta
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_get_delta")
+(define-method get_current_pos
+  (of-object "JsonParser")
+  (c-name "json_parser_get_current_pos")
   (return-type "guint")
-  (parameters
-    '("guint*" "msecs")
-  )
 )
 
-(define-method add_marker_at_frame
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_add_marker_at_frame")
-  (return-type "none")
-  (parameters
-    '("const-gchar*" "marker_name")
-    '("guint" "frame_num")
-  )
+
+
+;; From clutter-x11-texture-pixmap.h
+
+(define-function clutter_x11_texture_pixmap_get_type
+  (c-name "clutter_x11_texture_pixmap_get_type")
+  (return-type "GType")
 )
 
-(define-method add_marker_at_time
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_add_marker_at_time")
-  (return-type "none")
-  (parameters
-    '("const-gchar*" "marker_name")
-    '("guint" "msecs")
-  )
+(define-function clutter_x11_texture_pixmap_new
+  (c-name "clutter_x11_texture_pixmap_new")
+  (is-constructor-of "ClutterX11TexturePixmap")
+  (return-type "ClutterActor*")
 )
 
-(define-method remove_marker
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_remove_marker")
-  (return-type "none")
+(define-function clutter_x11_texture_pixmap_new_with_pixmap
+  (c-name "clutter_x11_texture_pixmap_new_with_pixmap")
+  (return-type "ClutterActor*")
   (parameters
-    '("const-gchar*" "marker_name")
+    '("Pixmap" "pixmap")
   )
 )
 
-(define-method list_markers
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_list_markers")
-  (return-type "gchar**")
+(define-function clutter_x11_texture_pixmap_new_with_window
+  (c-name "clutter_x11_texture_pixmap_new_with_window")
+  (return-type "ClutterActor*")
   (parameters
-    '("gint" "frame_num")
-    '("gsize*" "n_markers")
+    '("Window" "window")
   )
 )
 
-(define-method has_marker
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_has_marker")
-  (return-type "gboolean")
+(define-method set_pixmap
+  (of-object "ClutterX11TexturePixmap")
+  (c-name "clutter_x11_texture_pixmap_set_pixmap")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "marker_name")
+    '("Pixmap" "pixmap")
   )
 )
 
-(define-method advance_to_marker
-  (of-object "ClutterTimeline")
-  (c-name "clutter_timeline_advance_to_marker")
+(define-method set_window
+  (of-object "ClutterX11TexturePixmap")
+  (c-name "clutter_x11_texture_pixmap_set_window")
   (return-type "none")
   (parameters
-    '("const-gchar*" "marker_name")
+    '("Window" "window")
+    '("gboolean" "automatic")
   )
 )
 
-
-
-;; From clutter-timeout-pool.h
-
-(define-function clutter_timeout_pool_new
-  (c-name "clutter_timeout_pool_new")
-  (is-constructor-of "ClutterTimeoutPool")
-  (return-type "ClutterTimeoutPool*")
-  (parameters
-    '("gint" "priority")
-  )
+(define-method sync_window
+  (of-object "ClutterX11TexturePixmap")
+  (c-name "clutter_x11_texture_pixmap_sync_window")
+  (return-type "none")
 )
 
-(define-method add
-  (of-object "ClutterTimeoutPool")
-  (c-name "clutter_timeout_pool_add")
-  (return-type "guint")
+(define-method update_area
+  (of-object "ClutterX11TexturePixmap")
+  (c-name "clutter_x11_texture_pixmap_update_area")
+  (return-type "none")
   (parameters
-    '("guint" "interval")
-    '("GSourceFunc" "func")
-    '("gpointer" "data")
-    '("GDestroyNotify" "notify")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "width")
+    '("gint" "height")
   )
 )
 
-(define-method remove
-  (of-object "ClutterTimeoutPool")
-  (c-name "clutter_timeout_pool_remove")
+(define-method set_automatic
+  (of-object "ClutterX11TexturePixmap")
+  (c-name "clutter_x11_texture_pixmap_set_automatic")
   (return-type "none")
   (parameters
-    '("guint" "id")
+    '("gboolean" "setting")
   )
 )
 
 
 
-;; From clutter-types.h
+;; From clutter-x11.h
 
-(define-function clutter_geometry_get_type
-  (c-name "clutter_geometry_get_type")
-  (return-type "GType")
+(define-function clutter_x11_trap_x_errors
+  (c-name "clutter_x11_trap_x_errors")
+  (return-type "none")
 )
 
-(define-function clutter_vertex_get_type
-  (c-name "clutter_vertex_get_type")
-  (return-type "GType")
+(define-function clutter_x11_untrap_x_errors
+  (c-name "clutter_x11_untrap_x_errors")
+  (return-type "gint")
 )
 
-(define-function clutter_knot_get_type
-  (c-name "clutter_knot_get_type")
-  (return-type "GType")
+(define-function clutter_x11_get_default_display
+  (c-name "clutter_x11_get_default_display")
+  (return-type "Display*")
 )
 
-(define-method copy
-  (of-object "ClutterKnot")
-  (c-name "clutter_knot_copy")
-  (return-type "ClutterKnot*")
+(define-function clutter_x11_get_default_screen
+  (c-name "clutter_x11_get_default_screen")
+  (return-type "int")
 )
 
-(define-method free
-  (of-object "ClutterKnot")
-  (c-name "clutter_knot_free")
-  (return-type "none")
+(define-function clutter_x11_get_root_window
+  (c-name "clutter_x11_get_root_window")
+  (return-type "Window")
 )
 
-(define-method equal
-  (of-object "ClutterKnot")
-  (c-name "clutter_knot_equal")
-  (return-type "gboolean")
+(define-function clutter_x11_set_display
+  (c-name "clutter_x11_set_display")
+  (return-type "none")
   (parameters
-    '("const-ClutterKnot*" "knot_b")
+    '("Display*" "xdpy")
   )
 )
 
+(define-function clutter_x11_get_stage_window
+  (c-name "clutter_x11_get_stage_window")
+  (return-type "Window")
+  (parameters
+    '("ClutterStage*" "stage")
+  )
+)
 
+(define-function clutter_x11_get_stage_visual
+  (c-name "clutter_x11_get_stage_visual")
+  (return-type "XVisualInfo*")
+  (parameters
+    '("ClutterStage*" "stage")
+  )
+)
 
-;; From clutter-units.h
-
-(define-function clutter_unit_get_type
-  (c-name "clutter_unit_get_type")
-  (return-type "GType")
+(define-function clutter_x11_set_stage_foreign
+  (c-name "clutter_x11_set_stage_foreign")
+  (return-type "gboolean")
+  (parameters
+    '("ClutterStage*" "stage")
+    '("Window" "xwindow")
+  )
 )
 
-(define-function clutter_param_unit_get_type
-  (c-name "clutter_param_unit_get_type")
-  (return-type "GType")
+(define-function clutter_x11_add_filter
+  (c-name "clutter_x11_add_filter")
+  (return-type "none")
+  (parameters
+    '("ClutterX11FilterFunc" "func")
+    '("gpointer" "data")
+  )
 )
 
-(define-function clutter_value_set_unit
-  (c-name "clutter_value_set_unit")
+(define-function clutter_x11_remove_filter
+  (c-name "clutter_x11_remove_filter")
   (return-type "none")
   (parameters
-    '("GValue*" "value")
-    '("ClutterUnit" "units")
+    '("ClutterX11FilterFunc" "func")
+    '("gpointer" "data")
   )
 )
 
-(define-function clutter_value_get_unit
-  (c-name "clutter_value_get_unit")
-  (return-type "ClutterUnit")
+(define-function clutter_x11_handle_event
+  (c-name "clutter_x11_handle_event")
+  (return-type "ClutterX11FilterReturn")
   (parameters
-    '("const-GValue*" "value")
+    '("XEvent*" "xevent")
   )
 )
 
-(define-function clutter_param_spec_unit
-  (c-name "clutter_param_spec_unit")
-  (return-type "GParamSpec*")
+(define-function clutter_x11_set_display
+  (c-name "clutter_x11_set_display")
+  (return-type "none")
   (parameters
-    '("const-gchar*" "name")
-    '("const-gchar*" "nick")
-    '("const-gchar*" "blurb")
-    '("ClutterUnit" "minimum")
-    '("ClutterUnit" "maximum")
-    '("ClutterUnit" "default_value")
-    '("GParamFlags" "flags")
+    '("Display*" "xdpy")
   )
 )
 
+(define-function clutter_x11_disable_event_retrieval
+  (c-name "clutter_x11_disable_event_retrieval")
+  (return-type "none")
+)
 
+(define-function clutter_x11_has_event_retrieval
+  (c-name "clutter_x11_has_event_retrieval")
+  (return-type "gboolean")
+)
 
-;; From clutter-util.h
+(define-function clutter_x11_get_stage_from_window
+  (c-name "clutter_x11_get_stage_from_window")
+  (return-type "ClutterStage*")
+  (parameters
+    '("Window" "win")
+  )
+)
 
-(define-function clutter_util_next_p2
-  (c-name "clutter_util_next_p2")
-  (return-type "int")
+(define-function clutter_x11_get_input_devices
+  (c-name "clutter_x11_get_input_devices")
+  (return-type "GSList*")
+)
+
+(define-function clutter_x11_get_input_device_type
+  (c-name "clutter_x11_get_input_device_type")
+  (return-type "ClutterX11InputDeviceType")
   (parameters
-    '("int" "a")
+    '("ClutterX11XInputDevice*" "device")
   )
 )
 
+(define-function clutter_x11_enable_xinput
+  (c-name "clutter_x11_enable_xinput")
+  (return-type "none")
+)
 
+(define-function clutter_x11_has_xinput
+  (c-name "clutter_x11_has_xinput")
+  (return-type "gboolean")
+)
 
-;; From clutter-version.h
+(define-function clutter_x11_has_composite_extension
+  (c-name "clutter_x11_has_composite_extension")
+  (return-type "gboolean")
+)
 
 
 
-;; From stamp-clutter-enum-types.h
+;; From clutter-x11-enum-types.h
 
+(define-function clutter_x11_filter_return_get_type
+  (c-name "clutter_x11_filter_return_get_type")
+  (return-type "GType")
+)
 
+(define-function clutter_x11_xinput_event_types_get_type
+  (c-name "clutter_x11_xinput_event_types_get_type")
+  (return-type "GType")
+)
 
-;; From stamp-clutter-marshal.h
+(define-function clutter_x11_input_device_type_get_type
+  (c-name "clutter_x11_input_device_type_get_type")
+  (return-type "GType")
+)
 
 

Modified: cluttermm/trunk/clutter/src/clutter_signals.defs
==============================================================================
--- cluttermm/trunk/clutter/src/clutter_signals.defs	(original)
+++ cluttermm/trunk/clutter/src/clutter_signals.defs	Tue Dec 16 19:00:47 2008
@@ -482,28 +482,17 @@
   (construct-only #f)
 )
 
-;; From ClutterBackend
-
-;; From ClutterBehaviourBspline
-
-(define-signal knot-reached
-  (of-object "ClutterBehaviourBspline")
-  (return-type "void")
-  (when "last")
-  (parameters
-    '("const-ClutterKnot*" "p0")
-  )
-)
-
-(define-property alpha
-  (of-object "ClutterBehaviourBspline")
-  (prop-type "GParamObject")
-  (docs "Alpha Object to drive the behaviour")
+(define-property mode
+  (of-object "ClutterAlpha")
+  (prop-type "GParamEnum")
+  (docs "Progress mode")
   (readable #t)
   (writable #t)
   (construct-only #f)
 )
 
+;; From ClutterBackend
+
 ;; From ClutterBehaviourDepth
 
 (define-property alpha
@@ -690,7 +679,7 @@
   (return-type "void")
   (when "last")
   (parameters
-    '("const-ClutterKnot*" "p0")
+    '("guint" "p0")
   )
 )
 
@@ -703,11 +692,11 @@
   (construct-only #f)
 )
 
-(define-property knot
+(define-property path
   (of-object "ClutterBehaviourPath")
-  (prop-type "GParamBoxed")
-  (docs "Can be used to append a knot to the path")
-  (readable #f)
+  (prop-type "GParamObject")
+  (docs "The ClutterPath object representing the path to animate along")
+  (readable #t)
   (writable #t)
   (construct-only #f)
 )
@@ -1557,8 +1546,8 @@
 
 (define-property color
   (of-object "ClutterEntry")
-  (prop-type "GParamBoxed")
-  (docs "Font Colour")
+  (prop-type "ClutterParamSpecColor")
+  (docs "The color of the text")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2284,7 +2273,7 @@
 (define-property font-name
   (of-object "ClutterLabel")
   (prop-type "GParamString")
-  (docs "Pango font description")
+  (docs "The font to be used by the label")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2293,7 +2282,7 @@
 (define-property text
   (of-object "ClutterLabel")
   (prop-type "GParamString")
-  (docs "Text to render")
+  (docs "The text to render")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2301,8 +2290,8 @@
 
 (define-property color
   (of-object "ClutterLabel")
-  (prop-type "GParamBoxed")
-  (docs "Font Colour")
+  (prop-type "ClutterParamSpecColor")
+  (docs "Color of the font used by the label")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2320,7 +2309,7 @@
 (define-property use-markup
   (of-object "ClutterLabel")
   (prop-type "GParamBoolean")
-  (docs "The text of the label includes XML markup. See pango_parse_markup()")
+  (docs "Whether or not the text of the label includes Pango markup")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2329,7 +2318,7 @@
 (define-property alignment
   (of-object "ClutterLabel")
   (prop-type "GParamEnum")
-  (docs "The preferred alignment for the string")
+  (docs "The preferred alignment for the string, for multi-line text")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2338,7 +2327,7 @@
 (define-property wrap
   (of-object "ClutterLabel")
   (prop-type "GParamBoolean")
-  (docs "If set, wrap lines if the text becomes too wide")
+  (docs "If set, wrap the lines if the text becomes too wide")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2347,7 +2336,7 @@
 (define-property wrap-mode
   (of-object "ClutterLabel")
   (prop-type "GParamEnum")
-  (docs "If wrap is set, controls how line-wrapping is done")
+  (docs "Control how line-wrapping is done")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -2373,28 +2362,34 @@
 
 ;; From ClutterMedia
 
-(define-property position
+(define-signal eos
   (of-object "ClutterMedia")
-  (prop-type "GParamInt")
-  (docs "The position in the current stream in seconds.")
-  (readable #t)
-  (writable #t)
-  (construct-only #f)
+  (return-type "void")
+  (when "last")
 )
 
-(define-property can-seek
+(define-signal error
+  (of-object "ClutterMedia")
+  (return-type "void")
+  (when "last")
+  (parameters
+    '("gpointer" "p0")
+  )
+)
+
+(define-property playing
   (of-object "ClutterMedia")
   (prop-type "GParamBoolean")
-  (docs "TRUE if the current stream is seekable.")
+  (docs "TRUE if playing.")
   (readable #t)
-  (writable #f)
+  (writable #t)
   (construct-only #f)
 )
 
-(define-property duration
+(define-property buffer-percent
   (of-object "ClutterMedia")
   (prop-type "GParamInt")
-  (docs "The duration of the current stream in seconds.")
+  (docs "The percentage the current stream buffer is filled.")
   (readable #t)
   (writable #f)
   (construct-only #f)
@@ -2409,30 +2404,39 @@
   (construct-only #f)
 )
 
-(define-property playing
+(define-property volume
   (of-object "ClutterMedia")
-  (prop-type "GParamBoolean")
-  (docs "TRUE if playing.")
+  (prop-type "GParamDouble")
+  (docs "The audio volume.")
   (readable #t)
   (writable #t)
   (construct-only #f)
 )
 
-(define-property buffer-percent
+(define-property position
   (of-object "ClutterMedia")
   (prop-type "GParamInt")
-  (docs "The percentage the current stream buffer is filled.")
+  (docs "The position in the current stream in seconds.")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
+(define-property can-seek
+  (of-object "ClutterMedia")
+  (prop-type "GParamBoolean")
+  (docs "TRUE if the current stream is seekable.")
   (readable #t)
   (writable #f)
   (construct-only #f)
 )
 
-(define-property volume
+(define-property duration
   (of-object "ClutterMedia")
-  (prop-type "GParamDouble")
-  (docs "The audio volume.")
+  (prop-type "GParamInt")
+  (docs "The duration of the current stream in seconds.")
   (readable #t)
-  (writable #t)
+  (writable #f)
   (construct-only #f)
 )
 
@@ -2755,7 +2759,7 @@
 
 (define-property color
   (of-object "ClutterRectangle")
-  (prop-type "GParamBoxed")
+  (prop-type "ClutterParamSpecColor")
   (docs "The color of the rectangle")
   (readable #t)
   (writable #t)
@@ -2764,7 +2768,7 @@
 
 (define-property border-color
   (of-object "ClutterRectangle")
-  (prop-type "GParamBoxed")
+  (prop-type "ClutterParamSpecColor")
   (docs "The color of the border of the rectangle")
   (readable #t)
   (writable #t)
@@ -3199,8 +3203,8 @@
 
 (define-property color
   (of-object "ClutterStage")
-  (prop-type "GParamBoxed")
-  (docs "The color of the main stage")
+  (prop-type "ClutterParamSpecColor")
+  (docs "The color of the stage")
   (readable #t)
   (writable #t)
   (construct-only #f)
@@ -3233,6 +3237,15 @@
   (construct-only #f)
 )
 
+(define-property perspective
+  (of-object "ClutterStage")
+  (prop-type "GParamBoxed")
+  (docs "Perspective projection parameters")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
 (define-property title
   (of-object "ClutterStage")
   (prop-type "GParamString")
@@ -3674,6 +3687,15 @@
   (construct-only #f)
 )
 
+(define-property keep-aspect-ratio
+  (of-object "ClutterTexture")
+  (prop-type "GParamBoolean")
+  (docs "Keep the aspect ratio of the texture when requesting the preferred width or height")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
 ;; From ClutterTimeline
 
 (define-signal completed