From 14c3d44be469505cf8f3801fd5f63e04b6119c5f Mon Sep 17 00:00:00 2001
From: Artur Skawina <art.08.09@gmail.com>
Date: Sat, 4 Feb 2012 04:46:10 +0100
Subject: [PATCH] Mx support.

---
 gtk2/mx2.d   | 6478 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 gtk2/pango.d |    1 -
 2 files changed, 6478 insertions(+), 1 deletion(-)
 create mode 100644 gtk2/mx2.d

diff --git a/gtk2/mx2.d b/gtk2/mx2.d
new file mode 100644
index 0000000..ae01e67
--- /dev/null
+++ b/gtk2/mx2.d
@@ -0,0 +1,6478 @@
+// *** DO NOT EDIT ***
+// Automatically generated from "/usr/share/gir-1.0/Mx-2.0.gir"
+
+module Mx2;
+public import gtk2.atk;
+alias gtk2.atk Atk;
+public import gtk2.clutter;
+alias gtk2.clutter Clutter;
+public import gtk2.cogl;
+alias gtk2.cogl Cogl;
+public import gtk2.coglpango;
+alias gtk2.coglpango CoglPango;
+public import gtk2.gl;
+alias gtk2.gl GL;
+public import gtk2.glib2;
+alias gtk2.glib2 GLib2;
+public import gtk2.gobject2;
+alias gtk2.gobject2 GObject2;
+public import gtk2.gio2;
+alias gtk2.gio2 Gio2;
+public import gtk2.json;
+alias gtk2.json Json;
+public import gtk2.pango;
+alias gtk2.pango Pango;
+public import gtk2.pangocairo;
+alias gtk2.pangocairo PangoCairo;
+public import gtk2.pangoft2;
+alias gtk2.pangoft2 PangoFT2;
+public import gtk2.cairo;
+alias gtk2.cairo cairo;
+public import gtk2.fontconfig2;
+alias gtk2.fontconfig2 fontconfig2;
+public import gtk2.freetype2;
+alias gtk2.freetype2 freetype2;
+
+// package: "mx-2.0";
+// C header: "mx/mx.h";
+
+// c:symbol-prefixes: ["mx"]
+// c:identifier-prefixes: ["Mx"]
+
+// module Mx2;
+
+//  --- mixin/Mx2__MODULE_HEAD.d --->
+
+// Missing type:
+
+alias void* MxSettingsProperty;
+
+// <--- mixin/Mx2__MODULE_HEAD.d ---
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Action /* : GObject.InitiallyUnowned */ {
+   mixin Gio2.Action.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent initiallyunowned;
+   GObject2.InitiallyUnowned parent;
+   private ActionPrivate* priv;
+
+
+   // Creates a new, blank, #MxAction
+   // RETURNS: a newly allocated #MxAction
+   static Action* /*new*/ new_()() {
+      return mx_action_new();
+   }
+
+   // Creates a new #MxAction with the name and callback set
+   // RETURNS: a newly allocated #MxAction
+   // <name>: name of the action
+   // <display_name>: name of the action to display to the user
+   // <activated_cb>: callback to connect to the activated signal
+   // <user_data>: user data to be passed to the callback
+   static Action* /*new*/ new_full()(char* name, char* display_name, ActionCallbackFunc activated_cb, void* user_data) {
+      return mx_action_new_full(name, display_name, activated_cb, user_data);
+   }
+
+   // VERSION: 1.4
+   // Creates a new stateful action.
+   // 
+   // @state is the initial state of the action.  All future state values
+   // must have the same #GVariantType as the initial state.
+   // RETURNS: a new #MxAction
+   // <name>: the name of the action
+   // <parameter_type>: the type of the parameter to the activate function
+   // <state>: the initial state of the action
+   static Action* new_stateful()(char* name, GLib2.VariantType* parameter_type, GLib2.Variant* state) {
+      return mx_action_new_stateful(name, parameter_type, state);
+   }
+
+   // VERSION: 1.4
+   // Creates a new action with a parameter.
+   // 
+   // The created action is stateless.  See mx_action_new_stateful().
+   // RETURNS: a new #MxAction
+   // <name>: the name of the action
+   // <parameter_type>: the type of parameter to the activate function
+   static Action* new_with_parameter()(char* name, GLib2.VariantType* parameter_type=null) {
+      return mx_action_new_with_parameter(name, parameter_type);
+   }
+
+   // Get the value of the active property
+   // RETURNS: #TRUE if the action is active
+   int get_active()() {
+      return mx_action_get_active(&this);
+   }
+
+   // Get the display name of the action
+   // RETURNS: display-name of the action, owned by MxAction
+   char* get_display_name()() {
+      return mx_action_get_display_name(&this);
+   }
+
+   // Get the icon of the action
+   // RETURNS: icon of the action, owned by MxAction
+   char* get_icon()() {
+      return mx_action_get_icon(&this);
+   }
+
+   // Get the name of the action
+   // RETURNS: name of the action, owned by MxAction
+   char* get_name()() {
+      return mx_action_get_name(&this);
+   }
+
+   // Set the value of the active property
+   // <active>: the value to set
+   void set_active()(int active) {
+      mx_action_set_active(&this, active);
+   }
+
+   // Set the name of the action to display to the user
+   // <name>: new display name to set
+   void set_display_name()(char* name) {
+      mx_action_set_display_name(&this, name);
+   }
+
+   // The icon to be used in a visual representation of an action.
+   // <name>: new icon to set
+   void set_icon()(char* name) {
+      mx_action_set_icon(&this, name);
+   }
+
+   // Set the name of the action
+   // <name>: new name to set
+   void set_name()(char* name) {
+      mx_action_set_name(&this, name);
+   }
+
+   // VERSION: 1.4
+   // Indicates that the action was just activated.
+   // 
+   // @parameter will always be of the expected type.  In the event that
+   // an incorrect type was given, no signal will be emitted.
+   // <parameter>: the parameter to the activation
+   extern (C) alias static void function (Action* this_, GLib2.Variant* parameter=null, void* user_data=null) signal_activate;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"activate", CB:signal_activate)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"activate",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // DEPRECATED (v1.4) glib:signal: activated - Use MxAction::activate instead.
+   // Emitted when the MxAction is activated.
+   extern (C) alias static void function (Action* this_, void* user_data=null) signal_activated;
+   ulong signal_connect(string name:"activated", CB:signal_activated)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"activated",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+
+// Callback function called when action is activated.
+// <action>: An #MxAction
+// <user_data>: user data
+extern (C) alias void function (Action* action, void* user_data) ActionCallbackFunc;
+
+struct ActionClass {
+   GObject2.InitiallyUnownedClass parent_class;
+   extern (C) void function (Action* action) activated;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ActionPrivate {
+}
+
+struct ActorManager /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   ActorManagerPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Creates a new #MxActorManager, associated with the given stage.
+   // 
+   // <note><para>
+   // A reference will not be taken on the stage, and when the stage is destroyed,
+   // the actor manager will lose a reference. The actor manager can be kept
+   // alive by taking a reference, but will no longer divide up events.
+   // </para></note>
+   // RETURNS: An #MxActorManager, tied to the given #ClutterStage
+   // <stage>: A #ClutterStage
+   static ActorManager* new_()(Clutter.Stage* stage) {
+      return mx_actor_manager_new(stage);
+   }
+
+   // VERSION: 1.2
+   // Get the MxActorManager associated with a stage, or creates one if this is the
+   // first call to the function with the given #ClutterStage.
+   // 
+   // This is a convenience function that allows for easy association of one
+   // #MxActorManager to a #ClutterStage.
+   // RETURNS: An #MxActorManager
+   // <stage>: A #ClutterStage
+   static ActorManager* get_for_stage()(Clutter.Stage* stage) {
+      return mx_actor_manager_get_for_stage(stage);
+   }
+
+   // VERSION: 1.2
+   // Adds @actor to @container. The actor may not be parented immediately,
+   // or at all, if the operation is cancelled.
+   // 
+   // On successful completion, the #MxActorManager::actor_added signal will
+   // be fired.
+   // RETURNS: The ID for this operation.
+   // <container>: A #ClutterContainer
+   // <actor>: A #ClutterActor
+   c_ulong add_actor()(Clutter.Container* container, Clutter.Actor* actor) {
+      return mx_actor_manager_add_actor(&this, container, actor);
+   }
+
+   // VERSION: 1.2
+   // Cancels the given operation, if it exists. The
+   // #MxActorManager::operation_cancelled signal is fired whenever an operation
+   // is cancelled.
+   // <id>: An operation ID
+   void cancel_operation()(c_ulong id) {
+      mx_actor_manager_cancel_operation(&this, id);
+   }
+
+   // VERSION: 1.2
+   // Cancels all operations associated with the given actor.
+   // <actor>: A #ClutterActor
+   void cancel_operations()(Clutter.Actor* actor) {
+      mx_actor_manager_cancel_operations(&this, actor);
+   }
+
+   // Unintrospectable method: create_actor() / mx_actor_manager_create_actor()
+   // VERSION: 1.2
+   // Creates a #ClutterActor. The actor may not be created immediately,
+   // or at all, if the operation is cancelled.
+   // 
+   // On successful completion, the #MxActorManager::actor_created signal will
+   // be fired.
+   // RETURNS: The ID for this operation.
+   // <create_func>: A #ClutterActor creation function
+   // <userdata>: data to be passed to the function, or %NULL
+   // <destroy_func>: callback to invoke before the operation is removed
+   c_ulong create_actor()(ActorManagerCreateFunc create_func, void* userdata, GLib2.DestroyNotify destroy_func) {
+      return mx_actor_manager_create_actor(&this, create_func, userdata, destroy_func);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the amount of operations left in the queue.
+   // RETURNS: Number of operations left to perform
+   uint get_n_operations()() {
+      return mx_actor_manager_get_n_operations(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the #ClutterStage the actor manager is associated with.
+   // RETURNS: The #ClutterStage the actor is associated with.
+   Clutter.Stage* get_stage()() {
+      return mx_actor_manager_get_stage(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the current time slice being used for operations.
+   // RETURNS: The time-slice being used, in milliseconds
+   uint get_time_slice()() {
+      return mx_actor_manager_get_time_slice(&this);
+   }
+
+   // VERSION: 1.2
+   // Removes @actor from @container.
+   // 
+   // On successful completion, the #MxActorManager::actor_removed signal will
+   // be fired.
+   // 
+   // <note><para>
+   // The actor may not be removed immediately, and thus you may want to set
+   // the actor's opacity to 0 before calling this function.
+   // </para></note>
+   // RETURNS: The ID for this operation.
+   // <container>: A #ClutterContainer
+   // <actor>: A #ClutterActor
+   c_ulong remove_actor()(Clutter.Container* container, Clutter.Actor* actor) {
+      return mx_actor_manager_remove_actor(&this, container, actor);
+   }
+
+   // VERSION: 1.2
+   // Removes the container. This is a utility function that works by first
+   // removing all the children of the container, then the children itself. This
+   // effectively spreads the load of removing a large container. All prior
+   // operations associated with this container will be cancelled.
+   // 
+   // <note><para>
+   // The container may not be removed immediately, and thus you may want to set
+   // the container's opacity to 0 before calling this function.
+   // </para></note>
+   // <container>: A #ClutterContainer
+   void remove_container()(Clutter.Container* container) {
+      mx_actor_manager_remove_container(&this, container);
+   }
+
+   // VERSION: 1.2
+   // Sets the amount of time the actor manager will spend performing operations,
+   // before yielding to allow any necessary redrawing to occur.
+   // 
+   // Lower times will lead to smoother performance, but will increase the amount
+   // of time it takes for operations to complete.
+   // <msecs>: A time, in milliseconds
+   void set_time_slice()(uint msecs) {
+      mx_actor_manager_set_time_slice(&this, msecs);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an actor add operation has completed.
+   // <id>: The operation ID
+   // <container>: The #ClutterContainer the actor was added to
+   // <actor>: The added #ClutterActor
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, Clutter.Actor* container, Clutter.Actor* actor, void* user_data=null) signal_actor_added;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"actor-added", CB:signal_actor_added)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"actor-added",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an actor creation operation has completed.
+   // <id>: The operation ID
+   // <actor>: The created #ClutterActor
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, Clutter.Actor* actor, void* user_data=null) signal_actor_created;
+   ulong signal_connect(string name:"actor-created", CB:signal_actor_created)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"actor-created",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when all queued operations involving @actor have completed.
+   // <actor>: The #ClutterActor to which the signal pertains
+   extern (C) alias static void function (ActorManager* this_, Clutter.Actor* actor, void* user_data=null) signal_actor_finished;
+   ulong signal_connect(string name:"actor-finished", CB:signal_actor_finished)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"actor-finished",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an actor remove operation has completed.
+   // <id>: The operation ID
+   // <container>: The #ClutterContainer the actor was removed from
+   // <actor>: The removed #ClutterActor
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, Clutter.Actor* container, Clutter.Actor* actor, void* user_data=null) signal_actor_removed;
+   ulong signal_connect(string name:"actor-removed", CB:signal_actor_removed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"actor-removed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an operation has been cancelled.
+   // <id>: The operation id
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, void* user_data=null) signal_operation_cancelled;
+   ulong signal_connect(string name:"operation-cancelled", CB:signal_operation_cancelled)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"operation-cancelled",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an operation has completed successfully.
+   // <id>: The operation id
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, void* user_data=null) signal_operation_completed;
+   ulong signal_connect(string name:"operation-completed", CB:signal_operation_completed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"operation-completed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an operation has failed.
+   // <id>: The operation id
+   // <error>: A #GError describing the reason of the failure
+   extern (C) alias static void function (ActorManager* this_, c_ulong id, GLib2.Error* error, void* user_data=null) signal_operation_failed;
+   ulong signal_connect(string name:"operation-failed", CB:signal_operation_failed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"operation-failed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ActorManagerClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function (ActorManager* manager, c_ulong id, Clutter.Actor* actor) actor_created;
+   extern (C) void function (ActorManager* manager, c_ulong id, Clutter.Container* container, Clutter.Actor* actor) actor_added;
+   extern (C) void function (ActorManager* manager, c_ulong id, Clutter.Container* container, Clutter.Actor* actor) actor_removed;
+   extern (C) void function (ActorManager* manager, Clutter.Actor* actor) actor_finished;
+   extern (C) void function (ActorManager* manager, c_ulong id) operation_completed;
+   extern (C) void function (ActorManager* manager, c_ulong id) operation_cancelled;
+   extern (C) void function (ActorManager* manager, c_ulong id, GLib2.Error* error) operation_failed;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+// Unintrospectable callback: ActorManagerCreateFunc() / ()
+extern (C) alias Clutter.Actor* function (ActorManager* manager, void* userdata) ActorManagerCreateFunc;
+
+enum ActorManagerError {
+   CONTAINER_DESTROYED = 0,
+   ACTOR_DESTROYED = 1,
+   CREATION_FAILED = 2,
+   UNKNOWN_OPERATION = 3
+}
+struct ActorManagerPrivate {
+}
+
+
+// Class for handling an interval between to values. The contents of
+// the #MxAdjustment are private and should be accessed using the
+// public API.
+struct Adjustment /* : GObject.Object */ {
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance object;
+   GObject2.Object parent_instance;
+   private AdjustmentPrivate* priv;
+
+
+   // Create a new MxAdjustment
+   // RETURNS: a newly allocated MxAdjustment
+   static Adjustment* /*new*/ new_()() {
+      return mx_adjustment_new();
+   }
+
+   // Create a new MxAdjustment with the properties set to the values specified.
+   // RETURNS: a newly allocated MxAdjustment
+   // <value>: A #gdouble
+   // <lower>: A #gdouble
+   // <upper>: A #gdouble
+   // <step_increment>: A #gdouble
+   // <page_increment>: A #gdouble
+   // <page_size>: A #gdouble
+   static Adjustment* /*new*/ new_with_values()(double value, double lower, double upper, double step_increment, double page_increment, double page_size) {
+      return mx_adjustment_new_with_values(value, lower, upper, step_increment, page_increment, page_size);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxAdjustment:clamp-value property.
+   // RETURNS: the current value of the "clamp-value" property.
+   int get_clamp_value()() {
+      return mx_adjustment_get_clamp_value(&this);
+   }
+
+   // Get the value of the #MxAdjustment:elastic property.
+   // RETURNS: the current value of the "elastic" property.
+   int get_elastic()() {
+      return mx_adjustment_get_elastic(&this);
+   }
+
+   // Get the value of the #MxAdjustment:lower property.
+   // RETURNS: the current value of the "lower" property.
+   double get_lower()() {
+      return mx_adjustment_get_lower(&this);
+   }
+
+   // Get the value of the MxAdjustment:page-increment property.
+   // RETURNS: the current value of the "page-increment" property.
+   double get_page_increment()() {
+      return mx_adjustment_get_page_increment(&this);
+   }
+
+   // Get the value of the #MxAdjustment:page-size property.
+   // RETURNS: the current value of the "page-size" property.
+   double get_page_size()() {
+      return mx_adjustment_get_page_size(&this);
+   }
+
+   // Get the value of the MxAdjustment:step-increment property.
+   // RETURNS: the current value of the "step-increment" property.
+   double get_step_increment()() {
+      return mx_adjustment_get_step_increment(&this);
+   }
+
+   // Get the value of the #MxAdjustment:upper property.
+   // RETURNS: the current value of the "upper" property.
+   double get_upper()() {
+      return mx_adjustment_get_upper(&this);
+   }
+
+   // Get the current value of the #MxAdjustment:value property
+   // RETURNS: the current value of the "value" property
+   double get_value()() {
+      return mx_adjustment_get_value(&this);
+   }
+
+   // Get the various properties of MxAdjustment.
+   // <value>: A #gdouble
+   // <lower>: A #gdouble
+   // <upper>: A #gdouble
+   // <step_increment>: A #gdouble
+   // <page_increment>: A #gdouble
+   // <page_size>: A #gdouble
+   void get_values()(double* value, double* lower, double* upper, double* step_increment, double* page_increment, double* page_size) {
+      mx_adjustment_get_values(&this, value, lower, upper, step_increment, page_increment, page_size);
+   }
+
+   // Interpolate #MxAdjustment:value to the new value specified by @value, using
+   // the mode and duration given.
+   // <value>: A #gdouble
+   // <duration>: duration in milliseconds
+   // <mode>: A #ClutterAnimationMode
+   void interpolate()(double value, uint duration, c_ulong mode) {
+      mx_adjustment_interpolate(&this, value, duration, mode);
+   }
+
+   // Interpolate the value of #MxAdjustment:value to a new value calculated from
+   // @offset.
+   // <offset>: A #gdouble
+   // <duration>: duration in milliseconds
+   // <mode>: A #ClutterAnimationMode
+   void interpolate_relative()(double offset, uint duration, c_ulong mode) {
+      mx_adjustment_interpolate_relative(&this, offset, duration, mode);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxAdjustment:clamp-value property.
+   // <clamp>: a #gboolean
+   void set_clamp_value()(int clamp) {
+      mx_adjustment_set_clamp_value(&this, clamp);
+   }
+
+   // Set the value of the #MxAdjustment:elastic property.
+   // <elastic>: A #gboolean
+   void set_elastic()(int elastic) {
+      mx_adjustment_set_elastic(&this, elastic);
+   }
+
+   // Set the value of the #MxAdjustment:lower property.
+   // <lower>: A #gdouble
+   void set_lower()(double lower) {
+      mx_adjustment_set_lower(&this, lower);
+   }
+
+   // Set the value of the #MxAdjustment:page-increment property.
+   // <increment>: A #gdouble
+   void set_page_increment()(double increment) {
+      mx_adjustment_set_page_increment(&this, increment);
+   }
+
+   // Set the #MxAdjustment:page-size property.
+   // <page_size>: A #gdouble
+   void set_page_size()(double page_size) {
+      mx_adjustment_set_page_size(&this, page_size);
+   }
+
+   // Set the value of the #MxAdjustment:step-increment property.
+   // <increment>: A #gdouble
+   void set_step_increment()(double increment) {
+      mx_adjustment_set_step_increment(&this, increment);
+   }
+
+   // Set the value of the #MxAdjustment:upper property.
+   // <upper>: A #gdouble
+   void set_upper()(double upper) {
+      mx_adjustment_set_upper(&this, upper);
+   }
+
+   // Set the value of the #MxAdjustment:value property.
+   // <value>: A #gdouble
+   void set_value()(double value) {
+      mx_adjustment_set_value(&this, value);
+   }
+
+   // Set the various properties of MxAdjustment.
+   // <value>: A #gdouble
+   // <lower>: A #gdouble
+   // <upper>: A #gdouble
+   // <step_increment>: A #gdouble
+   // <page_increment>: A #gdouble
+   // <page_size>: A #gdouble
+   void set_values()(double value, double lower, double upper, double step_increment, double page_increment, double page_size) {
+      mx_adjustment_set_values(&this, value, lower, upper, step_increment, page_increment, page_size);
+   }
+   // Emitted when any of the adjustment values have changed
+   extern (C) alias static void function (Adjustment* this_, void* user_data=null) signal_changed;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"changed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+   // Emitted when the animation started by mx_adjustment_interpolate completes
+   extern (C) alias static void function (Adjustment* this_, void* user_data=null) signal_interpolation_completed;
+   ulong signal_connect(string name:"interpolation-completed", CB:signal_interpolation_completed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"interpolation-completed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+// Base class for #MxAdjustment.
+struct AdjustmentClass {
+   private GObject2.ObjectClass parent_class;
+   extern (C) void function (Adjustment* adjustment) changed;
+   extern (C) void function (Adjustment* adjustment) interpolation_completed;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+}
+
+struct AdjustmentPrivate {
+}
+
+// Set the alignment of the item
+enum Align {
+   START = 0,
+   MIDDLE = 1,
+   END = 2
+}
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Application /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   ApplicationPrivate* priv;
+
+
+   // Intialises everything needed to operate Clutter and use #MxApplication.
+   // See clutter_init().
+   // RETURNS: the #MxApplication singleton.
+   // <argc>: The number of arguments in argv.
+   // <argv>: A pointer to an array of arguments
+   // <name>: Unique application name.
+   // <flags>: Application flags.
+   static Application* /*new*/ new_()(/*inout*/ int* argc, /*inout*/ char*** argv, char* name, ApplicationFlags flags) {
+      return mx_application_new(argc, argv, name, flags);
+   }
+
+   // Add an action to the application.
+   // <action>: an #MxAction
+   void add_action()(Action* action) {
+      mx_application_add_action(&this, action);
+   }
+
+   // Adds a window to the list of windows associated with @application. If this
+   // is the first window, it will be treated as the primary window and used for
+   // startup notification.
+   // 
+   // This function does not take a reference on @window.
+   // <window>: The #MxWindow to add to the application
+   void add_window()(Window* window) {
+      mx_application_add_window(&this, window);
+   }
+
+   // Creates a window and associates it with the application.
+   // RETURNS: An #MxWindow.
+   Window* create_window()() {
+      return mx_application_create_window(&this);
+   }
+
+   // Retrieves all actions registered on @application.
+   // 
+   // of #MxAction<!-- -->s. Use g_list_free() on the returned list
+   // when done.
+   // RETURNS: a list
+   GLib2.List* /*new container*/ get_actions()() {
+      return mx_application_get_actions(&this);
+   }
+
+   // Get the application flags that where set on @application when created.
+   // RETURNS: the application flags
+   ApplicationFlags get_flags()() {
+      return mx_application_get_flags(&this);
+   }
+
+   // Retrieves all windows added to @application.
+   // 
+   // of #MxWindow<!-- -->s. The returned list is owned by
+   // @application and must not be altered.
+   // RETURNS: a list
+   GLib2.List* get_windows()() {
+      return mx_application_get_windows(&this);
+   }
+
+   // Run the named action for the application.
+   // <name>: name of the action to invoke
+   void invoke_action()(char* name) {
+      mx_application_invoke_action(&this, name);
+   }
+
+   // VERSION: 1.4
+   // Run the named action for the application, passing @variant as the parameter
+   // for the action.
+   // <name>: name of the action to invoke
+   // <variant>: parameter for the action
+   void invoke_action_with_parameter()(char* name, GLib2.Variant* variant) {
+      mx_application_invoke_action_with_parameter(&this, name, variant);
+   }
+
+   // Query whether #MxApplication is running. This will also return #TRUE if the
+   // given #MxApplication is single instance and there is an instance already
+   // running.
+   // RETURNS: #TRUE if the application is running
+   int is_running()() {
+      return mx_application_is_running(&this);
+   }
+
+   // Stop the application from running and quit the main loop. This will cause
+   // the call to mx_application_run() to complete.
+   void quit()() {
+      mx_application_quit(&this);
+   }
+
+   // Remove the action with the specified name from the application.
+   // <name>: name of the action to remove
+   void remove_action()(char* name) {
+      mx_application_remove_action(&this, name);
+   }
+
+   // Remove the specified window from the application. This will cause the window
+   // to be unreferenced and destroyed unless another reference is held on it.
+   // <window>: an #MxWindow
+   void remove_window()(Window* window) {
+      mx_application_remove_window(&this, window);
+   }
+
+   // Run the main loop of the application and start processing events. This
+   // function will not return until the application is quit. If the application
+   // is single instance and an existing instance is already running, this will
+   // cause the existing instance to be raised and the function will complete
+   // immediately.
+   void run()() {
+      mx_application_run(&this);
+   }
+   // Emitted when an action has been added or removed from the MxApplication.
+   extern (C) alias static void function (Application* this_, void* user_data=null) signal_actions_changed;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"actions-changed", CB:signal_actions_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"actions-changed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ApplicationClass {
+   GObject2.ObjectClass parent_class;
+   // RETURNS: An #MxWindow.
+   extern (C) Window* function (Application* application) create_window;
+   extern (C) void function (Application* application) raise;
+   extern (C) void function (Application* app) actions_changed;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+enum ApplicationFlags {
+   SINGLE_INSTANCE = 1,
+   KEEP_ALIVE = 4
+}
+struct ApplicationPrivate {
+}
+
+// The #MxBin struct contains only private data
+struct Bin /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance widget;
+   Widget parent_instance;
+   private BinPrivate* priv;
+
+
+   // Allocates the child of an #MxBin using the width and height from @box.
+   // This function should usually only be called by subclasses of #MxBin.
+   // 
+   // This function can be used to allocate the child of an #MxBin if no special
+   // allocation requirements are needed. It is similar to
+   // #mx_allocate_align_fill, except that it reads the alignment, padding and
+   // fill values from the #MxBin, and will call #clutter_actor_allocate on the
+   // child.
+   // <box>: The allocation box of the parent actor.
+   // <flags>: #ClutterAllocationFlags, usually provided by the. clutter_actor_allocate function.
+   void allocate_child()(Clutter.ActorBox* box, Clutter.AllocationFlags flags) {
+      mx_bin_allocate_child(&this, box, flags);
+   }
+
+   // Retrieves the horizontal and vertical alignment of the child
+   // inside a #MxBin, as set by mx_bin_set_alignment().
+   // <x_align>: return location for the horizontal alignment, or %NULL
+   // <y_align>: return location for the vertical alignment, or %NULL
+   void get_alignment()(Align* x_align, Align* y_align) {
+      mx_bin_get_alignment(&this, x_align, y_align);
+   }
+
+   // Retrieves a pointer to the child of @bin.
+   // RETURNS: a #ClutterActor, or %NULL
+   Clutter.Actor* get_child()() {
+      return mx_bin_get_child(&this);
+   }
+
+   // Retrieves the horizontal and vertical fill settings
+   // <x_fill>: return location for the horizontal fill, or %NULL
+   // <y_fill>: return location for the vertical fill, or %NULL
+   void get_fill()(/*out*/ int* x_fill, /*out*/ int* y_fill) {
+      mx_bin_get_fill(&this, x_fill, y_fill);
+   }
+
+   // Sets the horizontal and vertical alignment of the child
+   // inside a #MxBin.
+   // <x_align>: horizontal alignment
+   // <y_align>: vertical alignment
+   void set_alignment()(Align x_align, Align y_align) {
+      mx_bin_set_alignment(&this, x_align, y_align);
+   }
+
+   // Sets @child as the child of @bin.
+   // 
+   // If @bin already has a child, the previous child is removed.
+   // <child>: a #ClutterActor, or %NULL
+   void set_child()(Clutter.Actor* child) {
+      mx_bin_set_child(&this, child);
+   }
+
+   // Sets whether the child of @bin should fill out the horizontal
+   // and/or vertical allocation of the parent
+   // <x_fill>: %TRUE if the child should fill horizontally the @bin
+   // <y_fill>: %TRUE if the child should fill vertically the @bin
+   void set_fill()(int x_fill, int y_fill) {
+      mx_bin_set_fill(&this, x_fill, y_fill);
+   }
+}
+
+// The #MxBinClass struct contains only private data
+struct BinClass {
+   private WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct BinPrivate {
+}
+
+struct BorderImage {
+   char* uri;
+   int top, right, bottom, left;
+
+   int equal()(BorderImage* b2) {
+      return mx_border_image_equal(&this, b2);
+   }
+   static void set_from_string()(GObject2.Value* value, char* str, char* filename) {
+      mx_border_image_set_from_string(value, str, filename);
+   }
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct BoxLayout /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private BoxLayoutPrivate* priv;
+
+
+   // Create a new #MxBoxLayout.
+   // RETURNS: a newly allocated #MxBoxLayout
+   static BoxLayout* new_()() {
+      return mx_box_layout_new();
+   }
+   static BoxLayout* new_with_orientation()(Orientation orientation) {
+      return mx_box_layout_new_with_orientation(orientation);
+   }
+
+   // Inserts @actor at @position in @box.
+   // <actor>: the #ClutterActor actor to add to the box layout
+   // <position>: the position where to insert the actor
+   void add_actor()(Clutter.Actor* actor, int position) {
+      mx_box_layout_add_actor(&this, actor, position);
+   }
+
+   // Unintrospectable method: add_actor_with_properties() / mx_box_layout_add_actor_with_properties()
+   // Inserts @actor at @position in the layout @box. You can set some layout
+   // properties on the child at the same time.
+   // 
+   // If @position is negative, or is larger than the number of actors in the
+   // layout, the new actor is added on to the end of the list.
+   // <actor>: the #ClutterActor actor to add to the box layout
+   // <position>: the position where to insert the actor
+   // <first_property>: name of the first property to set
+   /+ Not available -- variadic methods unsupported - use the C function directly.
+      alias mx_box_layout_add_actor_with_properties add_actor_with_properties; // Variadic
+   +/
+
+   // Get the value of the #MxBoxLayoutChild:expand property
+   // RETURNS: the current value of the "expand" property
+   // <child>: A #ClutterActor
+   int child_get_expand()(Clutter.Actor* child) {
+      return mx_box_layout_child_get_expand(&this, child);
+   }
+
+   // Get the value of the #MxBoxLayoutChild:x-align property
+   // RETURNS: the current value of the "x-align" property
+   // <child>: A #ClutterActor
+   Align child_get_x_align()(Clutter.Actor* child) {
+      return mx_box_layout_child_get_x_align(&this, child);
+   }
+
+   // Get the value of the #MxBoxLayoutChild:x-fill property.
+   // RETURNS: the current value of the "x-fill" property.
+   // <child>: A #ClutterActor
+   int child_get_x_fill()(Clutter.Actor* child) {
+      return mx_box_layout_child_get_x_fill(&this, child);
+   }
+
+   // Get the value of the #MxBoxLayoutChild:y-align property.
+   // RETURNS: the current value of the "y-align" property.
+   // <child>: A #ClutterActor
+   Align child_get_y_align()(Clutter.Actor* child) {
+      return mx_box_layout_child_get_y_align(&this, child);
+   }
+
+   // Get the value of the #MxBoxLayoutChild:y-fill property
+   // RETURNS: the current value of the "y-fill" property
+   // <child>: A #ClutterActor
+   int child_get_y_fill()(Clutter.Actor* child) {
+      return mx_box_layout_child_get_y_fill(&this, child);
+   }
+
+   // Set the value of the #MxBoxLayoutChild:expand property.
+   // <child>: A #ClutterActor
+   // <expand>: A #gboolean
+   void child_set_expand()(Clutter.Actor* child, int expand) {
+      mx_box_layout_child_set_expand(&this, child, expand);
+   }
+
+   // Set the value of the #MxBoxLayoutChild:x-align property.
+   // <child>: A #ClutterActor
+   // <x_align>: An #MxAlign
+   void child_set_x_align()(Clutter.Actor* child, Align x_align) {
+      mx_box_layout_child_set_x_align(&this, child, x_align);
+   }
+
+   // Set the value of the #MxBoxLayoutChild:x-fill property.
+   // <child>: A #ClutterActor
+   // <x_fill>: A #gboolean
+   void child_set_x_fill()(Clutter.Actor* child, int x_fill) {
+      mx_box_layout_child_set_x_fill(&this, child, x_fill);
+   }
+
+   // Set the value of the #MxBoxLayoutChild:y-align property.
+   // <child>: A #ClutterActor
+   // <y_align>: An #MxAlign
+   void child_set_y_align()(Clutter.Actor* child, Align y_align) {
+      mx_box_layout_child_set_y_align(&this, child, y_align);
+   }
+
+   // Set the value of the #MxBoxLayoutChild:y-fill property.
+   // <child>: A #ClutterActor
+   // <y_fill>: A #gboolean
+   void child_set_y_fill()(Clutter.Actor* child, int y_fill) {
+      mx_box_layout_child_set_y_fill(&this, child, y_fill);
+   }
+
+   // Get the value of the #MxBoxLayout:enable-animations property.
+   // RETURNS: #TRUE if animations enabled
+   int get_enable_animations()() {
+      return mx_box_layout_get_enable_animations(&this);
+   }
+
+   // Get the value of the #MxBoxLayout:orientation property.
+   // RETURNS: the orientation of the layout
+   Orientation get_orientation()() {
+      return mx_box_layout_get_orientation(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxBoxLayout:scroll-to-focused property.
+   // RETURNS: #TRUE if automatically scrolling to the focused actor is enabled
+   int get_scroll_to_focused()() {
+      return mx_box_layout_get_scroll_to_focused(&this);
+   }
+
+   // Get the spacing between children in pixels
+   // RETURNS: the spacing value
+   uint get_spacing()() {
+      return mx_box_layout_get_spacing(&this);
+   }
+
+   // Enable animations when certain properties change.
+   // <enable_animations>: #TRUE to enable animations
+   void set_enable_animations()(int enable_animations) {
+      mx_box_layout_set_enable_animations(&this, enable_animations);
+   }
+
+   // Set the orientation of the box layout.
+   // <orientation>: orientation value for the layout
+   void set_orientation()(Orientation orientation) {
+      mx_box_layout_set_orientation(&this, orientation);
+   }
+
+   // VERSION: 1.2
+   // Enables or disables automatic scrolling to the focused actor.
+   // <scroll_to_focused>: #TRUE to enable automatically scrolling to the focused actor
+   void set_scroll_to_focused()(int scroll_to_focused) {
+      mx_box_layout_set_scroll_to_focused(&this, scroll_to_focused);
+   }
+
+   // Set the amount of spacing between children in pixels
+   // <spacing>: the spacing value
+   void set_spacing()(uint spacing) {
+      mx_box_layout_set_spacing(&this, spacing);
+   }
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct BoxLayoutChild /* : Clutter.ChildMeta */ {
+   alias parent this;
+   alias parent super_;
+   alias parent childmeta;
+   Clutter.ChildMeta parent;
+   private int expand;
+    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
+   uint, "x_fill", 1,
+   uint, "y_fill", 1,
+    uint, "__dummy32A", 30));
+   private Align x_align, y_align;
+}
+
+struct BoxLayoutChildClass {
+   Clutter.ChildMetaClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct BoxLayoutChildPrivate {
+}
+
+struct BoxLayoutClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct BoxLayoutPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Button /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance bin;
+   Bin parent_instance;
+   private ButtonPrivate* priv;
+
+
+   // Create a new button
+   // RETURNS: a new #MxButton
+   static Button* new_()() {
+      return mx_button_new();
+   }
+
+   // Create a new #MxButton with the specified label
+   // RETURNS: a new #MxButton
+   // <text>: text to set the label to
+   static Button* new_with_label()(char* text) {
+      return mx_button_new_with_label(text);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the #MxAction associated with @button.
+   // RETURNS: A #MxAction
+   Action* get_action()() {
+      return mx_button_get_action(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the icon-name being used on the button.
+   // 
+   // no icon has been set
+   // RETURNS: the icon-name. This must not be freed by the application. %NULL if
+   char* get_icon_name()() {
+      return mx_button_get_icon_name(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the icon's relative position to the text.
+   // RETURNS: A #MxPosition
+   Position get_icon_position()() {
+      return mx_button_get_icon_position(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the icon-size being used for the displayed icon inside the button.
+   // RETURNS: The icon-size being used for the button icon, in pixels
+   uint get_icon_size()() {
+      return mx_button_get_icon_size(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the visibility of the icon associated with the button's action.
+   // RETURNS: %TRUE if the icon is visible, %FALSE otherwise
+   int get_icon_visible()() {
+      return mx_button_get_icon_visible(&this);
+   }
+
+   // Get the toggle mode status of the button.
+   // RETURNS: #TRUE if toggle mode is set, otherwise #FALSE
+   int get_is_toggle()() {
+      return mx_button_get_is_toggle(&this);
+   }
+
+   // Get the text displayed on the button
+   // RETURNS: the text for the button. This must not be freed by the application
+   char* get_label()() {
+      return mx_button_get_label(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the visibility of the text associated with the button's action.
+   // RETURNS: %TRUE if the text is visible, %FALSE otherwise
+   int get_label_visible()() {
+      return mx_button_get_label_visible(&this);
+   }
+
+   // Get the state of the button that is in toggle mode.
+   // RETURNS: #TRUE if the button is toggled, or #FALSE if not
+   int get_toggled()() {
+      return mx_button_get_toggled(&this);
+   }
+
+   // VERSION: 1.2
+   // Sets @action as the action for @button. @Button will take its label and
+   // icon from @action.
+   // <action>: A #MxAction
+   void set_action()(Action* action) {
+      mx_button_set_action(&this, action);
+   }
+
+   // VERSION: 1.2
+   // Sets the icon-name used to display an icon on the button. Setting %NULL
+   // will remove the icon name, or resort to the icon-name set in the current
+   // style. Setting an icon name overrides any icon set in the style.
+   // <icon_name>: icon-name to use on the button
+   void set_icon_name()(char* icon_name=null) {
+      mx_button_set_icon_name(&this, icon_name);
+   }
+
+   // VERSION: 1.2
+   // Sets the icon position, relative to the text on the button.
+   // <position>: A #MxPosition
+   void set_icon_position()(Position position) {
+      mx_button_set_icon_position(&this, position);
+   }
+
+   // VERSION: 1.2
+   // Sets the icon-size to use for the icon displayed inside the button. This will
+   // override the icon-size set in the style. Setting a value of %0 resets to the
+   // size from the style.
+   void set_icon_size()(uint icon_size) {
+      mx_button_set_icon_size(&this, icon_size);
+   }
+
+   // VERSION: 1.2
+   // Sets the visibility of the icon associated with the button's action.
+   // <visible>: %TRUE if the icon should be visible
+   void set_icon_visible()(int visible) {
+      mx_button_set_icon_visible(&this, visible);
+   }
+
+   // Enables or disables toggle mode for the button. In toggle mode, the active
+   // state will be "toggled" when the user clicks the button.
+   // <toggle>: #TRUE or #FALSE
+   void set_is_toggle()(int toggle) {
+      mx_button_set_is_toggle(&this, toggle);
+   }
+
+   // Sets the text displayed on the button
+   // <text>: text to set the label to
+   void set_label()(char* text) {
+      mx_button_set_label(&this, text);
+   }
+
+   // VERSION: 1.2
+   // Sets the visibility of the text associated with the button's action.
+   // <visible>: %TRUE if the text should be visible
+   void set_label_visible()(int visible) {
+      mx_button_set_label_visible(&this, visible);
+   }
+
+   // Sets the toggled state of the button. This is only really useful if the
+   // button has #toggle-mode mode set to #TRUE.
+   // <toggled>: #TRUE or #FALSE
+   void set_toggled()(int toggled) {
+      mx_button_set_toggled(&this, toggled);
+   }
+
+   // Emitted when the user activates the button, either with a mouse press and
+   // release or with the keyboard.
+   extern (C) alias static void function (Button* this_, void* user_data=null) signal_clicked;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"clicked", CB:signal_clicked)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"clicked",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ButtonClass {
+   BinClass parent_class;
+   extern (C) void function (Button* button) clicked;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct ButtonGroup /* : GObject.InitiallyUnowned */ {
+   alias parent this;
+   alias parent super_;
+   alias parent initiallyunowned;
+   GObject2.InitiallyUnowned parent;
+   ButtonGroupPrivate* priv;
+
+
+   // Create a new #MxButtonGroup.
+   // RETURNS: a newly allocated #MxButtonGroup.
+   static ButtonGroup* new_()() {
+      return mx_button_group_new();
+   }
+
+   // Add @button to the #MxButtonGroup.
+   // <button>: A #MxButton
+   void add()(Button* button) {
+      mx_button_group_add(&this, button);
+   }
+
+   // Calls @callback for each button in the group.
+   // <callback>: A #ClutterCallback
+   // <userdata>: A #gpointer
+   void foreach_()(Clutter.Callback callback, void* userdata) {
+      mx_button_group_foreach(&this, callback, userdata);
+   }
+
+   // Get the current active button
+   // RETURNS: the currently active button
+   Button* get_active_button()() {
+      return mx_button_group_get_active_button(&this);
+   }
+
+   // Get the value of the #MxButtonGroup:allow-no-active property.
+   // RETURNS: the value of the "allow-no-active" property.
+   int get_allow_no_active()() {
+      return mx_button_group_get_allow_no_active(&this);
+   }
+
+   // Get a list of the buttons in the button group.
+   // 
+   // owned by the #MxButtonGroup and should not be modified by the
+   // application.
+   // RETURNS: a list of buttons. The list is
+   GLib2.SList* get_buttons()() {
+      return mx_button_group_get_buttons(&this);
+   }
+
+   // Remove @button from the #MxButtonGroup
+   // <button>: A #MxButton
+   void remove()(Button* button) {
+      mx_button_group_remove(&this, button);
+   }
+
+   // Set the current active button in the group. The previous active button will
+   // have #MxButton:toggled set to #FALSE.
+   // <button>: A #MxButton
+   void set_active_button()(Button* button=null) {
+      mx_button_group_set_active_button(&this, button);
+   }
+
+   // Set the value of the #MxButtonGroup:allow-no-active property.
+   // <allow_no_active>: A #gboolean
+   void set_allow_no_active()(int allow_no_active) {
+      mx_button_group_set_allow_no_active(&this, allow_no_active);
+   }
+}
+
+struct ButtonGroupClass {
+   GObject2.InitiallyUnownedClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ButtonGroupPrivate {
+}
+
+struct ButtonPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Clipboard /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   private ClipboardPrivate* priv;
+
+
+   // Get the global #MxClipboard object that represents the clipboard.
+   // 
+   // unrefferenced or freed.
+   // RETURNS: a #MxClipboard owned by Mx and must not be
+   static Clipboard* get_default()() {
+      return mx_clipboard_get_default();
+   }
+
+   // Request the data from the clipboard in text form. @callback is executed
+   // when the data is retreived.
+   // <callback>: function to be called when the text is retreived
+   // <user_data>: data to be passed to the callback
+   void get_text()(ClipboardCallbackFunc callback, void* user_data) {
+      mx_clipboard_get_text(&this, callback, user_data);
+   }
+
+   // Sets text as the current contents of the clipboard.
+   // <text>: text to copy to the clipboard
+   void set_text()(char* text) {
+      mx_clipboard_set_text(&this, text);
+   }
+}
+
+
+// Callback function called when text is retrieved from the clipboard.
+// <clipboard>: A #MxClipboard
+// <text>: text from the clipboard
+// <user_data>: user data
+extern (C) alias void function (Clipboard* clipboard, char* text, void* user_data) ClipboardCallbackFunc;
+
+struct ClipboardClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ClipboardPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct ComboBox /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private ComboBoxPrivate* priv;
+
+
+   // Create a new MxComboBox
+   // RETURNS: a newly allocated MxComboBox
+   static ComboBox* new_()() {
+      return mx_combo_box_new();
+   }
+
+   // Append an item to the combo box list
+   // <text>: name of the item
+   void append_text()(char* text) {
+      mx_combo_box_append_text(&this, text);
+   }
+
+   // Get the name of the icon displayed in the combo box
+   // 
+   // the combo box, or %NULL if there is no active icon.
+   // RETURNS: the text string of the name of the displayed icon, owned by
+   char* get_active_icon_name()() {
+      return mx_combo_box_get_active_icon_name(&this);
+   }
+
+   // Get the text displayed in the combo box
+   // RETURNS: the text string, owned by the combo box
+   char* get_active_text()() {
+      return mx_combo_box_get_active_text(&this);
+   }
+
+   // Get the index of the last item selected
+   // RETURNS: gint
+   int get_index()() {
+      return mx_combo_box_get_index(&this);
+   }
+
+   // Insert an item into the combo box list.
+   // <position>: zero indexed position to insert the item at
+   // <text>: name of the item
+   void insert_text()(int position, char* text) {
+      mx_combo_box_insert_text(&this, position, text);
+   }
+
+   // Insert an item with text and an icon into the combo box list.
+   // <position>: zero indexed position to insert the item at
+   // <text>: name of the item
+   // <icon>: name of an icon from the icon theme
+   void insert_text_with_icon()(int position, char* text, char* icon) {
+      mx_combo_box_insert_text_with_icon(&this, position, text, icon);
+   }
+
+   // Prepend an item to the combo box list
+   // <text>: name of the item
+   void prepend_text()(char* text) {
+      mx_combo_box_prepend_text(&this, text);
+   }
+
+   // VERSION: 1.4
+   // Remove all the items of @box
+   void remove_all()() {
+      mx_combo_box_remove_all(&this);
+   }
+
+   // Remove the item at @position
+   // <position>: position of the item to remove
+   void remove_text()(int position) {
+      mx_combo_box_remove_text(&this, position);
+   }
+
+   // Set the icon displayed in the combo box.
+   // <icon_name>: Icon name to use for displayed icon
+   void set_active_icon_name()(char* icon_name=null) {
+      mx_combo_box_set_active_icon_name(&this, icon_name);
+   }
+
+   // Set the text displayed in the combo box
+   // <text>: text to display
+   void set_active_text()(char* text) {
+      mx_combo_box_set_active_text(&this, text);
+   }
+
+   // Set the current combo box text from the item at @index in the list.
+   // <index>: the index of the list item to set
+   void set_index()(int index) {
+      mx_combo_box_set_index(&this, index);
+   }
+}
+
+struct ComboBoxClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ComboBoxPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct DeformBowTie /* : DeformTexture */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent deformtexture;
+   DeformTexture parent;
+   DeformBowTiePrivate* priv;
+
+   static DeformBowTie* new_()() {
+      return mx_deform_bow_tie_new();
+   }
+   int get_flip_back()() {
+      return mx_deform_bow_tie_get_flip_back(&this);
+   }
+   double get_period()() {
+      return mx_deform_bow_tie_get_period(&this);
+   }
+   void set_flip_back()(int flip_back) {
+      mx_deform_bow_tie_set_flip_back(&this, flip_back);
+   }
+   void set_period()(double period) {
+      mx_deform_bow_tie_set_period(&this, period);
+   }
+}
+
+struct DeformBowTieClass {
+   DeformTextureClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct DeformBowTiePrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct DeformPageTurn /* : DeformTexture */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent deformtexture;
+   DeformTexture parent;
+   DeformPageTurnPrivate* priv;
+
+   static DeformPageTurn* new_()() {
+      return mx_deform_page_turn_new();
+   }
+   double get_angle()() {
+      return mx_deform_page_turn_get_angle(&this);
+   }
+   double get_period()() {
+      return mx_deform_page_turn_get_period(&this);
+   }
+   double get_radius()() {
+      return mx_deform_page_turn_get_radius(&this);
+   }
+   void set_angle()(double angle) {
+      mx_deform_page_turn_set_angle(&this, angle);
+   }
+   void set_period()(double period) {
+      mx_deform_page_turn_set_period(&this, period);
+   }
+   void set_radius()(double radius) {
+      mx_deform_page_turn_set_radius(&this, radius);
+   }
+}
+
+struct DeformPageTurnClass {
+   DeformTextureClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct DeformPageTurnPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct DeformTexture /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   DeformTexturePrivate* priv;
+
+
+   // Retrieve the mesh resolution of the texture.
+   // See mx_deform_texture_set_resolution().
+   // <tiles_x>: The horizontal resolution
+   // <tiles_y>: The vertical resolution
+   void get_resolution()(/*out*/ int* tiles_x=null, /*out*/ int* tiles_y=null) {
+      mx_deform_texture_get_resolution(&this, tiles_x, tiles_y);
+   }
+
+   // Retrieves the textures used by @texture.
+   // <front>: The front-facing texture
+   // <back>: The back-facing texture
+   void get_textures()(/*out*/ Clutter.Texture** front=null, /*out*/ Clutter.Texture** back=null) {
+      mx_deform_texture_get_textures(&this, front, back);
+   }
+   // Make @texture re-calculate its vertices and redraw itself.
+   void invalidate()() {
+      mx_deform_texture_invalidate(&this);
+   }
+
+   // Sets the amount of sub-divisions used on each axis when generating
+   // the mesh, where a value of 1 for each axis will produce a single quad.
+   // <tiles_x>: The horizontal resolution
+   // <tiles_y>: The vertical resolution
+   void set_resolution()(int tiles_x, int tiles_y) {
+      mx_deform_texture_set_resolution(&this, tiles_x, tiles_y);
+   }
+
+   // Set textures to use as the sources of a deformation effect. Textures
+   // must not be parented.
+   // <front>: #ClutterTexture to use for the front-face.
+   // <back>: #ClutterTexture to use for the back-face.
+   void set_textures()(Clutter.Texture* front=null, Clutter.Texture* back=null) {
+      mx_deform_texture_set_textures(&this, front, back);
+   }
+}
+
+struct DeformTextureClass {
+   WidgetClass parent_class;
+   extern (C) void function (DeformTexture* texture, Cogl.TextureVertex* vertex, float width, float height) deform;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct DeformTexturePrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct DeformWaves /* : DeformTexture */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent deformtexture;
+   DeformTexture parent;
+   DeformWavesPrivate* priv;
+
+   static DeformWaves* new_()() {
+      return mx_deform_waves_new();
+   }
+   double get_amplitude()() {
+      return mx_deform_waves_get_amplitude(&this);
+   }
+   double get_angle()() {
+      return mx_deform_waves_get_angle(&this);
+   }
+   double get_period()() {
+      return mx_deform_waves_get_period(&this);
+   }
+   double get_radius()() {
+      return mx_deform_waves_get_radius(&this);
+   }
+   void set_amplitude()(double amplitude) {
+      mx_deform_waves_set_amplitude(&this, amplitude);
+   }
+   void set_angle()(double angle) {
+      mx_deform_waves_set_angle(&this, angle);
+   }
+   void set_period()(double period) {
+      mx_deform_waves_set_period(&this, period);
+   }
+   void set_radius()(double radius) {
+      mx_deform_waves_set_radius(&this, radius);
+   }
+}
+
+struct DeformWavesClass {
+   DeformTextureClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct DeformWavesPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Dialog /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent bin;
+   Bin parent;
+   private DialogPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Creates a new #MxDialog.
+   // RETURNS: A newly allocated #MxDialog
+   static Dialog* new_()() {
+      return mx_dialog_new();
+   }
+
+   // VERSION: 1.2
+   // Adds an #MxButton that represents @action to the button area of @dialog
+   // <action>: A #MxAction
+   void add_action()(Action* action) {
+      mx_dialog_add_action(&this, action);
+   }
+
+   // VERSION: 1.2
+   // Retrieves a list of actions added to @dialog.
+   // 
+   // #GList of #MxAction objects. The actions in the list are owned by the
+   // dialog.
+   // RETURNS: A newly allocated
+   GLib2.List* /*new container*/ get_actions()() {
+      return mx_dialog_get_actions(&this);
+   }
+
+   // VERSION: 1.2
+   // Removes the button associated with @action from the button area of @dialog
+   // <action>: A #MxAction
+   void remove_action()(Action* action) {
+      mx_dialog_remove_action(&this, action);
+   }
+
+   // VERSION: 1.2
+   // Sets the parent of the #MxDialog. This is the actor over which the
+   // modal frame will appear when clutter_actor_show() is called.
+   // <actor>: A #ClutterActor
+   void set_transient_parent()(Clutter.Actor* actor) {
+      mx_dialog_set_transient_parent(&this, actor);
+   }
+}
+
+struct DialogClass {
+   BinClass parent_class;
+}
+
+struct DialogPrivate {
+}
+
+enum DragAxis {
+   NONE = 0,
+   X = 1,
+   Y = 2
+}
+// This is an opaque structure whose members cannot be directly accessed.
+struct Draggable /* Interface */ {
+   mixin template __interface__() {      void disable()() {
+         mx_draggable_disable(cast(Draggable*)&this);
+      }
+      void enable()() {
+         mx_draggable_enable(cast(Draggable*)&this);
+      }
+      DragAxis get_axis()() {
+         return mx_draggable_get_axis(cast(Draggable*)&this);
+      }
+
+      // FIXME
+      // RETURNS: a #ClutterActor, or %NULL
+      Clutter.Actor* get_drag_actor()() {
+         return mx_draggable_get_drag_actor(cast(Draggable*)&this);
+      }
+      uint get_drag_threshold()() {
+         return mx_draggable_get_drag_threshold(cast(Draggable*)&this);
+      }
+      int is_enabled()() {
+         return mx_draggable_is_enabled(cast(Draggable*)&this);
+      }
+      void set_axis()(DragAxis axis) {
+         mx_draggable_set_axis(cast(Draggable*)&this, axis);
+      }
+      void set_drag_actor()(Clutter.Actor* actor) {
+         mx_draggable_set_drag_actor(cast(Draggable*)&this, actor);
+      }
+      void set_drag_threshold()(uint threshold) {
+         mx_draggable_set_drag_threshold(cast(Draggable*)&this, threshold);
+      }
+      extern (C) alias static void function (Draggable* this_, float object, float p0, int p1, Clutter.ModifierType* p2, void* user_data=null) signal_drag_begin;
+
+      ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return super_.signal_connect!name(cb, data, cf);
+      }
+
+      ulong signal_connect(string name:"drag-begin", CB:signal_drag_begin)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"drag-begin",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+      extern (C) alias static void function (Draggable* this_, float object, float p0, void* user_data=null) signal_drag_end;
+      ulong signal_connect(string name:"drag-end", CB:signal_drag_end)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"drag-end",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+      extern (C) alias static void function (Draggable* this_, float object, float p0, void* user_data=null) signal_drag_motion;
+      ulong signal_connect(string name:"drag-motion", CB:signal_drag_motion)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"drag-motion",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+   }
+   mixin __interface__;
+}
+
+// Interface for draggable #ClutterActor<!-- -->s.
+struct DraggableIface {
+   private GObject2.TypeInterface g_iface;
+   extern (C) void function (Draggable* draggable) enable;
+   extern (C) void function (Draggable* draggable) disable;
+   extern (C) void function (Draggable* draggable, float event_x, float event_y, int event_button, Clutter.ModifierType modifiers) drag_begin;
+   extern (C) void function (Draggable* draggable, float delta_x, float delta_y) drag_motion;
+   extern (C) void function (Draggable* draggable, float event_x, float event_y) drag_end;
+}
+
+// This is an opaque structure whose members cannot be directly accessed.
+struct Droppable /* Interface */ {
+   mixin template __interface__() {      int accept_drop()(Draggable* draggable) {
+         return mx_droppable_accept_drop(cast(Droppable*)&this, draggable);
+      }
+      void disable()() {
+         mx_droppable_disable(cast(Droppable*)&this);
+      }
+      void enable()() {
+         mx_droppable_enable(cast(Droppable*)&this);
+      }
+      int is_enabled()() {
+         return mx_droppable_is_enabled(cast(Droppable*)&this);
+      }
+      extern (C) alias static void function (Droppable* this_, Clutter.Actor* object, float p0, float p1, int p2, Clutter.ModifierType* p3, void* user_data=null) signal_drop;
+
+      ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return super_.signal_connect!name(cb, data, cf);
+      }
+
+      ulong signal_connect(string name:"drop", CB:signal_drop)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"drop",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+      extern (C) alias static void function (Droppable* this_, Clutter.Actor* object, void* user_data=null) signal_over_in;
+      ulong signal_connect(string name:"over-in", CB:signal_over_in)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"over-in",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+      extern (C) alias static void function (Droppable* this_, Clutter.Actor* object, void* user_data=null) signal_over_out;
+      ulong signal_connect(string name:"over-out", CB:signal_over_out)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"over-out",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+   }
+   mixin __interface__;
+}
+
+struct DroppableIface {
+   private GObject2.TypeInterface g_iface;
+   extern (C) void function (Droppable* droppable) enable;
+   extern (C) void function (Droppable* droppable) disable;
+   extern (C) int function (Droppable* droppable, Draggable* draggable) accept_drop;
+   extern (C) void function (Droppable* droppable, Draggable* draggable) over_in;
+   extern (C) void function (Droppable* droppable, Draggable* draggable) over_out;
+   extern (C) void function (Droppable* droppable, Draggable* draggable, float event_x, float event_y, int button, Clutter.ModifierType modifiers) drop;
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Entry /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance widget;
+   Widget parent_instance;
+   private EntryPrivate* priv;
+
+
+   // Create a new #MxEntry
+   // RETURNS: a new #MxEntry
+   static Entry* new_()() {
+      return mx_entry_new();
+   }
+
+   // Create a new #MxEntry with the specified entry
+   // RETURNS: a new #MxEntry
+   // <text>: text to set the entry to
+   static Entry* new_with_text()(char* text) {
+      return mx_entry_new_with_text(text);
+   }
+
+   // Retrieve the internal #ClutterText so that extra parameters can be set
+   // 
+   // owned by the #MxEntry and should not be unref'ed by the application.
+   // RETURNS: the #ClutterText used by #MxEntry. The entry is
+   Clutter.Actor* get_clutter_text()() {
+      return mx_entry_get_clutter_text(&this);
+   }
+
+   // Gets the text that is displayed when the entry is empty and unfocused
+   // 
+   // #MxEntry and should not be freed or modified.
+   // RETURNS: the current value of the hint property. This string is owned by the
+   char* get_hint_text()() {
+      return mx_entry_get_hint_text(&this);
+   }
+
+   // Get the suffix appended to the filename to use for the highlighted version
+   // of the icon.
+   // 
+   // #MxEntry and should not be freed or modified.
+   // RETURNS: the highlight filename suffix. This string is owned by the
+   char* get_icon_highlight_suffix()() {
+      return mx_entry_get_icon_highlight_suffix(&this);
+   }
+
+   // Gets the character to display instead of the text.
+   // RETURNS: a character, or 0 if input should not be hidden.
+   dchar get_password_char()() {
+      return mx_entry_get_password_char(&this);
+   }
+
+   // Get the text displayed on the entry
+   // RETURNS: the text for the entry. This must not be freed by the application
+   char* get_text()() {
+      return mx_entry_get_text(&this);
+   }
+
+   // Sets the text to display when the entry is empty and unfocused. When the
+   // entry is displaying the hint, it has a pseudo class of "indeterminate".
+   // A value of NULL unsets the hint.
+   // <text>: text to set as the entry hint
+   void set_hint_text()(char* text) {
+      mx_entry_set_hint_text(&this, text);
+   }
+
+   // Sets the suffix appended to the filename to use for the highlighted version
+   // of the icon. e.g. if you have set your primay icon to "primary-icon.png"
+   // and the suffix to "-highlight" #MxEntry will look for
+   // "primary-icon-highlight.png"
+   // <suffix>: the suffix to append to the filename for the highlight version
+   void set_icon_highlight_suffix()(char* suffix) {
+      mx_entry_set_icon_highlight_suffix(&this, suffix);
+   }
+
+   // Sets the character to display instead of the text. Use 0 to display
+   // the actual text.
+   // <password_char>: text to set as the entry hint
+   void set_password_char()(dchar password_char) {
+      mx_entry_set_password_char(&this, password_char);
+   }
+
+   // Set the primary icon of the entry to the given filename
+   // <filename>: filename of an icon
+   void set_primary_icon_from_file()(char* filename) {
+      mx_entry_set_primary_icon_from_file(&this, filename);
+   }
+   void set_primary_icon_tooltip_text()(char* text) {
+      mx_entry_set_primary_icon_tooltip_text(&this, text);
+   }
+
+   // Set the primary icon of the entry to the given filename
+   // <filename>: filename of an icon
+   void set_secondary_icon_from_file()(char* filename) {
+      mx_entry_set_secondary_icon_from_file(&this, filename);
+   }
+   void set_secondary_icon_tooltip_text()(char* text) {
+      mx_entry_set_secondary_icon_tooltip_text(&this, text);
+   }
+
+   // Sets the text displayed on the entry
+   // <text>: text to set the entry to
+   void set_text()(char* text) {
+      mx_entry_set_text(&this, text);
+   }
+   // Emitted when the primary icon is clicked
+   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_primary_icon_clicked;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"primary-icon-clicked", CB:signal_primary_icon_clicked)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"primary-icon-clicked",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+   // Emitted when the secondary icon is clicked
+   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_secondary_icon_clicked;
+   ulong signal_connect(string name:"secondary-icon-clicked", CB:signal_secondary_icon_clicked)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"secondary-icon-clicked",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct EntryClass {
+   WidgetClass parent_class;
+   extern (C) void function (Entry* entry) primary_icon_clicked;
+   extern (C) void function (Entry* entry) secondary_icon_clicked;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct EntryPrivate {
+}
+
+
+// The contents of the this structure are private and should only be accessed
+// through the public API.
+struct Expander /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent bin;
+   Bin parent;
+   private ExpanderPrivate* priv;
+
+
+   // Creates a new #MxExpander
+   // RETURNS: the newly allocated #MxExpander
+   static Expander* new_()() {
+      return mx_expander_new();
+   }
+
+   // Get the current state of the expander (the value of #MxExpander:expanded)
+   // RETURNS: #TRUE if the expander is open, #FALSE if it is closed
+   int get_expanded()() {
+      return mx_expander_get_expanded(&this);
+   }
+
+   // Set the state (the #MxExpander:expanded property) of the expander.
+   // This will cause the expander to open or close.
+   // <expanded>: the state of the expander to set
+   void set_expanded()(int expanded) {
+      mx_expander_set_expanded(&this, expanded);
+   }
+
+   // Sets the text displayed as the title of the expander
+   // <label>: string to set as the expander label
+   void set_label()(char* label) {
+      mx_expander_set_label(&this, label);
+   }
+
+   // Emitted after the expand animation finishes. Check the "expanded" property
+   // of the #MxExpander to determine if the expander is expanded or not.
+   extern (C) alias static void function (Expander* this_, void* user_data=null) signal_expand_complete;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"expand-complete", CB:signal_expand_complete)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"expand-complete",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ExpanderClass {
+   BinClass parent_class;
+   extern (C) void function (Expander* expander) expand_complete;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ExpanderPrivate {
+}
+
+struct FadeEffect /* : Clutter.OffscreenEffect */ {
+   alias parent this;
+   alias parent super_;
+   alias parent offscreeneffect;
+   Clutter.OffscreenEffect parent;
+   FadeEffectPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Creates a new #MxFadeEffect to be used with clutter_actor_add_effect().
+   // RETURNS: the newly created #MxFadeEffect, or %NULL
+   static FadeEffect* new_()() {
+      return mx_fade_effect_new();
+   }
+
+   // VERSION: 1.2
+   // Retrieves the border values for @effect.
+   // <top>: The upper border, in pixels
+   // <right>: The right border, in pixels
+   // <bottom>: The lower border, in pixels
+   // <left>: The left border, in pixels
+   void get_border()(/*out*/ uint* top, /*out*/ uint* right, /*out*/ uint* bottom, /*out*/ uint* left) {
+      mx_fade_effect_get_border(&this, top, right, bottom, left);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the bounding box of the effect.
+   // <x>: The x value of the effect bounds, in pixels
+   // <y>: The y value of the effect bounds, in pixels
+   // <width>: The width of the effect bounds, in pixels, or %0
+   // <height>: The height of the effect bounds, in pixels, or %0
+   void get_bounds()(/*out*/ int* x, /*out*/ int* y, /*out*/ uint* width, /*out*/ uint* height) {
+      mx_fade_effect_get_bounds(&this, x, y, width, height);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the color used for the fade effect.
+   // <color>: A #ClutterColor to store the color in
+   void get_color()(/*out*/ Clutter.Color* color) {
+      mx_fade_effect_get_color(&this, color);
+   }
+
+   // VERSION: 1.2
+   // Sets the border to be used for the fading effect. This is the number of
+   // pixels on each side of the effect that should be used to fade.
+   // <top>: The upper border, in pixels
+   // <right>: The right border, in pixels
+   // <bottom>: The lower border, in pixels
+   // <left>: The left border, in pixels
+   void set_border()(uint top, uint right, uint bottom, uint left) {
+      mx_fade_effect_set_border(&this, top, right, bottom, left);
+   }
+
+   // VERSION: 1.2
+   // Sets the bounding box of the effect. The effect will essentially treat
+   // this box as a clipping rectangle. Setting width or height to %0 will
+   // use the width or height of the #ClutterActor the effect is attached to.
+   // 
+   // <note><para>
+   // The effect border will apply to the bounds, and not to the un-altered
+   // rectangle, so an effect with an %x of %5 and a %left-border of %5 will
+   // have a gap of 5 blank pixels to the left, with a fade length of 5 pixels.
+   // </para></note>
+   // <x>: The x value of the effect bounds, in pixels
+   // <y>: The y value of the effect bounds, in pixels
+   // <width>: The width of the effect bounds, in pixels, or %0
+   // <height>: The height of the effect bounds, in pixels, or %0
+   void set_bounds()(int x, int y, uint width, uint height) {
+      mx_fade_effect_set_bounds(&this, x, y, width, height);
+   }
+
+   // VERSION: 1.2
+   // Sets the color of the fade effect. The effect will fade out towards
+   // the set border to this color.
+   // <color>: A #ClutterColor
+   void set_color()(Clutter.Color* color) {
+      mx_fade_effect_set_color(&this, color);
+   }
+}
+
+struct FadeEffectClass {
+   Clutter.OffscreenEffectClass parent_class;
+}
+
+struct FadeEffectPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct FloatingWidget /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   FloatingWidgetPrivate* priv;
+}
+
+struct FloatingWidgetClass {
+   WidgetClass parent_class;
+   extern (C) void function (Clutter.Actor* actor, Clutter.Color* color) floating_pick;
+   extern (C) void function (Clutter.Actor* actor) floating_paint;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct FloatingWidgetPrivate {
+}
+
+enum FocusDirection {
+   OUT = 0,
+   UP = 1,
+   DOWN = 2,
+   LEFT = 3,
+   RIGHT = 4,
+   NEXT = 5,
+   PREVIOUS = 6
+}
+enum FocusHint {
+   FIRST = 0,
+   LAST = 1,
+   PRIOR = 2,
+   FROM_ABOVE = 3,
+   FROM_BELOW = 4,
+   FROM_LEFT = 5,
+   FROM_RIGHT = 6
+}
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct FocusManager /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   FocusManagerPrivate* priv;
+
+
+   // Get the MxFocusManager associated with a stage, or create one if none exist
+   // for the specified stage.
+   // RETURNS: An #MxFocusManager
+   // <stage>: A #ClutterStage
+   static FocusManager* get_for_stage()(Clutter.Stage* stage) {
+      return mx_focus_manager_get_for_stage(stage);
+   }
+
+   // Get the currently focused #MxFocusable
+   // RETURNS: MxFocusable
+   Focusable* get_focused()() {
+      return mx_focus_manager_get_focused(&this);
+   }
+
+   // Get the stage the MxFocusManager is associated with
+   // RETURNS: A #ClutterStage
+   Clutter.Stage* get_stage()() {
+      return mx_focus_manager_get_stage(&this);
+   }
+
+   // Moves the current focus in the given direction.
+   // <direction>: The direction to move focus in
+   void move_focus()(FocusDirection direction) {
+      mx_focus_manager_move_focus(&this, direction);
+   }
+
+   // Sets the currently focused actor, with an #MxFocusHint of
+   // %MX_FOCUS_HINT_PRIOR.
+   // 
+   // Note: the final focused object may not be the same as @focusable if
+   // @focusable does not accept focus directly.
+   // <focusable>: the object to set focus on
+   void push_focus()(Focusable* focusable) {
+      mx_focus_manager_push_focus(&this, focusable);
+   }
+
+   // VERSION: 1.2
+   // Similar to #mx_focus_manager_push_focus, but allows the hint to be specified.
+   // 
+   // Note: the final focused object may not be the same as @focusable if
+   // @focusable does not accept focus directly.
+   // <focusable>: the object to set focus on
+   // <hint>: an #MxFocusHint
+   void push_focus_with_hint()(Focusable* focusable, FocusHint hint) {
+      mx_focus_manager_push_focus_with_hint(&this, focusable, hint);
+   }
+}
+
+struct FocusManagerClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct FocusManagerPrivate {
+}
+
+// This is an opaque structure whose members cannot be directly accessed.
+struct Focusable /* Interface */ {
+   mixin template __interface__() {
+      // Accept the focus
+      // RETURNS: the focusable
+      // <hint>: A #MxFocusHint
+      Focusable* accept_focus()(FocusHint hint) {
+         return mx_focusable_accept_focus(cast(Focusable*)&this, hint);
+      }
+
+      // Move the focus
+      // RETURNS: the newly focused focusable
+      // <direction>: A #MxFocusDirection
+      // <from>: focusable to move the focus from
+      Focusable* move_focus()(FocusDirection direction, Focusable* from) {
+         return mx_focusable_move_focus(cast(Focusable*)&this, direction, from);
+      }
+   }
+   mixin __interface__;
+}
+
+struct FocusableIface {
+   GObject2.ObjectClass parent_class;
+
+   // RETURNS: the focusable
+   // <hint>: A #MxFocusHint
+   extern (C) Focusable* function (Focusable* focusable, FocusHint hint) accept_focus;
+
+   // RETURNS: the newly focused focusable
+   // <direction>: A #MxFocusDirection
+   // <from>: focusable to move the focus from
+   extern (C) Focusable* function (Focusable* focusable, FocusDirection direction, Focusable* from) move_focus;
+}
+
+// Support values of font weight
+enum FontWeight {
+   NORMAL = 0,
+   BOLD = 1,
+   BOLDER = 2,
+   LIGHTER = 3
+}
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Frame /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent bin;
+   Bin parent;
+   FramePrivate* priv;
+
+
+   // Create a new #MxFrame
+   // RETURNS: a newly allocated #MxFrame
+   static Frame* new_()() {
+      return mx_frame_new();
+   }
+}
+
+struct FrameClass {
+   BinClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct FramePrivate {
+}
+
+
+// The contents of the this structure are private and should only be accessed
+// through the public API.
+struct Grid /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private GridPrivate* priv;
+
+   static Grid* new_()() {
+      return mx_grid_new();
+   }
+   Align get_child_x_align()() {
+      return mx_grid_get_child_x_align(&this);
+   }
+   Align get_child_y_align()() {
+      return mx_grid_get_child_y_align(&this);
+   }
+   float get_column_spacing()() {
+      return mx_grid_get_column_spacing(&this);
+   }
+   int get_homogenous_columns()() {
+      return mx_grid_get_homogenous_columns(&this);
+   }
+   int get_homogenous_rows()() {
+      return mx_grid_get_homogenous_rows(&this);
+   }
+   int get_line_alignment()() {
+      return mx_grid_get_line_alignment(&this);
+   }
+   int get_max_stride()() {
+      return mx_grid_get_max_stride(&this);
+   }
+   Orientation get_orientation()() {
+      return mx_grid_get_orientation(&this);
+   }
+   float get_row_spacing()() {
+      return mx_grid_get_row_spacing(&this);
+   }
+   void set_child_x_align()(Align value) {
+      mx_grid_set_child_x_align(&this, value);
+   }
+   void set_child_y_align()(Align value) {
+      mx_grid_set_child_y_align(&this, value);
+   }
+   void set_column_spacing()(float value) {
+      mx_grid_set_column_spacing(&this, value);
+   }
+   void set_homogenous_columns()(int value) {
+      mx_grid_set_homogenous_columns(&this, value);
+   }
+   void set_homogenous_rows()(int value) {
+      mx_grid_set_homogenous_rows(&this, value);
+   }
+   void set_line_alignment()(Align value) {
+      mx_grid_set_line_alignment(&this, value);
+   }
+   void set_max_stride()(int value) {
+      mx_grid_set_max_stride(&this, value);
+   }
+   void set_orientation()(Orientation orientation) {
+      mx_grid_set_orientation(&this, orientation);
+   }
+   void set_row_spacing()(float value) {
+      mx_grid_set_row_spacing(&this, value);
+   }
+}
+
+struct GridClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct GridPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Icon /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private IconPrivate* priv;
+
+
+   // Create a newly allocated #MxIcon
+   // RETURNS: A newly allocated #MxIcon
+   static Icon* new_()() {
+      return mx_icon_new();
+   }
+   char* get_icon_name()() {
+      return mx_icon_get_icon_name(&this);
+   }
+   int get_icon_size()() {
+      return mx_icon_get_icon_size(&this);
+   }
+   void set_icon_name()(char* icon_name) {
+      mx_icon_set_icon_name(&this, icon_name);
+   }
+   void set_icon_size()(int size) {
+      mx_icon_set_icon_size(&this, size);
+   }
+}
+
+struct IconClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct IconPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct IconTheme /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   IconThemePrivate* priv;
+
+
+   // Create a new #MxIconTheme. In most cicumstances, it is more useful to use
+   // #mx_icon_theme_get_default to load the default icon theme.
+   // RETURNS: a newly allocated #MxIconTheme.
+   static IconTheme* /*new*/ new_()() {
+      return mx_icon_theme_new();
+   }
+
+   // Return the default #MxIconTheme object used by the toolkit.
+   // RETURNS: an #MxIconTheme.
+   static IconTheme* get_default()() {
+      return mx_icon_theme_get_default();
+   }
+
+   // Gets the directories the #MxIconTheme will search in to find icons.
+   // RETURNS: the search paths
+   GLib2.List* get_search_paths()() {
+      return mx_icon_theme_get_search_paths(&this);
+   }
+
+   // Get the value of the #MxIconTheme:theme-name property.
+   // RETURNS: the current value of the "theme-name" property.
+   char* get_theme_name()() {
+      return mx_icon_theme_get_theme_name(&this);
+   }
+   int has_icon()(char* icon_name) {
+      return mx_icon_theme_has_icon(&this, icon_name);
+   }
+
+   // If the icon is available, returns a #CoglHandle of the icon.
+   // RETURNS: a #CoglHandle of the icon, or %NULL.
+   // <icon_name>: The name of the icon
+   // <size>: The desired size of the icon
+   Cogl.Handle lookup()(char* icon_name, int size) {
+      return mx_icon_theme_lookup(&this, icon_name, size);
+   }
+
+   // If the icon is available, returns a #ClutterTexture of the icon.
+   // RETURNS: a #ClutterTexture of the icon, or %NULL.
+   // <icon_name>: The name of the icon
+   // <size>: The desired size of the icon
+   Clutter.Texture* lookup_texture()(char* icon_name, int size) {
+      return mx_icon_theme_lookup_texture(&this, icon_name, size);
+   }
+
+   // Sets the directories the #MxIconTheme will search in to find icons.
+   // By default, it will look in the default system and local icon
+   // directories.
+   // <paths>: a list of search paths
+   void set_search_paths()(GLib2.List* paths) {
+      mx_icon_theme_set_search_paths(&this, paths);
+   }
+
+   // Set the value of the #MxIconTheme:theme-name property. This will cause the
+   // icon theme to be loaded if it differs from the existing theme name. If the
+   // theme could not be loaded, it will fall back to using the default icon theme
+   // (hicolor).
+   // 
+   // This will override the system's theme setting. To revert to the system
+   // icon theme, this function can be called with a %NULL @theme_name argument.
+   // <theme_name>: the name of an icon theme to load, or %NULL
+   void set_theme_name()(char* theme_name) {
+      mx_icon_theme_set_theme_name(&this, theme_name);
+   }
+}
+
+struct IconThemeClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct IconThemePrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Image /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private ImagePrivate* priv;
+
+
+   // VERSION: 1.2
+   // Creates a new #MxImage object.
+   // RETURNS: A newly created #MxImage object
+   static Image* new_()() {
+      return mx_image_new();
+   }
+
+   // VERSION: 1.2
+   // Sets the value of #MxImage:scale-mode to @scale_mode and animates the
+   // scale factor of the image between the previous value and the new value.
+   // <mode>: a #ClutterAnimationMode
+   // <duration>: duration of the animation in milliseconds
+   // <scale_mode>: The #MxImageScaleMode to set
+   void animate_scale_mode()(c_ulong mode, uint duration, ImageScaleMode scale_mode) {
+      mx_image_animate_scale_mode(&this, mode, duration, scale_mode);
+   }
+
+   // VERSION: 1.2
+   // Clear the current image and set a blank, transparent image.
+   // RETURNS: static void
+   void clear()() {
+      mx_image_clear(&this);
+   }
+
+   // VERSION: 1.2
+   // Determines whether image up-scaling is allowed.
+   // RETURNS: %TRUE if upscaling is allowed, %FALSE otherwise
+   int get_allow_upscale()() {
+      return mx_image_get_allow_upscale(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the MxImage:image-rotation property.
+   // RETURNS: The value of the image-rotation property.
+   float get_image_rotation()() {
+      return mx_image_get_image_rotation(&this);
+   }
+
+   // VERSION: 1.2
+   // Determines whether asynchronous image loading is in use.
+   // RETURNS: %TRUE if images are set to load asynchronously, %FALSE otherwise
+   int get_load_async()() {
+      return mx_image_get_load_async(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the height scaling threshold.
+   // RETURNS: The height scaling threshold, in pixels
+   uint get_scale_height_threshold()() {
+      return mx_image_get_scale_height_threshold(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the current scale mode of @MxImage.
+   // RETURNS: The current MxImageScaleMode
+   ImageScaleMode get_scale_mode()() {
+      return mx_image_get_scale_mode(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the width scaling threshold.
+   // RETURNS: The width scaling threshold, in pixels
+   uint get_scale_width_threshold()() {
+      return mx_image_get_scale_width_threshold(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the MxImage:transition-duration property.
+   // RETURNS: The value of the transition-duration property.
+   uint get_transition_duration()() {
+      return mx_image_get_transition_duration(&this);
+   }
+
+   // VERSION: 1.2
+   // Sets whether up-scaling of images is allowed. If set to %TRUE and a size
+   // larger than the image is requested, the image will be up-scaled in
+   // software.
+   // 
+   // The advantage of this is that software up-scaling is potentially higher
+   // quality, but it comes at the expense of video memory.
+   // <allow>: %TRUE to allow upscaling, %FALSE otherwise
+   void set_allow_upscale()(int allow) {
+      mx_image_set_allow_upscale(&this, allow);
+   }
+
+   // VERSION: 1.2
+   // Set the image data from unencoded image data, stored in memory. In case of
+   // failure, #FALSE is returned and @error is set. It is expected that @buffer
+   // will remain accessible for the duration of the load. Once it is finished
+   // with, @buffer_free_func will be called.
+   // RETURNS: #TRUE if the image was successfully updated
+   // <buffer>: A buffer pointing to encoded image data
+   // <buffer_size>: The size of @buffer, in bytes
+   // <buffer_free_func>: A function to free @buffer, or %NULL
+   int set_from_buffer()(ubyte* buffer, size_t buffer_size, GLib2.DestroyNotify buffer_free_func, GLib2.Error** error=null) {
+      return mx_image_set_from_buffer(&this, buffer, buffer_size, buffer_free_func, error);
+   }
+
+   // VERSION: 1.2
+   // Set the image data from unencoded image data, stored in memory, and scales
+   // it while loading. In case of failure, #FALSE is returned and @error is set.
+   // It is expected that @buffer will remain accessible for the duration of the
+   // load. Once it is finished with, @buffer_free_func will be called. The aspect
+   // ratio will always be maintained.
+   // RETURNS: #TRUE if the image was successfully updated
+   // <buffer>: A buffer pointing to encoded image data
+   // <buffer_size>: The size of @buffer, in bytes
+   // <buffer_free_func>: A function to free @buffer, or %NULL
+   // <width>: Width to scale the image to, or -1
+   // <height>: Height to scale the image to, or -1
+   int set_from_buffer_at_size()(ubyte* buffer, size_t buffer_size, GLib2.DestroyNotify buffer_free_func, int width, int height, GLib2.Error** error=null) {
+      return mx_image_set_from_buffer_at_size(&this, buffer, buffer_size, buffer_free_func, width, height, error);
+   }
+
+   // VERSION: 1.2
+   // Sets the contents of the image from the given Cogl texture.
+   // RETURNS: %TRUE on success, %FALSE on failure
+   // <texture>: A #CoglHandle to a texture
+   int set_from_cogl_texture()(Cogl.Handle texture) {
+      return mx_image_set_from_cogl_texture(&this, texture);
+   }
+
+   // VERSION: 1.2
+   // Set the image data from a buffer. In case of failure, #FALSE is returned
+   // and @error is set.
+   // RETURNS: #TRUE if the image was successfully updated
+   // <data>: Image data
+   // <pixel_format>: The #CoglPixelFormat of the buffer
+   // <width>: Width in pixels of image data.
+   // <height>: Height in pixels of image data
+   // <rowstride>: Distance in bytes between row starts.
+   int set_from_data()(ubyte* data, Cogl.PixelFormat pixel_format, int width, int height, int rowstride, GLib2.Error** error=null) {
+      return mx_image_set_from_data(&this, data, pixel_format, width, height, rowstride, error);
+   }
+
+   // VERSION: 1.2
+   // Set the image data from an image file. In case of failure, #FALSE is returned
+   // and @error is set.
+   // RETURNS: #TRUE if the image was successfully updated
+   // <filename>: Filename to read the file from
+   int set_from_file()(char* filename, GLib2.Error** error=null) {
+      return mx_image_set_from_file(&this, filename, error);
+   }
+
+   // VERSION: 1.2
+   // Set the image data from an image file, and scale the image during loading.
+   // In case of failure, #FALSE is returned and @error is set. The aspect ratio
+   // will always be maintained.
+   // RETURNS: #TRUE if the image was successfully updated
+   // <filename>: Filename to read the file from
+   // <width>: Width to scale the image to, or -1
+   // <height>: Height to scale the image to, or -1
+   int set_from_file_at_size()(char* filename, int width, int height, GLib2.Error** error=null) {
+      return mx_image_set_from_file_at_size(&this, filename, width, height, error);
+   }
+
+   // VERSION: 1.2
+   // Set the MxImage:image-rotation property.
+   // <rotation>: Rotation angle in degrees
+   void set_image_rotation()(float rotation) {
+      mx_image_set_image_rotation(&this, rotation);
+   }
+
+   // VERSION: 1.2
+   // Sets whether to load images asynchronously. Asynchronous image loading
+   // requires thread support (see g_thread_init()).
+   // 
+   // When using asynchronous image loading, all image-loading functions will
+   // return immediately as successful. The #MxImage::image-loaded and
+   // #MxImage::image-load-error signals are used to signal success or failure
+   // of asynchronous image loading.
+   // <load_async>: %TRUE to load images asynchronously
+   void set_load_async()(int load_async) {
+      mx_image_set_load_async(&this, load_async);
+   }
+
+   // VERSION: 1.2
+   // Sets the threshold used to determine whether to scale the height of the
+   // image. If a specific height is requested, the image height is allowed to
+   // differ by this amount before scaling is employed.
+   // 
+   // This can be useful to avoid excessive CPU usage when the image differs
+   // only slightly to the desired size.
+   // <pixels>: Number of pixels
+   void set_scale_height_threshold()(uint pixels) {
+      mx_image_set_scale_height_threshold(&this, pixels);
+   }
+
+   // VERSION: 1.2
+   // Set the scale mode on @MxImage
+   // <mode>: The #MxImageScaleMode to set
+   void set_scale_mode()(ImageScaleMode mode) {
+      mx_image_set_scale_mode(&this, mode);
+   }
+
+   // VERSION: 1.2
+   // Sets the threshold used to determine whether to scale the width of the
+   // image. If a specific width is requested, the image width is allowed to
+   // differ by this amount before scaling is employed.
+   // 
+   // This can be useful to avoid excessive CPU usage when the image differs
+   // only slightly to the desired size.
+   // <pixels>: Number of pixels
+   void set_scale_width_threshold()(uint pixels) {
+      mx_image_set_scale_width_threshold(&this, pixels);
+   }
+
+   // VERSION: 1.2
+   // Set the MxImage:transition-duration property.
+   // <duration>: Transition duration in milliseconds
+   void set_transition_duration()(uint duration) {
+      mx_image_set_transition_duration(&this, duration);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an asynchronous image load has encountered an error
+   // and cannot load the requested image.
+   extern (C) alias static void function (Image* this_, GLib2.Error* since, void* user_data=null) signal_image_load_error;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"image-load-error", CB:signal_image_load_error)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"image-load-error",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+
+   // VERSION: 1.2
+   // Emitted when an asynchronous image load has completed successfully
+   extern (C) alias static void function (Image* this_, void* user_data=null) signal_image_loaded;
+   ulong signal_connect(string name:"image-loaded", CB:signal_image_loaded)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"image-loaded",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ImageClass {
+   private WidgetClass parent_class;
+   extern (C) void function (Image* image) image_loaded;
+   extern (C) void function (Image* image, GLib2.Error* error) image_load_error;
+}
+
+enum ImageError {
+   BAD_FORMAT = 0,
+   NO_ASYNC = 1,
+   INTERNAL = 2,
+   INVALID_PARAMETER = 3
+}
+struct ImagePrivate {
+}
+
+// Defines the scaling mode of an image.
+enum ImageScaleMode {
+   NONE = 0,
+   FIT = 1,
+   CROP = 2
+}
+// This is an opaque structure whose members cannot be directly accessed.
+struct ItemFactory /* Interface */ {
+   mixin template __interface__() {
+      // Create an item
+      // RETURNS: the new item
+      Clutter.Actor* /*new*/ create()() {
+         return mx_item_factory_create(cast(ItemFactory*)&this);
+      }
+   }
+   mixin __interface__;
+}
+
+// Interface for creating custom items
+struct ItemFactoryIface {
+   private GObject2.TypeInterface g_iface;
+   // RETURNS: the new item
+   extern (C) Clutter.Actor* /*new*/ function (ItemFactory* factory) create;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+
+// The contents of the this structure are private and should only be accessed
+// through the public API.
+struct ItemView /* : Grid */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent grid;
+   Grid parent;
+   private ItemViewPrivate* priv;
+
+
+   // Create a new #MxItemView
+   // RETURNS: a newly allocated #MxItemView
+   static ItemView* new_()() {
+      return mx_item_view_new();
+   }
+
+   // Adds an attribute mapping between the current model and the objects from the
+   // cell renderer.
+   // <attribute>: Name of the attribute
+   // <column>: Column number
+   void add_attribute()(char* attribute, int column) {
+      mx_item_view_add_attribute(&this, attribute, column);
+   }
+
+   // Freeze the view. This means that the view will not act on changes to the
+   // model until it is thawed. Call #mx_item_view_thaw to thaw the view
+   void freeze()() {
+      mx_item_view_freeze(&this);
+   }
+
+   // Gets the #MxItemFactory used for creating new items.
+   // RETURNS: A #MxItemFactory.
+   ItemFactory* get_factory()() {
+      return mx_item_view_get_factory(&this);
+   }
+
+   // Get the item type currently being used to create items
+   // RETURNS: a #GType
+   Type get_item_type()() {
+      return mx_item_view_get_item_type(&this);
+   }
+
+   // Get the model currently used by the #MxItemView
+   // RETURNS: the current #ClutterModel
+   Clutter.Model* get_model()() {
+      return mx_item_view_get_model(&this);
+   }
+
+   // Sets @factory to be the factory used for creating new items
+   // <factory>: A #MxItemFactory
+   void set_factory()(ItemFactory* factory=null) {
+      mx_item_view_set_factory(&this, factory);
+   }
+
+   // Set the item type used to create items representing each row in the
+   // model
+   // <item_type>: A #GType
+   void set_item_type()(Type item_type) {
+      mx_item_view_set_item_type(&this, item_type);
+   }
+
+   // Set the model used by the #MxItemView
+   // <model>: A #ClutterModel
+   void set_model()(Clutter.Model* model) {
+      mx_item_view_set_model(&this, model);
+   }
+
+   // Thaw the view. This means that the view will now act on changes to the
+   // model.
+   void thaw()() {
+      mx_item_view_thaw(&this);
+   }
+}
+
+struct ItemViewClass {
+   GridClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ItemViewPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct KineticScrollView /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance bin;
+   Bin parent_instance;
+   private KineticScrollViewPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Creates a new #MxKineticScrollView.
+   // RETURNS: a newly allocated #MxKineticScrollView
+   static KineticScrollView* new_()() {
+      return mx_kinetic_scroll_view_new();
+   }
+
+   // VERSION: 1.4
+   // Retrieves the initial acceleration factor of the kinetic scroll-view.
+   // RETURNS: The initial acceleration factor of the kinetic scroll-view
+   double get_acceleration_factor()() {
+      return mx_kinetic_scroll_view_get_acceleration_factor(&this);
+   }
+
+   // VERSION: 1.4
+   // Retrieves the duration of the adjustment clamp animation.
+   // RETURNS: Clamp duration
+   uint get_clamp_duration()() {
+      return mx_kinetic_scroll_view_get_clamp_duration(&this);
+   }
+
+   // VERSION: 1.4
+   // Retrieves the animation mode to use for the adjustment clamp animation.
+   // RETURNS: Clamp mode
+   c_ulong get_clamp_mode()() {
+      return mx_kinetic_scroll_view_get_clamp_mode(&this);
+   }
+
+   // VERSION: 1.4
+   // Retrieves whether to clamp to step increments based on the center of the page.
+   // RETURNS: Clamp to center
+   int get_clamp_to_center()() {
+      return mx_kinetic_scroll_view_get_clamp_to_center(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the deceleration rate of the kinetic scroll-view.
+   // RETURNS: The deceleration rate of the kinetic scroll-view
+   double get_deceleration()() {
+      return mx_kinetic_scroll_view_get_deceleration(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the #MxKineticScrollView:mouse-button property
+   // 
+   // kinetic scroll-view
+   // RETURNS: The mouse button number used to initiate drag events on the
+   uint get_mouse_button()() {
+      return mx_kinetic_scroll_view_get_mouse_button(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the deceleration rate multiplier used when the scroll-view is
+   // scrolling beyond its boundaries.
+   double get_overshoot()() {
+      return mx_kinetic_scroll_view_get_overshoot(&this);
+   }
+
+   // Retrieves the scrolling policy of the kinetic scroll-view.
+   // RETURNS: A #MxScrollPolicy
+   ScrollPolicy get_scroll_policy()() {
+      return mx_kinetic_scroll_view_get_scroll_policy(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the #MxKineticScrollView:use-captured property.
+   // RETURNS: %TRUE if captured-events should be used to initiate scrolling
+   int get_use_captured()() {
+      return mx_kinetic_scroll_view_get_use_captured(&this);
+   }
+
+   // VERSION: 1.4
+   // Factor applied to the initial momentum.
+   // <acceleration_factor>: The acceleration factor
+   void set_acceleration_factor()(double acceleration_factor) {
+      mx_kinetic_scroll_view_set_acceleration_factor(&this, acceleration_factor);
+   }
+
+   // VERSION: 1.4
+   // Duration of the adjustment clamp animation.
+   // <clamp_duration>: Clamp duration
+   void set_clamp_duration()(uint clamp_duration) {
+      mx_kinetic_scroll_view_set_clamp_duration(&this, clamp_duration);
+   }
+
+   // VERSION: 1.4
+   // Animation mode to use for the adjustment clamp animation.
+   // <clamp_mode>: Clamp mode
+   void set_clamp_mode()(c_ulong clamp_mode) {
+      mx_kinetic_scroll_view_set_clamp_mode(&this, clamp_mode);
+   }
+
+   // VERSION: 1.4
+   // Set whether to clamp to step increments based on the center of the page.
+   // <clamp_to_center>: Clamp to center
+   void set_clamp_to_center()(int clamp_to_center) {
+      mx_kinetic_scroll_view_set_clamp_to_center(&this, clamp_to_center);
+   }
+
+   // VERSION: 1.2
+   // Sets the deceleration rate when a drag is finished on the kinetic
+   // scroll-view. This is the value that the momentum is divided by
+   // every 60th of a second.
+   // <rate>: The deceleration rate
+   void set_deceleration()(double rate) {
+      mx_kinetic_scroll_view_set_deceleration(&this, rate);
+   }
+
+   // VERSION: 1.2
+   // Sets the mouse button number used to initiate drag events on the kinetic
+   // scroll-view.
+   // <button>: A mouse button number
+   void set_mouse_button()(uint button) {
+      mx_kinetic_scroll_view_set_mouse_button(&this, button);
+   }
+
+   // VERSION: 1.2
+   // Sets the rate at which the view will decelerate when scrolling beyond its
+   // boundaries. The deceleration rate will be multiplied by this value every
+   // 60th of a second when the view is scrolling outside of the range set by its
+   // adjustments.
+   // 
+   // See mx_kinetic_scroll_view_set_deceleration()
+   // <overshoot>: The rate at which the view will decelerate when scrolling beyond its boundaries.
+   void set_overshoot()(double overshoot) {
+      mx_kinetic_scroll_view_set_overshoot(&this, overshoot);
+   }
+
+   // Sets the scrolling policy for the kinetic scroll-view. This controls the
+   // possible axes of movement, and can affect the minimum size of the widget.
+   // <policy>: A #MxScrollPolicy
+   void set_scroll_policy()(ScrollPolicy policy) {
+      mx_kinetic_scroll_view_set_scroll_policy(&this, policy);
+   }
+
+   // VERSION: 1.2
+   // Sets whether to use captured events to initiate drag events. This can be
+   // used to block events that would initiate scrolling from reaching the child
+   // actor.
+   // <use_captured>: %TRUE to use captured events
+   void set_use_captured()(int use_captured) {
+      mx_kinetic_scroll_view_set_use_captured(&this, use_captured);
+   }
+
+   // VERSION: 1.2
+   // Stops any current movement due to kinetic scrolling.
+   void stop()() {
+      mx_kinetic_scroll_view_stop(&this);
+   }
+}
+
+struct KineticScrollViewClass {
+   BinClass parent_class;
+}
+
+struct KineticScrollViewPrivate {
+}
+
+enum KineticScrollViewState {
+   IDLE = 0,
+   PANNING = 1,
+   SCROLLING = 2,
+   CLAMPING = 3
+}
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Label /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance widget;
+   Widget parent_instance;
+   private LabelPrivate* priv;
+
+
+   // Create a new #MxLabel
+   // RETURNS: a new #MxLabel
+   static Label* new_()() {
+      return mx_label_new();
+   }
+
+   // Create a new #MxLabel with the specified label
+   // RETURNS: a new #MxLabel
+   // <text>: text to set the label to
+   static Label* new_with_text()(char* text) {
+      return mx_label_new_with_text(text);
+   }
+
+   // Retrieve the internal #ClutterText so that extra parameters can be set
+   // 
+   // is owned by the #MxLabel and should not be unref'ed by the application.
+   // RETURNS: the #ClutterText used by #MxLabel. The label
+   Clutter.Actor* get_clutter_text()() {
+      return mx_label_get_clutter_text(&this);
+   }
+
+   // VERSION: 1.2
+   // Determines whether the label has been set to fade out when there isn't
+   // enough space allocated to display the entire label.
+   // RETURNS: %TRUE if the label is set to fade out, %FALSE otherwise
+   int get_fade_out()() {
+      return mx_label_get_fade_out(&this);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxLabel:line-wrap property.
+   // RETURNS: %TRUE if the "line-wrap" property is set.
+   int get_line_wrap()() {
+      return mx_label_get_line_wrap(&this);
+   }
+
+   // VERSION: 1.4
+   // Returns the current value of the #MxLabel:show-tooltip property.
+   // RETURNS: %TRUE if the #MxLabel:show-tooltip property is enabled
+   int get_show_tooltip()() {
+      return mx_label_get_show_tooltip(&this);
+   }
+
+   // Get the text displayed on the label
+   // RETURNS: the text for the label. This must not be freed by the application
+   char* get_text()() {
+      return mx_label_get_text(&this);
+   }
+
+   // VERSION: 1.2
+   // Determines whether the text of the label is being treated as Pango markup.
+   // 
+   // %FALSE otherwise.
+   // RETURNS: %TRUE if the text of the label is treated as Pango markup,
+   int get_use_markup()() {
+      return mx_label_get_use_markup(&this);
+   }
+   Align get_x_align()() {
+      return mx_label_get_x_align(&this);
+   }
+   Align get_y_align()() {
+      return mx_label_get_y_align(&this);
+   }
+
+   // VERSION: 1.2
+   // Set whether to fade out the end of the label, instead of ellipsizing.
+   // Enabling this mode will also set the #ClutterText:single-line-mode and
+   // #ClutterText:ellipsize properties.
+   // <fade>: %TRUE to fade out, %FALSE otherwise
+   void set_fade_out()(int fade) {
+      mx_label_set_fade_out(&this, fade);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxLabel:line-wrap property.
+   // <line_wrap>: new value of the line-wrap property.
+   void set_line_wrap()(int line_wrap) {
+      mx_label_set_line_wrap(&this, line_wrap);
+   }
+
+   // VERSION: 1.4
+   // Set the value of the #MxLabel:show-tooltip property
+   // <show_tooltip>: %TRUE if the tooltip should be shown
+   void set_show_tooltip()(int show_tooltip) {
+      mx_label_set_show_tooltip(&this, show_tooltip);
+   }
+
+   // Sets the text displayed on the label
+   // <text>: text to set the label to
+   void set_text()(char* text) {
+      mx_label_set_text(&this, text);
+   }
+
+   // Sets whether the text of the label should be treated as Pango markup.
+   // <use_markup>: %TRUE to use Pango markup, %FALSE otherwise
+   void set_use_markup()(int use_markup) {
+      mx_label_set_use_markup(&this, use_markup);
+   }
+   void set_x_align()(Align align_) {
+      mx_label_set_x_align(&this, align_);
+   }
+   void set_y_align()(Align align_) {
+      mx_label_set_y_align(&this, align_);
+   }
+}
+
+struct LabelClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct LabelPrivate {
+}
+
+
+// The contents of the this structure are private and should only be accessed
+// through the public API.
+struct ListView /* : BoxLayout */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent boxlayout;
+   BoxLayout parent;
+   private ListViewPrivate* priv;
+
+
+   // Create a new #MxListView
+   // RETURNS: a newly allocated #MxListView
+   static ListView* new_()() {
+      return mx_list_view_new();
+   }
+
+   // Adds an attribute mapping between the current model and the objects from the
+   // cell renderer.
+   // <attribute>: Name of the attribute
+   // <column>: Column number
+   void add_attribute()(char* attribute, int column) {
+      mx_list_view_add_attribute(&this, attribute, column);
+   }
+
+   // Freeze the view. This means that the view will not act on changes to the
+   // model until it is thawed. Call #mx_list_view_thaw to thaw the view.
+   void freeze()() {
+      mx_list_view_freeze(&this);
+   }
+
+   // Gets the #MxItemFactory used for creating new list items.
+   // RETURNS: A #MxItemFactory.
+   ItemFactory* get_factory()() {
+      return mx_list_view_get_factory(&this);
+   }
+
+   // Get the item type currently being used to create items
+   // RETURNS: a #GType
+   Type get_item_type()() {
+      return mx_list_view_get_item_type(&this);
+   }
+
+   // Get the model currently used by the #MxListView
+   // RETURNS: the current #ClutterModel
+   Clutter.Model* get_model()() {
+      return mx_list_view_get_model(&this);
+   }
+
+   // Sets @factory to be the factory used for creating new list items
+   // <factory>: A #MxItemFactory
+   void set_factory()(ItemFactory* factory=null) {
+      mx_list_view_set_factory(&this, factory);
+   }
+
+   // Set the item type used to create items representing each row in the
+   // model
+   // <item_type>: A #GType
+   void set_item_type()(Type item_type) {
+      mx_list_view_set_item_type(&this, item_type);
+   }
+
+   // Set the model used by the #MxListView
+   // <model>: A #ClutterModel
+   void set_model()(Clutter.Model* model) {
+      mx_list_view_set_model(&this, model);
+   }
+
+   // Thaw the view. This means that the view will now act on changes to the
+   // model.
+   void thaw()() {
+      mx_list_view_thaw(&this);
+   }
+}
+
+struct ListViewClass {
+   BoxLayoutClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ListViewPrivate {
+}
+
+enum LongPressAction {
+   QUERY = 0,
+   ACTION = 1,
+   CANCEL = 2
+}
+enum int MAJOR_VERSION = 1;
+enum int MICRO_VERSION = 2;
+enum int MINOR_VERSION = 99;
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Menu /* : FloatingWidget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent floatingwidget;
+   FloatingWidget parent;
+   private MenuPrivate* priv;
+
+
+   // Create a new #MxMenu
+   // RETURNS: a newly allocated #MxMenu
+   static Menu* new_()() {
+      return mx_menu_new();
+   }
+
+   // Append @action to @menu.
+   // <action>: A #MxAction
+   void add_action()(Action* action) {
+      mx_menu_add_action(&this, action);
+   }
+
+   // Remove @action from @menu.
+   // <action>: A #MxAction
+   void remove_action()(Action* action) {
+      mx_menu_remove_action(&this, action);
+   }
+   // Remove all the actions from @menu.
+   void remove_all()() {
+      mx_menu_remove_all(&this);
+   }
+
+   // Moves the menu to the specified position and shows it.
+   // <x>: X position
+   // <y>: Y position
+   void show_with_position()(float x, float y) {
+      mx_menu_show_with_position(&this, x, y);
+   }
+   extern (C) alias static void function (Menu* this_, Action* object, void* user_data=null) signal_action_activated;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"action-activated", CB:signal_action_activated)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"action-activated",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct MenuClass {
+   FloatingWidgetClass parent_class;
+   extern (C) void function (Menu* menu, Action* action) action_activated;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct MenuPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Notebook /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   NotebookPrivate* priv;
+
+   static Notebook* new_()() {
+      return mx_notebook_new();
+   }
+
+   // Get the current page
+   // RETURNS: the current page
+   Clutter.Actor* get_current_page()() {
+      return mx_notebook_get_current_page(&this);
+   }
+   int get_enable_gestures()() {
+      return mx_notebook_get_enable_gestures(&this);
+   }
+   // Change the current page to next one.
+   void next_page()() {
+      mx_notebook_next_page(&this);
+   }
+   // Change the current page to previous one.
+   void previous_page()() {
+      mx_notebook_previous_page(&this);
+   }
+   void set_current_page()(Clutter.Actor* page) {
+      mx_notebook_set_current_page(&this, page);
+   }
+   void set_enable_gestures()(int enabled) {
+      mx_notebook_set_enable_gestures(&this, enabled);
+   }
+}
+
+struct NotebookClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct NotebookPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Offscreen /* : Clutter.Texture */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent texture;
+   Clutter.Texture parent;
+   OffscreenPrivate* priv;
+
+
+   // Creates a new #MxOffscreen.
+   // RETURNS: a newly allocated #MxOffscreen
+   static Offscreen* new_()() {
+      return mx_offscreen_new();
+   }
+
+   // VERSION: 1.2
+   // Gets the value of the #MxOffscreen:accumulation-enabled property.
+   // RETURNS: #TRUE if the accumulation buffer is enabled
+   int get_accumulation_enabled()() {
+      return mx_offscreen_get_accumulation_enabled(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the #MxOffscreen:accumulation-material property.
+   // 
+   // for the accumulation buffer
+   // RETURNS: The #CoglHandle for the material used
+   Cogl.Handle get_accumulation_material()() {
+      return mx_offscreen_get_accumulation_material(&this);
+   }
+
+   // Gets the value of the #MxOffscreen:auto-update property.
+   // RETURNS: #TRUE if automatic updating of the offscreen surface is enabled
+   int get_auto_update()() {
+      return mx_offscreen_get_auto_update(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the value of the #MxOffscreen:buffer property.
+   // RETURNS: the #CoglHandle for the offscreen buffer object
+   Cogl.Handle get_buffer()() {
+      return mx_offscreen_get_buffer(&this);
+   }
+
+   // Gets the value of the #MxOffscreen:child property.
+   // RETURNS: The child of the offscreen widget
+   Clutter.Actor* get_child()() {
+      return mx_offscreen_get_child(&this);
+   }
+
+   // Gets the value of the #MxOffscreen:pick-child property.
+   // RETURNS: #TRUE if picking of the child is enabled.
+   int get_pick_child()() {
+      return mx_offscreen_get_pick_child(&this);
+   }
+
+   // VERSION: 1.2
+   // Gets the value of the #MxOffscreen:redirect-enabled property.
+   // RETURNS: #TRUE if offscreen redirection is enabled
+   int get_redirect_enabled()() {
+      return mx_offscreen_get_redirect_enabled(&this);
+   }
+
+   // VERSION: 1.2
+   // Sets whether the accumulation buffer is enabled. When enabled, an extra
+   // offscreen buffer is allocated, and the contents of the offscreen texture
+   // are blended with this accumulation buffer. By default, the blend function
+   // is set to blend the contents of the offscreen texture with the accumulation
+   // buffer at the opacity specified in the alpha component of the blend
+   // constant. This opacity is 50% by default.
+   // <enable>: #TRUE to enable an accumulation buffer
+   void set_accumulation_enabled()(int enable) {
+      mx_offscreen_set_accumulation_enabled(&this, enable);
+   }
+
+   // Enable automatic updating of the offscreen surface when the child is
+   // updated.
+   // <auto_update>: #TRUE if the offscreen surface should be automatically updated
+   void set_auto_update()(int auto_update) {
+      mx_offscreen_set_auto_update(&this, auto_update);
+   }
+
+   // Redirects the painting of @actor to the offscreen surface owned by
+   // @offscreen. In the event that @actor is unparented, it will be parented
+   // to @offscreen. Note that when you redirect the painting of @actor, it
+   // will no longer be painted in its original position in the scenegraph.
+   // <actor>: A #ClutterActor
+   void set_child()(Clutter.Actor* actor) {
+      mx_offscreen_set_child(&this, actor);
+   }
+
+   // Enable picking of the child actor.
+   // <pick>: #TRUE to enable picking of the child actor
+   void set_pick_child()(int pick) {
+      mx_offscreen_set_pick_child(&this, pick);
+   }
+
+   // VERSION: 1.2
+   // Sets the value of the #MxOffscreen:redirect-enabled property. When
+   // redirection is enabled, the painting of the child of @offscreen will be
+   // redirected to the texture of @offscreen.
+   // <enabled>: #TRUE if redirection to the offscreen surface should be enabled
+   void set_redirect_enabled()(int enabled) {
+      mx_offscreen_set_redirect_enabled(&this, enabled);
+   }
+
+   // Updates the offscreen surface. This causes the child of @offscreen to be
+   // drawn into the texture of @offscreen.
+   void update()() {
+      mx_offscreen_update(&this);
+   }
+}
+
+struct OffscreenClass {
+   Clutter.TextureClass parent_class;
+   extern (C) void function (Offscreen* self) paint_child;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct OffscreenPrivate {
+}
+
+// Defines the orientation of various layout widgets.
+enum Orientation {
+   HORIZONTAL = 0,
+   VERTICAL = 1
+}
+enum int PARAM_TRANSLATEABLE = 256;
+// The padding from the internal border of the parent container.
+struct Padding {
+   float top, right, bottom, left;
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct PathBar /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   PathBarPrivate* priv;
+
+   static PathBar* new_()() {
+      return mx_path_bar_new();
+   }
+   // Remove all the current buttons
+   void clear()() {
+      mx_path_bar_clear(&this);
+   }
+
+   // Get the value of the #MxPathBar:clear-on-change property
+   // RETURNS: the value of the "clear-on-change" property
+   int get_clear_on_change()() {
+      return mx_path_bar_get_clear_on_change(&this);
+   }
+
+   // Get the value of the #MxPathBar:editable property.
+   // RETURNS: the current value of the "editable" property.
+   int get_editable()() {
+      return mx_path_bar_get_editable(&this);
+   }
+
+   // Get the MxEntry used as the editable area in the MxPathBar.
+   // RETURNS: MxEntry *
+   Entry* get_entry()() {
+      return mx_path_bar_get_entry(&this);
+   }
+   char* get_label()(int level) {
+      return mx_path_bar_get_label(&this, level);
+   }
+   int get_level()() {
+      return mx_path_bar_get_level(&this);
+   }
+   char* get_text()() {
+      return mx_path_bar_get_text(&this);
+   }
+   int pop()() {
+      return mx_path_bar_pop(&this);
+   }
+   int push()(char* name) {
+      return mx_path_bar_push(&this, name);
+   }
+
+   // Set theh value of the #MxPathBar:clear-on-change property
+   // <clear_on_change>: the new value of the property
+   void set_clear_on_change()(int clear_on_change) {
+      mx_path_bar_set_clear_on_change(&this, clear_on_change);
+   }
+
+   // Set the value of the #MxPathBar:editable property.
+   // <editable>: #TRUE if the path bar should be editable
+   void set_editable()(int editable) {
+      mx_path_bar_set_editable(&this, editable);
+   }
+
+   // Set the text on the button specified by @level
+   // <level>: A #gint
+   // <label>: A #gchar
+   void set_label()(int level, char* label) {
+      mx_path_bar_set_label(&this, level, label);
+   }
+
+   // Set the text in the editable area of the #MxPathBar
+   // <text>: string to set the editable text to.
+   void set_text()(char* text) {
+      mx_path_bar_set_text(&this, text);
+   }
+}
+
+struct PathBarClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct PathBarPrivate {
+}
+
+// Defines the position of an interface element.
+enum Position /* Version 1.2 */ {
+   TOP = 0,
+   RIGHT = 1,
+   BOTTOM = 2,
+   LEFT = 3
+}
+
+// The contents of this structure are private and should only be
+// accessed through the public API.
+struct ProgressBar /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private ProgressBarPrivate* priv;
+
+
+   // Create a new progress bar
+   // RETURNS: a new #MxProgressBar
+   static ProgressBar* new_()() {
+      return mx_progress_bar_new();
+   }
+
+   // Get the progress of the progress bar
+   // RETURNS: A value between 0.0 and 1.0
+   double get_progress()() {
+      return mx_progress_bar_get_progress(&this);
+   }
+
+   // Set the progress of the progress bar
+   // <progress>: A value between 0.0 and 1.0
+   void set_progress()(double progress) {
+      mx_progress_bar_set_progress(&this, progress);
+   }
+}
+
+struct ProgressBarClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ProgressBarPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct ScrollBar /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance bin;
+   Bin parent_instance;
+   private ScrollBarPrivate* priv;
+
+
+   // Create a new #MxScrollBar
+   // RETURNS: a new #MxScrollBar
+   static ScrollBar* new_()() {
+      return mx_scroll_bar_new();
+   }
+
+   // Create a new #MxScrollBar with the given adjustment set
+   // RETURNS: a new #MxScrollBar
+   // <adjustment>: an #MxAdjustment
+   static ScrollBar* new_with_adjustment()(Adjustment* adjustment) {
+      return mx_scroll_bar_new_with_adjustment(adjustment);
+   }
+
+   // Gets the adjustment object that stores the current position
+   // of the scrollbar.
+   // RETURNS: the adjustment
+   Adjustment* get_adjustment()() {
+      return mx_scroll_bar_get_adjustment(&this);
+   }
+   Orientation get_orientation()() {
+      return mx_scroll_bar_get_orientation(&this);
+   }
+   void set_adjustment()(Adjustment* adjustment) {
+      mx_scroll_bar_set_adjustment(&this, adjustment);
+   }
+   void set_orientation()(Orientation orientation) {
+      mx_scroll_bar_set_orientation(&this, orientation);
+   }
+   extern (C) alias static void function (ScrollBar* this_, void* user_data=null) signal_scroll_start;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"scroll-start", CB:signal_scroll_start)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"scroll-start",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+   extern (C) alias static void function (ScrollBar* this_, void* user_data=null) signal_scroll_stop;
+   ulong signal_connect(string name:"scroll-stop", CB:signal_scroll_stop)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"scroll-stop",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ScrollBarClass {
+   BinClass parent_class;
+   extern (C) void function (ScrollBar* bar) scroll_start;
+   extern (C) void function (ScrollBar* bar) scroll_stop;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ScrollBarPrivate {
+}
+
+// Defines the scrolling policy of scrollable widgets.
+enum ScrollPolicy {
+   NONE = 0,
+   HORIZONTAL = 1,
+   VERTICAL = 2,
+   BOTH = 3
+}
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct ScrollView /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance bin;
+   Bin parent_instance;
+   private ScrollViewPrivate* priv;
+
+   static ScrollView* new_()() {
+      return mx_scroll_view_new();
+   }
+
+   // Ensures that a given region is visible in the ScrollView, with the top-left
+   // taking precedence.
+   // <geometry>: The region to make visible
+   void ensure_visible()(Clutter.Geometry* geometry) {
+      mx_scroll_view_ensure_visible(&this, geometry);
+   }
+   int get_enable_gestures()() {
+      return mx_scroll_view_get_enable_gestures(&this);
+   }
+   int get_enable_mouse_scrolling()() {
+      return mx_scroll_view_get_enable_mouse_scrolling(&this);
+   }
+   ScrollPolicy get_scroll_policy()() {
+      return mx_scroll_view_get_scroll_policy(&this);
+   }
+   void set_enable_gestures()(int enabled) {
+      mx_scroll_view_set_enable_gestures(&this, enabled);
+   }
+   void set_enable_mouse_scrolling()(int enabled) {
+      mx_scroll_view_set_enable_mouse_scrolling(&this, enabled);
+   }
+   void set_scroll_policy()(ScrollPolicy policy) {
+      mx_scroll_view_set_scroll_policy(&this, policy);
+   }
+}
+
+struct ScrollViewClass {
+   BinClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ScrollViewPrivate {
+}
+
+// This is an opaque structure whose members cannot be directly accessed.
+struct Scrollable /* Interface */ {
+   mixin template __interface__() {
+      // Gets the adjustment objects that store the offsets of the scrollable widget
+      // into its possible scrolling area.
+      // <hadjustment>: location to store the horizontal adjustment, or %NULL
+      // <vadjustment>: location to store the vertical adjustment, or %NULL
+      void get_adjustments()(/*out*/ Adjustment** hadjustment=null, /*out*/ Adjustment** vadjustment=null) {
+         mx_scrollable_get_adjustments(cast(Scrollable*)&this, hadjustment, vadjustment);
+      }
+      void set_adjustments()(Adjustment* hadjustment, Adjustment* vadjustment) {
+         mx_scrollable_set_adjustments(cast(Scrollable*)&this, hadjustment, vadjustment);
+      }
+   }
+   mixin __interface__;
+}
+
+struct ScrollableIface {
+   private GObject2.TypeInterface parent;
+   extern (C) void function (Scrollable* scrollable, Adjustment* hadjustment, Adjustment* vadjustment) set_adjustments;
+
+   // <hadjustment>: location to store the horizontal adjustment, or %NULL
+   // <vadjustment>: location to store the vertical adjustment, or %NULL
+   extern (C) void function (Scrollable* scrollable, /*out*/ Adjustment** hadjustment=null, /*out*/ Adjustment** vadjustment=null) get_adjustments;
+}
+
+struct Settings /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   SettingsPrivate* priv;
+
+
+   // Get the global MxSettings object.
+   // RETURNS: an #MxSettings object
+   static Settings* get_default()() {
+      return mx_settings_get_default();
+   }
+}
+
+struct SettingsClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct SettingsPrivate {
+}
+
+struct SettingsProvider {
+}
+
+struct SettingsProviderIface {
+   private GObject2.TypeInterface parent_iface;
+   // Unintrospectable functionp: setting_changed() / ()
+   extern (C) void function (SettingsProvider* provider, MxSettingsProperty id) setting_changed;
+   // Unintrospectable functionp: get_setting() / ()
+   extern (C) int function (SettingsProvider* provider, MxSettingsProperty id, void* value) get_setting;
+   // Unintrospectable functionp: set_setting() / ()
+   extern (C) int function (SettingsProvider* provider, MxSettingsProperty id, void* value) set_setting;
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Slider /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private SliderPrivate* priv;
+
+
+   // Create a new slider
+   // RETURNS: a new #MxSlider
+   static Slider* new_()() {
+      return mx_slider_new();
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxSlider:buffer-value property.
+   // RETURNS: The current value of the "buffer-value" property.
+   double get_buffer_value()() {
+      return mx_slider_get_buffer_value(&this);
+   }
+
+   // Retrieve the current value of the media bar
+   // RETURNS: gdouble
+   double get_value()() {
+      return mx_slider_get_value(&this);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxSlider:buffer-value property.
+   // <value>: the new buffer value of the slider
+   void set_buffer_value()(double value) {
+      mx_slider_set_buffer_value(&this, value);
+   }
+
+   // Set the value of the slider
+   // <value>: A value between 0.0 and 1.0
+   void set_value()(double value) {
+      mx_slider_set_value(&this, value);
+   }
+   extern (C) alias static void function (Slider* this_, void* user_data=null) signal_slide_start;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"slide-start", CB:signal_slide_start)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"slide-start",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+   extern (C) alias static void function (Slider* this_, void* user_data=null) signal_slide_stop;
+   ulong signal_connect(string name:"slide-stop", CB:signal_slide_stop)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"slide-stop",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct SliderClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct SliderPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Spinner /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private SpinnerPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Create a new #MxSpinner widget.
+   // RETURNS: a newly allocated #MxSpinner
+   static Spinner* new_()() {
+      return mx_spinner_new();
+   }
+
+   // VERSION: 1.2
+   // Determines whether the spinner is animating.
+   // RETURNS: %TRUE if the spinner is animating, %FALSE otherwise
+   int get_animating()() {
+      return mx_spinner_get_animating(&this);
+   }
+
+   // VERSION: 1.2
+   // Sets whether the spinner is animating. A spinner can be stopped if
+   // the task it represents has finished, or to save energy.
+   // <animating>: %TRUE to enable animation, %FALSE to disable
+   void set_animating()(int animating) {
+      mx_spinner_set_animating(&this, animating);
+   }
+
+   // VERSION: 1.2
+   // Emitted after the animation has displayed the final frame.
+   extern (C) alias static void function (Spinner* this_, void* user_data=null) signal_looped;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"looped", CB:signal_looped)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"looped",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct SpinnerClass {
+   WidgetClass parent_class;
+   extern (C) void function (Spinner* spinner) looped;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+}
+
+struct SpinnerPrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Stack /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   private StackPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Create a new #MxStack.
+   // RETURNS: a newly allocated #MxStack
+   static Stack* new_()() {
+      return mx_stack_new();
+   }
+
+   // VERSION: 1.4
+   // Get the value of the #MxStackChild:fit property.
+   // RETURNS: the current value of the #MxStackChild:crop property
+   // <child>: A #ClutterActor
+   int child_get_crop()(Clutter.Actor* child) {
+      return mx_stack_child_get_crop(&this, child);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxStackChild:fit property.
+   // RETURNS: the current value of the #MxStackChild:fit property
+   // <child>: A #ClutterActor
+   int child_get_fit()(Clutter.Actor* child) {
+      return mx_stack_child_get_fit(&this, child);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxStackChild:x-align property
+   // RETURNS: the current value of the "x-align" property
+   // <child>: A #ClutterActor
+   Align child_get_x_align()(Clutter.Actor* child) {
+      return mx_stack_child_get_x_align(&this, child);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxStackChild:x-fill property.
+   // RETURNS: the current value of the "x-fill" property.
+   // <child>: A #ClutterActor
+   int child_get_x_fill()(Clutter.Actor* child) {
+      return mx_stack_child_get_x_fill(&this, child);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxStackChild:y-align property.
+   // RETURNS: the current value of the "y-align" property.
+   // <child>: A #ClutterActor
+   Align child_get_y_align()(Clutter.Actor* child) {
+      return mx_stack_child_get_y_align(&this, child);
+   }
+
+   // VERSION: 1.2
+   // Get the value of the #MxStackChild:y-fill property
+   // RETURNS: the current value of the "y-fill" property
+   // <child>: A #ClutterActor
+   int child_get_y_fill()(Clutter.Actor* child) {
+      return mx_stack_child_get_y_fill(&this, child);
+   }
+
+   // VERSION: 1.4
+   // Set the value of the #MxStackChild:crop property.
+   // <child>: A #ClutterActor
+   // <crop>: A #gboolean
+   void child_set_crop()(Clutter.Actor* child, int crop) {
+      mx_stack_child_set_crop(&this, child, crop);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxStackChild:fit property.
+   // <child>: A #ClutterActor
+   // <fit>: A #gboolean
+   void child_set_fit()(Clutter.Actor* child, int fit) {
+      mx_stack_child_set_fit(&this, child, fit);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxStackChild:x-align property.
+   // <child>: A #ClutterActor
+   // <x_align>: An #MxAlign
+   void child_set_x_align()(Clutter.Actor* child, Align x_align) {
+      mx_stack_child_set_x_align(&this, child, x_align);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxStackChild:x-fill property.
+   // <child>: A #ClutterActor
+   // <x_fill>: A #gboolean
+   void child_set_x_fill()(Clutter.Actor* child, int x_fill) {
+      mx_stack_child_set_x_fill(&this, child, x_fill);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxStackChild:y-align property.
+   // <child>: A #ClutterActor
+   // <y_align>: An #MxAlign
+   void child_set_y_align()(Clutter.Actor* child, Align y_align) {
+      mx_stack_child_set_y_align(&this, child, y_align);
+   }
+
+   // VERSION: 1.2
+   // Set the value of the #MxStackChild:y-fill property.
+   // <child>: A #ClutterActor
+   // <y_fill>: A #gboolean
+   void child_set_y_fill()(Clutter.Actor* child, int y_fill) {
+      mx_stack_child_set_y_fill(&this, child, y_fill);
+   }
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct StackChild /* : Clutter.ChildMeta */ {
+   alias parent this;
+   alias parent super_;
+   alias parent childmeta;
+   Clutter.ChildMeta parent;
+    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
+   uint, "x_fill", 1,
+   uint, "y_fill", 1,
+   uint, "fit", 1,
+   uint, "crop", 1,
+    uint, "__dummy32A", 28));
+   private Align x_align, y_align;
+}
+
+struct StackChildClass {
+   Clutter.ChildMetaClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct StackChildPrivate {
+}
+
+struct StackClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct StackPrivate {
+}
+
+// This is an opaque structure whose members cannot be directly accessed.
+struct Stylable /* Interface */ {
+   mixin template __interface__() {      void apply_clutter_text_attributes()(Clutter.Text* text) {
+         mx_stylable_apply_clutter_text_attributes(cast(Stylable*)&this, text);
+      }
+      void connect_change_notifiers()() {
+         mx_stylable_connect_change_notifiers(cast(Stylable*)&this);
+      }
+
+      // Finds the #GParamSpec installed by @stylable for the property
+      // with @property_name.
+      // 
+      // or %NULL if no property with that name was found
+      // RETURNS: a #GParamSpec for the given property,
+      // <property_name>: the name of the property to find
+      GObject2.ParamSpec* find_property()(char* property_name) {
+         return mx_stylable_find_property(cast(Stylable*)&this, property_name);
+      }
+
+      // Unintrospectable method: get() / mx_stylable_get()
+      // Gets the style properties for @stylable.
+      // 
+      // In general, a copy is made of the property contents and the called
+      // is responsible for freeing the memory in the appropriate manner for
+      // the property type.
+      // 
+      // <example>
+      // <title>Using mx_stylable_get(<!-- -->)</title>
+      // <para>An example of using mx_stylable_get() to get the contents of
+      // two style properties - one of type #G_TYPE_INT and one of type
+      // #CLUTTER_TYPE_COLOR:</para>
+      // <programlisting>
+      // gint x_spacing;
+      // ClutterColor *bg_color;
+      // 
+      // mx_stylable_get (stylable,
+      // "x-spacing", &amp;x_spacing,
+      // "bg-color", &amp;bg_color,
+      // NULL);
+      // 
+      // /<!-- -->* do something with x_spacing and bg_color *<!-- -->/
+      // 
+      // clutter_color_free (bg_color);
+      // </programlisting>
+      // </example>
+      // <first_property_name>: name of the first property to get
+      /+ Not available -- variadic methods unsupported - use the C function directly.
+         alias mx_stylable_get get; // Variadic
+      +/
+
+      // Query @stylable for the default value of property @property_name and
+      // fill @value_out with the result.
+      // 
+      // been returned.
+      // RETURNS: %TRUE if property @property_name exists and the default value has
+      // <property_name>: name of the property to query
+      // <value_out>: return location for the default value
+      int get_default_value()(char* property_name, /*out*/ GObject2.Value* value_out) {
+         return mx_stylable_get_default_value(cast(Stylable*)&this, property_name, value_out);
+      }
+
+      // Retrieves the value of @property_name for @stylable, and puts it
+      // into @value.
+      // <property_name>: the name of the property
+      // <value>: return location for an empty #GValue
+      void get_property()(char* property_name, /*out*/ GObject2.Value* value) {
+         mx_stylable_get_property(cast(Stylable*)&this, property_name, value);
+      }
+
+      // Retrieves the #MxStyle used by @stylable. This function does not
+      // alter the reference count of the returned object.
+      // RETURNS: a #MxStyle
+      Style* get_style()() {
+         return mx_stylable_get_style(cast(Stylable*)&this);
+      }
+
+      // Get the current style class name
+      // 
+      // should not be modified or freed.
+      // RETURNS: the class name string. The string is owned by the #MxWidget and
+      char* get_style_class()() {
+         return mx_stylable_get_style_class(cast(Stylable*)&this);
+      }
+
+      // Get the current style pseudo class. This can contain multiple pseudo class
+      // names, separated by ':'.
+      // 
+      // should not be modified or freed.
+      // RETURNS: the pseudo class string. The string is owned by the #MxWidget and
+      char* get_style_pseudo_class()() {
+         return mx_stylable_get_style_pseudo_class(cast(Stylable*)&this);
+      }
+
+      // Retrieves all the #GParamSpec<!-- -->s installed by @stylable.
+      // 
+      // of #GParamSpec<!-- -->s. Free it with  g_free() when done.
+      // RETURNS: an array
+      // <n_props>: return location for the number of properties, or %NULL
+      GObject2.ParamSpec** /*new container*/ list_properties()(/*out*/ uint* n_props) {
+         return mx_stylable_list_properties(cast(Stylable*)&this, n_props);
+      }
+
+      // Sets @style as the new #MxStyle to be used by @stylable.
+      // 
+      // The #MxStylable will take ownership of the passed #MxStyle.
+      // 
+      // After the #MxStyle has been set, the MxStylable::style-set signal
+      // will be emitted.
+      // <style>: a #MxStyle
+      void set_style()(Style* style) {
+         mx_stylable_set_style(cast(Stylable*)&this, style);
+      }
+
+      // Set the style class name
+      // <style_class>: a new style class string
+      void set_style_class()(char* style_class) {
+         mx_stylable_set_style_class(cast(Stylable*)&this, style_class);
+      }
+
+      // Set the style pseudo class. The string can contain multiple pseudo class
+      // names, separated by ':'.
+      // <pseudo_class>: a new pseudo class string
+      void set_style_pseudo_class()(char* pseudo_class) {
+         mx_stylable_set_style_pseudo_class(cast(Stylable*)&this, pseudo_class);
+      }
+
+      // Emit the "style-changed" signal on @stylable to notify it that one or more
+      // of the style properties has changed.
+      // 
+      // If @stylable is a #ClutterContainer then the "style-changed" notification is
+      // propagated to it's children, since their style may depend on one or more
+      // properties of the parent.
+      // <flags>: flags that control the style changing
+      void style_changed()(StyleChangedFlags flags) {
+         mx_stylable_style_changed(cast(Stylable*)&this, flags);
+      }
+
+      // VERSION: 1.2
+      // Add a pseudo-class name to the list of pseudo classes, contained in the
+      // #MxStylable:style-pseudo-class property.
+      // <new_class>: A pseudo-class name to add
+      void style_pseudo_class_add()(char* new_class) {
+         mx_stylable_style_pseudo_class_add(cast(Stylable*)&this, new_class);
+      }
+
+      // VERSION: 1.2
+      // Check if the given pseudo-class name is contained in the list of
+      // set pseudo classes on this #MxStylable object.
+      // RETURNS: %TRUE if the given pseudo-class is set, %FALSE otherwise
+      // <pseudo_class>: A pseudo-class name
+      int style_pseudo_class_contains()(char* pseudo_class) {
+         return mx_stylable_style_pseudo_class_contains(cast(Stylable*)&this, pseudo_class);
+      }
+
+      // VERSION: 1.2
+      // Remove the specified pseudo class name from the list of pseudo classes
+      // contained in the #MxStylable:style-pseudo-class property.
+      // <remove_class>: A pseudo class name to remove
+      void style_pseudo_class_remove()(char* remove_class) {
+         mx_stylable_style_pseudo_class_remove(cast(Stylable*)&this, remove_class);
+      }
+
+      // The ::style-changed signal is emitted each time one of the style
+      // properties have changed.
+      // <flags>: the #MxStyleChangedFlags associated with the signal
+      extern (C) alias static void function (Stylable* this_, StyleChangedFlags* flags, void* user_data=null) signal_style_changed;
+
+      ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return super_.signal_connect!name(cb, data, cf);
+      }
+
+      ulong signal_connect(string name:"style-changed", CB:signal_style_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+         return signal_connect_data!()(&this, cast(char*)"style-changed",
+         cast(GObject2.Callback)cb, data, null, cf);
+      }
+   }
+   mixin __interface__;
+}
+
+struct StylableIface {
+   private GObject2.TypeInterface g_iface;
+   // RETURNS: a #MxStyle
+   extern (C) Style* function (Stylable* stylable) get_style;
+   // <style>: a #MxStyle
+   extern (C) void function (Stylable* stylable, Style* style) set_style;
+   // RETURNS: the class name string. The string is owned by the #MxWidget and
+   extern (C) char* function (Stylable* stylable) get_style_class;
+   // <style_class>: a new style class string
+   extern (C) void function (Stylable* stylable, char* style_class) set_style_class;
+   // RETURNS: the pseudo class string. The string is owned by the #MxWidget and
+   extern (C) char* function (Stylable* stylable) get_style_pseudo_class;
+   // <pseudo_class>: a new pseudo class string
+   extern (C) void function (Stylable* stylable, char* pseudo_class) set_style_pseudo_class;
+   // <flags>: flags that control the style changing
+   extern (C) void function (Stylable* stylable, StyleChangedFlags flags) style_changed;
+
+
+   // Installs a property for @owner_type using @pspec as the property
+   // description.
+   // 
+   // This function should be used inside the #MxStylableIface initialization
+   // function of a class, for instance:
+   // 
+   // <informalexample><programlisting>
+   // G_DEFINE_TYPE_WITH_CODE (FooActor, foo_actor, CLUTTER_TYPE_ACTOR,
+   // G_IMPLEMENT_INTERFACE (MX_TYPE_STYLABLE,
+   // mx_stylable_init));
+   // ...
+   // static void
+   // mx_stylable_init (MxStylableIface *iface)
+   // {
+   // static gboolean is_initialized = FALSE;
+   // 
+   // if (!is_initialized)
+   // {
+   // ...
+   // mx_stylable_iface_install_property (stylable,
+   // FOO_TYPE_ACTOR,
+   // g_param_spec_int ("x-spacing",
+   // "X Spacing",
+   // "Horizontal spacing",
+   // -1, G_MAXINT,
+   // 2,
+   // G_PARAM_READWRITE));
+   // ...
+   // }
+   // }
+   // </programlisting></informalexample>
+   // <owner_type>: #GType of the style property owner
+   // <pspec>: a #GParamSpec
+   void install_property()(Type owner_type, GObject2.ParamSpec* pspec) {
+      mx_stylable_iface_install_property(&this, owner_type, pspec);
+   }
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Style /* : GObject.Object */ {
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance object;
+   GObject2.Object parent_instance;
+   private StylePrivate* priv;
+
+
+   // Creates a new #MxStyle object. This must be freed using #g_object_unref
+   // when no longer required.
+   // RETURNS: a newly allocated #MxStyle
+   static Style* /*new*/ new_()() {
+      return mx_style_new();
+   }
+
+   // Return the default MxStyle object. This includes the current theme (if
+   // any).
+   // 
+   // unref'd by applications
+   // RETURNS: a #MxStyle object. This must not be freed or
+   static Style* get_default()() {
+      return mx_style_get_default();
+   }
+
+   // Unintrospectable method: get() / mx_style_get()
+   // Gets the style properties for @stylable from @style.
+   // 
+   // In general, a copy is made of the property contents and the caller
+   // is responsible for freeing the memory in the appropriate manner for
+   // the property type.
+   // <stylable>: a #MxStylable
+   // <first_property_name>: name of the first property to get
+   /+ Not available -- variadic methods unsupported - use the C function directly.
+      alias mx_style_get get; // Variadic
+   +/
+
+   // Requests the property described in @pspec for the specified stylable
+   // <stylable>: a stylable to retreive the data for
+   // <pspec>: a #GParamSpec describing the property required
+   // <value>: a #GValue to place the return value in
+   void get_property()(Stylable* stylable, GObject2.ParamSpec* pspec, /*out*/ GObject2.Value* value) {
+      mx_style_get_property(&this, stylable, pspec, value);
+   }
+
+   // Unintrospectable method: get_valist() / mx_style_get_valist()
+   // Gets the style properties for @stylable from @style.
+   // 
+   // Please refer to mx_style_get() for further information.
+   // <stylable>: a #MxStylable
+   // <first_property_name>: name of the first property to get
+   // <va_args>: return location for the first property, followed optionally by more name/return location pairs, followed by %NULL
+   void get_valist()(Stylable* stylable, char* first_property_name, va_list va_args) {
+      mx_style_get_valist(&this, stylable, first_property_name, va_args);
+   }
+
+   // Load style information from the specified file.
+   // 
+   // FALSE on error.
+   // RETURNS: TRUE if the style information was loaded successfully. Returns
+   // <filename>: filename of the style sheet to load
+   int load_from_file()(char* filename, GLib2.Error** error=null) {
+      return mx_style_load_from_file(&this, filename, error);
+   }
+
+   // Indicates that the style data has changed in some way. For example, a new
+   // stylesheet may have been loaded.
+   extern (C) alias static void function (Style* this_, void* user_data=null) signal_changed;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"changed", CB:signal_changed)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"changed",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+enum StyleChangedFlags {
+   NONE = 0,
+   FORCE = 1,
+   INVALIDATE_CACHE = 2
+}
+struct StyleClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function (Style* style) changed;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+enum StyleError {
+   INVALID_FILE = 0
+}
+struct StylePrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Table /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance widget;
+   Widget parent_instance;
+   private TablePrivate* priv;
+
+
+   // Create a new #MxTable
+   // RETURNS: a new #MxTable
+   static Table* new_()() {
+      return mx_table_new();
+   }
+
+   // Add an actor at the specified row and column
+   // 
+   // Note, column and rows numbers start from zero
+   // <actor>: the child to insert
+   // <row>: the row to place the child into
+   // <column>: the column to place the child into
+   void add_actor()(Clutter.Actor* actor, int row, int column) {
+      mx_table_add_actor(&this, actor, row, column);
+   }
+
+   // Unintrospectable method: add_actor_with_properties() / mx_table_add_actor_with_properties()
+   // Add an actor into at the specified row and column, with additional child
+   // properties to set.
+   // <actor>: the child #ClutterActor
+   // <row>: the row to place the child into
+   // <column>: the column to place the child into
+   // <first_property_name>: name of the first property to set
+   /+ Not available -- variadic methods unsupported - use the C function directly.
+      alias mx_table_add_actor_with_properties add_actor_with_properties; // Variadic
+   +/
+
+   // Get the column of the child.
+   // RETURNS: the column of the child
+   // <child>: a #ClutterActor
+   int child_get_column()(Clutter.Actor* child) {
+      return mx_table_child_get_column(&this, child);
+   }
+
+   // Get the column span of the child. Defaults to 1.
+   // RETURNS: the column span of the child
+   // <child>: a #ClutterActor
+   int child_get_column_span()(Clutter.Actor* child) {
+      return mx_table_child_get_column_span(&this, child);
+   }
+
+   // Get the row of the child.
+   // RETURNS: the row of the child
+   // <child>: a #ClutterActor
+   int child_get_row()(Clutter.Actor* child) {
+      return mx_table_child_get_row(&this, child);
+   }
+
+   // Get the row span of the child. Defaults to 1.
+   // RETURNS: the row span of the child
+   // <child>: A #ClutterActor
+   int child_get_row_span()(Clutter.Actor* child) {
+      return mx_table_child_get_row_span(&this, child);
+   }
+
+   // Get the x-align value of the child
+   // RETURNS: An #MxAlign value
+   // <child>: A #ClutterActor
+   Align child_get_x_align()(Clutter.Actor* child) {
+      return mx_table_child_get_x_align(&this, child);
+   }
+
+   // Get the x-expand property of the child
+   // RETURNS: #TRUE if the child is set to x-expand
+   // <child>: A #ClutterActor
+   int child_get_x_expand()(Clutter.Actor* child) {
+      return mx_table_child_get_x_expand(&this, child);
+   }
+
+   // Get the x-fill state of the child
+   // RETURNS: #TRUE if the child is set to x-fill
+   // <child>: A #ClutterActor
+   int child_get_x_fill()(Clutter.Actor* child) {
+      return mx_table_child_get_x_fill(&this, child);
+   }
+
+   // Get the y-align value of the child
+   // RETURNS: An #MxAlign value
+   // <child>: A #ClutterActor
+   Align child_get_y_align()(Clutter.Actor* child) {
+      return mx_table_child_get_y_align(&this, child);
+   }
+
+   // Get the y-expand property of the child.
+   // RETURNS: #TRUE if the child is set to y-expand
+   // <child>: A #ClutterActor
+   int child_get_y_expand()(Clutter.Actor* child) {
+      return mx_table_child_get_y_expand(&this, child);
+   }
+
+   // Get the y-fill state of the child
+   // RETURNS: #TRUE if the child is set to y-fill
+   // <child>: A #ClutterActor
+   int child_get_y_fill()(Clutter.Actor* child) {
+      return mx_table_child_get_y_fill(&this, child);
+   }
+
+   // Set the column of the child
+   // <child>: a #ClutterActor
+   // <col>: the column of the child
+   void child_set_column()(Clutter.Actor* child, int col) {
+      mx_table_child_set_column(&this, child, col);
+   }
+
+   // Set the column span of the child.
+   // <child>: An #ClutterActor
+   // <span>: The number of columns to span
+   void child_set_column_span()(Clutter.Actor* child, int span) {
+      mx_table_child_set_column_span(&this, child, span);
+   }
+
+   // Set the row of the child
+   // <child>: a #ClutterActor
+   // <row>: the row of the child
+   void child_set_row()(Clutter.Actor* child, int row) {
+      mx_table_child_set_row(&this, child, row);
+   }
+
+   // Set the row span of the child.
+   // <child>: A #ClutterActor
+   // <span>: the number of rows to span
+   void child_set_row_span()(Clutter.Actor* child, int span) {
+      mx_table_child_set_row_span(&this, child, span);
+   }
+
+   // Set the alignment of the child within its cell. This will only have an effect
+   // if the the x-fill property is FALSE.
+   // <child>: A #ClutterActor
+   // <align>: A #MxAlign value
+   void child_set_x_align()(Clutter.Actor* child, Align align_) {
+      mx_table_child_set_x_align(&this, child, align_);
+   }
+
+   // Set x-expand on the child. This causes the column which the child
+   // resides in to be allocated any extra space if the allocation of the table is
+   // larger than the preferred size.
+   // <child>: A #ClutterActor
+   // <expand>: the new value of the x expand child property
+   void child_set_x_expand()(Clutter.Actor* child, int expand) {
+      mx_table_child_set_x_expand(&this, child, expand);
+   }
+
+   // Set the fill state of the child on the x-axis. This will cause the child to
+   // be allocated the maximum available space.
+   // <child>: A #ClutterActor
+   // <fill>: the fill state
+   void child_set_x_fill()(Clutter.Actor* child, int fill) {
+      mx_table_child_set_x_fill(&this, child, fill);
+   }
+
+   // Set the value of the y-align property. This will only have an effect if
+   // y-fill value is set to FALSE.
+   // <child>: A #ClutterActor
+   // <align>: A #MxAlign value
+   void child_set_y_align()(Clutter.Actor* child, Align align_) {
+      mx_table_child_set_y_align(&this, child, align_);
+   }
+
+   // Set y-expand on the child. This causes the row which the child
+   // resides in to be allocated any extra space if the allocation of the table is
+   // larger than the preferred size.
+   // <child>: A #ClutterActor
+   // <expand>: the new value of the y-expand child property
+   void child_set_y_expand()(Clutter.Actor* child, int expand) {
+      mx_table_child_set_y_expand(&this, child, expand);
+   }
+
+   // Set the fill state of the child on the y-axis. This will cause the child to
+   // be allocated the maximum available space.
+   // <child>: A #ClutterActor
+   // <fill>: the fill state
+   void child_set_y_fill()(Clutter.Actor* child, int fill) {
+      mx_table_child_set_y_fill(&this, child, fill);
+   }
+
+   // Retrieve the current number of columns in @table
+   // RETURNS: the number of columns
+   int get_column_count()() {
+      return mx_table_get_column_count(&this);
+   }
+
+   // Gets the amount of spacing between columns.
+   // RETURNS: the spacing between columns in device units
+   int get_column_spacing()() {
+      return mx_table_get_column_spacing(&this);
+   }
+
+   // Retrieve the current number rows in the @table
+   // RETURNS: the number of rows
+   int get_row_count()() {
+      return mx_table_get_row_count(&this);
+   }
+
+   // Gets the amount of spacing between rows.
+   // RETURNS: the spacing between rows in device units
+   int get_row_spacing()() {
+      return mx_table_get_row_spacing(&this);
+   }
+
+   // Sets the amount of spacing between columns.
+   // <spacing>: spacing in pixels
+   void set_column_spacing()(int spacing) {
+      mx_table_set_column_spacing(&this, spacing);
+   }
+
+   // Sets the amount of spacing between rows.
+   // <spacing>: spacing in pixels
+   void set_row_spacing()(int spacing) {
+      mx_table_set_row_spacing(&this, spacing);
+   }
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct TableChild /* : Clutter.ChildMeta */ {
+   alias method_parent this;
+   alias method_parent super_;
+   alias method_parent childmeta;
+   Clutter.ChildMeta method_parent;
+}
+
+struct TableChildClass {
+   Clutter.ChildMetaClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct TableClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct TablePrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct TextureCache /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+
+
+   // Returns the default texture cache. This is owned by Mx and should not be
+   // unreferenced or freed.
+   // RETURNS: a MxTextureCache
+   static TextureCache* get_default()() {
+      return mx_texture_cache_get_default();
+   }
+
+   // VERSION: 1.2
+   // Checks whether the given URI/path is contained within the texture
+   // cache.
+   // RETURNS: %TRUE if the image exists, %FALSE otherwise
+   // <uri>: A URI or path to an image file
+   int contains()(char* uri) {
+      return mx_texture_cache_contains(&this, uri);
+   }
+
+   // VERSION: 1.2
+   // Checks whether there are any textures associated with the given URI by
+   // the given identifier.
+   // RETURNS: %TRUE if the data exists, %FALSE otherwise
+   // <uri>: A URI or path to an image file
+   // <ident>: A unique identifier
+   int contains_meta()(char* uri, void* ident) {
+      return mx_texture_cache_contains_meta(&this, uri, ident);
+   }
+
+   // This is a wrapper around mx_texture_cache_get_texture() which returns
+   // a ClutterActor.
+   // RETURNS: a newly created ClutterTexture
+   // <uri>: A URI or path to a image file
+   Clutter.Actor* get_actor()(char* uri) {
+      return mx_texture_cache_get_actor(&this, uri);
+   }
+
+   // Create a #CoglHandle representing a texture of the specified image. Adds
+   // the image to the cache if the image had not been previously loaded.
+   // Subsequent calls with the same image URI/path will return the #CoglHandle of
+   // the previously loaded image with an increased reference count.
+   // RETURNS: a #CoglHandle to the cached texture
+   // <uri>: A URI or path to an image file
+   Cogl.Handle get_cogl_texture()(char* uri) {
+      return mx_texture_cache_get_cogl_texture(&this, uri);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the #CoglHandle of the previously added image associated
+   // with the given unique identifier.
+   // 
+   // See mx_texture_cache_insert_meta()
+   // 
+   // reference. %NULL if no image was found.
+   // RETURNS: A #CoglHandle to a texture, with an added
+   // <uri>: A URI or path to an image file
+   // <ident>: A unique identifier
+   Cogl.Handle /*new*/ get_meta_cogl_texture()(char* uri, void* ident) {
+      return mx_texture_cache_get_meta_cogl_texture(&this, uri, ident);
+   }
+
+   // VERSION: 1.2
+   // Create a new ClutterTexture using the previously added image associated
+   // with the given unique identifier.
+   // 
+   // See mx_texture_cache_insert_meta()
+   // 
+   // %NULL if no image was found
+   // RETURNS: A newly allocated #ClutterTexture, or
+   // <uri>: A URI or path to an image file
+   // <ident>: A unique identifier
+   Clutter.Texture* /*new*/ get_meta_texture()(char* uri, void* ident) {
+      return mx_texture_cache_get_meta_texture(&this, uri, ident);
+   }
+
+   // Returns the number of items in the texture cache
+   // RETURNS: the current size of the cache
+   int get_size()() {
+      return mx_texture_cache_get_size(&this);
+   }
+
+   // Create a new ClutterTexture with the specified image. Adds the image to the
+   // cache if the image had not been previously loaded. Subsequent calls with
+   // the same image URI/path will return a new ClutterTexture with the previously
+   // loaded image.
+   // RETURNS: a newly created ClutterTexture
+   // <uri>: A URI or path to a image file
+   Clutter.Texture* get_texture()(char* uri) {
+      return mx_texture_cache_get_texture(&this, uri);
+   }
+
+   // VERSION: 1.2
+   // Inserts a texture into the texture cache. This can be useful if you
+   // want to cache a texture from a custom or unhandled URI type, or you
+   // want to override a particular texture.
+   // 
+   // If the image is already in the cache, this texture will replace it. A
+   // reference will be taken on the given texture.
+   // <uri>: A URI or local file path
+   // <texture>: A #CoglHandle to a texture
+   void insert()(char* uri, Cogl.Handle* texture) {
+      mx_texture_cache_insert(&this, uri, texture);
+   }
+
+   // VERSION: 1.2
+   // Inserts a texture that's associated with a URI into the cache.
+   // If the metadata already exists for this URI, it will be replaced.
+   // 
+   // This is useful if you have a widely used modification of an image,
+   // for example, an image with a border composited around it.
+   // <uri>: A URI or local file path
+   // <ident>: A unique identifier
+   // <texture>: A #CoglHandle to a texture
+   // <destroy_func>: An optional destruction function for @ident
+   void insert_meta()(char* uri, void* ident, Cogl.Handle* texture, GLib2.DestroyNotify destroy_func) {
+      mx_texture_cache_insert_meta(&this, uri, ident, texture, destroy_func);
+   }
+   void load_cache()(char* filename) {
+      mx_texture_cache_load_cache(&this, filename);
+   }
+}
+
+struct TextureCacheClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function (TextureCache* self, char* uri, Clutter.Texture* texture) loaded;
+   extern (C) void function (TextureCache* self, GLib2.Error* error) error_loading;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct TextureFrame /* : Clutter.Actor */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance actor;
+   Clutter.Actor parent_instance;
+   private TextureFramePrivate* priv;
+
+
+   // A #MxTextureFrame is a specialized texture that efficiently clones
+   // an area of the given @texture while keeping preserving portions of the
+   // same texture.
+   // 
+   // A #MxTextureFrame can be used to make a rectangular texture fit a
+   // given size without stretching its borders.
+   // RETURNS: the newly created #MxTextureFrame
+   // <texture>: a #ClutterTexture or %NULL
+   // <top>: top margin preserving its content
+   // <right>: right margin preserving its content
+   // <bottom>: bottom margin preserving its content
+   // <left>: left margin preserving its content
+   static TextureFrame* new_()(Clutter.Texture* texture, float top, float right, float bottom, float left) {
+      return mx_texture_frame_new(texture, top, right, bottom, left);
+   }
+
+   // Retrieve the current slice lines from the specified frame.
+   // <top>: width of the top slice
+   // <right>: width of the right slice
+   // <bottom>: width of the bottom slice
+   // <left>: width of the left slice
+   void get_border_values()(float* top, float* right, float* bottom, float* left) {
+      mx_texture_frame_get_border_values(&this, top, right, bottom, left);
+   }
+
+   // Return the texture used by the #MxTextureFrame
+   // RETURNS: a #ClutterTexture owned by the #MxTextureFrame
+   Clutter.Texture* get_parent_texture()() {
+      return mx_texture_frame_get_parent_texture(&this);
+   }
+
+   // Set the slice lines of the specified frame. The slices are calculated as
+   // widths from the edge of the frame.
+   // <top>: width of the top slice
+   // <right>: width of the right slice
+   // <bottom>: width of the bottom slice
+   // <left>: width of the left slice
+   void set_border_values()(float top, float right, float bottom, float left) {
+      mx_texture_frame_set_border_values(&this, top, right, bottom, left);
+   }
+
+   // Set the #ClutterTexture used by this #MxTextureFrame
+   // <texture>: A #ClutterTexture
+   void set_parent_texture()(Clutter.Texture* texture) {
+      mx_texture_frame_set_parent_texture(&this, texture);
+   }
+}
+
+struct TextureFrameClass {
+   Clutter.ActorClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct TextureFramePrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Toggle /* : Widget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent widget;
+   Widget parent;
+   TogglePrivate* priv;
+
+   static Toggle* new_()() {
+      return mx_toggle_new();
+   }
+   int get_active()() {
+      return mx_toggle_get_active(&this);
+   }
+   void set_active()(int active) {
+      mx_toggle_set_active(&this, active);
+   }
+}
+
+struct ToggleClass {
+   WidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct TogglePrivate {
+}
+
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Toolbar /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent bin;
+   Bin parent;
+   ToolbarPrivate* priv;
+
+
+   // Create a new #MxToolbar. This is not normally necessary if using #MxWindow,
+   // where #mx_window_get_toolbar should be used to retrieve the toolbar instead.
+   // RETURNS: A newly allocated #MxToolbar
+   static Toolbar* new_()() {
+      return mx_toolbar_new();
+   }
+
+   // Get the value of the #MxToolbar:has-close-button property.
+   // RETURNS: the current value of the "hast-close-button" property.
+   int get_has_close_button()() {
+      return mx_toolbar_get_has_close_button(&this);
+   }
+
+   // Set the #MxToolbar:has-close-button property
+   // <has_close_button>: #TRUE if a close button should be displayed
+   void set_has_close_button()(int has_close_button) {
+      mx_toolbar_set_has_close_button(&this, has_close_button);
+   }
+
+   // Emitted when the close button of the toolbar is clicked.
+   // 
+   // Normally, the parent stage will be closed when the close button is
+   // clicked. Return #TRUE from this handler to prevent the stage from being
+   // destroyed.
+   // RETURNS: #TRUE to prevent the parent stage being destroyed.
+   extern (C) alias static c_int function (Toolbar* this_, void* user_data=null) signal_close_button_clicked;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"close-button-clicked", CB:signal_close_button_clicked)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"close-button-clicked",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct ToolbarClass {
+   BinClass parent_class;
+   extern (C) int function (Toolbar* toolbar) close_button_clicked;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ToolbarPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Tooltip /* : FloatingWidget */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance floatingwidget;
+   FloatingWidget parent_instance;
+   private TooltipPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Browse mode is entered whenever a tooltip is displayed and it is
+   // left after a short delay when a tooltip is hidden. This is used to
+   // make tooltips display quicker when a previous tooltip is already
+   // displayed.
+   // 
+   // otherwise.
+   // RETURNS: %TRUE if the app is in tooltip browse mode or %FALSE
+   static int is_in_browse_mode()() {
+      return mx_tooltip_is_in_browse_mode();
+   }
+
+   // Get the text displayed on the tooltip
+   // RETURNS: the text for the tooltip. This must not be freed by the application
+   char* get_text()() {
+      return mx_tooltip_get_text(&this);
+   }
+
+   // Retrieve the area on the stage that the tooltip currently applies to
+   // 
+   // by the application.
+   // RETURNS: the #ClutterGeometry, owned by the tooltip which must not be freed
+   Clutter.Geometry* get_tip_area()() {
+      return mx_tooltip_get_tip_area(&this);
+   }
+   // Hide the tooltip
+   void hide()() {
+      mx_tooltip_hide(&this);
+   }
+
+   // Sets the text displayed on the tooltip
+   // <text>: text to set the label to
+   void set_text()(char* text) {
+      mx_tooltip_set_text(&this, text);
+   }
+
+   // Set the area on the stage that the tooltip applies to.
+   // <area>: A #ClutterGeometry
+   void set_tip_area()(Clutter.Geometry* area) {
+      mx_tooltip_set_tip_area(&this, area);
+   }
+
+   // Utility function to set the geometry of the tooltip area
+   // from an existing actor.
+   // See also mx_tooltip_set_tip_area
+   // <actor>: A #ClutterActor
+   void set_tip_area_from_actor()(Clutter.Actor* actor) {
+      mx_tooltip_set_tip_area_from_actor(&this, actor);
+   }
+   // Show the tooltip relative to the associated widget.
+   void show()() {
+      mx_tooltip_show(&this);
+   }
+}
+
+// Defines the animation when tooltips are shown and hidden.
+enum TooltipAnimation /* Version 1.2 */ {
+   BOUNCE = 0,
+   FADE = 1
+}
+struct TooltipClass {
+   FloatingWidgetClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct TooltipPrivate {
+}
+
+enum int VERSION_HEX = 0;
+enum VERSION_S = "1.99.2";
+
+// The contents of this structure are private and should only be accessed
+// through the public API.
+struct Viewport /* : Bin */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Container.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Focusable.__interface__;
+   mixin Scrollable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent this;
+   alias parent super_;
+   alias parent bin;
+   Bin parent;
+   private ViewportPrivate* priv;
+
+   static Viewport* new_()() {
+      return mx_viewport_new();
+   }
+   void get_origin()(float* x, float* y, float* z) {
+      mx_viewport_get_origin(&this, x, y, z);
+   }
+   int get_sync_adjustments()() {
+      return mx_viewport_get_sync_adjustments(&this);
+   }
+   void set_origin()(float x, float y, float z) {
+      mx_viewport_set_origin(&this, x, y, z);
+   }
+   void set_sync_adjustments()(int sync) {
+      mx_viewport_set_sync_adjustments(&this, sync);
+   }
+}
+
+struct ViewportClass {
+   BinClass parent_class;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct ViewportPrivate {
+}
+
+
+// Base class for stylable actors. The contents of the #MxWidget
+// structure are private and should only be accessed through the
+// public API.
+struct Widget /* : Clutter.Actor */ {
+   mixin Atk.ImplementorIface.__interface__;
+   mixin Clutter.Animatable.__interface__;
+   mixin Clutter.Scriptable.__interface__;
+   mixin Stylable.__interface__;
+   alias parent_instance this;
+   alias parent_instance super_;
+   alias parent_instance actor;
+   Clutter.Actor parent_instance;
+   private WidgetPrivate* priv;
+
+
+   // VERSION: 1.2
+   // Used to implement how a new style instance should be applied in the widget.
+   // For instance, setting style instance on stylable internal children.
+   // <style>: A #MxStyle
+   void apply_style()(Style* style) {
+      mx_widget_apply_style(&this, style);
+   }
+
+   // Copies @allocation into @area and accounts for the padding values. This
+   // gives the area that is available in which to allocate children with respect
+   // to padding.
+   // <allocation>: A #ClutterActorBox
+   // <area>: A #ClutterActorBox
+   void get_available_area()(Clutter.ActorBox* allocation, Clutter.ActorBox* area) {
+      mx_widget_get_available_area(&this, allocation, area);
+   }
+
+   // Get the texture used as the background image. This is set using the
+   // "background-image" CSS property. This function should normally only be used
+   // by subclasses.
+   // RETURNS: a #ClutterActor
+   Clutter.Actor* get_background_image()() {
+      return mx_widget_get_background_image(&this);
+   }
+
+   // Get the texture used as the border image. This is set using the
+   // "border-image" CSS property. This function should normally only be used
+   // by subclasses.
+   // RETURNS: #ClutterActor
+   Clutter.Actor* get_border_image()() {
+      return mx_widget_get_border_image(&this);
+   }
+   // Get the value of the "disabled" property.
+   int get_disabled()() {
+      return mx_widget_get_disabled(&this);
+   }
+
+   // Get the object in the #MxWidget:menu property.
+   // RETURNS: The current object in the "menu" property.
+   Menu* get_menu()() {
+      return mx_widget_get_menu(&this);
+   }
+
+   // Gets the padding of the widget, set using the "padding" CSS property. This
+   // function should normally only be used by subclasses.
+   // <padding>: A pointer to an #MxPadding to fill
+   void get_padding()(Padding* padding) {
+      mx_widget_get_padding(&this, padding);
+   }
+
+   // Get the value of the "tooltip-delay" property.
+   // RETURNS: the current delay value in milliseconds
+   uint get_tooltip_delay()() {
+      return mx_widget_get_tooltip_delay(&this);
+   }
+
+   // Get the current tooltip string
+   // RETURNS: The current tooltip string, owned by the #MxWidget
+   char* get_tooltip_text()() {
+      return mx_widget_get_tooltip_text(&this);
+   }
+   // Hide the tooltip for @widget
+   void hide_tooltip()() {
+      mx_widget_hide_tooltip(&this);
+   }
+
+   // Cancel a long-press timeout if one is running and emit the signal to notify
+   // that the long-press has been cancelled.
+   void long_press_cancel()() {
+      mx_widget_long_press_cancel(&this);
+   }
+
+   // Emit the long-press query signal and start a long-press timeout if required.
+   // <event>: the event used to determine whether to run a long-press
+   void long_press_query()(Clutter.ButtonEvent* event) {
+      mx_widget_long_press_query(&this, event);
+   }
+
+   // Invokes #MxWidget::paint_background() using the default background
+   // image and/or color from the @widget style
+   // 
+   // This function should be used by subclasses of #MxWidget that override
+   // the paint() virtual function and cannot chain up
+   void paint_background()() {
+      mx_widget_paint_background(&this);
+   }
+
+   // Set the disabled property. Disabled widgets have a "disabled" pseudo-class
+   // until disabled is set to #FALSE.
+   // <disabled>: value to set
+   void set_disabled()(int disabled) {
+      mx_widget_set_disabled(&this, disabled);
+   }
+
+   // Set the value of the #MxWidget:menu property.
+   // <menu>: A #MxMenu
+   void set_menu()(Menu* menu) {
+      mx_widget_set_menu(&this, menu);
+   }
+
+   // Set the value, in milliseconds, of the "tooltip-delay" property.
+   // This is initially set to MX_WIDGET_TOOLTIP_TIMEOUT.
+   void set_tooltip_delay()(uint delay) {
+      mx_widget_set_tooltip_delay(&this, delay);
+   }
+
+   // Set the tooltip text of the widget. Note that setting tooltip text will cause
+   // the widget to be set reactive. If you no longer need tooltips and you do not
+   // need the widget to be reactive, you must set ClutterActor::reactive to
+   // %FALSE.
+   // <text>: text to set as the tooltip
+   void set_tooltip_text()(char* text) {
+      mx_widget_set_tooltip_text(&this, text);
+   }
+   // Show the tooltip for @widget
+   void show_tooltip()() {
+      mx_widget_show_tooltip(&this);
+   }
+   // Emitted when the user holds a mouse button down for a longer period.
+   extern (C) alias static c_int function (Widget* this_, float object, float p0, LongPressAction* p1, void* user_data=null) signal_long_press;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"long-press", CB:signal_long_press)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"long-press",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+// Base class for stylable actors.
+struct WidgetClass {
+   private Clutter.ActorClass parent_class;
+   extern (C) void function (Widget* self, Clutter.Actor* background, Clutter.Color* color) paint_background;
+   extern (C) int function (Widget* widget, LongPressAction action, float x, float y) long_press;
+   // <style>: A #MxStyle
+   extern (C) void function (Widget* widget, Style* style) apply_style;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+   extern (C) void function () _padding_5;
+   extern (C) void function () _padding_6;
+   extern (C) void function () _padding_7;
+   extern (C) void function () _padding_8;
+}
+
+struct WidgetPrivate {
+}
+
+
+// The contents of this structure is private and should only be accessed using
+// the provided API.
+struct Window /* : GObject.Object */ {
+   alias parent this;
+   alias parent super_;
+   alias parent object;
+   GObject2.Object parent;
+   WindowPrivate* priv;
+
+
+   // Creates a new #MxWindow.
+   // RETURNS: A #MxWindow
+   static Window* /*new*/ new_()() {
+      return mx_window_new();
+   }
+
+   // Creates a new #MxWindow, using @stage as the backing #ClutterStage. This
+   // function is meant for use primarily for embedding a #MxWindow into
+   // a foreign stage when using a Clutter toolkit integration library.
+   // RETURNS: A #MxWindow
+   // <stage>: A #ClutterStage
+   static Window* /*new*/ new_with_clutter_stage()(Clutter.Stage* stage) {
+      return mx_window_new_with_clutter_stage(stage);
+   }
+
+   // Gets the #MxWindow parent of the #ClutterStage, if it exists.
+   // RETURNS: A #MxWindow, or %NULL
+   // <stage>: A #ClutterStage
+   static Window* get_for_stage()(Clutter.Stage* stage) {
+      return mx_window_get_for_stage(stage);
+   }
+
+   // Get the primary child of the window. See mx_window_set_child().
+   // RETURNS: A #ClutterActor, or %NULL
+   Clutter.Actor* get_child()() {
+      return mx_window_get_child(&this);
+   }
+
+   // Gets the #ClutterStage managed by the window.
+   // RETURNS: A #ClutterStage
+   Clutter.Stage* get_clutter_stage()() {
+      return mx_window_get_clutter_stage(&this);
+   }
+
+   // VERSION: 1.2
+   // Determines if the window has been set to be in fullscreen mode.
+   // 
+   // otherwise %FALSE
+   // RETURNS: %TRUE if the window has been set to be in fullscreen mode,
+   int get_fullscreen()() {
+      return mx_window_get_fullscreen(&this);
+   }
+
+   // Determines whether the window has a toolbar or not.
+   // See mx_window_set_has_toolbar().
+   // RETURNS: %TRUE if the window has a toolbar, otherwise %FALSE
+   int get_has_toolbar()() {
+      return mx_window_get_has_toolbar(&this);
+   }
+
+   // Gets the currently set window icon name. This will be %NULL if there is none
+   // set, or the icon was set with mx_window_set_icon_from_cogl_texture().
+   // RETURNS: The window icon name, or %NULL
+   char* get_icon_name()() {
+      return mx_window_get_icon_name(&this);
+   }
+
+   // Determines if the window is in small-screen mode.
+   // See mx_window_set_small_screen().
+   // RETURNS: %TRUE if the window is in small-screen mode, otherwise %FALSE
+   int get_small_screen()() {
+      return mx_window_get_small_screen(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the title used for the window.
+   // RETURNS: The title used for the window
+   char* get_title()() {
+      return mx_window_get_title(&this);
+   }
+
+   // Retrieves the toolbar associated with the window.
+   // RETURNS: A #MxToolbar
+   Toolbar* get_toolbar()() {
+      return mx_window_get_toolbar(&this);
+   }
+
+   // Retrieves the absolute position of the window on the screen.
+   // <x>: A pointer for the x-coordinate
+   // <y>: A pointer for the y-coordinate
+   void get_window_position()(/*out*/ int* x, /*out*/ int* y) {
+      mx_window_get_window_position(&this, x, y);
+   }
+
+   // VERSION: 1.2
+   // Retrieve the rotation of the window.
+   // RETURNS: An #MxWindowRotation
+   WindowRotation get_window_rotation()() {
+      return mx_window_get_window_rotation(&this);
+   }
+
+   // VERSION: 1.2
+   // Retrieves the size of the display area of the window, taking into
+   // account any window border. This includes the area occupied by the
+   // window's toolbar, if it's enabled.
+   // <width>: A #gint pointer for the window's width
+   // <height>: A #gint pointer for the window's height
+   void get_window_size()(/*out*/ int* width, /*out*/ int* height) {
+      mx_window_get_window_size(&this, width, height);
+   }
+
+   // VERSION: 1.2
+   // Hide the window
+   void hide()() {
+      mx_window_hide(&this);
+   }
+
+   // VERSION: 1.2
+   // Present the window. The actual behaviour is specific to the window system.
+   void present()() {
+      mx_window_present(&this);
+   }
+
+   // Adds @actor to the window and sets it as the primary child. When the
+   // stage managed in the window changes size, the child will be resized
+   // to match it.
+   // <actor>: A #ClutterActor
+   void set_child()(Clutter.Actor* actor) {
+      mx_window_set_child(&this, actor);
+   }
+
+   // VERSION: 1.2
+   // Set the window to be in fullscreen mode or windowed mode.
+   // 
+   // <note><para>
+   // Setting fullscreen mode doesn't necessarily mean the window is actually
+   // fullscreen. Setting this property is only a request to the underlying
+   // window system.
+   // </para></note>
+   // <fullscreen>: %TRUE to request fullscreen mode, %FALSE to disable
+   void set_fullscreen()(int fullscreen) {
+      mx_window_set_fullscreen(&this, fullscreen);
+   }
+
+   // Sets whether the window has a toolbar or not. If the window has a toolbar,
+   // client-side window decorations will be enabled.
+   // <toolbar>: %TRUE if the toolbar should be displayed
+   void set_has_toolbar()(int toolbar) {
+      mx_window_set_has_toolbar(&this, toolbar);
+   }
+
+   // Sets the window icon from a texture. This will take precedence over
+   // any currently set icon-name.
+   // <texture>: A #CoglHandle for a texture
+   void set_icon_from_cogl_texture()(Cogl.Handle texture) {
+      mx_window_set_icon_from_cogl_texture(&this, texture);
+   }
+
+   // Set an icon-name to use for the window icon. The icon will be looked up
+   // from the default theme.
+   // <icon_name>: An icon name, or %NULL
+   void set_icon_name()(char* icon_name=null) {
+      mx_window_set_icon_name(&this, icon_name);
+   }
+
+   // Enables or disables small-screen mode. This mode is meant primarily
+   // for platforms with limited screen-space, such as netbooks. When enabled,
+   // the window will take up all available room and will disable moving and
+   // resizing.
+   // <small_screen>: %TRUE if small-screen mode should be enabled
+   void set_small_screen()(int small_screen) {
+      mx_window_set_small_screen(&this, small_screen);
+   }
+
+   // VERSION: 1.2
+   // Sets the title used for the window, the results of which are
+   // window-system specific.
+   // <title>: A string to use for the window title name
+   void set_title()(char* title) {
+      mx_window_set_title(&this, title);
+   }
+
+   // VERSION: 1.2
+   // Sets the toolbar associated with the window.
+   void set_toolbar()(Toolbar* toolbar) {
+      mx_window_set_toolbar(&this, toolbar);
+   }
+
+   // Sets the absolute position of the window on the screen.
+   // <x>: An x-coordinate
+   // <y>: A y-coordinate
+   void set_window_position()(int x, int y) {
+      mx_window_set_window_position(&this, x, y);
+   }
+
+   // VERSION: 1.2
+   // Set the rotation of the window.
+   // <rotation>: The #MxWindowRotation
+   void set_window_rotation()(WindowRotation rotation) {
+      mx_window_set_window_rotation(&this, rotation);
+   }
+
+   // VERSION: 1.2
+   // Sets the size of the window, taking into account any window border. This
+   // corresponds to the window's available area for its child, minus the area
+   // occupied by the window's toolbar, if it's enabled.
+   // 
+   // <note><para>
+   // Setting the window size may involve a request to the underlying windowing
+   // system, and may not immediately be reflected.
+   // </para></note>
+   // <width>: A width, in pixels
+   // <height>: A height, in pixels
+   void set_window_size()(int width, int height) {
+      mx_window_set_window_size(&this, width, height);
+   }
+
+   // VERSION: 1.2
+   // Show the window
+   void show()() {
+      mx_window_show(&this);
+   }
+   // Emitted when the stage managed by the window is destroyed.
+   extern (C) alias static void function (Window* this_, void* user_data=null) signal_destroy;
+
+   ulong signal_connect(string name, CB)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return super_.signal_connect!name(cb, data, cf);
+   }
+
+   ulong signal_connect(string name:"destroy", CB:signal_destroy)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
+      return signal_connect_data!()(&this, cast(char*)"destroy",
+      cast(GObject2.Callback)cb, data, null, cf);
+   }
+}
+
+struct WindowClass {
+   GObject2.ObjectClass parent_class;
+   extern (C) void function (Window* window) destroy;
+   extern (C) void function () _padding_0;
+   extern (C) void function () _padding_1;
+   extern (C) void function () _padding_2;
+   extern (C) void function () _padding_3;
+   extern (C) void function () _padding_4;
+}
+
+struct WindowPrivate {
+}
+
+// Defines the clock-wise rotation angle of a window.
+enum WindowRotation /* Version 1.2 */ {
+   _0 = 0,
+   _90 = 1,
+   _180 = 2,
+   _270 = 3
+}
+static void actor_box_clamp_to_pixels()(Clutter.ActorBox* box) {
+   mx_actor_box_clamp_to_pixels(box);
+}
+
+static void allocate_align_fill()(Clutter.Actor* child, Clutter.ActorBox* childbox, Align x_alignment, Align y_alignment, int x_fill, int y_fill) {
+   mx_allocate_align_fill(child, childbox, x_alignment, y_alignment, x_fill, y_fill);
+}
+
+// MOVED TO: BorderImage.set_from_string
+static void border_image_set_from_string()(GObject2.Value* value, char* str, char* filename) {
+   mx_border_image_set_from_string(value, str, filename);
+}
+
+
+// VERSION: 1.2
+// MOVED TO: FocusHint.from_direction
+// Transforms a focus direction to a focus hint. This is a convenience
+// function for actors that implement the #MxFocusable interface, to
+// pass the correct #MxFocusHint to their children when calling
+// mx_focusable_accept_focus().
+// 
+// %MX_FOCUS_DIRECTION_UP maps to %MX_FOCUS_HINT_FROM_BELOW,
+// %MX_FOCUS_DIRECTION_DOWN maps to %MX_FOCUS_HINT_FROM_ABOVE,
+// %MX_FOCUS_DIRECTION_LEFT maps to %MX_FOCUS_HINT_FROM_RIGHT,
+// %MX_FOCUS_DIRECTION_RIGHT maps to %MX_FOCUS_HINT_FROM_LEFT,
+// %MX_FOCUS_DIRECTION_NEXT maps to %MX_FOCUS_HINT_FIRST,
+// %MX_FOCUS_DIRECTION_PREVIOUS maps to %MX_FOCUS_HINT_LAST and
+// anything else maps to %MX_FOCUS_HINT_PRIOR.
+// RETURNS: A #MxFocusHint
+// <direction>: A #MxFocusDirection
+static FocusHint focus_hint_from_direction()(FocusDirection direction) {
+   return mx_focus_hint_from_direction(direction);
+}
+
+// MOVED TO: FontWeight.set_from_string
+static void font_weight_set_from_string()(GObject2.Value* value, char* str) {
+   mx_font_weight_set_from_string(value, str);
+}
+
+// MOVED TO: ImageError.quark
+static GLib2.Quark image_error_quark()() {
+   return mx_image_error_quark();
+}
+
+
+// Initializes internationalization support for Mx. If MxApplication is
+// used, this is called automatically. Otherwise it has to be called
+// together with clutter_init() before using Mx.
+static void set_locale()() {
+   mx_set_locale();
+}
+
+
+// Generates a string describing the time given in @time_ using
+// colloquial language suitable for display to the user. Examples of
+// what might be returned are "A few minutes ago" or "Yesterday".
+// RETURNS: a string. Free with g_free().
+// <time_>: a time value
+static char* /*new*/ utils_format_time()(GLib2.TimeVal* time_) {
+   return mx_utils_format_time(time_);
+}
+
+
+// C prototypes:
+
+extern (C) {
+Action* /*new*/ mx_action_new();
+Action* /*new*/ mx_action_new_full(char* name, char* display_name, ActionCallbackFunc activated_cb, void* user_data);
+Action* mx_action_new_stateful(char* name, GLib2.VariantType* parameter_type, GLib2.Variant* state);
+Action* mx_action_new_with_parameter(char* name, GLib2.VariantType* parameter_type=null);
+int mx_action_get_active(Action* this_);
+char* mx_action_get_display_name(Action* this_);
+char* mx_action_get_icon(Action* this_);
+char* mx_action_get_name(Action* this_);
+void mx_action_set_active(Action* this_, int active);
+void mx_action_set_display_name(Action* this_, char* name);
+void mx_action_set_icon(Action* this_, char* name);
+void mx_action_set_name(Action* this_, char* name);
+ActorManager* mx_actor_manager_new(Clutter.Stage* stage);
+ActorManager* mx_actor_manager_get_for_stage(Clutter.Stage* stage);
+c_ulong mx_actor_manager_add_actor(ActorManager* this_, Clutter.Container* container, Clutter.Actor* actor);
+void mx_actor_manager_cancel_operation(ActorManager* this_, c_ulong id);
+void mx_actor_manager_cancel_operations(ActorManager* this_, Clutter.Actor* actor);
+c_ulong mx_actor_manager_create_actor(ActorManager* this_, ActorManagerCreateFunc create_func, void* userdata, GLib2.DestroyNotify destroy_func);
+uint mx_actor_manager_get_n_operations(ActorManager* this_);
+Clutter.Stage* mx_actor_manager_get_stage(ActorManager* this_);
+uint mx_actor_manager_get_time_slice(ActorManager* this_);
+c_ulong mx_actor_manager_remove_actor(ActorManager* this_, Clutter.Container* container, Clutter.Actor* actor);
+void mx_actor_manager_remove_container(ActorManager* this_, Clutter.Container* container);
+void mx_actor_manager_set_time_slice(ActorManager* this_, uint msecs);
+Adjustment* /*new*/ mx_adjustment_new();
+Adjustment* /*new*/ mx_adjustment_new_with_values(double value, double lower, double upper, double step_increment, double page_increment, double page_size);
+int mx_adjustment_get_clamp_value(Adjustment* this_);
+int mx_adjustment_get_elastic(Adjustment* this_);
+double mx_adjustment_get_lower(Adjustment* this_);
+double mx_adjustment_get_page_increment(Adjustment* this_);
+double mx_adjustment_get_page_size(Adjustment* this_);
+double mx_adjustment_get_step_increment(Adjustment* this_);
+double mx_adjustment_get_upper(Adjustment* this_);
+double mx_adjustment_get_value(Adjustment* this_);
+void mx_adjustment_get_values(Adjustment* this_, double* value, double* lower, double* upper, double* step_increment, double* page_increment, double* page_size);
+void mx_adjustment_interpolate(Adjustment* this_, double value, uint duration, c_ulong mode);
+void mx_adjustment_interpolate_relative(Adjustment* this_, double offset, uint duration, c_ulong mode);
+void mx_adjustment_set_clamp_value(Adjustment* this_, int clamp);
+void mx_adjustment_set_elastic(Adjustment* this_, int elastic);
+void mx_adjustment_set_lower(Adjustment* this_, double lower);
+void mx_adjustment_set_page_increment(Adjustment* this_, double increment);
+void mx_adjustment_set_page_size(Adjustment* this_, double page_size);
+void mx_adjustment_set_step_increment(Adjustment* this_, double increment);
+void mx_adjustment_set_upper(Adjustment* this_, double upper);
+void mx_adjustment_set_value(Adjustment* this_, double value);
+void mx_adjustment_set_values(Adjustment* this_, double value, double lower, double upper, double step_increment, double page_increment, double page_size);
+Application* /*new*/ mx_application_new(/*inout*/ int* argc, /*inout*/ char*** argv, char* name, ApplicationFlags flags);
+void mx_application_add_action(Application* this_, Action* action);
+void mx_application_add_window(Application* this_, Window* window);
+Window* mx_application_create_window(Application* this_);
+GLib2.List* /*new container*/ mx_application_get_actions(Application* this_);
+ApplicationFlags mx_application_get_flags(Application* this_);
+GLib2.List* mx_application_get_windows(Application* this_);
+void mx_application_invoke_action(Application* this_, char* name);
+void mx_application_invoke_action_with_parameter(Application* this_, char* name, GLib2.Variant* variant);
+int mx_application_is_running(Application* this_);
+void mx_application_quit(Application* this_);
+void mx_application_remove_action(Application* this_, char* name);
+void mx_application_remove_window(Application* this_, Window* window);
+void mx_application_run(Application* this_);
+void mx_bin_allocate_child(Bin* this_, Clutter.ActorBox* box, Clutter.AllocationFlags flags);
+void mx_bin_get_alignment(Bin* this_, Align* x_align, Align* y_align);
+Clutter.Actor* mx_bin_get_child(Bin* this_);
+void mx_bin_get_fill(Bin* this_, /*out*/ int* x_fill, /*out*/ int* y_fill);
+void mx_bin_set_alignment(Bin* this_, Align x_align, Align y_align);
+void mx_bin_set_child(Bin* this_, Clutter.Actor* child);
+void mx_bin_set_fill(Bin* this_, int x_fill, int y_fill);
+int mx_border_image_equal(BorderImage* this_, BorderImage* b2);
+void mx_border_image_set_from_string(GObject2.Value* value, char* str, char* filename);
+BoxLayout* mx_box_layout_new();
+BoxLayout* mx_box_layout_new_with_orientation(Orientation orientation);
+void mx_box_layout_add_actor(BoxLayout* this_, Clutter.Actor* actor, int position);
+void mx_box_layout_add_actor_with_properties(BoxLayout* this_, Clutter.Actor* actor, int position, char* first_property, ...);
+int mx_box_layout_child_get_expand(BoxLayout* this_, Clutter.Actor* child);
+Align mx_box_layout_child_get_x_align(BoxLayout* this_, Clutter.Actor* child);
+int mx_box_layout_child_get_x_fill(BoxLayout* this_, Clutter.Actor* child);
+Align mx_box_layout_child_get_y_align(BoxLayout* this_, Clutter.Actor* child);
+int mx_box_layout_child_get_y_fill(BoxLayout* this_, Clutter.Actor* child);
+void mx_box_layout_child_set_expand(BoxLayout* this_, Clutter.Actor* child, int expand);
+void mx_box_layout_child_set_x_align(BoxLayout* this_, Clutter.Actor* child, Align x_align);
+void mx_box_layout_child_set_x_fill(BoxLayout* this_, Clutter.Actor* child, int x_fill);
+void mx_box_layout_child_set_y_align(BoxLayout* this_, Clutter.Actor* child, Align y_align);
+void mx_box_layout_child_set_y_fill(BoxLayout* this_, Clutter.Actor* child, int y_fill);
+int mx_box_layout_get_enable_animations(BoxLayout* this_);
+Orientation mx_box_layout_get_orientation(BoxLayout* this_);
+int mx_box_layout_get_scroll_to_focused(BoxLayout* this_);
+uint mx_box_layout_get_spacing(BoxLayout* this_);
+void mx_box_layout_set_enable_animations(BoxLayout* this_, int enable_animations);
+void mx_box_layout_set_orientation(BoxLayout* this_, Orientation orientation);
+void mx_box_layout_set_scroll_to_focused(BoxLayout* this_, int scroll_to_focused);
+void mx_box_layout_set_spacing(BoxLayout* this_, uint spacing);
+Button* mx_button_new();
+Button* mx_button_new_with_label(char* text);
+Action* mx_button_get_action(Button* this_);
+char* mx_button_get_icon_name(Button* this_);
+Position mx_button_get_icon_position(Button* this_);
+uint mx_button_get_icon_size(Button* this_);
+int mx_button_get_icon_visible(Button* this_);
+int mx_button_get_is_toggle(Button* this_);
+char* mx_button_get_label(Button* this_);
+int mx_button_get_label_visible(Button* this_);
+int mx_button_get_toggled(Button* this_);
+void mx_button_set_action(Button* this_, Action* action);
+void mx_button_set_icon_name(Button* this_, char* icon_name=null);
+void mx_button_set_icon_position(Button* this_, Position position);
+void mx_button_set_icon_size(Button* this_, uint icon_size);
+void mx_button_set_icon_visible(Button* this_, int visible);
+void mx_button_set_is_toggle(Button* this_, int toggle);
+void mx_button_set_label(Button* this_, char* text);
+void mx_button_set_label_visible(Button* this_, int visible);
+void mx_button_set_toggled(Button* this_, int toggled);
+ButtonGroup* mx_button_group_new();
+void mx_button_group_add(ButtonGroup* this_, Button* button);
+void mx_button_group_foreach(ButtonGroup* this_, Clutter.Callback callback, void* userdata);
+Button* mx_button_group_get_active_button(ButtonGroup* this_);
+int mx_button_group_get_allow_no_active(ButtonGroup* this_);
+GLib2.SList* mx_button_group_get_buttons(ButtonGroup* this_);
+void mx_button_group_remove(ButtonGroup* this_, Button* button);
+void mx_button_group_set_active_button(ButtonGroup* this_, Button* button=null);
+void mx_button_group_set_allow_no_active(ButtonGroup* this_, int allow_no_active);
+Clipboard* mx_clipboard_get_default();
+void mx_clipboard_get_text(Clipboard* this_, ClipboardCallbackFunc callback, void* user_data);
+void mx_clipboard_set_text(Clipboard* this_, char* text);
+ComboBox* mx_combo_box_new();
+void mx_combo_box_append_text(ComboBox* this_, char* text);
+char* mx_combo_box_get_active_icon_name(ComboBox* this_);
+char* mx_combo_box_get_active_text(ComboBox* this_);
+int mx_combo_box_get_index(ComboBox* this_);
+void mx_combo_box_insert_text(ComboBox* this_, int position, char* text);
+void mx_combo_box_insert_text_with_icon(ComboBox* this_, int position, char* text, char* icon);
+void mx_combo_box_prepend_text(ComboBox* this_, char* text);
+void mx_combo_box_remove_all(ComboBox* this_);
+void mx_combo_box_remove_text(ComboBox* this_, int position);
+void mx_combo_box_set_active_icon_name(ComboBox* this_, char* icon_name=null);
+void mx_combo_box_set_active_text(ComboBox* this_, char* text);
+void mx_combo_box_set_index(ComboBox* this_, int index);
+DeformBowTie* mx_deform_bow_tie_new();
+int mx_deform_bow_tie_get_flip_back(DeformBowTie* this_);
+double mx_deform_bow_tie_get_period(DeformBowTie* this_);
+void mx_deform_bow_tie_set_flip_back(DeformBowTie* this_, int flip_back);
+void mx_deform_bow_tie_set_period(DeformBowTie* this_, double period);
+DeformPageTurn* mx_deform_page_turn_new();
+double mx_deform_page_turn_get_angle(DeformPageTurn* this_);
+double mx_deform_page_turn_get_period(DeformPageTurn* this_);
+double mx_deform_page_turn_get_radius(DeformPageTurn* this_);
+void mx_deform_page_turn_set_angle(DeformPageTurn* this_, double angle);
+void mx_deform_page_turn_set_period(DeformPageTurn* this_, double period);
+void mx_deform_page_turn_set_radius(DeformPageTurn* this_, double radius);
+void mx_deform_texture_get_resolution(DeformTexture* this_, /*out*/ int* tiles_x=null, /*out*/ int* tiles_y=null);
+void mx_deform_texture_get_textures(DeformTexture* this_, /*out*/ Clutter.Texture** front=null, /*out*/ Clutter.Texture** back=null);
+void mx_deform_texture_invalidate(DeformTexture* this_);
+void mx_deform_texture_set_resolution(DeformTexture* this_, int tiles_x, int tiles_y);
+void mx_deform_texture_set_textures(DeformTexture* this_, Clutter.Texture* front=null, Clutter.Texture* back=null);
+DeformWaves* mx_deform_waves_new();
+double mx_deform_waves_get_amplitude(DeformWaves* this_);
+double mx_deform_waves_get_angle(DeformWaves* this_);
+double mx_deform_waves_get_period(DeformWaves* this_);
+double mx_deform_waves_get_radius(DeformWaves* this_);
+void mx_deform_waves_set_amplitude(DeformWaves* this_, double amplitude);
+void mx_deform_waves_set_angle(DeformWaves* this_, double angle);
+void mx_deform_waves_set_period(DeformWaves* this_, double period);
+void mx_deform_waves_set_radius(DeformWaves* this_, double radius);
+Dialog* mx_dialog_new();
+void mx_dialog_add_action(Dialog* this_, Action* action);
+GLib2.List* /*new container*/ mx_dialog_get_actions(Dialog* this_);
+void mx_dialog_remove_action(Dialog* this_, Action* action);
+void mx_dialog_set_transient_parent(Dialog* this_, Clutter.Actor* actor);
+void mx_draggable_disable(Draggable* this_);
+void mx_draggable_enable(Draggable* this_);
+DragAxis mx_draggable_get_axis(Draggable* this_);
+Clutter.Actor* mx_draggable_get_drag_actor(Draggable* this_);
+uint mx_draggable_get_drag_threshold(Draggable* this_);
+int mx_draggable_is_enabled(Draggable* this_);
+void mx_draggable_set_axis(Draggable* this_, DragAxis axis);
+void mx_draggable_set_drag_actor(Draggable* this_, Clutter.Actor* actor);
+void mx_draggable_set_drag_threshold(Draggable* this_, uint threshold);
+int mx_droppable_accept_drop(Droppable* this_, Draggable* draggable);
+void mx_droppable_disable(Droppable* this_);
+void mx_droppable_enable(Droppable* this_);
+int mx_droppable_is_enabled(Droppable* this_);
+Entry* mx_entry_new();
+Entry* mx_entry_new_with_text(char* text);
+Clutter.Actor* mx_entry_get_clutter_text(Entry* this_);
+char* mx_entry_get_hint_text(Entry* this_);
+char* mx_entry_get_icon_highlight_suffix(Entry* this_);
+dchar mx_entry_get_password_char(Entry* this_);
+char* mx_entry_get_text(Entry* this_);
+void mx_entry_set_hint_text(Entry* this_, char* text);
+void mx_entry_set_icon_highlight_suffix(Entry* this_, char* suffix);
+void mx_entry_set_password_char(Entry* this_, dchar password_char);
+void mx_entry_set_primary_icon_from_file(Entry* this_, char* filename);
+void mx_entry_set_primary_icon_tooltip_text(Entry* this_, char* text);
+void mx_entry_set_secondary_icon_from_file(Entry* this_, char* filename);
+void mx_entry_set_secondary_icon_tooltip_text(Entry* this_, char* text);
+void mx_entry_set_text(Entry* this_, char* text);
+Expander* mx_expander_new();
+int mx_expander_get_expanded(Expander* this_);
+void mx_expander_set_expanded(Expander* this_, int expanded);
+void mx_expander_set_label(Expander* this_, char* label);
+FadeEffect* mx_fade_effect_new();
+void mx_fade_effect_get_border(FadeEffect* this_, /*out*/ uint* top, /*out*/ uint* right, /*out*/ uint* bottom, /*out*/ uint* left);
+void mx_fade_effect_get_bounds(FadeEffect* this_, /*out*/ int* x, /*out*/ int* y, /*out*/ uint* width, /*out*/ uint* height);
+void mx_fade_effect_get_color(FadeEffect* this_, /*out*/ Clutter.Color* color);
+void mx_fade_effect_set_border(FadeEffect* this_, uint top, uint right, uint bottom, uint left);
+void mx_fade_effect_set_bounds(FadeEffect* this_, int x, int y, uint width, uint height);
+void mx_fade_effect_set_color(FadeEffect* this_, Clutter.Color* color);
+FocusManager* mx_focus_manager_get_for_stage(Clutter.Stage* stage);
+Focusable* mx_focus_manager_get_focused(FocusManager* this_);
+Clutter.Stage* mx_focus_manager_get_stage(FocusManager* this_);
+void mx_focus_manager_move_focus(FocusManager* this_, FocusDirection direction);
+void mx_focus_manager_push_focus(FocusManager* this_, Focusable* focusable);
+void mx_focus_manager_push_focus_with_hint(FocusManager* this_, Focusable* focusable, FocusHint hint);
+Focusable* mx_focusable_accept_focus(Focusable* this_, FocusHint hint);
+Focusable* mx_focusable_move_focus(Focusable* this_, FocusDirection direction, Focusable* from);
+Frame* mx_frame_new();
+Grid* mx_grid_new();
+Align mx_grid_get_child_x_align(Grid* this_);
+Align mx_grid_get_child_y_align(Grid* this_);
+float mx_grid_get_column_spacing(Grid* this_);
+int mx_grid_get_homogenous_columns(Grid* this_);
+int mx_grid_get_homogenous_rows(Grid* this_);
+int mx_grid_get_line_alignment(Grid* this_);
+int mx_grid_get_max_stride(Grid* this_);
+Orientation mx_grid_get_orientation(Grid* this_);
+float mx_grid_get_row_spacing(Grid* this_);
+void mx_grid_set_child_x_align(Grid* this_, Align value);
+void mx_grid_set_child_y_align(Grid* this_, Align value);
+void mx_grid_set_column_spacing(Grid* this_, float value);
+void mx_grid_set_homogenous_columns(Grid* this_, int value);
+void mx_grid_set_homogenous_rows(Grid* this_, int value);
+void mx_grid_set_line_alignment(Grid* this_, Align value);
+void mx_grid_set_max_stride(Grid* this_, int value);
+void mx_grid_set_orientation(Grid* this_, Orientation orientation);
+void mx_grid_set_row_spacing(Grid* this_, float value);
+Icon* mx_icon_new();
+char* mx_icon_get_icon_name(Icon* this_);
+int mx_icon_get_icon_size(Icon* this_);
+void mx_icon_set_icon_name(Icon* this_, char* icon_name);
+void mx_icon_set_icon_size(Icon* this_, int size);
+IconTheme* /*new*/ mx_icon_theme_new();
+IconTheme* mx_icon_theme_get_default();
+GLib2.List* mx_icon_theme_get_search_paths(IconTheme* this_);
+char* mx_icon_theme_get_theme_name(IconTheme* this_);
+int mx_icon_theme_has_icon(IconTheme* this_, char* icon_name);
+Cogl.Handle mx_icon_theme_lookup(IconTheme* this_, char* icon_name, int size);
+Clutter.Texture* mx_icon_theme_lookup_texture(IconTheme* this_, char* icon_name, int size);
+void mx_icon_theme_set_search_paths(IconTheme* this_, GLib2.List* paths);
+void mx_icon_theme_set_theme_name(IconTheme* this_, char* theme_name);
+Image* mx_image_new();
+void mx_image_animate_scale_mode(Image* this_, c_ulong mode, uint duration, ImageScaleMode scale_mode);
+void mx_image_clear(Image* this_);
+int mx_image_get_allow_upscale(Image* this_);
+float mx_image_get_image_rotation(Image* this_);
+int mx_image_get_load_async(Image* this_);
+uint mx_image_get_scale_height_threshold(Image* this_);
+ImageScaleMode mx_image_get_scale_mode(Image* this_);
+uint mx_image_get_scale_width_threshold(Image* this_);
+uint mx_image_get_transition_duration(Image* this_);
+void mx_image_set_allow_upscale(Image* this_, int allow);
+int mx_image_set_from_buffer(Image* this_, ubyte* buffer, size_t buffer_size, GLib2.DestroyNotify buffer_free_func, GLib2.Error** error);
+int mx_image_set_from_buffer_at_size(Image* this_, ubyte* buffer, size_t buffer_size, GLib2.DestroyNotify buffer_free_func, int width, int height, GLib2.Error** error);
+int mx_image_set_from_cogl_texture(Image* this_, Cogl.Handle texture);
+int mx_image_set_from_data(Image* this_, ubyte* data, Cogl.PixelFormat pixel_format, int width, int height, int rowstride, GLib2.Error** error);
+int mx_image_set_from_file(Image* this_, char* filename, GLib2.Error** error);
+int mx_image_set_from_file_at_size(Image* this_, char* filename, int width, int height, GLib2.Error** error);
+void mx_image_set_image_rotation(Image* this_, float rotation);
+void mx_image_set_load_async(Image* this_, int load_async);
+void mx_image_set_scale_height_threshold(Image* this_, uint pixels);
+void mx_image_set_scale_mode(Image* this_, ImageScaleMode mode);
+void mx_image_set_scale_width_threshold(Image* this_, uint pixels);
+void mx_image_set_transition_duration(Image* this_, uint duration);
+Clutter.Actor* /*new*/ mx_item_factory_create(ItemFactory* this_);
+ItemView* mx_item_view_new();
+void mx_item_view_add_attribute(ItemView* this_, char* attribute, int column);
+void mx_item_view_freeze(ItemView* this_);
+ItemFactory* mx_item_view_get_factory(ItemView* this_);
+Type mx_item_view_get_item_type(ItemView* this_);
+Clutter.Model* mx_item_view_get_model(ItemView* this_);
+void mx_item_view_set_factory(ItemView* this_, ItemFactory* factory=null);
+void mx_item_view_set_item_type(ItemView* this_, Type item_type);
+void mx_item_view_set_model(ItemView* this_, Clutter.Model* model);
+void mx_item_view_thaw(ItemView* this_);
+KineticScrollView* mx_kinetic_scroll_view_new();
+double mx_kinetic_scroll_view_get_acceleration_factor(KineticScrollView* this_);
+uint mx_kinetic_scroll_view_get_clamp_duration(KineticScrollView* this_);
+c_ulong mx_kinetic_scroll_view_get_clamp_mode(KineticScrollView* this_);
+int mx_kinetic_scroll_view_get_clamp_to_center(KineticScrollView* this_);
+double mx_kinetic_scroll_view_get_deceleration(KineticScrollView* this_);
+uint mx_kinetic_scroll_view_get_mouse_button(KineticScrollView* this_);
+double mx_kinetic_scroll_view_get_overshoot(KineticScrollView* this_);
+ScrollPolicy mx_kinetic_scroll_view_get_scroll_policy(KineticScrollView* this_);
+int mx_kinetic_scroll_view_get_use_captured(KineticScrollView* this_);
+void mx_kinetic_scroll_view_set_acceleration_factor(KineticScrollView* this_, double acceleration_factor);
+void mx_kinetic_scroll_view_set_clamp_duration(KineticScrollView* this_, uint clamp_duration);
+void mx_kinetic_scroll_view_set_clamp_mode(KineticScrollView* this_, c_ulong clamp_mode);
+void mx_kinetic_scroll_view_set_clamp_to_center(KineticScrollView* this_, int clamp_to_center);
+void mx_kinetic_scroll_view_set_deceleration(KineticScrollView* this_, double rate);
+void mx_kinetic_scroll_view_set_mouse_button(KineticScrollView* this_, uint button);
+void mx_kinetic_scroll_view_set_overshoot(KineticScrollView* this_, double overshoot);
+void mx_kinetic_scroll_view_set_scroll_policy(KineticScrollView* this_, ScrollPolicy policy);
+void mx_kinetic_scroll_view_set_use_captured(KineticScrollView* this_, int use_captured);
+void mx_kinetic_scroll_view_stop(KineticScrollView* this_);
+Label* mx_label_new();
+Label* mx_label_new_with_text(char* text);
+Clutter.Actor* mx_label_get_clutter_text(Label* this_);
+int mx_label_get_fade_out(Label* this_);
+int mx_label_get_line_wrap(Label* this_);
+int mx_label_get_show_tooltip(Label* this_);
+char* mx_label_get_text(Label* this_);
+int mx_label_get_use_markup(Label* this_);
+Align mx_label_get_x_align(Label* this_);
+Align mx_label_get_y_align(Label* this_);
+void mx_label_set_fade_out(Label* this_, int fade);
+void mx_label_set_line_wrap(Label* this_, int line_wrap);
+void mx_label_set_show_tooltip(Label* this_, int show_tooltip);
+void mx_label_set_text(Label* this_, char* text);
+void mx_label_set_use_markup(Label* this_, int use_markup);
+void mx_label_set_x_align(Label* this_, Align align_);
+void mx_label_set_y_align(Label* this_, Align align_);
+ListView* mx_list_view_new();
+void mx_list_view_add_attribute(ListView* this_, char* attribute, int column);
+void mx_list_view_freeze(ListView* this_);
+ItemFactory* mx_list_view_get_factory(ListView* this_);
+Type mx_list_view_get_item_type(ListView* this_);
+Clutter.Model* mx_list_view_get_model(ListView* this_);
+void mx_list_view_set_factory(ListView* this_, ItemFactory* factory=null);
+void mx_list_view_set_item_type(ListView* this_, Type item_type);
+void mx_list_view_set_model(ListView* this_, Clutter.Model* model);
+void mx_list_view_thaw(ListView* this_);
+Menu* mx_menu_new();
+void mx_menu_add_action(Menu* this_, Action* action);
+void mx_menu_remove_action(Menu* this_, Action* action);
+void mx_menu_remove_all(Menu* this_);
+void mx_menu_show_with_position(Menu* this_, float x, float y);
+Notebook* mx_notebook_new();
+Clutter.Actor* mx_notebook_get_current_page(Notebook* this_);
+int mx_notebook_get_enable_gestures(Notebook* this_);
+void mx_notebook_next_page(Notebook* this_);
+void mx_notebook_previous_page(Notebook* this_);
+void mx_notebook_set_current_page(Notebook* this_, Clutter.Actor* page);
+void mx_notebook_set_enable_gestures(Notebook* this_, int enabled);
+Offscreen* mx_offscreen_new();
+int mx_offscreen_get_accumulation_enabled(Offscreen* this_);
+Cogl.Handle mx_offscreen_get_accumulation_material(Offscreen* this_);
+int mx_offscreen_get_auto_update(Offscreen* this_);
+Cogl.Handle mx_offscreen_get_buffer(Offscreen* this_);
+Clutter.Actor* mx_offscreen_get_child(Offscreen* this_);
+int mx_offscreen_get_pick_child(Offscreen* this_);
+int mx_offscreen_get_redirect_enabled(Offscreen* this_);
+void mx_offscreen_set_accumulation_enabled(Offscreen* this_, int enable);
+void mx_offscreen_set_auto_update(Offscreen* this_, int auto_update);
+void mx_offscreen_set_child(Offscreen* this_, Clutter.Actor* actor);
+void mx_offscreen_set_pick_child(Offscreen* this_, int pick);
+void mx_offscreen_set_redirect_enabled(Offscreen* this_, int enabled);
+void mx_offscreen_update(Offscreen* this_);
+PathBar* mx_path_bar_new();
+void mx_path_bar_clear(PathBar* this_);
+int mx_path_bar_get_clear_on_change(PathBar* this_);
+int mx_path_bar_get_editable(PathBar* this_);
+Entry* mx_path_bar_get_entry(PathBar* this_);
+char* mx_path_bar_get_label(PathBar* this_, int level);
+int mx_path_bar_get_level(PathBar* this_);
+char* mx_path_bar_get_text(PathBar* this_);
+int mx_path_bar_pop(PathBar* this_);
+int mx_path_bar_push(PathBar* this_, char* name);
+void mx_path_bar_set_clear_on_change(PathBar* this_, int clear_on_change);
+void mx_path_bar_set_editable(PathBar* this_, int editable);
+void mx_path_bar_set_label(PathBar* this_, int level, char* label);
+void mx_path_bar_set_text(PathBar* this_, char* text);
+ProgressBar* mx_progress_bar_new();
+double mx_progress_bar_get_progress(ProgressBar* this_);
+void mx_progress_bar_set_progress(ProgressBar* this_, double progress);
+ScrollBar* mx_scroll_bar_new();
+ScrollBar* mx_scroll_bar_new_with_adjustment(Adjustment* adjustment);
+Adjustment* mx_scroll_bar_get_adjustment(ScrollBar* this_);
+Orientation mx_scroll_bar_get_orientation(ScrollBar* this_);
+void mx_scroll_bar_set_adjustment(ScrollBar* this_, Adjustment* adjustment);
+void mx_scroll_bar_set_orientation(ScrollBar* this_, Orientation orientation);
+ScrollView* mx_scroll_view_new();
+void mx_scroll_view_ensure_visible(ScrollView* this_, Clutter.Geometry* geometry);
+int mx_scroll_view_get_enable_gestures(ScrollView* this_);
+int mx_scroll_view_get_enable_mouse_scrolling(ScrollView* this_);
+ScrollPolicy mx_scroll_view_get_scroll_policy(ScrollView* this_);
+void mx_scroll_view_set_enable_gestures(ScrollView* this_, int enabled);
+void mx_scroll_view_set_enable_mouse_scrolling(ScrollView* this_, int enabled);
+void mx_scroll_view_set_scroll_policy(ScrollView* this_, ScrollPolicy policy);
+void mx_scrollable_get_adjustments(Scrollable* this_, /*out*/ Adjustment** hadjustment=null, /*out*/ Adjustment** vadjustment=null);
+void mx_scrollable_set_adjustments(Scrollable* this_, Adjustment* hadjustment, Adjustment* vadjustment);
+Settings* mx_settings_get_default();
+Slider* mx_slider_new();
+double mx_slider_get_buffer_value(Slider* this_);
+double mx_slider_get_value(Slider* this_);
+void mx_slider_set_buffer_value(Slider* this_, double value);
+void mx_slider_set_value(Slider* this_, double value);
+Spinner* mx_spinner_new();
+int mx_spinner_get_animating(Spinner* this_);
+void mx_spinner_set_animating(Spinner* this_, int animating);
+Stack* mx_stack_new();
+int mx_stack_child_get_crop(Stack* this_, Clutter.Actor* child);
+int mx_stack_child_get_fit(Stack* this_, Clutter.Actor* child);
+Align mx_stack_child_get_x_align(Stack* this_, Clutter.Actor* child);
+int mx_stack_child_get_x_fill(Stack* this_, Clutter.Actor* child);
+Align mx_stack_child_get_y_align(Stack* this_, Clutter.Actor* child);
+int mx_stack_child_get_y_fill(Stack* this_, Clutter.Actor* child);
+void mx_stack_child_set_crop(Stack* this_, Clutter.Actor* child, int crop);
+void mx_stack_child_set_fit(Stack* this_, Clutter.Actor* child, int fit);
+void mx_stack_child_set_x_align(Stack* this_, Clutter.Actor* child, Align x_align);
+void mx_stack_child_set_x_fill(Stack* this_, Clutter.Actor* child, int x_fill);
+void mx_stack_child_set_y_align(Stack* this_, Clutter.Actor* child, Align y_align);
+void mx_stack_child_set_y_fill(Stack* this_, Clutter.Actor* child, int y_fill);
+void mx_stylable_apply_clutter_text_attributes(Stylable* this_, Clutter.Text* text);
+void mx_stylable_connect_change_notifiers(Stylable* this_);
+GObject2.ParamSpec* mx_stylable_find_property(Stylable* this_, char* property_name);
+void mx_stylable_get(Stylable* this_, char* first_property_name, ...);
+int mx_stylable_get_default_value(Stylable* this_, char* property_name, /*out*/ GObject2.Value* value_out);
+void mx_stylable_get_property(Stylable* this_, char* property_name, /*out*/ GObject2.Value* value);
+Style* mx_stylable_get_style(Stylable* this_);
+char* mx_stylable_get_style_class(Stylable* this_);
+char* mx_stylable_get_style_pseudo_class(Stylable* this_);
+GObject2.ParamSpec** /*new container*/ mx_stylable_list_properties(Stylable* this_, /*out*/ uint* n_props);
+void mx_stylable_set_style(Stylable* this_, Style* style);
+void mx_stylable_set_style_class(Stylable* this_, char* style_class);
+void mx_stylable_set_style_pseudo_class(Stylable* this_, char* pseudo_class);
+void mx_stylable_style_changed(Stylable* this_, StyleChangedFlags flags);
+void mx_stylable_style_pseudo_class_add(Stylable* this_, char* new_class);
+int mx_stylable_style_pseudo_class_contains(Stylable* this_, char* pseudo_class);
+void mx_stylable_style_pseudo_class_remove(Stylable* this_, char* remove_class);
+void mx_stylable_iface_install_property(StylableIface* this_, Type owner_type, GObject2.ParamSpec* pspec);
+Style* /*new*/ mx_style_new();
+Style* mx_style_get_default();
+void mx_style_get(Style* this_, Stylable* stylable, char* first_property_name, ...);
+void mx_style_get_property(Style* this_, Stylable* stylable, GObject2.ParamSpec* pspec, /*out*/ GObject2.Value* value);
+void mx_style_get_valist(Style* this_, Stylable* stylable, char* first_property_name, va_list va_args);
+int mx_style_load_from_file(Style* this_, char* filename, GLib2.Error** error);
+Table* mx_table_new();
+void mx_table_add_actor(Table* this_, Clutter.Actor* actor, int row, int column);
+void mx_table_add_actor_with_properties(Table* this_, Clutter.Actor* actor, int row, int column, char* first_property_name, ...);
+int mx_table_child_get_column(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_column_span(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_row(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_row_span(Table* this_, Clutter.Actor* child);
+Align mx_table_child_get_x_align(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_x_expand(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_x_fill(Table* this_, Clutter.Actor* child);
+Align mx_table_child_get_y_align(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_y_expand(Table* this_, Clutter.Actor* child);
+int mx_table_child_get_y_fill(Table* this_, Clutter.Actor* child);
+void mx_table_child_set_column(Table* this_, Clutter.Actor* child, int col);
+void mx_table_child_set_column_span(Table* this_, Clutter.Actor* child, int span);
+void mx_table_child_set_row(Table* this_, Clutter.Actor* child, int row);
+void mx_table_child_set_row_span(Table* this_, Clutter.Actor* child, int span);
+void mx_table_child_set_x_align(Table* this_, Clutter.Actor* child, Align align_);
+void mx_table_child_set_x_expand(Table* this_, Clutter.Actor* child, int expand);
+void mx_table_child_set_x_fill(Table* this_, Clutter.Actor* child, int fill);
+void mx_table_child_set_y_align(Table* this_, Clutter.Actor* child, Align align_);
+void mx_table_child_set_y_expand(Table* this_, Clutter.Actor* child, int expand);
+void mx_table_child_set_y_fill(Table* this_, Clutter.Actor* child, int fill);
+int mx_table_get_column_count(Table* this_);
+int mx_table_get_column_spacing(Table* this_);
+int mx_table_get_row_count(Table* this_);
+int mx_table_get_row_spacing(Table* this_);
+void mx_table_set_column_spacing(Table* this_, int spacing);
+void mx_table_set_row_spacing(Table* this_, int spacing);
+TextureCache* mx_texture_cache_get_default();
+int mx_texture_cache_contains(TextureCache* this_, char* uri);
+int mx_texture_cache_contains_meta(TextureCache* this_, char* uri, void* ident);
+Clutter.Actor* mx_texture_cache_get_actor(TextureCache* this_, char* uri);
+Cogl.Handle mx_texture_cache_get_cogl_texture(TextureCache* this_, char* uri);
+Cogl.Handle /*new*/ mx_texture_cache_get_meta_cogl_texture(TextureCache* this_, char* uri, void* ident);
+Clutter.Texture* /*new*/ mx_texture_cache_get_meta_texture(TextureCache* this_, char* uri, void* ident);
+int mx_texture_cache_get_size(TextureCache* this_);
+Clutter.Texture* mx_texture_cache_get_texture(TextureCache* this_, char* uri);
+void mx_texture_cache_insert(TextureCache* this_, char* uri, Cogl.Handle* texture);
+void mx_texture_cache_insert_meta(TextureCache* this_, char* uri, void* ident, Cogl.Handle* texture, GLib2.DestroyNotify destroy_func);
+void mx_texture_cache_load_cache(TextureCache* this_, char* filename);
+TextureFrame* mx_texture_frame_new(Clutter.Texture* texture, float top, float right, float bottom, float left);
+void mx_texture_frame_get_border_values(TextureFrame* this_, float* top, float* right, float* bottom, float* left);
+Clutter.Texture* mx_texture_frame_get_parent_texture(TextureFrame* this_);
+void mx_texture_frame_set_border_values(TextureFrame* this_, float top, float right, float bottom, float left);
+void mx_texture_frame_set_parent_texture(TextureFrame* this_, Clutter.Texture* texture);
+Toggle* mx_toggle_new();
+int mx_toggle_get_active(Toggle* this_);
+void mx_toggle_set_active(Toggle* this_, int active);
+Toolbar* mx_toolbar_new();
+int mx_toolbar_get_has_close_button(Toolbar* this_);
+void mx_toolbar_set_has_close_button(Toolbar* this_, int has_close_button);
+int mx_tooltip_is_in_browse_mode();
+char* mx_tooltip_get_text(Tooltip* this_);
+Clutter.Geometry* mx_tooltip_get_tip_area(Tooltip* this_);
+void mx_tooltip_hide(Tooltip* this_);
+void mx_tooltip_set_text(Tooltip* this_, char* text);
+void mx_tooltip_set_tip_area(Tooltip* this_, Clutter.Geometry* area);
+void mx_tooltip_set_tip_area_from_actor(Tooltip* this_, Clutter.Actor* actor);
+void mx_tooltip_show(Tooltip* this_);
+Viewport* mx_viewport_new();
+void mx_viewport_get_origin(Viewport* this_, float* x, float* y, float* z);
+int mx_viewport_get_sync_adjustments(Viewport* this_);
+void mx_viewport_set_origin(Viewport* this_, float x, float y, float z);
+void mx_viewport_set_sync_adjustments(Viewport* this_, int sync);
+void mx_widget_apply_style(Widget* this_, Style* style);
+void mx_widget_get_available_area(Widget* this_, Clutter.ActorBox* allocation, Clutter.ActorBox* area);
+Clutter.Actor* mx_widget_get_background_image(Widget* this_);
+Clutter.Actor* mx_widget_get_border_image(Widget* this_);
+int mx_widget_get_disabled(Widget* this_);
+Menu* mx_widget_get_menu(Widget* this_);
+void mx_widget_get_padding(Widget* this_, Padding* padding);
+uint mx_widget_get_tooltip_delay(Widget* this_);
+char* mx_widget_get_tooltip_text(Widget* this_);
+void mx_widget_hide_tooltip(Widget* this_);
+void mx_widget_long_press_cancel(Widget* this_);
+void mx_widget_long_press_query(Widget* this_, Clutter.ButtonEvent* event);
+void mx_widget_paint_background(Widget* this_);
+void mx_widget_set_disabled(Widget* this_, int disabled);
+void mx_widget_set_menu(Widget* this_, Menu* menu);
+void mx_widget_set_tooltip_delay(Widget* this_, uint delay);
+void mx_widget_set_tooltip_text(Widget* this_, char* text);
+void mx_widget_show_tooltip(Widget* this_);
+Window* /*new*/ mx_window_new();
+Window* /*new*/ mx_window_new_with_clutter_stage(Clutter.Stage* stage);
+Window* mx_window_get_for_stage(Clutter.Stage* stage);
+Clutter.Actor* mx_window_get_child(Window* this_);
+Clutter.Stage* mx_window_get_clutter_stage(Window* this_);
+int mx_window_get_fullscreen(Window* this_);
+int mx_window_get_has_toolbar(Window* this_);
+char* mx_window_get_icon_name(Window* this_);
+int mx_window_get_small_screen(Window* this_);
+char* mx_window_get_title(Window* this_);
+Toolbar* mx_window_get_toolbar(Window* this_);
+void mx_window_get_window_position(Window* this_, /*out*/ int* x, /*out*/ int* y);
+WindowRotation mx_window_get_window_rotation(Window* this_);
+void mx_window_get_window_size(Window* this_, /*out*/ int* width, /*out*/ int* height);
+void mx_window_hide(Window* this_);
+void mx_window_present(Window* this_);
+void mx_window_set_child(Window* this_, Clutter.Actor* actor);
+void mx_window_set_fullscreen(Window* this_, int fullscreen);
+void mx_window_set_has_toolbar(Window* this_, int toolbar);
+void mx_window_set_icon_from_cogl_texture(Window* this_, Cogl.Handle texture);
+void mx_window_set_icon_name(Window* this_, char* icon_name=null);
+void mx_window_set_small_screen(Window* this_, int small_screen);
+void mx_window_set_title(Window* this_, char* title);
+void mx_window_set_toolbar(Window* this_, Toolbar* toolbar);
+void mx_window_set_window_position(Window* this_, int x, int y);
+void mx_window_set_window_rotation(Window* this_, WindowRotation rotation);
+void mx_window_set_window_size(Window* this_, int width, int height);
+void mx_window_show(Window* this_);
+void mx_actor_box_clamp_to_pixels(Clutter.ActorBox* box);
+void mx_allocate_align_fill(Clutter.Actor* child, Clutter.ActorBox* childbox, Align x_alignment, Align y_alignment, int x_fill, int y_fill);
+FocusHint mx_focus_hint_from_direction(FocusDirection direction);
+void mx_font_weight_set_from_string(GObject2.Value* value, char* str);
+GLib2.Quark mx_image_error_quark();
+void mx_set_locale();
+char* /*new*/ mx_utils_format_time(GLib2.TimeVal* time_);
+}
diff --git a/gtk2/pango.d b/gtk2/pango.d
index 3c01863..80c4a94 100644
--- a/gtk2/pango.d
+++ b/gtk2/pango.d
@@ -28,7 +28,6 @@ int PIXELS(T)(T d)       { return (cast(int)d+512)>>10; }
 int PIXELS_FLOOR(T)(T d) { return (cast(int)d)>>10; }
 int PIXELS_CEIL(T)(T d)  { return (cast(int)d+1023)>>10; }
 
-
 // <--- mixin/Pango__MODULE_HEAD.d ---
 
 alias uint Glyph;
-- 
2.11.4.GIT