Update. Clutter now working.

[girtod.git] / gtk2 / gtk2.d

// *** DO NOT EDIT ***
// Automatically generated from "/usr/share/gir-1.0/Gtk-2.0.gir"

module Gtk2;
public import gtk2.atk;
alias gtk2.atk Atk;
public import gtk2.glib2;
alias gtk2.glib2 GLib2;
public import gtk2.gmodule2;
alias gtk2.gmodule2 GModule2;
public import gtk2.gobject2;
alias gtk2.gobject2 GObject2;
public import gtk2.gdk2;
alias gtk2.gdk2 Gdk2;
public import gtk2.gdkpixbuf2;
alias gtk2.gdkpixbuf2 GdkPixbuf2;
public import gtk2.gio2;
alias gtk2.gio2 Gio2;
public import gtk2.pango;
alias gtk2.pango Pango;
public import gtk2.cairo;
alias gtk2.cairo cairo;

// c:symbol-prefixes: ["gtk"]
// c:identifier-prefixes: ["Gtk"]

// module Gtk2;


// A <structname>GtkAllocation</structname> of a widget represents region which has been allocated to the
// widget by its parent. It is a subregion of its parents allocation. See
// <xref linkend="size-allocation"/> for more information.
alias Gdk2.Rectangle Allocation;
alias GObject2.BaseInitFunc ClassInitFunc;
alias GObject2.EnumValue EnumValue;
alias GObject2.FlagsValue FlagValue;
alias Type FundamentalType;
alias GObject2.InstanceInitFunc ObjectInitFunc;
alias GObject2.SignalCMarshaller SignalMarshaller;
/* alias Type Type; */
alias GObject2.TypeClass TypeClass;
alias GObject2.TypeInstance TypeObject;
enum int ARG_READWRITE = 0;

// The #GtkAboutDialog offers a simple way to display information about
// a program like its logo, name, copyright, website and license. It is
// also possible to give credits to the authors, documenters, translators
// and artists who have worked on the program. An about dialog is typically
// opened when the user selects the <literal>About</literal> option from
// the <literal>Help</literal> menu. All parts of the dialog are optional.
// About dialog often contain links and email addresses. #GtkAboutDialog
// supports this by offering global hooks, which are called when the user
// clicks on a link or email address, see gtk_about_dialog_set_email_hook()
// and gtk_about_dialog_set_url_hook(). Email addresses in the
// authors, documenters and artists properties are recognized by looking for
// <literal>&lt;user@<!-- -->host&gt;</literal>, URLs are
// recognized by looking for <literal>http://url</literal>, with
// <literal>url</literal> extending to the next space, tab or line break.
// <para id="gtk-about-dialog-hook-setup">
// Since 2.18 #GtkAboutDialog provides default website and email hooks that
// use gtk_show_uri().
// </para>
// If you want provide your own hooks overriding the default ones, it is
// important to do so before setting the website and email URL properties,
// like this:
// <informalexample><programlisting>
// gtk_about_dialog_set_url_hook (GTK_ABOUT_DIALOG (dialog), launch_url, NULL, NULL);
// gtk_about_dialog_set_website (GTK_ABOUT_DIALOG (dialog), app_url);
// </programlisting></informalexample>
// To disable the default hooks, you can pass %NULL as the hook func. Then,
// the #GtkAboutDialog widget will not display the website or the
// email addresses as clickable.
// To make constructing a #GtkAboutDialog as convenient as possible, you can
// use the function gtk_show_about_dialog() which constructs and shows a dialog
// and keeps it around so that it can be shown again.
// Note that GTK+ sets a default title of <literal>_("About &percnt;s")</literal>
// on the dialog window (where &percnt;s is replaced by the name of the
// application, but in order to ensure proper translation of the title,
// applications should set the title property explicitly when constructing
// a #GtkAboutDialog, as shown in the following example:
// <informalexample><programlisting>
// gtk_show_about_dialog (NULL,
// "program-name", "ExampleCode",
// "logo", example_logo,
// "title" _("About ExampleCode"),
// NULL);
// </programlisting></informalexample>
// Note that prior to GTK+ 2.12, the #GtkAboutDialog:program-name property
// was called "name". This was changed to avoid the conflict with the
// #GtkWidget:name property.
struct AboutDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   private void* private_data;


   // Creates a new #GtkAboutDialog.
   // RETURNS: a newly created #GtkAboutDialog
   static AboutDialog* new_() {
      return gtk_about_dialog_new();
   }

   // Unintrospectable function: set_email_hook() / gtk_about_dialog_set_email_hook()
   // Installs a global function to be called whenever the user activates an
   // email link in an about dialog.
   // Since 2.18 there exists a default function which uses gtk_show_uri(). To
   // deactivate it, you can pass %NULL for @func.
   // RETURNS: the previous email hook.
   // <func>: a function to call when an email link is activated.
   // <data>: data to pass to @func
   // <destroy>: #GDestroyNotify for @data
   static AboutDialogActivateLinkFunc set_email_hook(AboutDialogActivateLinkFunc func, void* data, GLib2.DestroyNotify destroy) {
      return gtk_about_dialog_set_email_hook(func, data, destroy);
   }

   // Unintrospectable function: set_url_hook() / gtk_about_dialog_set_url_hook()
   // Installs a global function to be called whenever the user activates a
   // URL link in an about dialog.
   // Since 2.18 there exists a default function which uses gtk_show_uri(). To
   // deactivate it, you can pass %NULL for @func.
   // RETURNS: the previous URL hook.
   // <func>: a function to call when a URL link is activated.
   // <data>: data to pass to @func
   // <destroy>: #GDestroyNotify for @data
   static AboutDialogActivateLinkFunc set_url_hook(AboutDialogActivateLinkFunc func, void* data, GLib2.DestroyNotify destroy) {
      return gtk_about_dialog_set_url_hook(func, data, destroy);
   }

   // Returns the string which are displayed in the artists tab
   // of the secondary credits dialog.
   // %NULL-terminated string array containing the artists. The array is
   // owned by the about dialog and must not be modified.
   // RETURNS: A
   char** get_artists() {
      return gtk_about_dialog_get_artists(&this);
   }

   // Returns the string which are displayed in the authors tab
   // of the secondary credits dialog.
   // %NULL-terminated string array containing the authors. The array is
   // owned by the about dialog and must not be modified.
   // RETURNS: A
   char** get_authors() {
      return gtk_about_dialog_get_authors(&this);
   }

   // Returns the comments string.
   // dialog and must not be modified.
   // RETURNS: The comments. The string is owned by the about
   char* get_comments() {
      return gtk_about_dialog_get_comments(&this);
   }

   // Returns the copyright string.
   // dialog and must not be modified.
   // RETURNS: The copyright string. The string is owned by the about
   char* get_copyright() {
      return gtk_about_dialog_get_copyright(&this);
   }

   // Returns the string which are displayed in the documenters
   // tab of the secondary credits dialog.
   // %NULL-terminated string array containing the documenters. The
   // array is owned by the about dialog and must not be modified.
   // RETURNS: A
   char** get_documenters() {
      return gtk_about_dialog_get_documenters(&this);
   }

   // Returns the license information.
   // dialog and must not be modified.
   // RETURNS: The license information. The string is owned by the about
   char* get_license() {
      return gtk_about_dialog_get_license(&this);
   }

   // Returns the pixbuf displayed as logo in the about dialog.
   // pixbuf is owned by the about dialog. If you want to keep a
   // reference to it, you have to call g_object_ref() on it.
   // RETURNS: the pixbuf displayed as logo. The
   GdkPixbuf2.Pixbuf* get_logo() {
      return gtk_about_dialog_get_logo(&this);
   }

   // Returns the icon name displayed as logo in the about dialog.
   // owned by the dialog. If you want to keep a reference
   // to it, you have to call g_strdup() on it.
   // RETURNS: the icon name displayed as logo. The string is
   char* get_logo_icon_name() {
      return gtk_about_dialog_get_logo_icon_name(&this);
   }

   // Returns the program name displayed in the about dialog.
   // dialog and must not be modified.
   // RETURNS: The program name. The string is owned by the about
   char* get_name() {
      return gtk_about_dialog_get_name(&this);
   }

   // Returns the program name displayed in the about dialog.
   // dialog and must not be modified.
   // RETURNS: The program name. The string is owned by the about
   char* get_program_name() {
      return gtk_about_dialog_get_program_name(&this);
   }

   // Returns the translator credits string which is displayed
   // in the translators tab of the secondary credits dialog.
   // owned by the about dialog and must not be modified.
   // RETURNS: The translator credits string. The string is
   char* get_translator_credits() {
      return gtk_about_dialog_get_translator_credits(&this);
   }

   // Returns the version string.
   // dialog and must not be modified.
   // RETURNS: The version string. The string is owned by the about
   char* get_version() {
      return gtk_about_dialog_get_version(&this);
   }

   // Returns the website URL.
   // dialog and must not be modified.
   // RETURNS: The website URL. The string is owned by the about
   char* get_website() {
      return gtk_about_dialog_get_website(&this);
   }

   // Returns the label used for the website link.
   // owned by the about dialog and must not be modified.
   // RETURNS: The label used for the website link. The string is
   char* get_website_label() {
      return gtk_about_dialog_get_website_label(&this);
   }

   // Returns whether the license text in @about is
   // automatically wrapped.
   // RETURNS: %TRUE if the license text is wrapped
   int get_wrap_license() {
      return gtk_about_dialog_get_wrap_license(&this);
   }

   // Sets the strings which are displayed in the artists tab
   // of the secondary credits dialog.
   // <artists>: a %NULL-terminated array of strings
   void set_artists(char** artists) {
      gtk_about_dialog_set_artists(&this, artists);
   }

   // Sets the strings which are displayed in the authors tab
   // of the secondary credits dialog.
   // <authors>: a %NULL-terminated array of strings
   void set_authors(char** authors) {
      gtk_about_dialog_set_authors(&this, authors);
   }

   // Sets the comments string to display in the about dialog.
   // This should be a short string of one or two lines.
   // <comments>: a comments string
   void set_comments(char* comments=null) {
      gtk_about_dialog_set_comments(&this, comments);
   }

   // Sets the copyright string to display in the about dialog.
   // This should be a short string of one or two lines.
   // <copyright>: (allow-none) the copyright string
   void set_copyright(char* copyright) {
      gtk_about_dialog_set_copyright(&this, copyright);
   }

   // Sets the strings which are displayed in the documenters tab
   // of the secondary credits dialog.
   // <documenters>: a %NULL-terminated array of strings
   void set_documenters(char** documenters) {
      gtk_about_dialog_set_documenters(&this, documenters);
   }

   // Sets the license information to be displayed in the secondary
   // license dialog. If @license is %NULL, the license button is
   // hidden.
   // <license>: the license information or %NULL
   void set_license(char* license=null) {
      gtk_about_dialog_set_license(&this, license);
   }

   // Sets the pixbuf to be displayed as logo in the about dialog.
   // If it is %NULL, the default window icon set with
   // gtk_window_set_default_icon() will be used.
   // <logo>: a #GdkPixbuf, or %NULL
   void set_logo(GdkPixbuf2.Pixbuf* logo=null) {
      gtk_about_dialog_set_logo(&this, logo);
   }

   // Sets the pixbuf to be displayed as logo in the about dialog.
   // If it is %NULL, the default window icon set with
   // gtk_window_set_default_icon() will be used.
   // <icon_name>: an icon name, or %NULL
   void set_logo_icon_name(char* icon_name=null) {
      gtk_about_dialog_set_logo_icon_name(&this, icon_name);
   }

   // Sets the name to display in the about dialog.
   // If this is not set, it defaults to g_get_application_name().
   // <name>: the program name
   void set_name(char* name=null) {
      gtk_about_dialog_set_name(&this, name);
   }

   // Sets the name to display in the about dialog.
   // If this is not set, it defaults to g_get_application_name().
   // <name>: the program name
   void set_program_name(char* name) {
      gtk_about_dialog_set_program_name(&this, name);
   }

   // Sets the translator credits string which is displayed in
   // the translators tab of the secondary credits dialog.
   // The intended use for this string is to display the translator
   // of the language which is currently used in the user interface.
   // Using gettext(), a simple way to achieve that is to mark the
   // string for translation:
   // |[
   // gtk_about_dialog_set_translator_credits (about, _("translator-credits"));
   // ]|
   // It is a good idea to use the customary msgid "translator-credits" for this
   // purpose, since translators will already know the purpose of that msgid, and
   // since #GtkAboutDialog will detect if "translator-credits" is untranslated
   // and hide the tab.
   // <translator_credits>: the translator credits
   void set_translator_credits(char* translator_credits=null) {
      gtk_about_dialog_set_translator_credits(&this, translator_credits);
   }

   // Sets the version string to display in the about dialog.
   // <version>: the version string
   void set_version(char* version_=null) {
      gtk_about_dialog_set_version(&this, version_);
   }

   // Sets the URL to use for the website link.
   // Note that that the hook functions need to be set up
   // before calling this function.
   // <website>: a URL string starting with "http://"
   void set_website(char* website=null) {
      gtk_about_dialog_set_website(&this, website);
   }

   // Sets the label to be used for the website link.
   // It defaults to the website URL.
   // <website_label>: the label used for the website link
   void set_website_label(char* website_label) {
      gtk_about_dialog_set_website_label(&this, website_label);
   }

   // Sets whether the license text in @about is
   // automatically wrapped.
   // <wrap_license>: whether to wrap the license
   void set_wrap_license(int wrap_license) {
      gtk_about_dialog_set_wrap_license(&this, wrap_license);
   }

   // The signal which gets emitted to activate a URI.
   // Applications may connect to it to override the default behaviour,
   // which is to call gtk_show_uri().
   // RETURNS: %TRUE if the link has been activated
   // <uri>: the URI that is activated
   extern (C) alias static c_int function (AboutDialog* this_, char* uri, void* user_data=null) signal_activate_link;

   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-link", CB/*:signal_activate_link*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-link",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// The type of a function which is called when a URL or email
// link is activated.
// <about>: the #GtkAboutDialog in which the link was activated
// <link_>: the URL or email address to which the activated link points
// <data>: user data that was passed when the function was registered with gtk_about_dialog_set_email_hook() or gtk_about_dialog_set_url_hook()
extern (C) alias void function (AboutDialog* about, char* link_, void* data) AboutDialogActivateLinkFunc;

struct AboutDialogClass {
   DialogClass parent_class;
   extern (C) int function (AboutDialog* dialog, char* uri) activate_link;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

enum AccelFlags {
   VISIBLE = 1,
   LOCKED = 2,
   MASK = 7
}

// A #GtkAccelGroup represents a group of keyboard accelerators,
// typically attached to a toplevel #GtkWindow (with
// gtk_window_add_accel_group()). Usually you won't need to create a
// #GtkAccelGroup directly; instead, when using #GtkItemFactory, GTK+
// automatically sets up the accelerators for your menus in the item
// factory's #GtkAccelGroup.
// Note that <firstterm>accelerators</firstterm> are different from
// <firstterm>mnemonics</firstterm>. Accelerators are shortcuts for
// activating a menu item; they appear alongside the menu item they're a
// shortcut for. For example "Ctrl+Q" might appear alongside the "Quit"
// menu item. Mnemonics are shortcuts for GUI elements such as text
// entries or buttons; they appear as underlined characters. See
// gtk_label_new_with_mnemonic(). Menu items can have both accelerators
// and mnemonics, of course.
struct AccelGroup /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   uint lock_count;
   Gdk2.ModifierType modifier_mask;
   GLib2.SList* acceleratables;
   uint n_accels;
   AccelGroupEntry* priv_accels;


   // Creates a new #GtkAccelGroup.
   // RETURNS: a new #GtkAccelGroup object
   static AccelGroup* /*new*/ new_() {
      return gtk_accel_group_new();
   }

   // Finds the #GtkAccelGroup to which @closure is connected; 
   // see gtk_accel_group_connect().
   // RETURNS: the #GtkAccelGroup to which @closure is connected, or %NULL.
   // <closure>: a #GClosure
   static AccelGroup* from_accel_closure(GObject2.Closure* closure) {
      return gtk_accel_group_from_accel_closure(closure);
   }

   // Finds the first accelerator in @accel_group 
   // that matches @accel_key and @accel_mods, and
   // activates it.
   // RETURNS: %TRUE if an accelerator was activated and handled this keypress
   // <accel_quark>: the quark for the accelerator name
   // <acceleratable>: the #GObject, usually a #GtkWindow, on which to activate the accelerator.
   // <accel_key>: accelerator keyval from a key event
   // <accel_mods>: keyboard state mask from a key event
   int activate(GLib2.Quark accel_quark, GObject2.Object* acceleratable, uint accel_key, Gdk2.ModifierType accel_mods) {
      return gtk_accel_group_activate(&this, accel_quark, acceleratable, accel_key, accel_mods);
   }

   // Installs an accelerator in this group. When @accel_group is being activated
   // in response to a call to gtk_accel_groups_activate(), @closure will be
   // invoked if the @accel_key and @accel_mods from gtk_accel_groups_activate()
   // match those of this connection.
   // The signature used for the @closure is that of #GtkAccelGroupActivate.
   // Note that, due to implementation details, a single closure can only be
   // connected to one accelerator group.
   // <accel_key>: key value of the accelerator
   // <accel_mods>: modifier combination of the accelerator
   // <accel_flags>: a flag mask to configure this accelerator
   // <closure>: closure to be executed upon accelerator activation
   void connect(uint accel_key, Gdk2.ModifierType accel_mods, AccelFlags accel_flags, GObject2.Closure* closure) {
      gtk_accel_group_connect(&this, accel_key, accel_mods, accel_flags, closure);
   }

   // Installs an accelerator in this group, using an accelerator path to look
   // up the appropriate key and modifiers (see gtk_accel_map_add_entry()).
   // When @accel_group is being activated in response to a call to
   // gtk_accel_groups_activate(), @closure will be invoked if the @accel_key and
   // for the path.
   // The signature used for the @closure is that of #GtkAccelGroupActivate.
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: path used for determining key and modifiers.
   // <closure>: closure to be executed upon accelerator activation
   void connect_by_path(char* accel_path, GObject2.Closure* closure) {
      gtk_accel_group_connect_by_path(&this, accel_path, closure);
   }

   // Removes an accelerator previously installed through
   // gtk_accel_group_connect().
   // Since 2.20 @closure can be %NULL.
   // RETURNS: %TRUE if the closure was found and got disconnected
   // <closure>: the closure to remove from this accelerator group, or %NULL to remove all closures
   int disconnect(GObject2.Closure* closure=null) {
      return gtk_accel_group_disconnect(&this, closure);
   }

   // Removes an accelerator previously installed through
   // gtk_accel_group_connect().
   // RETURNS: %TRUE if there was an accelerator which could be removed, %FALSE otherwise
   // <accel_key>: key value of the accelerator
   // <accel_mods>: modifier combination of the accelerator
   int disconnect_key(uint accel_key, Gdk2.ModifierType accel_mods) {
      return gtk_accel_group_disconnect_key(&this, accel_key, accel_mods);
   }

   // Unintrospectable method: find() / gtk_accel_group_find()
   // Finds the first entry in an accelerator group for which
   // RETURNS: the key of the first entry passing
   // <find_func>: a function to filter the entries of @accel_group with
   // <data>: data to pass to @find_func
   AccelKey* find(AccelGroupFindFunc find_func, void* data) {
      return gtk_accel_group_find(&this, find_func, data);
   }

   // Locks are added and removed using gtk_accel_group_lock() and
   // gtk_accel_group_unlock().
   // %FALSE otherwise.
   // RETURNS: %TRUE if there are 1 or more locks on the @accel_group,
   int get_is_locked() {
      return gtk_accel_group_get_is_locked(&this);
   }

   // Gets a #GdkModifierType representing the mask for this
   // RETURNS: the modifier mask for this accel group.
   Gdk2.ModifierType get_modifier_mask() {
      return gtk_accel_group_get_modifier_mask(&this);
   }

   // Locks the given accelerator group.
   // Locking an acelerator group prevents the accelerators contained
   // within it to be changed during runtime. Refer to
   // gtk_accel_map_change_entry() about runtime accelerator changes.
   // If called more than once, @accel_group remains locked until
   // gtk_accel_group_unlock() has been called an equivalent number
   // of times.
   void lock() {
      gtk_accel_group_lock(&this);
   }

   // Unintrospectable method: query() / gtk_accel_group_query()
   // Queries an accelerator group for all entries matching @accel_key and
   // RETURNS: an array of @n_entries #GtkAccelGroupEntry elements, or %NULL. The array is owned by GTK+ and must not be freed.
   // <accel_key>: key value of the accelerator
   // <accel_mods>: modifier combination of the accelerator
   // <n_entries>: location to return the number of entries found, or %NULL
   AccelGroupEntry* query(uint accel_key, Gdk2.ModifierType accel_mods, uint* n_entries=null) {
      return gtk_accel_group_query(&this, accel_key, accel_mods, n_entries);
   }
   // Undoes the last call to gtk_accel_group_lock() on this @accel_group.
   void unlock() {
      gtk_accel_group_unlock(&this);
   }

   // The accel-activate signal is an implementation detail of
   // #GtkAccelGroup and not meant to be used by applications.
   // RETURNS: %TRUE if the accelerator was activated
   // <acceleratable>: the object on which the accelerator was activated
   // <keyval>: the accelerator keyval
   // <modifier>: the modifier combination of the accelerator
   extern (C) alias static c_int function (AccelGroup* this_, GObject2.Object* acceleratable, c_uint keyval, Gdk2.ModifierType* modifier, void* user_data=null) signal_accel_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:"accel-activate", CB/*:signal_accel_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accel-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The accel-changed signal is emitted when a #GtkAccelGroupEntry
   // is added to or removed from the accel group. 
   // Widgets like #GtkAccelLabel which display an associated 
   // accelerator should connect to this signal, and rebuild 
   // their visual representation if the @accel_closure is theirs.
   // <keyval>: the accelerator keyval
   // <modifier>: the modifier combination of the accelerator
   // <accel_closure>: the #GClosure of the accelerator
   extern (C) alias static void function (AccelGroup* this_, c_uint keyval, Gdk2.ModifierType* modifier, GObject2.Closure* accel_closure, void* user_data=null) signal_accel_changed;
   ulong signal_connect(string name:"accel-changed", CB/*:signal_accel_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accel-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

extern (C) alias int function (AccelGroup* accel_group, GObject2.Object* acceleratable, uint keyval, Gdk2.ModifierType modifier) AccelGroupActivate;

struct AccelGroupClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (AccelGroup* accel_group, uint keyval, Gdk2.ModifierType modifier, GObject2.Closure* accel_closure) accel_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct AccelGroupEntry {
   AccelKey key;
   GObject2.Closure* closure;
   GLib2.Quark accel_path_quark;
}

extern (C) alias int function (AccelKey* key, GObject2.Closure* closure, void* data) AccelGroupFindFunc;

struct AccelKey {
   uint accel_key;
   Gdk2.ModifierType accel_mods;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "accel_flags", 16,
    uint, "__dummy32A", 16));
}


// The #GtkAccelLabel widget is a subclass of #GtkLabel that also displays an
// accelerator key on the right of the label text, e.g. 'Ctl+S'.
// It is commonly used in menus to show the keyboard short-cuts for commands.
// The accelerator key to display is not set explicitly.
// Instead, the #GtkAccelLabel displays the accelerators which have been added to
// a particular widget. This widget is set by calling
// gtk_accel_label_set_accel_widget().
// For example, a #GtkMenuItem widget may have an accelerator added to emit the
// "activate" signal when the 'Ctl+S' key combination is pressed.
// A #GtkAccelLabel is created and added to the #GtkMenuItem, and
// gtk_accel_label_set_accel_widget() is called with the #GtkMenuItem as the
// second argument. The #GtkAccelLabel will now display 'Ctl+S' after its label.
// Note that creating a #GtkMenuItem with gtk_menu_item_new_with_label() (or
// one of the similar functions for #GtkCheckMenuItem and #GtkRadioMenuItem)
// automatically adds a #GtkAccelLabel to the #GtkMenuItem and calls
// gtk_accel_label_set_accel_widget() to set it up for you.
// A #GtkAccelLabel will only display accelerators which have %GTK_ACCEL_VISIBLE
// set (see #GtkAccelFlags).
// A #GtkAccelLabel can display multiple accelerators and even signal names,
// though it is almost always used to display just one accelerator key.
// <example>
// <title>Creating a simple menu item with an accelerator key.</title>
// <programlisting>
// GtkWidget *save_item;
// GtkAccelGroup *accel_group;
// /<!---->* Create a GtkAccelGroup and add it to the window. *<!---->/
// accel_group = gtk_accel_group_new (<!-- -->);
// gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
// /<!---->* Create the menu item using the convenience function. *<!---->/
// save_item = gtk_menu_item_new_with_label ("Save");
// gtk_widget_show (save_item);
// gtk_container_add (GTK_CONTAINER (menu), save_item);
// /<!---->* Now add the accelerator to the GtkMenuItem. Note that since we called
// gtk_menu_item_new_with_label(<!-- -->) to create the GtkMenuItem the
// GtkAccelLabel is automatically set up to display the GtkMenuItem
// accelerators. We just need to make sure we use GTK_ACCEL_VISIBLE here. *<!---->/
// gtk_widget_add_accelerator (save_item, "activate", accel_group,
// GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
// </programlisting>
// </example>
struct AccelLabel /* : Label */ {
   alias label this;
   alias label super_;
   Label label;
   uint gtk_reserved, accel_padding;
   Widget* accel_widget;
   GObject2.Closure* accel_closure;
   AccelGroup* accel_group;
   char* accel_string;
   ushort accel_string_width;


   // Creates a new #GtkAccelLabel.
   // RETURNS: a new #GtkAccelLabel.
   // <string>: the label string. Must be non-%NULL.
   static AccelLabel* new_(char* string_) {
      return gtk_accel_label_new(string_);
   }

   // Fetches the widget monitored by this accelerator label. See
   // gtk_accel_label_set_accel_widget().
   // RETURNS: the object monitored by the accelerator label, or %NULL.
   Widget* get_accel_widget() {
      return gtk_accel_label_get_accel_widget(&this);
   }

   // Returns the width needed to display the accelerator key(s).
   // This is used by menus to align all of the #GtkMenuItem widgets, and shouldn't
   // be needed by applications.
   // RETURNS: the width needed to display the accelerator key(s).
   uint get_accel_width() {
      return gtk_accel_label_get_accel_width(&this);
   }

   // Recreates the string representing the accelerator keys.
   // This should not be needed since the string is automatically updated whenever
   // accelerators are added or removed from the associated widget.
   // RETURNS: always returns %FALSE.
   int refetch() {
      return gtk_accel_label_refetch(&this);
   }

   // Sets the closure to be monitored by this accelerator label. The closure
   // must be connected to an accelerator group; see gtk_accel_group_connect().
   // <accel_closure>: the closure to monitor for accelerator changes.
   void set_accel_closure(GObject2.Closure* accel_closure) {
      gtk_accel_label_set_accel_closure(&this, accel_closure);
   }

   // Sets the widget to be monitored by this accelerator label.
   // <accel_widget>: the widget to be monitored.
   void set_accel_widget(Widget* accel_widget) {
      gtk_accel_label_set_accel_widget(&this, accel_widget);
   }
}

struct AccelLabelClass {
   LabelClass parent_class;
   char* signal_quote1, signal_quote2, mod_name_shift, mod_name_control, mod_name_alt, mod_separator, accel_seperator;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "latin1_to_char", 1,
    uint, "__dummy32A", 31));
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct AccelMap /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Registers a new accelerator with the global accelerator map.
   // This function should only be called once per @accel_path
   // with the canonical @accel_key and @accel_mods for this path.
   // To change the accelerator during runtime programatically, use
   // gtk_accel_map_change_entry().
   // The accelerator path must consist of "&lt;WINDOWTYPE&gt;/Category1/Category2/.../Action",
   // where &lt;WINDOWTYPE&gt; should be a unique application-specific identifier, that
   // corresponds to the kind of window the accelerator is being used in, e.g. "Gimp-Image",
   // "Abiword-Document" or "Gnumeric-Settings".
   // The Category1/.../Action portion is most appropriately chosen by the action the
   // accelerator triggers, i.e. for accelerators on menu items, choose the item's menu path,
   // e.g. "File/Save As", "Image/View/Zoom" or "Edit/Select All".
   // So a full valid accelerator path may look like:
   // "&lt;Gimp-Toolbox&gt;/File/Dialogs/Tool Options...".
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: valid accelerator path
   // <accel_key>: the accelerator key
   // <accel_mods>: the accelerator modifiers
   static void add_entry(char* accel_path, uint accel_key, Gdk2.ModifierType accel_mods) {
      gtk_accel_map_add_entry(accel_path, accel_key, accel_mods);
   }

   // Adds a filter to the global list of accel path filters.
   // Accel map entries whose accel path matches one of the filters
   // are skipped by gtk_accel_map_foreach().
   // This function is intended for GTK+ modules that create their own
   // menus, but don't want them to be saved into the applications accelerator
   // map dump.
   // <filter_pattern>: a pattern (see #GPatternSpec)
   static void add_filter(char* filter_pattern) {
      gtk_accel_map_add_filter(filter_pattern);
   }

   // Changes the @accel_key and @accel_mods currently associated with @accel_path.
   // Due to conflicts with other accelerators, a change may not always be possible,
   // conflicts. A change will only occur if all conflicts could be resolved (which
   // might not be the case if conflicting accelerators are locked). Successful
   // changes are indicated by a %TRUE return value.
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // RETURNS: %TRUE if the accelerator could be changed, %FALSE otherwise
   // <accel_path>: a valid accelerator path
   // <accel_key>: the new accelerator key
   // <accel_mods>: the new accelerator modifiers
   // <replace>: %TRUE if other accelerators may be deleted upon conflicts
   static int change_entry(char* accel_path, uint accel_key, Gdk2.ModifierType accel_mods, int replace) {
      return gtk_accel_map_change_entry(accel_path, accel_key, accel_mods, replace);
   }

   // Unintrospectable function: foreach() / gtk_accel_map_foreach()
   // Loops over the entries in the accelerator map whose accel path 
   // doesn't match any of the filters added with gtk_accel_map_add_filter(), 
   // and execute @foreach_func on each. The signature of @foreach_func is 
   // that of #GtkAccelMapForeach, the @changed parameter indicates whether
   // this accelerator was changed during runtime (thus, would need
   // saving during an accelerator map dump).
   // <data>: data to be passed into @foreach_func
   // <foreach_func>: function to be executed for each accel map entry which is not filtered out
   static void foreach_(void* data, AccelMapForeach foreach_func) {
      gtk_accel_map_foreach(data, foreach_func);
   }

   // Unintrospectable function: foreach_unfiltered() / gtk_accel_map_foreach_unfiltered()
   // Loops over all entries in the accelerator map, and execute
   // #GtkAccelMapForeach, the @changed parameter indicates whether
   // this accelerator was changed during runtime (thus, would need
   // saving during an accelerator map dump).
   // <data>: data to be passed into @foreach_func
   // <foreach_func>: function to be executed for each accel map entry
   static void foreach_unfiltered(void* data, AccelMapForeach foreach_func) {
      gtk_accel_map_foreach_unfiltered(data, foreach_func);
   }

   // Unintrospectable function: get() / gtk_accel_map_get()
   // Gets the singleton global #GtkAccelMap object. This object
   // is useful only for notification of changes to the accelerator
   // map via the ::changed signal; it isn't a parameter to the
   // other accelerator map functions.
   // RETURNS: the global #GtkAccelMap object
   static AccelMap* get() {
      return gtk_accel_map_get();
   }

   // Parses a file previously saved with gtk_accel_map_save() for
   // accelerator specifications, and propagates them accordingly.
   // <file_name>: a file containing accelerator specifications, in the GLib file name encoding
   static void load(char* file_name) {
      gtk_accel_map_load(file_name);
   }

   // Filedescriptor variant of gtk_accel_map_load().
   // Note that the file descriptor will not be closed by this function.
   // <fd>: a valid readable file descriptor
   static void load_fd(int fd) {
      gtk_accel_map_load_fd(fd);
   }

   // #GScanner variant of gtk_accel_map_load().
   // <scanner>: a #GScanner which has already been provided with an input file
   static void load_scanner(GLib2.Scanner* scanner) {
      gtk_accel_map_load_scanner(scanner);
   }

   // Locks the given accelerator path. If the accelerator map doesn't yet contain
   // an entry for @accel_path, a new one is created.
   // Locking an accelerator path prevents its accelerator from being changed 
   // during runtime. A locked accelerator path can be unlocked by 
   // gtk_accel_map_unlock_path(). Refer to gtk_accel_map_change_entry() 
   // for information about runtime accelerator changes.
   // If called more than once, @accel_path remains locked until
   // gtk_accel_map_unlock_path() has been called an equivalent number
   // of times.
   // Note that locking of individual accelerator paths is independent from 
   // locking the #GtkAccelGroup containing them. For runtime accelerator
   // changes to be possible both the accelerator path and its #GtkAccelGroup
   // have to be unlocked.
   // <accel_path>: a valid accelerator path
   static void lock_path(char* accel_path) {
      gtk_accel_map_lock_path(accel_path);
   }

   // Looks up the accelerator entry for @accel_path and fills in @key.
   // RETURNS: %TRUE if @accel_path is known, %FALSE otherwise
   // <accel_path>: a valid accelerator path
   // <key>: the accelerator key to be filled in (optional)
   static int lookup_entry(char* accel_path, AccelKey* key) {
      return gtk_accel_map_lookup_entry(accel_path, key);
   }

   // Saves current accelerator specifications (accelerator path, key
   // and modifiers) to @file_name.
   // The file is written in a format suitable to be read back in by
   // gtk_accel_map_load().
   // <file_name>: the name of the file to contain accelerator specifications, in the GLib file name encoding
   static void save(char* file_name) {
      gtk_accel_map_save(file_name);
   }

   // Filedescriptor variant of gtk_accel_map_save().
   // Note that the file descriptor will not be closed by this function.
   // <fd>: a valid writable file descriptor
   static void save_fd(int fd) {
      gtk_accel_map_save_fd(fd);
   }

   // Undoes the last call to gtk_accel_map_lock_path() on this @accel_path.
   // Refer to gtk_accel_map_lock_path() for information about accelerator path locking.
   // <accel_path>: a valid accelerator path
   static void unlock_path(char* accel_path) {
      gtk_accel_map_unlock_path(accel_path);
   }

   // Notifies of a change in the global accelerator map.
   // The path is also used as the detail for the signal,
   // so it is possible to connect to
   // changed::<replaceable>accel_path</replaceable>.
   // <accel_path>: the path of the accelerator that changed
   // <accel_key>: the key value for the new accelerator
   // <accel_mods>: the modifier mask for the new accelerator
   extern (C) alias static void function (AccelMap* this_, char* accel_path, c_uint accel_key, Gdk2.ModifierType* accel_mods, 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);
   }
}

struct AccelMapClass {
}

extern (C) alias void function (void* data, char* accel_path, uint accel_key, Gdk2.ModifierType accel_mods, int changed) AccelMapForeach;

struct Accessible /* : Atk.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   Atk.Object parent;
   Widget* widget;


   // This function specifies the callback function to be called when the widget
   // corresponding to a GtkAccessible is destroyed.
   void connect_widget_destroyed() {
      gtk_accessible_connect_widget_destroyed(&this);
   }

   // Gets the #GtkWidget corresponding to the #GtkAccessible. The returned widget
   // does not have a reference added, so you do not need to unref it.
   // the #GtkAccessible, or %NULL.
   // RETURNS: pointer to the #GtkWidget corresponding to
   Widget* get_widget() {
      return gtk_accessible_get_widget(&this);
   }

   // Sets the #GtkWidget corresponding to the #GtkAccessible.
   // <widget>: a #GtkWidget
   void set_widget(Widget* widget) {
      gtk_accessible_set_widget(&this, widget);
   }
}

struct AccessibleClass {
   Atk.ObjectClass parent_class;
   extern (C) void function (Accessible* accessible) connect_widget_destroyed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// Actions represent operations that the user can be perform, along with
// some information how it should be presented in the interface. Each action
// provides methods to create icons, menu items and toolbar items
// representing itself.
// As well as the callback that is called when the action gets activated,
// the following also gets associated with the action:
// <itemizedlist>
// <listitem><para>a name (not translated, for path lookup)</para></listitem>
// <listitem><para>a label (translated, for display)</para></listitem>
// <listitem><para>an accelerator</para></listitem>
// <listitem><para>whether label indicates a stock id</para></listitem>
// <listitem><para>a tooltip (optional, translated)</para></listitem>
// <listitem><para>a toolbar label (optional, shorter than label)</para></listitem>
// </itemizedlist>
// The action will also have some state information:
// <itemizedlist>
// <listitem><para>visible (shown/hidden)</para></listitem>
// <listitem><para>sensitive (enabled/disabled)</para></listitem>
// </itemizedlist>
// Apart from regular actions, there are <link linkend="GtkToggleAction">toggle
// actions</link>, which can be toggled between two states and <link
// linkend="GtkRadioAction">radio actions</link>, of which only one in a group
// can be in the "active" state. Other actions can be implemented as #GtkAction
// subclasses.
// Each action can have one or more proxy menu item, toolbar button or
// other proxy widgets.  Proxies mirror the state of the action (text
// label, tooltip, icon, visible, sensitive, etc), and should change when
// the action's state changes. When the proxy is activated, it should
// activate its action.
struct Action /* : GObject.Object */ {
   alias object this;
   alias object super_;
   GObject2.Object object;
   private ActionPrivate* private_data;


   // Creates a new #GtkAction object. To add the action to a
   // #GtkActionGroup and set the accelerator for the action,
   // call gtk_action_group_add_action_with_accel().
   // See <xref linkend="XML-UI"/> for information on allowed action
   // names.
   // RETURNS: a new #GtkAction
   // <name>: A unique name for the action
   // <label>: the label displayed in menu items and on buttons, or %NULL
   // <tooltip>: a tooltip for the action, or %NULL
   // <stock_id>: the stock icon to display in widgets representing the action, or %NULL
   static Action* /*new*/ new_(char* name, char* label, char* tooltip, char* stock_id) {
      return gtk_action_new(name, label, tooltip, stock_id);
   }

   // Emits the "activate" signal on the specified action, if it isn't 
   // insensitive. This gets called by the proxy widgets when they get 
   // activated.
   // It can also be used to manually activate an action.
   void activate() {
      gtk_action_activate(&this);
   }

   // Disable activation signals from the action 
   // This is needed when updating the state of your proxy
   // #GtkActivatable widget could result in calling gtk_action_activate(),
   // this is a convenience function to avoid recursing in those
   // cases (updating toggle state for instance).
   void block_activate() {
      gtk_action_block_activate(&this);
   }

   // Disables calls to the gtk_action_activate()
   // function by signals on the given proxy widget.  This is used to
   // break notification loops for things like check or radio actions.
   // This function is intended for use by action implementations.
   // action directly so this doesnt apply anymore.
   // <proxy>: a proxy widget
   void block_activate_from(Widget* proxy) {
      gtk_action_block_activate_from(&this, proxy);
   }

   // Installs the accelerator for @action if @action has an
   // accel path and group. See gtk_action_set_accel_path() and 
   // gtk_action_set_accel_group()
   // Since multiple proxies may independently trigger the installation
   // of the accelerator, the @action counts the number of times this
   // function has been called and doesn't remove the accelerator until
   // gtk_action_disconnect_accelerator() has been called as many times.
   void connect_accelerator() {
      gtk_action_connect_accelerator(&this);
   }

   // Connects a widget to an action object as a proxy.  Synchronises 
   // various properties of the action with the widget (such as label 
   // text, icon, tooltip, etc), and attaches a callback so that the 
   // action gets activated when the proxy widget does.
   // If the widget is already connected to an action, it is disconnected
   // first.
   // <proxy>: the proxy widget
   void connect_proxy(Widget* proxy) {
      gtk_action_connect_proxy(&this, proxy);
   }

   // This function is intended for use by action implementations to
   // create icons displayed in the proxy widgets.
   // RETURNS: a widget that displays the icon for this action.
   // <icon_size>: the size of the icon that should be created.
   Widget* create_icon(int icon_size) {
      return gtk_action_create_icon(&this, icon_size);
   }

   // If @action provides a #GtkMenu widget as a submenu for the menu
   // item or the toolbar item it creates, this function returns an
   // instance of that menu.
   // action, or %NULL.
   // RETURNS: the menu item provided by the
   Widget* create_menu() {
      return gtk_action_create_menu(&this);
   }

   // Creates a menu item widget that proxies for the given action.
   // RETURNS: a menu item connected to the action.
   Widget* create_menu_item() {
      return gtk_action_create_menu_item(&this);
   }

   // Creates a toolbar item widget that proxies for the given action.
   // RETURNS: a toolbar item connected to the action.
   Widget* create_tool_item() {
      return gtk_action_create_tool_item(&this);
   }
   // Undoes the effect of one call to gtk_action_connect_accelerator().
   void disconnect_accelerator() {
      gtk_action_disconnect_accelerator(&this);
   }

   // Disconnects a proxy widget from an action.  
   // Does <emphasis>not</emphasis> destroy the widget, however.
   // <proxy>: the proxy widget
   void disconnect_proxy(Widget* proxy) {
      gtk_action_disconnect_proxy(&this, proxy);
   }

   // Returns the accel closure for this action.
   // returned closure is owned by GTK+ and must not be unreffed
   // or modified.
   // RETURNS: the accel closure for this action. The
   GObject2.Closure* get_accel_closure() {
      return gtk_action_get_accel_closure(&this);
   }

   // Returns the accel path for this action.  
   // if none is set. The returned string is owned by GTK+ 
   // and must not be freed or modified.
   // RETURNS: the accel path for this action, or %NULL
   char* get_accel_path() {
      return gtk_action_get_accel_path(&this);
   }

   // Returns whether @action<!-- -->'s menu item proxies will ignore the
   // #GtkSettings:gtk-menu-images setting and always show their image,
   // if available.
   // RETURNS: %TRUE if the menu item proxies will always show their image
   int get_always_show_image() {
      return gtk_action_get_always_show_image(&this);
   }

   // Gets the gicon of @action.
   // RETURNS: The action's #GIcon if one is set.
   Gio2.Icon* get_gicon() {
      return gtk_action_get_gicon(&this);
   }

   // Gets the icon name of @action.
   // RETURNS: the icon name
   char* get_icon_name() {
      return gtk_action_get_icon_name(&this);
   }

   // Checks whether @action is important or not
   // RETURNS: whether @action is important
   int get_is_important() {
      return gtk_action_get_is_important(&this);
   }

   // Gets the label text of @action.
   // RETURNS: the label text
   char* get_label() {
      return gtk_action_get_label(&this);
   }

   // Returns the name of the action.
   // be freed.
   // RETURNS: the name of the action. The string belongs to GTK+ and should not
   char* get_name() {
      return gtk_action_get_name(&this);
   }

   // Returns the proxy widgets for an action.
   // See also gtk_widget_get_action().
   // and must not be modified.
   // RETURNS: a #GSList of proxy widgets. The list is owned by GTK+
   GLib2.SList* get_proxies() {
      return gtk_action_get_proxies(&this);
   }

   // Returns whether the action itself is sensitive. Note that this doesn't 
   // necessarily mean effective sensitivity. See gtk_action_is_sensitive() 
   // for that.
   // RETURNS: %TRUE if the action itself is sensitive.
   int get_sensitive() {
      return gtk_action_get_sensitive(&this);
   }

   // Gets the short label text of @action.
   // RETURNS: the short label text.
   char* get_short_label() {
      return gtk_action_get_short_label(&this);
   }

   // Gets the stock id of @action.
   // RETURNS: the stock id
   char* get_stock_id() {
      return gtk_action_get_stock_id(&this);
   }

   // Gets the tooltip text of @action.
   // RETURNS: the tooltip text
   char* get_tooltip() {
      return gtk_action_get_tooltip(&this);
   }

   // Returns whether the action itself is visible. Note that this doesn't 
   // necessarily mean effective visibility. See gtk_action_is_sensitive() 
   // for that.
   // RETURNS: %TRUE if the action itself is visible.
   int get_visible() {
      return gtk_action_get_visible(&this);
   }

   // Checks whether @action is visible when horizontal
   // RETURNS: whether @action is visible when horizontal
   int get_visible_horizontal() {
      return gtk_action_get_visible_horizontal(&this);
   }

   // Checks whether @action is visible when horizontal
   // RETURNS: whether @action is visible when horizontal
   int get_visible_vertical() {
      return gtk_action_get_visible_vertical(&this);
   }

   // Returns whether the action is effectively sensitive.
   // are both sensitive.
   // RETURNS: %TRUE if the action and its associated action group
   int is_sensitive() {
      return gtk_action_is_sensitive(&this);
   }

   // Returns whether the action is effectively visible.
   // are both visible.
   // RETURNS: %TRUE if the action and its associated action group
   int is_visible() {
      return gtk_action_is_visible(&this);
   }

   // Sets the #GtkAccelGroup in which the accelerator for this action
   // will be installed.
   // <accel_group>: a #GtkAccelGroup or %NULL
   void set_accel_group(AccelGroup* accel_group=null) {
      gtk_action_set_accel_group(&this, accel_group);
   }

   // Sets the accel path for this action.  All proxy widgets associated
   // with the action will have this accel path, so that their
   // accelerators are consistent.
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: the accelerator path
   void set_accel_path(char* accel_path) {
      gtk_action_set_accel_path(&this, accel_path);
   }

   // Sets whether @action<!-- -->'s menu item proxies will ignore the
   // #GtkSettings:gtk-menu-images setting and always show their image, if available.
   // Use this if the menu item would be useless or hard to use
   // without their image.
   // <always_show>: %TRUE if menuitem proxies should always show their image
   void set_always_show_image(int always_show) {
      gtk_action_set_always_show_image(&this, always_show);
   }

   // Sets the icon of @action.
   // <icon>: the #GIcon to set
   void set_gicon(Gio2.Icon* icon) {
      gtk_action_set_gicon(&this, icon);
   }

   // Sets the icon name on @action
   // <icon_name>: the icon name to set
   void set_icon_name(char* icon_name) {
      gtk_action_set_icon_name(&this, icon_name);
   }

   // Sets whether the action is important, this attribute is used
   // primarily by toolbar items to decide whether to show a label
   // or not.
   // <is_important>: %TRUE to make the action important
   void set_is_important(int is_important) {
      gtk_action_set_is_important(&this, is_important);
   }

   // Sets the label of @action.
   // <label>: the label text to set
   void set_label(char* label) {
      gtk_action_set_label(&this, label);
   }

   // Sets the ::sensitive property of the action to @sensitive. Note that 
   // this doesn't necessarily mean effective sensitivity. See 
   // gtk_action_is_sensitive() 
   // for that.
   // <sensitive>: %TRUE to make the action sensitive
   void set_sensitive(int sensitive) {
      gtk_action_set_sensitive(&this, sensitive);
   }

   // Sets a shorter label text on @action.
   // <short_label>: the label text to set
   void set_short_label(char* short_label) {
      gtk_action_set_short_label(&this, short_label);
   }

   // Sets the stock id on @action
   // <stock_id>: the stock id
   void set_stock_id(char* stock_id) {
      gtk_action_set_stock_id(&this, stock_id);
   }

   // Sets the tooltip text on @action
   // <tooltip>: the tooltip text
   void set_tooltip(char* tooltip) {
      gtk_action_set_tooltip(&this, tooltip);
   }

   // Sets the ::visible property of the action to @visible. Note that 
   // this doesn't necessarily mean effective visibility. See 
   // gtk_action_is_visible() 
   // for that.
   // <visible>: %TRUE to make the action visible
   void set_visible(int visible) {
      gtk_action_set_visible(&this, visible);
   }

   // Sets whether @action is visible when horizontal
   // <visible_horizontal>: whether the action is visible horizontally
   void set_visible_horizontal(int visible_horizontal) {
      gtk_action_set_visible_horizontal(&this, visible_horizontal);
   }

   // Sets whether @action is visible when vertical
   // <visible_vertical>: whether the action is visible vertically
   void set_visible_vertical(int visible_vertical) {
      gtk_action_set_visible_vertical(&this, visible_vertical);
   }
   // Reenable activation signals from the action
   void unblock_activate() {
      gtk_action_unblock_activate(&this);
   }

   // Re-enables calls to the gtk_action_activate()
   // function by signals on the given proxy widget.  This undoes the
   // blocking done by gtk_action_block_activate_from().
   // This function is intended for use by action implementations.
   // action directly so this doesnt apply anymore.
   // <proxy>: a proxy widget
   void unblock_activate_from(Widget* proxy) {
      gtk_action_unblock_activate_from(&this, proxy);
   }
   // The "activate" signal is emitted when the action is activated.
   extern (C) alias static void function (Action* this_, 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);
   }
}

struct ActionClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (Action* action) activate;
   Type menu_item_type, toolbar_item_type;
   // RETURNS: a menu item connected to the action.
   extern (C) Widget* function (Action* action) create_menu_item;
   // RETURNS: a toolbar item connected to the action.
   extern (C) Widget* function (Action* action) create_tool_item;
   // <proxy>: the proxy widget
   extern (C) void function (Action* action, Widget* proxy) connect_proxy;
   // <proxy>: the proxy widget
   extern (C) void function (Action* action, Widget* proxy) disconnect_proxy;
   // RETURNS: the menu item provided by the
   extern (C) Widget* function (Action* action) create_menu;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ActionEntry {
   char* name, stock_id, label, accelerator, tooltip;
   GObject2.Callback callback;
}

struct ActionGroup /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private ActionGroupPrivate* private_data;


   // Creates a new #GtkActionGroup object. The name of the action group
   // is used when associating <link linkend="Action-Accel">keybindings</link> 
   // with the actions.
   // RETURNS: the new #GtkActionGroup
   // <name>: the name of the action group.
   static ActionGroup* /*new*/ new_(char* name) {
      return gtk_action_group_new(name);
   }

   // Adds an action object to the action group. Note that this function
   // does not set up the accel path of the action, which can lead to problems
   // if a user tries to modify the accelerator of a menuitem associated with
   // the action. Therefore you must either set the accel path yourself with
   // gtk_action_set_accel_path(), or use 
   // <literal>gtk_action_group_add_action_with_accel (..., NULL)</literal>.
   // <action>: an action
   void add_action(Action* action) {
      gtk_action_group_add_action(&this, action);
   }

   // Adds an action object to the action group and sets up the accelerator.
   // If @accelerator is %NULL, attempts to use the accelerator associated 
   // with the stock_id of the action. 
   // Accel paths are set to
   // <literal>&lt;Actions&gt;/<replaceable>group-name</replaceable>/<replaceable>action-name</replaceable></literal>.
   // <action>: the action to add
   // <accelerator>: the accelerator for the action, in the format understood by gtk_accelerator_parse(), or "" for no accelerator, or %NULL to use the stock accelerator
   void add_action_with_accel(Action* action, char* accelerator=null) {
      gtk_action_group_add_action_with_accel(&this, action, accelerator);
   }

   // This is a convenience function to create a number of actions and add them 
   // to the action group.
   // The "activate" signals of the actions are connected to the callbacks and 
   // their accel paths are set to 
   // <literal>&lt;Actions&gt;/<replaceable>group-name</replaceable>/<replaceable>action-name</replaceable></literal>.
   // <entries>: an array of action descriptions
   // <n_entries>: the number of entries
   // <user_data>: data to pass to the action callbacks
   void add_actions(ActionEntry* entries, uint n_entries, void* user_data) {
      gtk_action_group_add_actions(&this, entries, n_entries, user_data);
   }

   // This variant of gtk_action_group_add_actions() adds a #GDestroyNotify
   // callback for @user_data.
   // <entries>: an array of action descriptions
   // <n_entries>: the number of entries
   // <user_data>: data to pass to the action callbacks
   // <destroy>: destroy notification callback for @user_data
   void add_actions_full(ActionEntry* entries, uint n_entries, void* user_data, GLib2.DestroyNotify destroy) {
      gtk_action_group_add_actions_full(&this, entries, n_entries, user_data, destroy);
   }

   // Unintrospectable method: add_radio_actions() / gtk_action_group_add_radio_actions()
   // This is a convenience routine to create a group of radio actions and
   // add them to the action group. 
   // The "changed" signal of the first radio action is connected to the 
   // <literal>&lt;Actions&gt;/<replaceable>group-name</replaceable>/<replaceable>action-name</replaceable></literal>.
   // <entries>: an array of radio action descriptions
   // <n_entries>: the number of entries
   // <value>: the value of the action to activate initially, or -1 if no action should be activated
   // <on_change>: the callback to connect to the changed signal
   // <user_data>: data to pass to the action callbacks
   void add_radio_actions(RadioActionEntry* entries, uint n_entries, int value, GObject2.Callback on_change, void* user_data) {
      gtk_action_group_add_radio_actions(&this, entries, n_entries, value, on_change, user_data);
   }

   // This variant of gtk_action_group_add_radio_actions() adds a 
   // #GDestroyNotify callback for @user_data.
   // <entries>: an array of radio action descriptions
   // <n_entries>: the number of entries
   // <value>: the value of the action to activate initially, or -1 if no action should be activated
   // <on_change>: the callback to connect to the changed signal
   // <user_data>: data to pass to the action callbacks
   // <destroy>: destroy notification callback for @user_data
   void add_radio_actions_full(RadioActionEntry* entries, uint n_entries, int value, GObject2.Callback on_change, void* user_data, GLib2.DestroyNotify destroy) {
      gtk_action_group_add_radio_actions_full(&this, entries, n_entries, value, on_change, user_data, destroy);
   }

   // This is a convenience function to create a number of toggle actions and add them 
   // to the action group.
   // The "activate" signals of the actions are connected to the callbacks and 
   // their accel paths are set to 
   // <literal>&lt;Actions&gt;/<replaceable>group-name</replaceable>/<replaceable>action-name</replaceable></literal>.
   // <entries>: an array of toggle action descriptions
   // <n_entries>: the number of entries
   // <user_data>: data to pass to the action callbacks
   void add_toggle_actions(ToggleActionEntry* entries, uint n_entries, void* user_data) {
      gtk_action_group_add_toggle_actions(&this, entries, n_entries, user_data);
   }

   // This variant of gtk_action_group_add_toggle_actions() adds a 
   // #GDestroyNotify callback for @user_data.
   // <entries>: an array of toggle action descriptions
   // <n_entries>: the number of entries
   // <user_data>: data to pass to the action callbacks
   // <destroy>: destroy notification callback for @user_data
   void add_toggle_actions_full(ToggleActionEntry* entries, uint n_entries, void* user_data, GLib2.DestroyNotify destroy) {
      gtk_action_group_add_toggle_actions_full(&this, entries, n_entries, user_data, destroy);
   }

   // Looks up an action in the action group by name.
   // RETURNS: the action, or %NULL if no action by that name exists
   // <action_name>: the name of the action
   Action* get_action(char* action_name) {
      return gtk_action_group_get_action(&this, action_name);
   }

   // Gets the name of the action group.
   // RETURNS: the name of the action group.
   char* get_name() {
      return gtk_action_group_get_name(&this);
   }

   // Returns %TRUE if the group is sensitive.  The constituent actions
   // can only be logically sensitive (see gtk_action_is_sensitive()) if
   // they are sensitive (see gtk_action_get_sensitive()) and their group
   // is sensitive.
   // RETURNS: %TRUE if the group is sensitive.
   int get_sensitive() {
      return gtk_action_group_get_sensitive(&this);
   }

   // Returns %TRUE if the group is visible.  The constituent actions
   // can only be logically visible (see gtk_action_is_visible()) if
   // they are visible (see gtk_action_get_visible()) and their group
   // is visible.
   // RETURNS: %TRUE if the group is visible.
   int get_visible() {
      return gtk_action_group_get_visible(&this);
   }

   // Lists the actions in the action group.
   // RETURNS: an allocated list of the action objects in the action group
   GLib2.List* /*new container*/ list_actions() {
      return gtk_action_group_list_actions(&this);
   }

   // Removes an action object from the action group.
   // <action>: an action
   void remove_action(Action* action) {
      gtk_action_group_remove_action(&this, action);
   }

   // Changes the sensitivity of @action_group
   // <sensitive>: new sensitivity
   void set_sensitive(int sensitive) {
      gtk_action_group_set_sensitive(&this, sensitive);
   }

   // Sets a function to be used for translating the @label and @tooltip of 
   // #GtkActionGroupEntry<!-- -->s added by gtk_action_group_add_actions().
   // If you're using gettext(), it is enough to set the translation domain
   // with gtk_action_group_set_translation_domain().
   // <func>: a #GtkTranslateFunc
   // <data>: data to be passed to @func and @notify
   // <notify>: a #GDestroyNotify function to be called when @action_group is destroyed and when the translation function is changed again
   void set_translate_func(TranslateFunc func, void* data, GLib2.DestroyNotify notify) {
      gtk_action_group_set_translate_func(&this, func, data, notify);
   }

   // Sets the translation domain and uses g_dgettext() for translating the 
   // gtk_action_group_add_actions().
   // If you're not using gettext() for localization, see 
   // gtk_action_group_set_translate_func().
   // <domain>: the translation domain to use for g_dgettext() calls
   void set_translation_domain(char* domain) {
      gtk_action_group_set_translation_domain(&this, domain);
   }

   // Changes the visible of @action_group.
   // <visible>: new visiblity
   void set_visible(int visible) {
      gtk_action_group_set_visible(&this, visible);
   }

   // Translates a string using the specified translate_func(). This
   // is mainly intended for language bindings.
   // RETURNS: the translation of @string
   // <string>: a string
   char* translate_string(char* string_) {
      return gtk_action_group_translate_string(&this, string_);
   }

   // The ::connect-proxy signal is emitted after connecting a proxy to 
   // an action in the group. Note that the proxy may have been connected 
   // to a different action before.
   // This is intended for simple customizations for which a custom action
   // class would be too clumsy, e.g. showing tooltips for menuitems in the
   // statusbar.
   // #GtkUIManager proxies the signal and provides global notification 
   // just before any action is connected to a proxy, which is probably more
   // convenient to use.
   // <action>: the action
   // <proxy>: the proxy
   extern (C) alias static void function (ActionGroup* this_, Action* action, Widget* proxy, void* user_data=null) signal_connect_proxy;

   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:"connect-proxy", CB/*:signal_connect_proxy*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"connect-proxy",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::disconnect-proxy signal is emitted after disconnecting a proxy 
   // from an action in the group. 
   // #GtkUIManager proxies the signal and provides global notification 
   // just before any action is connected to a proxy, which is probably more
   // convenient to use.
   // <action>: the action
   // <proxy>: the proxy
   extern (C) alias static void function (ActionGroup* this_, Action* action, Widget* proxy, void* user_data=null) signal_disconnect_proxy;
   ulong signal_connect(string name:"disconnect-proxy", CB/*:signal_disconnect_proxy*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"disconnect-proxy",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::post-activate signal is emitted just after the @action in the
   // This is intended for #GtkUIManager to proxy the signal and provide global
   // notification just after any action is activated.
   // <action>: the action
   extern (C) alias static void function (ActionGroup* this_, Action* action, void* user_data=null) signal_post_activate;
   ulong signal_connect(string name:"post-activate", CB/*:signal_post_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"post-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::pre-activate signal is emitted just before the @action in the
   // This is intended for #GtkUIManager to proxy the signal and provide global
   // notification just before any action is activated.
   // <action>: the action
   extern (C) alias static void function (ActionGroup* this_, Action* action, void* user_data=null) signal_pre_activate;
   ulong signal_connect(string name:"pre-activate", CB/*:signal_pre_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"pre-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ActionGroupClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: the action, or %NULL if no action by that name exists
   // <action_name>: the name of the action
   extern (C) Action* function (ActionGroup* action_group, char* action_name) get_action;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ActionGroupPrivate {
}

struct ActionPrivate {
}


// Activatable widgets can be connected to a #GtkAction and reflects
// the state of its action. A #GtkActivatable can also provide feedback
// through its action, as they are responsible for activating their
// related actions.
// <refsect2>
// <title>Implementing GtkActivatable</title>
// <para>
// When extending a class that is already #GtkActivatable; it is only
// necessary to implement the #GtkActivatable->sync_action_properties()
// and #GtkActivatable->update() methods and chain up to the parent
// implementation, however when introducing
// a new #GtkActivatable class; the #GtkActivatable:related-action and
// #GtkActivatable:use-action-appearance properties need to be handled by
// the implementor. Handling these properties is mostly a matter of installing
// the action pointer and boolean flag on your instance, and calling
// gtk_activatable_do_set_related_action() and
// gtk_activatable_sync_action_properties() at the appropriate times.
// </para>
// <example>
// <title>A class fragment implementing #GtkActivatable</title>
// <programlisting><![CDATA[
// enum {
// ...
// PROP_ACTIVATABLE_RELATED_ACTION,
// PROP_ACTIVATABLE_USE_ACTION_APPEARANCE
// }
// struct _FooBarPrivate
// {
// ...
// GtkAction      *action;
// gboolean        use_action_appearance;
// };
// ...
// static void foo_bar_activatable_interface_init         (GtkActivatableIface  *iface);
// static void foo_bar_activatable_update                 (GtkActivatable       *activatable,
// GtkAction            *action,
// const gchar          *property_name);
// static void foo_bar_activatable_sync_action_properties (GtkActivatable       *activatable,
// GtkAction            *action);
// ...
// static void
// foo_bar_class_init (FooBarClass *klass)
// {
// ...
// g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action");
// g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance");
// ...
// }
// static void
// foo_bar_activatable_interface_init (GtkActivatableIface  *iface)
// {
// iface->update = foo_bar_activatable_update;
// iface->sync_action_properties = foo_bar_activatable_sync_action_properties;
// }
// ... Break the reference using gtk_activatable_do_set_related_action()...
// static void 
// foo_bar_dispose (GObject *object)
// {
// FooBar *bar = FOO_BAR (object);
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);
// ...
// if (priv->action)
// {
// gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), NULL);
// priv->action = NULL;
// }
// G_OBJECT_CLASS (foo_bar_parent_class)->dispose (object);
// }
// ... Handle the "related-action" and "use-action-appearance" properties ...
// static void
// foo_bar_set_property (GObject         *object,
// guint            prop_id,
// const GValue    *value,
// GParamSpec      *pspec)
// {
// FooBar *bar = FOO_BAR (object);
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);
// switch (prop_id)
// {
// ...
// case PROP_ACTIVATABLE_RELATED_ACTION:
// foo_bar_set_related_action (bar, g_value_get_object (value));
// break;
// case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
// foo_bar_set_use_action_appearance (bar, g_value_get_boolean (value));
// break;
// default:
// G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
// break;
// }
// }
// static void
// foo_bar_get_property (GObject         *object,
// guint            prop_id,
// GValue          *value,
// GParamSpec      *pspec)
// {
// FooBar *bar = FOO_BAR (object);
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);
// switch (prop_id)
// { 
// ...
// case PROP_ACTIVATABLE_RELATED_ACTION:
// g_value_set_object (value, priv->action);
// break;
// case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
// g_value_set_boolean (value, priv->use_action_appearance);
// break;
// default:
// G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
// break;
// }
// }
// static void
// foo_bar_set_use_action_appearance (FooBar   *bar, 
// gboolean  use_appearance)
// {
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);
// if (priv->use_action_appearance != use_appearance)
// {
// priv->use_action_appearance = use_appearance;
// gtk_activatable_sync_action_properties (GTK_ACTIVATABLE (bar), priv->action);
// }
// }
// ... call gtk_activatable_do_set_related_action() and then assign the action pointer, 
// no need to reference the action here since gtk_activatable_do_set_related_action() already 
// holds a reference here for you...
// static void
// foo_bar_set_related_action (FooBar    *bar, 
// GtkAction *action)
// {
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);
// if (priv->action == action)
// return;
// gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), action);
// priv->action = action;
// }
// ... Selectively reset and update activatable depending on the use-action-appearance property ...
// static void
// gtk_button_activatable_sync_action_properties (GtkActivatable       *activatable,
// GtkAction            *action)
// {
// GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);
// if (!action)
// return;
// if (gtk_action_is_visible (action))
// gtk_widget_show (GTK_WIDGET (activatable));
// else
// gtk_widget_hide (GTK_WIDGET (activatable));
// gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
// ...
// if (priv->use_action_appearance)
// {
// if (gtk_action_get_stock_id (action))
// foo_bar_set_stock (button, gtk_action_get_stock_id (action));
// else if (gtk_action_get_label (action))
// foo_bar_set_label (button, gtk_action_get_label (action));
// ...
// }
// }
// static void 
// foo_bar_activatable_update (GtkActivatable       *activatable,
// GtkAction            *action,
// const gchar          *property_name)
// {
// FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (activatable);
// if (strcmp (property_name, "visible") == 0)
// {
// if (gtk_action_is_visible (action))
// gtk_widget_show (GTK_WIDGET (activatable));
// else
// gtk_widget_hide (GTK_WIDGET (activatable));
// }
// else if (strcmp (property_name, "sensitive") == 0)
// gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
// ...
// if (!priv->use_action_appearance)
// return;
// if (strcmp (property_name, "stock-id") == 0)
// foo_bar_set_stock (button, gtk_action_get_stock_id (action));
// else if (strcmp (property_name, "label") == 0)
// foo_bar_set_label (button, gtk_action_get_label (action));
// ...
// }]]></programlisting>
// </example>
// </refsect2>
struct Activatable {

   // This is a utility function for #GtkActivatable implementors.
   // When implementing #GtkActivatable you must call this when
   // handling changes of the #GtkActivatable:related-action, and
   // you must also use this to break references in #GObject->dispose().
   // This function adds a reference to the currently set related
   // action for you, it also makes sure the #GtkActivatable->update()
   // method is called when the related #GtkAction properties change
   // and registers to the action's proxy list.
   // <note><para>Be careful to call this before setting the local
   // copy of the #GtkAction property, since this function uses 
   // gtk_activatable_get_action() to retrieve the previous action</para></note>
   // <action>: the #GtkAction to set
   void do_set_related_action(Action* action) {
      gtk_activatable_do_set_related_action(&this, action);
   }

   // Gets the related #GtkAction for @activatable.
   // RETURNS: the related #GtkAction if one is set.
   Action* get_related_action() {
      return gtk_activatable_get_related_action(&this);
   }

   // Gets whether this activatable should reset its layout
   // and appearance when setting the related action or when
   // the action changes appearance.
   // RETURNS: whether @activatable uses its actions appearance.
   int get_use_action_appearance() {
      return gtk_activatable_get_use_action_appearance(&this);
   }

   // Sets the related action on the @activatable object.
   // <note><para>#GtkActivatable implementors need to handle the #GtkActivatable:related-action
   // property and call gtk_activatable_do_set_related_action() when it changes.</para></note>
   // <action>: the #GtkAction to set
   void set_related_action(Action* action) {
      gtk_activatable_set_related_action(&this, action);
   }

   // Sets whether this activatable should reset its layout and appearance
   // when setting the related action or when the action changes appearance
   // <note><para>#GtkActivatable implementors need to handle the
   // #GtkActivatable:use-action-appearance property and call
   // gtk_activatable_sync_action_properties() to update @activatable
   // if needed.</para></note>
   // <use_appearance>: whether to use the actions appearance
   void set_use_action_appearance(int use_appearance) {
      gtk_activatable_set_use_action_appearance(&this, use_appearance);
   }

   // This is called to update the activatable completely, this is called
   // internally when the #GtkActivatable::related-action property is set
   // or unset and by the implementing class when
   // #GtkActivatable::use-action-appearance changes.
   // <action>: the related #GtkAction or %NULL
   void sync_action_properties(Action* action=null) {
      gtk_activatable_sync_action_properties(&this, action);
   }
}

struct ActivatableIface /* Version 2.16 */ {
   GObject2.TypeInterface g_iface;
   extern (C) void function (Activatable* activatable, Action* action, char* property_name) update;
   // <action>: the related #GtkAction or %NULL
   extern (C) void function (Activatable* activatable, Action* action=null) sync_action_properties;
}

struct Adjustment /* : Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   Object parent_instance;
   double lower, upper, value, step_increment, page_increment, page_size;

   static Adjustment* new_(double value, double lower, double upper, double step_increment, double page_increment, double page_size) {
      return gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
   }
   void changed() {
      gtk_adjustment_changed(&this);
   }
   void clamp_page(double lower, double upper) {
      gtk_adjustment_clamp_page(&this, lower, upper);
   }

   // Sets all properties of the adjustment at once.
   // Use this function to avoid multiple emissions of the "changed"
   // signal. See gtk_adjustment_set_lower() for an alternative way
   // of compressing multiple emissions of "changed" into one.
   // <value>: the new value
   // <lower>: the new minimum value
   // <upper>: the new maximum value
   // <step_increment>: the new step increment
   // <page_increment>: the new page increment
   // <page_size>: the new page size
   void configure(double value, double lower, double upper, double step_increment, double page_increment, double page_size) {
      gtk_adjustment_configure(&this, value, lower, upper, step_increment, page_increment, page_size);
   }

   // Retrieves the minimum value of the adjustment.
   // RETURNS: The current minimum value of the adjustment.
   double get_lower() {
      return gtk_adjustment_get_lower(&this);
   }

   // Retrieves the page increment of the adjustment.
   // RETURNS: The current page increment of the adjustment.
   double get_page_increment() {
      return gtk_adjustment_get_page_increment(&this);
   }

   // Retrieves the page size of the adjustment.
   // RETURNS: The current page size of the adjustment.
   double get_page_size() {
      return gtk_adjustment_get_page_size(&this);
   }

   // Retrieves the step increment of the adjustment.
   // RETURNS: The current step increment of the adjustment.
   double get_step_increment() {
      return gtk_adjustment_get_step_increment(&this);
   }

   // Retrieves the maximum value of the adjustment.
   // RETURNS: The current maximum value of the adjustment.
   double get_upper() {
      return gtk_adjustment_get_upper(&this);
   }

   // Gets the current value of the adjustment. See
   // gtk_adjustment_set_value ().
   // RETURNS: The current value of the adjustment.
   double get_value() {
      return gtk_adjustment_get_value(&this);
   }

   // Sets the minimum value of the adjustment.
   // When setting multiple adjustment properties via their individual
   // setters, multiple "changed" signals will be emitted. However, since
   // the emission of the "changed" signal is tied to the emission of the
   // "GObject::notify" signals of the changed properties, it's possible
   // to compress the "changed" signals into one by calling
   // g_object_freeze_notify() and g_object_thaw_notify() around the
   // calls to the individual setters.
   // Alternatively, using a single g_object_set() for all the properties
   // to change, or using gtk_adjustment_configure() has the same effect
   // of compressing "changed" emissions.
   // <lower>: the new minimum value
   void set_lower(double lower) {
      gtk_adjustment_set_lower(&this, lower);
   }

   // Sets the page increment of the adjustment.
   // See gtk_adjustment_set_lower() about how to compress multiple
   // emissions of the "changed" signal when setting multiple adjustment
   // properties.
   // <page_increment>: the new page increment
   void set_page_increment(double page_increment) {
      gtk_adjustment_set_page_increment(&this, page_increment);
   }

   // Sets the page size of the adjustment.
   // See gtk_adjustment_set_lower() about how to compress multiple
   // emissions of the "changed" signal when setting multiple adjustment
   // properties.
   // <page_size>: the new page size
   void set_page_size(double page_size) {
      gtk_adjustment_set_page_size(&this, page_size);
   }

   // Sets the step increment of the adjustment.
   // See gtk_adjustment_set_lower() about how to compress multiple
   // emissions of the "changed" signal when setting multiple adjustment
   // properties.
   // <step_increment>: the new step increment
   void set_step_increment(double step_increment) {
      gtk_adjustment_set_step_increment(&this, step_increment);
   }

   // Sets the maximum value of the adjustment.
   // Note that values will be restricted by
   // <literal>upper - page-size</literal> if the page-size
   // property is nonzero.
   // See gtk_adjustment_set_lower() about how to compress multiple
   // emissions of the "changed" signal when setting multiple adjustment
   // properties.
   // <upper>: the new maximum value
   void set_upper(double upper) {
      gtk_adjustment_set_upper(&this, upper);
   }
   void set_value(double value) {
      gtk_adjustment_set_value(&this, value);
   }
   void value_changed() {
      gtk_adjustment_value_changed(&this);
   }
   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);
   }
   extern (C) alias static void function (Adjustment* this_, void* user_data=null) signal_value_changed;
   ulong signal_connect(string name:"value-changed", CB/*:signal_value_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"value-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct AdjustmentClass {
   ObjectClass parent_class;
   extern (C) void function (Adjustment* adjustment) changed;
   extern (C) void function (Adjustment* adjustment) value_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// The #GtkAlignment widget controls the alignment and size of its child widget.
// The scale settings are used to specify how much the child widget should
// expand to fill the space allocated to the #GtkAlignment.
// The values can range from 0 (meaning the child doesn't expand at all) to
// 1 (meaning the child expands to fill all of the available space).
// The align settings are used to place the child widget within the available
// area. The values range from 0 (top or left) to 1 (bottom or right).
// Of course, if the scale settings are both set to 1, the alignment settings
// have no effect.
struct Alignment /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   float xalign, yalign, xscale, yscale;


   // Creates a new #GtkAlignment.
   // RETURNS: the new #GtkAlignment.
   // <xalign>: the horizontal alignment of the child widget, from 0 (left) to 1 (right).
   // <yalign>: the vertical alignment of the child widget, from 0 (top) to 1 (bottom).
   // <xscale>: the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the #GtkAlignment.
   // <yscale>: the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to @xscale.
   static Alignment* new_(float xalign, float yalign, float xscale, float yscale) {
      return gtk_alignment_new(xalign, yalign, xscale, yscale);
   }

   // Gets the padding on the different sides of the widget.
   // See gtk_alignment_set_padding ().
   // <padding_top>: location to store the padding for the top of the widget, or %NULL
   // <padding_bottom>: location to store the padding for the bottom of the widget, or %NULL
   // <padding_left>: location to store the padding for the left of the widget, or %NULL
   // <padding_right>: location to store the padding for the right of the widget, or %NULL
   void get_padding(/*out*/ uint* padding_top=null, /*out*/ uint* padding_bottom=null, /*out*/ uint* padding_left=null, /*out*/ uint* padding_right=null) {
      gtk_alignment_get_padding(&this, padding_top, padding_bottom, padding_left, padding_right);
   }

   // Sets the #GtkAlignment values.
   // <xalign>: the horizontal alignment of the child widget, from 0 (left) to 1 (right).
   // <yalign>: the vertical alignment of the child widget, from 0 (top) to 1 (bottom).
   // <xscale>: the amount that the child widget expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all of the space allocated for the #GtkAlignment.
   // <yscale>: the amount that the child widget expands vertically to fill up unused space, from 0 to 1. The values are similar to @xscale.
   void set(float xalign, float yalign, float xscale, float yscale) {
      gtk_alignment_set(&this, xalign, yalign, xscale, yscale);
   }

   // Sets the padding on the different sides of the widget.
   // The padding adds blank space to the sides of the widget. For instance,
   // this can be used to indent the child widget towards the right by adding
   // padding on the left.
   // <padding_top>: the padding at the top of the widget
   // <padding_bottom>: the padding at the bottom of the widget
   // <padding_left>: the padding at the left of the widget
   // <padding_right>: the padding at the right of the widget.
   void set_padding(uint padding_top, uint padding_bottom, uint padding_left, uint padding_right) {
      gtk_alignment_set_padding(&this, padding_top, padding_bottom, padding_left, padding_right);
   }
}

struct AlignmentClass {
   BinClass parent_class;
}

struct AlignmentPrivate {
}

enum AnchorType {
   CENTER = 0,
   NORTH = 1,
   NORTH_WEST = 2,
   NORTH_EAST = 3,
   SOUTH = 4,
   SOUTH_WEST = 5,
   SOUTH_EAST = 6,
   WEST = 7,
   EAST = 8,
   N = 1,
   NW = 2,
   NE = 3,
   S = 4,
   SW = 5,
   SE = 6,
   W = 7,
   E = 8
}
struct Arg {
   Type type;
   char* name;

   union d {
      char char_data;
      ubyte uchar_data;
      int bool_data;
      int int_data;
      uint uint_data;
      c_long long_data;
      c_ulong ulong_data;
      float float_data;
      double double_data;
      char* string_data;
      Object* object_data;
      void* pointer_data;

      struct signal_data {
         GObject2.Callback f;
         void* d;
      }
   }
}

enum ArgFlags {
   READABLE = 1,
   WRITABLE = 2,
   CONSTRUCT = 4,
   CONSTRUCT_ONLY = 8,
   CHILD_ARG = 16
}

// GtkArrow should be used to draw simple arrows that need to point in
// one of the four cardinal directions (up, down, left, or right).  The
// style of the arrow can be one of shadow in, shadow out, etched in, or
// etched out.  Note that these directions and style types may be
// ammended in versions of GTK+ to come.
// GtkArrow will fill any space alloted to it, but since it is inherited
// from #GtkMisc, it can be padded and/or aligned, to fill exactly the
// space the programmer desires.
// Arrows are created with a call to gtk_arrow_new().  The direction or
// style of an arrow can be changed after creation by using gtk_arrow_set().
struct Arrow /* : Misc */ {
   alias misc this;
   alias misc super_;
   Misc misc;
   short arrow_type, shadow_type;


   // Creates a new #GtkArrow widget.
   // RETURNS: the new #GtkArrow widget.
   // <arrow_type>: a valid #GtkArrowType.
   // <shadow_type>: a valid #GtkShadowType.
   static Arrow* new_(ArrowType arrow_type, ShadowType shadow_type) {
      return gtk_arrow_new(arrow_type, shadow_type);
   }

   // Sets the direction and style of the #GtkArrow, @arrow.
   // <arrow_type>: a valid #GtkArrowType.
   // <shadow_type>: a valid #GtkShadowType.
   void set(ArrowType arrow_type, ShadowType shadow_type) {
      gtk_arrow_set(&this, arrow_type, shadow_type);
   }
}

struct ArrowClass {
   MiscClass parent_class;
}

enum ArrowPlacement {
   BOTH = 0,
   START = 1,
   END = 2
}
enum ArrowType {
   UP = 0,
   DOWN = 1,
   LEFT = 2,
   RIGHT = 3,
   NONE = 4
}

// The #GtkAspectFrame is useful when you want
// pack a widget so that it can resize but always retains
// the same aspect ratio. For instance, one might be
// drawing a small preview of a larger image. #GtkAspectFrame
// derives from #GtkFrame, so it can draw a label and
// a frame around the child. The frame will be
// "shrink-wrapped" to the size of the child.
struct AspectFrame /* : Frame */ {
   alias frame this;
   alias frame super_;
   Frame frame;
   float xalign, yalign, ratio;
   int obey_child;
   Allocation center_allocation;


   // Create a new #GtkAspectFrame.
   // RETURNS: the new #GtkAspectFrame.
   // <label>: Label text.
   // <xalign>: Horizontal alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned)
   // <yalign>: Vertical alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned)
   // <ratio>: The desired aspect ratio.
   // <obey_child>: If %TRUE, @ratio is ignored, and the aspect ratio is taken from the requistion of the child.
   static AspectFrame* new_(char* label, float xalign, float yalign, float ratio, int obey_child) {
      return gtk_aspect_frame_new(label, xalign, yalign, ratio, obey_child);
   }

   // Set parameters for an existing #GtkAspectFrame.
   // <xalign>: Horizontal alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned)
   // <yalign>: Vertical alignment of the child within the allocation of the #GtkAspectFrame. This ranges from 0.0 (left aligned) to 1.0 (right aligned)
   // <ratio>: The desired aspect ratio.
   // <obey_child>: If %TRUE, @ratio is ignored, and the aspect ratio is taken from the requistion of the child.
   void set(float xalign, float yalign, float ratio, int obey_child) {
      gtk_aspect_frame_set(&this, xalign, yalign, ratio, obey_child);
   }
}

struct AspectFrameClass {
   FrameClass parent_class;
}


// A #GtkAssistant is a widget used to represent a generally complex
// operation splitted in several steps, guiding the user through its pages
// and controlling the page flow to collect the necessary data.
// <refsect2 id="GtkAssistant-BUILDER-UI">
// <title>GtkAssistant as GtkBuildable</title>
// <para>
// The GtkAssistant implementation of the GtkBuildable interface exposes the
// To add pages to an assistant in GtkBuilder, simply add it as a
// &lt;child&gt; to the GtkAssistant object, and set its child properties
// as necessary.
// </para>
// </refsect2>
struct Assistant /* : Window */ {
   alias parent this;
   alias parent super_;
   alias parent window;
   Window parent;
   Widget* cancel_, forward, back, apply_, close_, last;
   private AssistantPrivate* priv;


   // Creates a new #GtkAssistant.
   // RETURNS: a newly created #GtkAssistant
   static Assistant* new_() {
      return gtk_assistant_new();
   }

   // Adds a widget to the action area of a #GtkAssistant.
   // <child>: a #GtkWidget
   void add_action_widget(Widget* child) {
      gtk_assistant_add_action_widget(&this, child);
   }

   // Appends a page to the @assistant.
   // RETURNS: the index (starting at 0) of the inserted page
   // <page>: a #GtkWidget
   int append_page(Widget* page) {
      return gtk_assistant_append_page(&this, page);
   }

   // Erases the visited page history so the back button is not
   // shown on the current page, and removes the cancel button
   // from subsequent pages.
   // Use this when the information provided up to the current
   // page is hereafter deemed permanent and cannot be modified
   // or undone.  For example, showing a progress page to track
   // a long-running, unreversible operation after the user has
   // clicked apply on a confirmation page.
   void commit() {
      gtk_assistant_commit(&this);
   }

   // Returns the page number of the current page
   // the @assistant, if the @assistant has no pages, -1 will be returned
   // RETURNS: The index (starting from 0) of the current page in
   int get_current_page() {
      return gtk_assistant_get_current_page(&this);
   }

   // Returns the number of pages in the @assistant
   // RETURNS: The number of pages in the @assistant.
   int get_n_pages() {
      return gtk_assistant_get_n_pages(&this);
   }

   // Returns the child widget contained in page number @page_num.
   // if @page_num is out of bounds.
   // RETURNS: The child widget, or %NULL
   // <page_num>: The index of a page in the @assistant, or -1 to get the last page;
   Widget* get_nth_page(int page_num) {
      return gtk_assistant_get_nth_page(&this, page_num);
   }

   // Gets whether @page is complete.
   // RETURNS: %TRUE if @page is complete.
   // <page>: a page of @assistant
   int get_page_complete(Widget* page) {
      return gtk_assistant_get_page_complete(&this, page);
   }

   // Gets the header image for @page.
   // if there's no header image for the page.
   // RETURNS: the header image for @page, or %NULL
   // <page>: a page of @assistant
   GdkPixbuf2.Pixbuf* get_page_header_image(Widget* page) {
      return gtk_assistant_get_page_header_image(&this, page);
   }

   // Gets the header image for @page.
   // if there's no side image for the page.
   // RETURNS: the side image for @page, or %NULL
   // <page>: a page of @assistant
   GdkPixbuf2.Pixbuf* get_page_side_image(Widget* page) {
      return gtk_assistant_get_page_side_image(&this, page);
   }

   // Gets the title for @page.
   // RETURNS: the title for @page.
   // <page>: a page of @assistant
   char* get_page_title(Widget* page) {
      return gtk_assistant_get_page_title(&this, page);
   }

   // Gets the page type of @page.
   // RETURNS: the page type of @page.
   // <page>: a page of @assistant
   AssistantPageType get_page_type(Widget* page) {
      return gtk_assistant_get_page_type(&this, page);
   }

   // Inserts a page in the @assistant at a given position.
   // RETURNS: the index (starting from 0) of the inserted page
   // <page>: a #GtkWidget
   // <position>: the index (starting at 0) at which to insert the page, or -1 to append the page to the @assistant
   int insert_page(Widget* page, int position) {
      return gtk_assistant_insert_page(&this, page, position);
   }

   // Prepends a page to the @assistant.
   // RETURNS: the index (starting at 0) of the inserted page
   // <page>: a #GtkWidget
   int prepend_page(Widget* page) {
      return gtk_assistant_prepend_page(&this, page);
   }

   // Removes a widget from the action area of a #GtkAssistant.
   // <child>: a #GtkWidget
   void remove_action_widget(Widget* child) {
      gtk_assistant_remove_action_widget(&this, child);
   }

   // Switches the page to @page_num. Note that this will only be necessary
   // in custom buttons, as the @assistant flow can be set with
   // gtk_assistant_set_forward_page_func().
   // <page_num>: index of the page to switch to, starting from 0. If negative, the last page will be used. If greater than the number of pages in the @assistant, nothing will be done.
   void set_current_page(int page_num) {
      gtk_assistant_set_current_page(&this, page_num);
   }

   // Sets the page forwarding function to be @page_func, this function will
   // be used to determine what will be the next page when the user presses
   // the forward button. Setting @page_func to %NULL will make the assistant
   // to use the default forward function, which just goes to the next visible 
   // page.
   // <page_func>: the #GtkAssistantPageFunc, or %NULL to use the default one
   // <data>: user data for @page_func
   // <destroy>: destroy notifier for @data
   void set_forward_page_func(AssistantPageFunc page_func, void* data, GLib2.DestroyNotify destroy) {
      gtk_assistant_set_forward_page_func(&this, page_func, data, destroy);
   }

   // Sets whether @page contents are complete. This will make
   // <page>: a page of @assistant
   // <complete>: the completeness status of the page
   void set_page_complete(Widget* page, int complete) {
      gtk_assistant_set_page_complete(&this, page, complete);
   }

   // Sets a header image for @page. This image is displayed in the header
   // area of the assistant when @page is the current page.
   // <page>: a page of @assistant
   // <pixbuf>: the new header image @page
   void set_page_header_image(Widget* page, GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_assistant_set_page_header_image(&this, page, pixbuf);
   }

   // Sets a header image for @page. This image is displayed in the side
   // area of the assistant when @page is the current page.
   // <page>: a page of @assistant
   // <pixbuf>: the new header image @page
   void set_page_side_image(Widget* page, GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_assistant_set_page_side_image(&this, page, pixbuf);
   }

   // Sets a title for @page. The title is displayed in the header
   // area of the assistant when @page is the current page.
   // <page>: a page of @assistant
   // <title>: the new title for @page
   void set_page_title(Widget* page, char* title) {
      gtk_assistant_set_page_title(&this, page, title);
   }

   // Sets the page type for @page. The page type determines the page
   // behavior in the @assistant.
   // <page>: a page of @assistant
   // <type>: the new type for @page
   void set_page_type(Widget* page, AssistantPageType type) {
      gtk_assistant_set_page_type(&this, page, type);
   }

   // Forces @assistant to recompute the buttons state.
   // GTK+ automatically takes care of this in most situations, 
   // e.g. when the user goes to a different page, or when the
   // visibility or completeness of a page changes.
   // One situation where it can be necessary to call this
   // function is when changing a value on the current page
   // affects the future page flow of the assistant.
   void update_buttons_state() {
      gtk_assistant_update_buttons_state(&this);
   }

   // The ::apply signal is emitted when the apply button is clicked. The default
   // behavior of the #GtkAssistant is to switch to the page after the current
   // page, unless the current page is the last one.
   // A handler for the ::apply signal should carry out the actions for which
   // the wizard has collected data. If the action takes a long time to complete,
   // you might consider putting a page of type %GTK_ASSISTANT_PAGE_PROGRESS
   // after the confirmation page and handle this operation within the
   // #GtkAssistant::prepare signal of the progress page.
   extern (C) alias static void function (Assistant* this_, void* user_data=null) signal_apply;

   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:"apply", CB/*:signal_apply*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"apply",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // The ::cancel signal is emitted when then the cancel button is clicked.
   extern (C) alias static void function (Assistant* this_, void* user_data=null) signal_cancel;
   ulong signal_connect(string name:"cancel", CB/*:signal_cancel*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cancel",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::close signal is emitted either when the close button of
   // a summary page is clicked, or when the apply button in the last
   // page in the flow (of type %GTK_ASSISTANT_PAGE_CONFIRM) is clicked.
   extern (C) alias static void function (Assistant* this_, void* user_data=null) signal_close;
   ulong signal_connect(string name:"close", CB/*:signal_close*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"close",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::prepare signal is emitted when a new page is set as the assistant's
   // current page, before making the new page visible. A handler for this signal
   // can do any preparation which are necessary before showing @page.
   // <page>: the current page
   extern (C) alias static void function (Assistant* this_, Widget* page, void* user_data=null) signal_prepare;
   ulong signal_connect(string name:"prepare", CB/*:signal_prepare*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"prepare",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct AssistantClass {
   WindowClass parent_class;
   extern (C) void function (Assistant* assistant, Widget* page) prepare;
   extern (C) void function (Assistant* assistant) apply;
   extern (C) void function (Assistant* assistant) close;
   extern (C) void function (Assistant* assistant) cancel;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
}


// A function used by gtk_assistant_set_forward_page_func() to know which
// is the next page given a current one. It's called both for computing the
// next page when the user presses the "forward" button and for handling
// the behavior of the "last" button.
// RETURNS: The next page number.
// <current_page>: The page number used to calculate the next page.
// <data>: user data.
extern (C) alias int function (int current_page, void* data) AssistantPageFunc;


// An enum for determining the page role inside the #GtkAssistant. It's
// used to handle buttons sensitivity and visibility.
// Note that an assistant needs to end its page flow with a page of type
// %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
// %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
enum AssistantPageType {
   CONTENT = 0,
   INTRO = 1,
   CONFIRM = 2,
   SUMMARY = 3,
   PROGRESS = 4
}
struct AssistantPrivate {
}

enum AttachOptions {
   EXPAND = 1,
   SHRINK = 2,
   FILL = 4
}
enum int BINARY_AGE = 2408;
enum int BUTTONBOX_DEFAULT = -1;

// The #GtkBin widget is a container with just one child.
// It is not very useful itself, but it is useful for deriving subclasses,
// since it provides common code needed for handling a single child widget.
// Many GTK+ widgets are subclasses of #GtkBin, including #GtkWindow,
// #GtkButton, #GtkFrame, #GtkHandleBox or #GtkScrolledWindow.
struct Bin /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   Widget* child;


   // Gets the child of the #GtkBin, or %NULL if the bin contains
   // no child widget. The returned widget does not have a reference
   // added, so you do not need to unref it.
   // RETURNS: pointer to child of the #GtkBin
   Widget* get_child() {
      return gtk_bin_get_child(&this);
   }
}

struct BinClass {
   ContainerClass parent_class;
}

struct BindingArg {
   Type arg_type;

   union d {
      c_long long_data;
      double double_data;
      char* string_data;
   }
}

struct BindingEntry {
   uint keyval;
   Gdk2.ModifierType modifiers;
   BindingSet* binding_set;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "destroyed", 1,
   uint, "in_emission", 1,
   uint, "marks_unbound", 1,
    uint, "__dummy32A", 29));
   BindingEntry* set_next, hash_next;
   BindingSignal* signals;
}

struct BindingSet {
   char* set_name;
   int priority;
   GLib2.SList* widget_path_pspecs, widget_class_pspecs, class_branch_pspecs;
   BindingEntry* entries, current;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "parsed", 1,
    uint, "__dummy32A", 31));


   // Find a key binding matching @keyval and @modifiers within
   // RETURNS: %TRUE if a binding was found and activated
   // <keyval>: key value of the binding
   // <modifiers>: key modifier of the binding
   // <object>: object to activate when binding found
   int activate(uint keyval, Gdk2.ModifierType modifiers, Object* object) {
      return gtk_binding_set_activate(&this, keyval, modifiers, object);
   }

   // This function is used internally by the GtkRC parsing mechanism to
   // assign match patterns to #GtkBindingSet structures.
   // <path_type>: path type the pattern applies to
   // <path_pattern>: the actual match pattern
   // <priority>: binding priority
   void add_path(PathType path_type, char* path_pattern, PathPriorityType priority) {
      gtk_binding_set_add_path(&this, path_type, path_pattern, priority);
   }
}

struct BindingSignal {
   BindingSignal* next;
   char* signal_name;
   uint n_args;
   BindingArg* args;
}

struct Border {
   int left, right, top, bottom;


   // Allocates a new #GtkBorder structure and initializes its elements to zero.
   // freed with gtk_border_free()
   // RETURNS: a new empty #GtkBorder. The newly allocated #GtkBorder should be
   static Border* /*new*/ new_() {
      return gtk_border_new();
   }

   // Copies a #GtkBorder structure.
   // RETURNS: a copy of @border_.
   Border* /*new*/ copy() {
      return gtk_border_copy(&this);
   }
   // Frees a #GtkBorder structure.
   void free() {
      gtk_border_free(&this);
   }
}

struct Box /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children;
   short spacing;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "homogeneous", 1,
    uint, "__dummy32A", 31));


   // Returns whether the box is homogeneous (all children are the
   // same size). See gtk_box_set_homogeneous().
   // RETURNS: %TRUE if the box is homogeneous.
   int get_homogeneous() {
      return gtk_box_get_homogeneous(&this);
   }

   // Gets the value set by gtk_box_set_spacing().
   // RETURNS: spacing between children
   int get_spacing() {
      return gtk_box_get_spacing(&this);
   }

   // Adds @child to @box, packed with reference to the end of @box.  
   // The @child is packed after (away from end of) any other child 
   // packed with reference to the end of @box.
   // <child>: the #GtkWidget to be added to @box
   // <expand>: %TRUE if the new child is to be given extra space allocated to @box. The extra space will be divided evenly between all children of @box that use this option
   // <fill>: %TRUE if space given to @child by the @expand option is actually allocated to @child, rather than just padding it.  This parameter has no effect if @expand is set to %FALSE.  A child is always allocated the full height of a #GtkHBox and the full width of a #GtkVBox.  This option affects the other dimension
   // <padding>: extra space in pixels to put between this child and its neighbors, over and above the global amount specified by #GtkBox:spacing property.  If @child is a widget at one of the reference ends of @box, then @padding pixels are also put between
   void pack_end(Widget* child, int expand, int fill, uint padding) {
      gtk_box_pack_end(&this, child, expand, fill, padding);
   }

   // Adds @widget to @box, packed with reference to the end of @box.
   // The child is packed after any other child packed with reference 
   // to the start of @box. 
   // Parameters for how to pack the child @widget, #GtkBox:expand, 
   // #GtkBox:fill and #GtkBox:padding, are given their default
   // values, %TRUE, %TRUE, and 0, respectively.
   // <widget>: the #GtkWidget to be added to @box
   void pack_end_defaults(Widget* widget) {
      gtk_box_pack_end_defaults(&this, widget);
   }

   // Adds @child to @box, packed with reference to the start of @box.
   // The @child is packed after any other child packed with reference 
   // to the start of @box.
   // <child>: the #GtkWidget to be added to @box
   // <expand>: %TRUE if the new child is to be given extra space allocated to
   // <fill>: %TRUE if space given to @child by the @expand option is actually allocated to @child, rather than just padding it.  This parameter has no effect if @expand is set to %FALSE.  A child is always allocated the full height of a #GtkHBox and the full width of a #GtkVBox. This option affects the other dimension
   // <padding>: extra space in pixels to put between this child and its neighbors, over and above the global amount specified by #GtkBox:spacing property.  If @child is a widget at one of the reference ends of @box, then @padding pixels are also put between
   void pack_start(Widget* child, int expand, int fill, uint padding) {
      gtk_box_pack_start(&this, child, expand, fill, padding);
   }

   // Adds @widget to @box, packed with reference to the start of @box.
   // The child is packed after any other child packed with reference 
   // to the start of @box. 
   // Parameters for how to pack the child @widget, #GtkBox:expand, 
   // #GtkBox:fill and #GtkBox:padding, are given their default
   // values, %TRUE, %TRUE, and 0, respectively.
   // <widget>: the #GtkWidget to be added to @box
   void pack_start_defaults(Widget* widget) {
      gtk_box_pack_start_defaults(&this, widget);
   }

   // Obtains information about how @child is packed into @box.
   // <child>: the #GtkWidget of the child to query
   // <expand>: pointer to return location for #GtkBox:expand child property
   // <fill>: pointer to return location for #GtkBox:fill child property
   // <padding>: pointer to return location for #GtkBox:padding child property
   // <pack_type>: pointer to return location for #GtkBox:pack-type child property
   void query_child_packing(Widget* child, int* expand, int* fill, uint* padding, PackType* pack_type) {
      gtk_box_query_child_packing(&this, child, expand, fill, padding, pack_type);
   }

   // Moves @child to a new @position in the list of @box children.  
   // The list is the <structfield>children</structfield> field of
   // #GtkBox-struct, and contains both widgets packed #GTK_PACK_START 
   // as well as widgets packed #GTK_PACK_END, in the order that these 
   // widgets were added to @box.
   // A widget's position in the @box children list determines where 
   // the widget is packed into @box.  A child widget at some position 
   // in the list will be packed just after all other widgets of the 
   // same packing type that appear earlier in the list.
   // <child>: the #GtkWidget to move
   // <position>: the new position for @child in the list of children of @box, starting from 0. If negative, indicates the end of the list
   void reorder_child(Widget* child, int position) {
      gtk_box_reorder_child(&this, child, position);
   }

   // Sets the way @child is packed into @box.
   // <child>: the #GtkWidget of the child to set
   // <expand>: the new value of the #GtkBox:expand child property
   // <fill>: the new value of the #GtkBox:fill child property
   // <padding>: the new value of the #GtkBox:padding child property
   // <pack_type>: the new value of the #GtkBox:pack-type child property
   void set_child_packing(Widget* child, int expand, int fill, uint padding, PackType pack_type) {
      gtk_box_set_child_packing(&this, child, expand, fill, padding, pack_type);
   }

   // Sets the #GtkBox:homogeneous property of @box, controlling 
   // whether or not all children of @box are given equal space 
   // in the box.
   // <homogeneous>: a boolean value, %TRUE to create equal allotments, %FALSE for variable allotments
   void set_homogeneous(int homogeneous) {
      gtk_box_set_homogeneous(&this, homogeneous);
   }

   // Sets the #GtkBox:spacing property of @box, which is the 
   // number of pixels to place between children of @box.
   // <spacing>: the number of pixels to put between children
   void set_spacing(int spacing) {
      gtk_box_set_spacing(&this, spacing);
   }
}


// The #GtkBoxChild holds a child widget of #GtkBox and describes how the child
// is to be packed into the #GtkBox. All fields of this #GtkBoxChild should be
// considered read-only and they should never be set directly by an application.
// Use gtk_box_query_child_packing() and gtk_box_set_child_packing() to query
// and set the #GtkBoxChild.padding, #GtkBoxChild.expand, #GtkBoxChild.fill and
// #GtkBoxChild.pack fields.
struct BoxChild {
   Widget* widget;
   ushort padding;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "expand", 1,
   uint, "fill", 1,
   uint, "pack", 1,
   uint, "is_secondary", 1,
    uint, "__dummy32A", 28));
}

struct BoxClass {
   ContainerClass parent_class;
}


// In order to allow construction from a <link linkend="BUILDER-UI">GtkBuilder
// UI description</link>, an object class must implement the
// GtkBuildable interface. The interface includes methods for setting
// names and properties of objects, parsing custom tags, constructing
// child objects.
// The GtkBuildable interface is implemented by all widgets and
// many of the non-widget objects that are provided by GTK+. The
// main user of this interface is #GtkBuilder, there should be
// very little need for applications to call any
// <function>gtk_buildable_...</function> functions.
struct Buildable {

   // Adds a child to @buildable. @type is an optional string
   // describing how the child should be added.
   // <builder>: a #GtkBuilder
   // <child>: child to add
   // <type>: kind of child or %NULL
   void add_child(Builder* builder, GObject2.Object* child, char* type=null) {
      gtk_buildable_add_child(&this, builder, child, type);
   }

   // Constructs a child of @buildable with the name @name.
   // #GtkBuilder calls this function if a "constructor" has been
   // specified in the UI definition.
   // RETURNS: the constructed child
   // <builder>: #GtkBuilder used to construct this object
   // <name>: name of child to construct
   GObject2.Object* /*new*/ construct_child(Builder* builder, char* name) {
      return gtk_buildable_construct_child(&this, builder, name);
   }

   // This is similar to gtk_buildable_parser_finished() but is
   // called once for each custom tag handled by the @buildable.
   // <builder>: a #GtkBuilder
   // <child>: child object or %NULL for non-child tags
   // <tagname>: the name of the tag
   // <data>: user data created in custom_tag_start
   void custom_finished(Builder* builder, GObject2.Object* child, char* tagname, void* data) {
      gtk_buildable_custom_finished(&this, builder, child, tagname, data);
   }

   // This is called at the end of each custom element handled by 
   // the buildable.
   // <builder>: #GtkBuilder used to construct this object
   // <child>: child object or %NULL for non-child tags
   // <tagname>: name of tag
   // <data>: user data that will be passed in to parser functions
   void custom_tag_end(Builder* builder, GObject2.Object* child, char* tagname, void* data) {
      gtk_buildable_custom_tag_end(&this, builder, child, tagname, data);
   }

   // This is called for each unknown element under &lt;child&gt;.
   // if it doesn't.
   // RETURNS: %TRUE if a object has a custom implementation, %FALSE
   // <builder>: a #GtkBuilder used to construct this object
   // <child>: child object or %NULL for non-child tags
   // <tagname>: name of tag
   // <parser>: a #GMarkupParser structure to fill in
   // <data>: return location for user data that will be passed in to parser functions
   int custom_tag_start(Builder* builder, GObject2.Object* child, char* tagname, /*out*/ GLib2.MarkupParser* parser, /*out*/ void** data) {
      return gtk_buildable_custom_tag_start(&this, builder, child, tagname, parser, data);
   }

   // Get the internal child called @childname of the @buildable object.
   // RETURNS: the internal child of the buildable object
   // <builder>: a #GtkBuilder
   // <childname>: name of child
   GObject2.Object* get_internal_child(Builder* builder, char* childname) {
      return gtk_buildable_get_internal_child(&this, builder, childname);
   }

   // Gets the name of the @buildable object. 
   // #GtkBuilder sets the name based on the the 
   // <link linkend="BUILDER-UI">GtkBuilder UI definition</link> 
   // used to construct the @buildable.
   // RETURNS: the name set with gtk_buildable_set_name()
   char* get_name() {
      return gtk_buildable_get_name(&this);
   }

   // Called when the builder finishes the parsing of a 
   // <link linkend="BUILDER-UI">GtkBuilder UI definition</link>. 
   // Note that this will be called once for each time 
   // gtk_builder_add_from_file() or gtk_builder_add_from_string() 
   // is called on a builder.
   // <builder>: a #GtkBuilder
   void parser_finished(Builder* builder) {
      gtk_buildable_parser_finished(&this, builder);
   }

   // Sets the property name @name to @value on the @buildable object.
   // <builder>: a #GtkBuilder
   // <name>: name of property
   // <value>: value of property
   void set_buildable_property(Builder* builder, char* name, GObject2.Value* value) {
      gtk_buildable_set_buildable_property(&this, builder, name, value);
   }

   // Sets the name of the @buildable object.
   // <name>: name to set
   void set_name(char* name) {
      gtk_buildable_set_name(&this, name);
   }
}


// The GtkBuildableIface interface contains method that are
// necessary to allow #GtkBuilder to construct an object from
// a GtkBuilder UI definition.
struct BuildableIface {
   GObject2.TypeInterface g_iface;
   // <name>: name to set
   extern (C) void function (Buildable* buildable, char* name) set_name;
   // RETURNS: the name set with gtk_buildable_set_name()
   extern (C) char* function (Buildable* buildable) get_name;

   // <builder>: a #GtkBuilder
   // <child>: child to add
   // <type>: kind of child or %NULL
   extern (C) void function (Buildable* buildable, Builder* builder, GObject2.Object* child, char* type=null) add_child;

   // <builder>: a #GtkBuilder
   // <name>: name of property
   // <value>: value of property
   extern (C) void function (Buildable* buildable, Builder* builder, char* name, GObject2.Value* value) set_buildable_property;

   // RETURNS: the constructed child
   // <builder>: #GtkBuilder used to construct this object
   // <name>: name of child to construct
   extern (C) GObject2.Object* /*new*/ function (Buildable* buildable, Builder* builder, char* name) construct_child;

   // RETURNS: %TRUE if a object has a custom implementation, %FALSE
   // <builder>: a #GtkBuilder used to construct this object
   // <child>: child object or %NULL for non-child tags
   // <tagname>: name of tag
   // <parser>: a #GMarkupParser structure to fill in
   // <data>: return location for user data that will be passed in to parser functions
   extern (C) int function (Buildable* buildable, Builder* builder, GObject2.Object* child, char* tagname, /*out*/ GLib2.MarkupParser* parser, /*out*/ void** data) custom_tag_start;

   // <builder>: #GtkBuilder used to construct this object
   // <child>: child object or %NULL for non-child tags
   // <tagname>: name of tag
   // <data>: user data that will be passed in to parser functions
   extern (C) void function (Buildable* buildable, Builder* builder, GObject2.Object* child, char* tagname, void* data) custom_tag_end;

   // <builder>: a #GtkBuilder
   // <child>: child object or %NULL for non-child tags
   // <tagname>: the name of the tag
   // <data>: user data created in custom_tag_start
   extern (C) void function (Buildable* buildable, Builder* builder, GObject2.Object* child, char* tagname, void* data) custom_finished;
   // <builder>: a #GtkBuilder
   extern (C) void function (Buildable* buildable, Builder* builder) parser_finished;

   // RETURNS: the internal child of the buildable object
   // <builder>: a #GtkBuilder
   // <childname>: name of child
   extern (C) GObject2.Object* function (Buildable* buildable, Builder* builder, char* childname) get_internal_child;
}

struct Builder /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   BuilderPrivate* priv;


   // Creates a new builder object.
   // RETURNS: a new #GtkBuilder object
   static Builder* /*new*/ new_() {
      return gtk_builder_new();
   }

   // Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder 
   // UI definition</link> and merges it with the current contents of @builder. 
   // Upon errors 0 will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR 
   // domain.
   // RETURNS: A positive value on success, 0 if an error occurred
   // <filename>: the name of the file to parse
   uint add_from_file(char* filename, GLib2.Error** error=null) {
      return gtk_builder_add_from_file(&this, filename, error);
   }

   // Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder 
   // UI definition</link> and merges it with the current contents of @builder. 
   // Upon errors 0 will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
   // RETURNS: A positive value on success, 0 if an error occurred
   // <buffer>: the string to parse
   // <length>: the length of @buffer (may be -1 if @buffer is nul-terminated)
   uint add_from_string(char* buffer, size_t length, GLib2.Error** error=null) {
      return gtk_builder_add_from_string(&this, buffer, length, error);
   }

   // Parses a file containing a <link linkend="BUILDER-UI">GtkBuilder 
   // UI definition</link> building only the requested objects and merges
   // them with the current contents of @builder. 
   // Upon errors 0 will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR 
   // domain.
   // <note><para>
   // If you are adding an object that depends on an object that is not 
   // its child (for instance a #GtkTreeView that depends on its
   // #GtkTreeModel), you have to explicitely list all of them in @object_ids. 
   // </para></note>
   // RETURNS: A positive value on success, 0 if an error occurred
   // <filename>: the name of the file to parse
   // <object_ids>: nul-terminated array of objects to build
   uint add_objects_from_file(char* filename, char** object_ids, GLib2.Error** error=null) {
      return gtk_builder_add_objects_from_file(&this, filename, object_ids, error);
   }

   // Parses a string containing a <link linkend="BUILDER-UI">GtkBuilder 
   // UI definition</link> building only the requested objects and merges
   // them with the current contents of @builder. 
   // Upon errors 0 will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
   // <note><para>
   // If you are adding an object that depends on an object that is not 
   // its child (for instance a #GtkTreeView that depends on its
   // #GtkTreeModel), you have to explicitely list all of them in @object_ids. 
   // </para></note>
   // RETURNS: A positive value on success, 0 if an error occurred
   // <buffer>: the string to parse
   // <length>: the length of @buffer (may be -1 if @buffer is nul-terminated)
   // <object_ids>: nul-terminated array of objects to build
   uint add_objects_from_string(char* buffer, size_t length, char** object_ids, GLib2.Error** error=null) {
      return gtk_builder_add_objects_from_string(&this, buffer, length, object_ids, error);
   }

   // This method is a simpler variation of gtk_builder_connect_signals_full().
   // It uses #GModule's introspective features (by opening the module %NULL) 
   // to look at the application's symbol table. From here it tries to match
   // the signal handler names given in the interface description with
   // symbols in the application and connects the signals.
   // Note that this function will not work correctly if #GModule is not
   // supported on the platform.
   // When compiling applications for Windows, you must declare signal callbacks
   // with #G_MODULE_EXPORT, or they will not be put in the symbol table.
   // On Linux and Unices, this is not necessary; applications should instead
   // be compiled with the -Wl,--export-dynamic CFLAGS, and linked against
   // gmodule-export-2.0.
   // <user_data>: a pointer to a structure sent in as user data to all signals
   void connect_signals(void* user_data) {
      gtk_builder_connect_signals(&this, user_data);
   }

   // This function can be thought of the interpreted language binding
   // version of gtk_builder_connect_signals(), except that it does not
   // require GModule to function correctly.
   // <func>: the function used to connect the signals
   // <user_data>: arbitrary data that will be passed to the connection function
   void connect_signals_full(BuilderConnectFunc func, void* user_data) {
      gtk_builder_connect_signals_full(&this, func, user_data);
   }

   // Gets the object named @name. Note that this function does not
   // increment the reference count of the returned object. 
   // it could not be found in the object tree.
   // RETURNS: the object named @name or %NULL if
   // <name>: name of object to get
   GObject2.Object* get_object(char* name) {
      return gtk_builder_get_object(&this, name);
   }

   // Gets all objects that have been constructed by @builder. Note that 
   // this function does not increment the reference counts of the returned
   // objects.
   // constructed by the #GtkBuilder instance. It should be freed by
   // g_slist_free()
   // RETURNS: a newly-allocated #GSList containing all the objects
   GLib2.SList* /*new container*/ get_objects() {
      return gtk_builder_get_objects(&this);
   }

   // Gets the translation domain of @builder.
   // by the builder object and must not be modified or freed.
   // RETURNS: the translation domain. This string is owned
   char* get_translation_domain() {
      return gtk_builder_get_translation_domain(&this);
   }

   // Looks up a type by name, using the virtual function that 
   // #GtkBuilder has for that purpose. This is mainly used when
   // implementing the #GtkBuildable interface on a type.
   // if no type was found
   // RETURNS: the #GType found for @type_name or #G_TYPE_INVALID
   // <type_name>: type name to lookup
   Type get_type_from_name(char* type_name) {
      return gtk_builder_get_type_from_name(&this, type_name);
   }

   // Sets the translation domain of @builder. 
   // See #GtkBuilder:translation-domain.
   // <domain>: the translation domain or %NULL
   void set_translation_domain(char* domain=null) {
      gtk_builder_set_translation_domain(&this, domain);
   }

   // This function demarshals a value from a string. This function
   // calls g_value_init() on the @value argument, so it need not be
   // initialised beforehand.
   // This function can handle char, uchar, boolean, int, uint, long,
   // ulong, enum, flags, float, double, string, #GdkColor and
   // #GtkAdjustment type values. Support for #GtkWidget type values is
   // still to come.
   // Upon errors %FALSE will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR domain.
   // RETURNS: %TRUE on success
   // <pspec>: the #GParamSpec for the property
   // <string>: the string representation of the value
   // <value>: the #GValue to store the result in
   int value_from_string(GObject2.ParamSpec* pspec, char* string_, /*out*/ GObject2.Value* value, GLib2.Error** error=null) {
      return gtk_builder_value_from_string(&this, pspec, string_, value, error);
   }

   // Like gtk_builder_value_from_string(), this function demarshals 
   // a value from a string, but takes a #GType instead of #GParamSpec.
   // This function calls g_value_init() on the @value argument, so it 
   // need not be initialised beforehand.
   // Upon errors %FALSE will be returned and @error will be assigned a
   // #GError from the #GTK_BUILDER_ERROR domain.
   // RETURNS: %TRUE on success
   // <type>: the #GType of the value
   // <string>: the string representation of the value
   // <value>: the #GValue to store the result in
   int value_from_string_type(Type type, char* string_, /*out*/ GObject2.Value* value, GLib2.Error** error=null) {
      return gtk_builder_value_from_string_type(&this, type, string_, value, error);
   }
}

struct BuilderClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: the #GType found for @type_name or #G_TYPE_INVALID
   // <type_name>: type name to lookup
   extern (C) Type function (Builder* builder, char* type_name) get_type_from_name;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
   extern (C) void function () _gtk_reserved7;
   extern (C) void function () _gtk_reserved8;
}


// This is the signature of a function used to connect signals.  It is used
// by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full()
// methods.  It is mainly intended for interpreted language bindings, but
// could be useful where the programmer wants more control over the signal
// connection process.
// <builder>: a #GtkBuilder
// <object>: object to connect a signal to
// <signal_name>: name of the signal
// <handler_name>: name of the handler
// <connect_object>: a #GObject, if non-%NULL, use g_signal_connect_object()
// <flags>: #GConnectFlags to use
// <user_data>: user data
extern (C) alias void function (Builder* builder, GObject2.Object* object, char* signal_name, char* handler_name, GObject2.Object* connect_object, GObject2.ConnectFlags flags, void* user_data) BuilderConnectFunc;

enum BuilderError {
   INVALID_TYPE_FUNCTION = 0,
   UNHANDLED_TAG = 1,
   MISSING_ATTRIBUTE = 2,
   INVALID_ATTRIBUTE = 3,
   INVALID_TAG = 4,
   MISSING_PROPERTY_VALUE = 5,
   INVALID_VALUE = 6,
   VERSION_MISMATCH = 7,
   DUPLICATE_ID = 8
}
struct BuilderPrivate {
}

struct Button /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   Gdk2.Window* event_window;
   char* label_text;
   uint activate_timeout;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "constructed", 1,
   uint, "in_button", 1,
   uint, "button_down", 1,
   uint, "relief", 2,
   uint, "use_underline", 1,
   uint, "use_stock", 1,
   uint, "depressed", 1,
   uint, "depress_on_activate", 1,
   uint, "focus_on_click", 1,
    uint, "__dummy32A", 22));

   static Button* new_() {
      return gtk_button_new();
   }

   // Creates a new #GtkButton containing the image and text from a stock item.
   // Some stock ids have preprocessor macros like #GTK_STOCK_OK and
   // #GTK_STOCK_APPLY.
   // If @stock_id is unknown, then it will be treated as a mnemonic
   // label (as for gtk_button_new_with_mnemonic()).
   // RETURNS: a new #GtkButton
   // <stock_id>: the name of the stock item
   static Button* new_from_stock(char* stock_id) {
      return gtk_button_new_from_stock(stock_id);
   }
   static Button* new_with_label(char* label) {
      return gtk_button_new_with_label(label);
   }

   // Creates a new #GtkButton containing a label.
   // If characters in @label are preceded by an underscore, they are underlined.
   // If you need a literal underscore character in a label, use '__' (two 
   // underscores). The first underlined character represents a keyboard 
   // accelerator called a mnemonic.
   // Pressing Alt and that key activates the button.
   // RETURNS: a new #GtkButton
   // <label>: The text of the button, with an underscore in front of the mnemonic character
   static Button* new_with_mnemonic(char* label) {
      return gtk_button_new_with_mnemonic(label);
   }
   void clicked() {
      gtk_button_clicked(&this);
   }
   void enter() {
      gtk_button_enter(&this);
   }

   // Gets the alignment of the child in the button.
   // <xalign>: return location for horizontal alignment
   // <yalign>: return location for vertical alignment
   void get_alignment(/*out*/ float* xalign, /*out*/ float* yalign) {
      gtk_button_get_alignment(&this, xalign, yalign);
   }

   // Returns the button's event window if it is realized, %NULL otherwise.
   // This function should be rarely needed.
   // RETURNS: @button's event window.
   Gdk2.Window* get_event_window() {
      return gtk_button_get_event_window(&this);
   }

   // Returns whether the button grabs focus when it is clicked with the mouse.
   // See gtk_button_set_focus_on_click().
   // the mouse.
   // RETURNS: %TRUE if the button grabs focus when it is clicked with
   int get_focus_on_click() {
      return gtk_button_get_focus_on_click(&this);
   }

   // Gets the widget that is currenty set as the image of @button.
   // This may have been explicitly set by gtk_button_set_image()
   // or constructed by gtk_button_new_from_stock().
   // RETURNS: a #GtkWidget or %NULL in case there is no image
   Widget* get_image() {
      return gtk_button_get_image(&this);
   }

   // Gets the position of the image relative to the text 
   // inside the button.
   // RETURNS: the position
   PositionType get_image_position() {
      return gtk_button_get_image_position(&this);
   }

   // Fetches the text from the label of the button, as set by
   // gtk_button_set_label(). If the label text has not 
   // been set the return value will be %NULL. This will be the 
   // case if you create an empty button with gtk_button_new() to 
   // use as a container.
   // by the widget and must not be modified or freed.
   // RETURNS: The text of the label widget. This string is owned
   char* get_label() {
      return gtk_button_get_label(&this);
   }
   ReliefStyle get_relief() {
      return gtk_button_get_relief(&this);
   }

   // Returns whether the button label is a stock item.
   // select a stock item instead of being
   // used directly as the label text.
   // RETURNS: %TRUE if the button label is used to
   int get_use_stock() {
      return gtk_button_get_use_stock(&this);
   }

   // Returns whether an embedded underline in the button label indicates a
   // mnemonic. See gtk_button_set_use_underline ().
   // indicates the mnemonic accelerator keys.
   // RETURNS: %TRUE if an embedded underline in the button label
   int get_use_underline() {
      return gtk_button_get_use_underline(&this);
   }
   void leave() {
      gtk_button_leave(&this);
   }
   void pressed() {
      gtk_button_pressed(&this);
   }
   void released() {
      gtk_button_released(&this);
   }

   // Sets the alignment of the child. This property has no effect unless 
   // the child is a #GtkMisc or a #GtkAligment.
   // <xalign>: the horizontal position of the child, 0.0 is left aligned, 1.0 is right aligned
   // <yalign>: the vertical position of the child, 0.0 is top aligned, 1.0 is bottom aligned
   void set_alignment(float xalign, float yalign) {
      gtk_button_set_alignment(&this, xalign, yalign);
   }

   // Sets whether the button will grab focus when it is clicked with the mouse.
   // Making mouse clicks not grab focus is useful in places like toolbars where
   // you don't want the keyboard focus removed from the main area of the
   // application.
   // <focus_on_click>: whether the button grabs focus when clicked with the mouse
   void set_focus_on_click(int focus_on_click) {
      gtk_button_set_focus_on_click(&this, focus_on_click);
   }

   // Set the image of @button to the given widget. Note that
   // it depends on the #GtkSettings:gtk-button-images setting whether the
   // image will be displayed or not, you don't have to call
   // gtk_widget_show() on @image yourself.
   // <image>: a widget to set as the image for the button
   void set_image(Widget* image) {
      gtk_button_set_image(&this, image);
   }

   // Sets the position of the image relative to the text 
   // inside the button.
   // <position>: the position
   void set_image_position(PositionType position) {
      gtk_button_set_image_position(&this, position);
   }

   // Sets the text of the label of the button to @str. This text is
   // also used to select the stock item if gtk_button_set_use_stock()
   // is used.
   // This will also clear any previously set labels.
   // <label>: a string
   void set_label(char* label) {
      gtk_button_set_label(&this, label);
   }
   void set_relief(ReliefStyle newstyle) {
      gtk_button_set_relief(&this, newstyle);
   }

   // If %TRUE, the label set on the button is used as a
   // stock id to select the stock item for the button.
   // <use_stock>: %TRUE if the button should use a stock item
   void set_use_stock(int use_stock) {
      gtk_button_set_use_stock(&this, use_stock);
   }

   // If true, an underline in the text of the button label indicates
   // the next character should be used for the mnemonic accelerator key.
   // <use_underline>: %TRUE if underlines in the text indicate mnemonics
   void set_use_underline(int use_underline) {
      gtk_button_set_use_underline(&this, use_underline);
   }

   // The ::activate signal on GtkButton is an action signal and
   // emitting it causes the button to animate press then release. 
   // Applications should never connect to this signal, but use the
   // #GtkButton::clicked signal.
   extern (C) alias static void function (Button* this_, 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);
   }
   // Emitted when the button has been activated (pressed and released).
   extern (C) alias static void function (Button* this_, void* user_data=null) signal_clicked;
   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);
   }
   // Emitted when the pointer enters the button.
   extern (C) alias static void function (Button* this_, void* user_data=null) signal_enter;
   ulong signal_connect(string name:"enter", CB/*:signal_enter*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"enter",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Emitted when the pointer leaves the button.
   extern (C) alias static void function (Button* this_, void* user_data=null) signal_leave;
   ulong signal_connect(string name:"leave", CB/*:signal_leave*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"leave",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Emitted when the button is pressed.
   extern (C) alias static void function (Button* this_, void* user_data=null) signal_pressed;
   ulong signal_connect(string name:"pressed", CB/*:signal_pressed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"pressed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Emitted when the button is released.
   extern (C) alias static void function (Button* this_, void* user_data=null) signal_released;
   ulong signal_connect(string name:"released", CB/*:signal_released*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"released",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

enum ButtonAction {
   IGNORED = 0,
   SELECTS = 1,
   DRAGS = 2,
   EXPANDS = 4
}
struct ButtonBox /* : Box */ {
   alias box this;
   alias box super_;
   Box box;
   int child_min_width, child_min_height, child_ipad_x, child_ipad_y;
   ButtonBoxStyle layout_style;

   void get_child_ipadding(int* ipad_x, int* ipad_y) {
      gtk_button_box_get_child_ipadding(&this, ipad_x, ipad_y);
   }

   // Returns whether @child should appear in a secondary group of children.
   // RETURNS: whether @child should appear in a secondary group of children.
   // <child>: a child of @widget
   int get_child_secondary(Widget* child) {
      return gtk_button_box_get_child_secondary(&this, child);
   }
   void get_child_size(int* min_width, int* min_height) {
      gtk_button_box_get_child_size(&this, min_width, min_height);
   }
   ButtonBoxStyle get_layout() {
      return gtk_button_box_get_layout(&this);
   }
   void set_child_ipadding(int ipad_x, int ipad_y) {
      gtk_button_box_set_child_ipadding(&this, ipad_x, ipad_y);
   }

   // Sets whether @child should appear in a secondary group of children.
   // A typical use of a secondary child is the help button in a dialog.
   // This group appears after the other children if the style
   // is %GTK_BUTTONBOX_START, %GTK_BUTTONBOX_SPREAD or
   // %GTK_BUTTONBOX_EDGE, and before the other children if the style
   // is %GTK_BUTTONBOX_END. For horizontal button boxes, the definition
   // of before/after depends on direction of the widget (see
   // gtk_widget_set_direction()). If the style is %GTK_BUTTONBOX_START
   // or %GTK_BUTTONBOX_END, then the secondary children are aligned at
   // the other end of the button box from the main children. For the
   // other styles, they appear immediately next to the main children.
   // <child>: a child of @widget
   // <is_secondary>: if %TRUE, the @child appears in a secondary group of the button box.
   void set_child_secondary(Widget* child, int is_secondary) {
      gtk_button_box_set_child_secondary(&this, child, is_secondary);
   }
   void set_child_size(int min_width, int min_height) {
      gtk_button_box_set_child_size(&this, min_width, min_height);
   }
   void set_layout(ButtonBoxStyle layout_style) {
      gtk_button_box_set_layout(&this, layout_style);
   }
}

struct ButtonBoxClass {
   BoxClass parent_class;
}

enum ButtonBoxStyle {
   DEFAULT_STYLE = 0,
   SPREAD = 1,
   EDGE = 2,
   START = 3,
   END = 4,
   CENTER = 5
}
struct ButtonClass {
   BinClass parent_class;
   extern (C) void function (Button* button) pressed;
   extern (C) void function (Button* button) released;
   extern (C) void function (Button* button) clicked;
   extern (C) void function (Button* button) enter;
   extern (C) void function (Button* button) leave;
   extern (C) void function (Button* button) activate;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// Prebuilt sets of buttons for the dialog. If
// none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
// then call gtk_dialog_add_buttons().
// <note>
// Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
// and %GTK_BUTTONS_OK_CANCEL are discouraged by the
// <ulink url="http://library.gnome.org/devel/hig-book/stable/">GNOME HIG</ulink>.
// </note>
enum ButtonsType {
   NONE = 0,
   OK = 1,
   CLOSE = 2,
   CANCEL = 3,
   YES_NO = 4,
   OK_CANCEL = 5
}
struct CList /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   ushort flags;
   void* reserved1, reserved2;
   uint freeze_count;
   Gdk2.Rectangle internal_allocation;
   int rows, row_height;
   GLib2.List* row_list, row_list_end;
   int columns;
   Gdk2.Rectangle column_title_area;
   Gdk2.Window* title_window;
   CListColumn* column;
   Gdk2.Window* clist_window;
   int clist_window_width, clist_window_height, hoffset, voffset;
   ShadowType shadow_type;
   SelectionMode selection_mode;
   GLib2.List* selection, selection_end, undo_selection_, undo_unselection;
   int undo_anchor;
   ubyte[5] button_actions;
   ubyte drag_button;
   CListCellInfo click_cell;
   Adjustment* hadjustment, vadjustment;
   Gdk2.GC* xor_gc, fg_gc, bg_gc;
   Gdk2.Cursor* cursor_drag;
   int x_drag, focus_row, focus_header_column, anchor;
   StateType anchor_state;
   int drag_pos, htimer, vtimer;
   SortType sort_type;
   CListCompareFunc compare;
   int sort_column, drag_highlight_row;
   CListDragPos drag_highlight_pos;

   static CList* new_(int columns) {
      return gtk_clist_new(columns);
   }
   static CList* new_with_titles(int columns, char* titles) {
      return gtk_clist_new_with_titles(columns, titles);
   }
   int append(char* text) {
      return gtk_clist_append(&this, text);
   }
   void clear() {
      gtk_clist_clear(&this);
   }
   void column_title_active(int column) {
      gtk_clist_column_title_active(&this, column);
   }
   void column_title_passive(int column) {
      gtk_clist_column_title_passive(&this, column);
   }
   void column_titles_active() {
      gtk_clist_column_titles_active(&this);
   }
   void column_titles_hide() {
      gtk_clist_column_titles_hide(&this);
   }
   void column_titles_passive() {
      gtk_clist_column_titles_passive(&this);
   }
   void column_titles_show() {
      gtk_clist_column_titles_show(&this);
   }
   int columns_autosize() {
      return gtk_clist_columns_autosize(&this);
   }
   int find_row_from_data(void* data) {
      return gtk_clist_find_row_from_data(&this, data);
   }
   void freeze() {
      gtk_clist_freeze(&this);
   }
   // Unintrospectable method: get_cell_style() / gtk_clist_get_cell_style()
   Style* get_cell_style(int row, int column) {
      return gtk_clist_get_cell_style(&this, row, column);
   }
   CellType get_cell_type(int row, int column) {
      return gtk_clist_get_cell_type(&this, row, column);
   }
   char* /*new*/ get_column_title(int column) {
      return gtk_clist_get_column_title(&this, column);
   }
   // Unintrospectable method: get_column_widget() / gtk_clist_get_column_widget()
   Widget* get_column_widget(int column) {
      return gtk_clist_get_column_widget(&this, column);
   }
   // Unintrospectable method: get_hadjustment() / gtk_clist_get_hadjustment()
   Adjustment* get_hadjustment() {
      return gtk_clist_get_hadjustment(&this);
   }
   int get_pixmap(int row, int column, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask) {
      return gtk_clist_get_pixmap(&this, row, column, pixmap, mask);
   }
   int get_pixtext(int row, int column, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask) {
      return gtk_clist_get_pixtext(&this, row, column, text, spacing, pixmap, mask);
   }
   // Unintrospectable method: get_row_data() / gtk_clist_get_row_data()
   void* get_row_data(int row) {
      return gtk_clist_get_row_data(&this, row);
   }
   // Unintrospectable method: get_row_style() / gtk_clist_get_row_style()
   Style* get_row_style(int row) {
      return gtk_clist_get_row_style(&this, row);
   }
   int get_selectable(int row) {
      return gtk_clist_get_selectable(&this, row);
   }
   int get_selection_info(int x, int y, int* row, int* column) {
      return gtk_clist_get_selection_info(&this, x, y, row, column);
   }
   int get_text(int row, int column, char** text) {
      return gtk_clist_get_text(&this, row, column, text);
   }
   // Unintrospectable method: get_vadjustment() / gtk_clist_get_vadjustment()
   Adjustment* get_vadjustment() {
      return gtk_clist_get_vadjustment(&this);
   }
   int insert(int row, char* text) {
      return gtk_clist_insert(&this, row, text);
   }
   void moveto(int row, int column, float row_align, float col_align) {
      gtk_clist_moveto(&this, row, column, row_align, col_align);
   }
   int optimal_column_width(int column) {
      return gtk_clist_optimal_column_width(&this, column);
   }
   int prepend(char* text) {
      return gtk_clist_prepend(&this, text);
   }
   void remove(int row) {
      gtk_clist_remove(&this, row);
   }
   Visibility row_is_visible(int row) {
      return gtk_clist_row_is_visible(&this, row);
   }
   void row_move(int source_row, int dest_row) {
      gtk_clist_row_move(&this, source_row, dest_row);
   }
   void select_all() {
      gtk_clist_select_all(&this);
   }
   void select_row(int row, int column) {
      gtk_clist_select_row(&this, row, column);
   }
   void set_auto_sort(int auto_sort) {
      gtk_clist_set_auto_sort(&this, auto_sort);
   }
   void set_background(int row, Gdk2.Color* color) {
      gtk_clist_set_background(&this, row, color);
   }
   void set_button_actions(uint button, ubyte button_actions) {
      gtk_clist_set_button_actions(&this, button, button_actions);
   }
   void set_cell_style(int row, int column, Style* style) {
      gtk_clist_set_cell_style(&this, row, column, style);
   }
   void set_column_auto_resize(int column, int auto_resize) {
      gtk_clist_set_column_auto_resize(&this, column, auto_resize);
   }
   void set_column_justification(int column, Justification justification) {
      gtk_clist_set_column_justification(&this, column, justification);
   }
   void set_column_max_width(int column, int max_width) {
      gtk_clist_set_column_max_width(&this, column, max_width);
   }
   void set_column_min_width(int column, int min_width) {
      gtk_clist_set_column_min_width(&this, column, min_width);
   }
   void set_column_resizeable(int column, int resizeable) {
      gtk_clist_set_column_resizeable(&this, column, resizeable);
   }
   void set_column_title(int column, char* title) {
      gtk_clist_set_column_title(&this, column, title);
   }
   void set_column_visibility(int column, int visible) {
      gtk_clist_set_column_visibility(&this, column, visible);
   }
   void set_column_widget(int column, Widget* widget) {
      gtk_clist_set_column_widget(&this, column, widget);
   }
   void set_column_width(int column, int width) {
      gtk_clist_set_column_width(&this, column, width);
   }
   // Unintrospectable method: set_compare_func() / gtk_clist_set_compare_func()
   void set_compare_func(CListCompareFunc cmp_func) {
      gtk_clist_set_compare_func(&this, cmp_func);
   }
   void set_foreground(int row, Gdk2.Color* color) {
      gtk_clist_set_foreground(&this, row, color);
   }
   void set_hadjustment(Adjustment* adjustment) {
      gtk_clist_set_hadjustment(&this, adjustment);
   }
   void set_pixmap(int row, int column, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null) {
      gtk_clist_set_pixmap(&this, row, column, pixmap, mask);
   }
   void set_pixtext(int row, int column, char* text, ubyte spacing, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask) {
      gtk_clist_set_pixtext(&this, row, column, text, spacing, pixmap, mask);
   }
   void set_reorderable(int reorderable) {
      gtk_clist_set_reorderable(&this, reorderable);
   }
   void set_row_data(int row, void* data) {
      gtk_clist_set_row_data(&this, row, data);
   }
   void set_row_data_full(int row, void* data, GLib2.DestroyNotify destroy) {
      gtk_clist_set_row_data_full(&this, row, data, destroy);
   }
   void set_row_height(uint height) {
      gtk_clist_set_row_height(&this, height);
   }
   void set_row_style(int row, Style* style) {
      gtk_clist_set_row_style(&this, row, style);
   }
   void set_selectable(int row, int selectable) {
      gtk_clist_set_selectable(&this, row, selectable);
   }
   void set_selection_mode(SelectionMode mode) {
      gtk_clist_set_selection_mode(&this, mode);
   }
   void set_shadow_type(ShadowType type) {
      gtk_clist_set_shadow_type(&this, type);
   }
   void set_shift(int row, int column, int vertical, int horizontal) {
      gtk_clist_set_shift(&this, row, column, vertical, horizontal);
   }
   void set_sort_column(int column) {
      gtk_clist_set_sort_column(&this, column);
   }
   void set_sort_type(SortType sort_type) {
      gtk_clist_set_sort_type(&this, sort_type);
   }
   void set_text(int row, int column, char* text) {
      gtk_clist_set_text(&this, row, column, text);
   }
   void set_use_drag_icons(int use_icons) {
      gtk_clist_set_use_drag_icons(&this, use_icons);
   }
   void set_vadjustment(Adjustment* adjustment) {
      gtk_clist_set_vadjustment(&this, adjustment);
   }
   void sort() {
      gtk_clist_sort(&this);
   }
   void swap_rows(int row1, int row2) {
      gtk_clist_swap_rows(&this, row1, row2);
   }
   void thaw() {
      gtk_clist_thaw(&this);
   }
   void undo_selection() {
      gtk_clist_undo_selection(&this);
   }
   void unselect_all() {
      gtk_clist_unselect_all(&this);
   }
   void unselect_row(int row, int column) {
      gtk_clist_unselect_row(&this, row, column);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_abort_column_resize;

   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:"abort-column-resize", CB/*:signal_abort_column_resize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"abort-column-resize",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, int object, void* user_data=null) signal_click_column;
   ulong signal_connect(string name:"click-column", CB/*:signal_click_column*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"click-column",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_end_selection;
   ulong signal_connect(string name:"end-selection", CB/*:signal_end_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"end-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, ScrollType* object, float p0, c_int p1, void* user_data=null) signal_extend_selection;
   ulong signal_connect(string name:"extend-selection", CB/*:signal_extend_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"extend-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, int object, int p0, void* user_data=null) signal_resize_column;
   ulong signal_connect(string name:"resize-column", CB/*:signal_resize_column*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"resize-column",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, int object, int p0, void* user_data=null) signal_row_move;
   ulong signal_connect(string name:"row-move", CB/*:signal_row_move*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-move",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, ScrollType* object, float p0, void* user_data=null) signal_scroll_horizontal;
   ulong signal_connect(string name:"scroll-horizontal", CB/*:signal_scroll_horizontal*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-horizontal",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, ScrollType* object, float p0, void* user_data=null) signal_scroll_vertical;
   ulong signal_connect(string name:"scroll-vertical", CB/*:signal_scroll_vertical*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-vertical",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_select_all;
   ulong signal_connect(string name:"select-all", CB/*:signal_select_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, int object, int p0, Gdk2.Event* p1, void* user_data=null) signal_select_row;
   ulong signal_connect(string name:"select-row", CB/*:signal_select_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;
   ulong signal_connect(string name:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_start_selection;
   ulong signal_connect(string name:"start-selection", CB/*:signal_start_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"start-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_toggle_add_mode;
   ulong signal_connect(string name:"toggle-add-mode", CB/*:signal_toggle_add_mode*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-add-mode",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_toggle_focus_row;
   ulong signal_connect(string name:"toggle-focus-row", CB/*:signal_toggle_focus_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-focus-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_undo_selection;
   ulong signal_connect(string name:"undo-selection", CB/*:signal_undo_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"undo-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, void* user_data=null) signal_unselect_all;
   ulong signal_connect(string name:"unselect-all", CB/*:signal_unselect_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (CList* this_, int object, int p0, Gdk2.Event* p1, void* user_data=null) signal_unselect_row;
   ulong signal_connect(string name:"unselect-row", CB/*:signal_unselect_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CListCellInfo {
   int row, column;
}

struct CListClass {
   ContainerClass parent_class;
   extern (C) void function (CList* clist, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
   extern (C) void function (CList* clist) refresh;
   extern (C) void function (CList* clist, int row, int column, Gdk2.Event* event) select_row;
   extern (C) void function (CList* clist, int row, int column, Gdk2.Event* event) unselect_row;
   extern (C) void function (CList* clist, int source_row, int dest_row) row_move;
   extern (C) void function (CList* clist, int column) click_column;
   extern (C) void function (CList* clist, int column, int width) resize_column;
   extern (C) void function (CList* clist) toggle_focus_row;
   extern (C) void function (CList* clist) select_all;
   extern (C) void function (CList* clist) unselect_all;
   extern (C) void function (CList* clist) undo_selection;
   extern (C) void function (CList* clist) start_selection;
   extern (C) void function (CList* clist) end_selection;
   extern (C) void function (CList* clist, ScrollType scroll_type, float position, int auto_start_selection) extend_selection;
   extern (C) void function (CList* clist, ScrollType scroll_type, float position) scroll_horizontal;
   extern (C) void function (CList* clist, ScrollType scroll_type, float position) scroll_vertical;
   extern (C) void function (CList* clist) toggle_add_mode;
   extern (C) void function (CList* clist) abort_column_resize;
   extern (C) void function (CList* clist, Gdk2.Event* event) resync_selection;
   // Unintrospectable functionp: selection_find() / ()
   extern (C) GLib2.List* function (CList* clist, int row_number, GLib2.List* row_list_element) selection_find;
   extern (C) void function (CList* clist, Gdk2.Rectangle* area, int row, CListRow* clist_row) draw_row;
   extern (C) void function (CList* clist, CListRow* target_row, int target_row_number, CListDragPos drag_pos) draw_drag_highlight;
   extern (C) void function (CList* clist) clear;
   extern (C) void function (CList* clist, int row) fake_unselect_all;
   extern (C) void function (CList* clist) sort_list;
   extern (C) int function (CList* clist, int row, char* text) insert_row;
   extern (C) void function (CList* clist, int row) remove_row;
   extern (C) void function (CList* clist, CListRow* clist_row, int column, CellType type, char* text, ubyte spacing, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask) set_cell_contents;
   extern (C) void function (CList* clist, CListRow* clist_row, int column, Requisition* requisition) cell_size_request;
}

struct CListColumn {
   char* title;
   Gdk2.Rectangle area;
   Widget* button;
   Gdk2.Window* window;
   int width, min_width, max_width;
   Justification justification;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "visible", 1,
   uint, "width_set", 1,
   uint, "resizeable", 1,
   uint, "auto_resize", 1,
   uint, "button_passive", 1,
    uint, "__dummy32A", 27));
}

extern (C) alias int function (CList* clist, const(void)* ptr1, const(void)* ptr2) CListCompareFunc;

struct CListDestInfo {
   CListCellInfo cell;
   CListDragPos insert_pos;
}

enum CListDragPos {
   NONE = 0,
   BEFORE = 1,
   INTO = 2,
   AFTER = 3
}
struct CListRow {
   Cell* cell;
   StateType state;
   Gdk2.Color foreground, background;
   Style* style;
   void* data;
   GLib2.DestroyNotify destroy;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "fg_set", 1,
   uint, "bg_set", 1,
   uint, "selectable", 1,
    uint, "__dummy32A", 29));
}

struct CTree /* : CList */ {
   alias clist this;
   alias clist super_;
   CList clist;
   Gdk2.GC* lines_gc;
   int tree_indent, tree_spacing, tree_column;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "line_style", 2,
   uint, "expander_style", 2,
   uint, "show_stub", 1,
    uint, "__dummy32A", 27));
   CTreeCompareDragFunc drag_compare;

   static CTree* new_(int columns, int tree_column) {
      return gtk_ctree_new(columns, tree_column);
   }
   static CTree* new_with_titles(int columns, int tree_column, char* titles) {
      return gtk_ctree_new_with_titles(columns, tree_column, titles);
   }
   void collapse(CTreeNode* node) {
      gtk_ctree_collapse(&this, node);
   }
   void collapse_recursive(CTreeNode* node) {
      gtk_ctree_collapse_recursive(&this, node);
   }
   void collapse_to_depth(CTreeNode* node, int depth) {
      gtk_ctree_collapse_to_depth(&this, node, depth);
   }
   void expand(CTreeNode* node) {
      gtk_ctree_expand(&this, node);
   }
   void expand_recursive(CTreeNode* node) {
      gtk_ctree_expand_recursive(&this, node);
   }
   void expand_to_depth(CTreeNode* node, int depth) {
      gtk_ctree_expand_to_depth(&this, node, depth);
   }
   // Unintrospectable method: export_to_gnode() / gtk_ctree_export_to_gnode()
   GLib2.Node* export_to_gnode(GLib2.Node* parent, GLib2.Node* sibling, CTreeNode* node, CTreeGNodeFunc func, void* data) {
      return gtk_ctree_export_to_gnode(&this, parent, sibling, node, func, data);
   }
   int find(CTreeNode* node, CTreeNode* child) {
      return gtk_ctree_find(&this, node, child);
   }
   // Unintrospectable method: find_all_by_row_data() / gtk_ctree_find_all_by_row_data()
   GLib2.List* find_all_by_row_data(CTreeNode* node, void* data) {
      return gtk_ctree_find_all_by_row_data(&this, node, data);
   }
   // Unintrospectable method: find_all_by_row_data_custom() / gtk_ctree_find_all_by_row_data_custom()
   GLib2.List* find_all_by_row_data_custom(CTreeNode* node, void* data, GLib2.CompareFunc func) {
      return gtk_ctree_find_all_by_row_data_custom(&this, node, data, func);
   }
   // Unintrospectable method: find_by_row_data() / gtk_ctree_find_by_row_data()
   CTreeNode* find_by_row_data(CTreeNode* node, void* data) {
      return gtk_ctree_find_by_row_data(&this, node, data);
   }
   // Unintrospectable method: find_by_row_data_custom() / gtk_ctree_find_by_row_data_custom()
   CTreeNode* find_by_row_data_custom(CTreeNode* node, void* data, GLib2.CompareFunc func) {
      return gtk_ctree_find_by_row_data_custom(&this, node, data, func);
   }
   // Unintrospectable method: find_node_ptr() / gtk_ctree_find_node_ptr()
   CTreeNode* find_node_ptr(CTreeRow* ctree_row) {
      return gtk_ctree_find_node_ptr(&this, ctree_row);
   }
   int get_node_info(CTreeNode* node, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap_closed, Gdk2.Bitmap** mask_closed, Gdk2.Pixmap** pixmap_opened, Gdk2.Bitmap** mask_opened, int* is_leaf, int* expanded) {
      return gtk_ctree_get_node_info(&this, node, text, spacing, pixmap_closed, mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
   }
   // Unintrospectable method: insert_gnode() / gtk_ctree_insert_gnode()
   CTreeNode* insert_gnode(CTreeNode* parent, CTreeNode* sibling, GLib2.Node* gnode, CTreeGNodeFunc func, void* data) {
      return gtk_ctree_insert_gnode(&this, parent, sibling, gnode, func, data);
   }
   // Unintrospectable method: insert_node() / gtk_ctree_insert_node()
   CTreeNode* insert_node(CTreeNode* parent, CTreeNode* sibling, char* text, ubyte spacing, Gdk2.Pixmap* pixmap_closed, Gdk2.Bitmap* mask_closed, Gdk2.Pixmap* pixmap_opened, Gdk2.Bitmap* mask_opened, int is_leaf, int expanded) {
      return gtk_ctree_insert_node(&this, parent, sibling, text, spacing, pixmap_closed, mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
   }
   int is_ancestor(CTreeNode* node, CTreeNode* child) {
      return gtk_ctree_is_ancestor(&this, node, child);
   }
   int is_hot_spot(int x, int y) {
      return gtk_ctree_is_hot_spot(&this, x, y);
   }
   int is_viewable(CTreeNode* node) {
      return gtk_ctree_is_viewable(&this, node);
   }
   // Unintrospectable method: last() / gtk_ctree_last()
   CTreeNode* last(CTreeNode* node) {
      return gtk_ctree_last(&this, node);
   }
   void move(CTreeNode* node, CTreeNode* new_parent=null, CTreeNode* new_sibling=null) {
      gtk_ctree_move(&this, node, new_parent, new_sibling);
   }
   // Unintrospectable method: node_get_cell_style() / gtk_ctree_node_get_cell_style()
   Style* node_get_cell_style(CTreeNode* node, int column) {
      return gtk_ctree_node_get_cell_style(&this, node, column);
   }
   CellType node_get_cell_type(CTreeNode* node, int column) {
      return gtk_ctree_node_get_cell_type(&this, node, column);
   }
   int node_get_pixmap(CTreeNode* node, int column, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask) {
      return gtk_ctree_node_get_pixmap(&this, node, column, pixmap, mask);
   }
   int node_get_pixtext(CTreeNode* node, int column, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask) {
      return gtk_ctree_node_get_pixtext(&this, node, column, text, spacing, pixmap, mask);
   }
   // Unintrospectable method: node_get_row_data() / gtk_ctree_node_get_row_data()
   void* node_get_row_data(CTreeNode* node) {
      return gtk_ctree_node_get_row_data(&this, node);
   }
   // Unintrospectable method: node_get_row_style() / gtk_ctree_node_get_row_style()
   Style* node_get_row_style(CTreeNode* node) {
      return gtk_ctree_node_get_row_style(&this, node);
   }
   int node_get_selectable(CTreeNode* node) {
      return gtk_ctree_node_get_selectable(&this, node);
   }
   int node_get_text(CTreeNode* node, int column, char** text) {
      return gtk_ctree_node_get_text(&this, node, column, text);
   }
   Visibility node_is_visible(CTreeNode* node) {
      return gtk_ctree_node_is_visible(&this, node);
   }
   void node_moveto(CTreeNode* node, int column, float row_align, float col_align) {
      gtk_ctree_node_moveto(&this, node, column, row_align, col_align);
   }
   // Unintrospectable method: node_nth() / gtk_ctree_node_nth()
   CTreeNode* node_nth(uint row) {
      return gtk_ctree_node_nth(&this, row);
   }
   void node_set_background(CTreeNode* node, Gdk2.Color* color) {
      gtk_ctree_node_set_background(&this, node, color);
   }
   void node_set_cell_style(CTreeNode* node, int column, Style* style) {
      gtk_ctree_node_set_cell_style(&this, node, column, style);
   }
   void node_set_foreground(CTreeNode* node, Gdk2.Color* color) {
      gtk_ctree_node_set_foreground(&this, node, color);
   }
   void node_set_pixmap(CTreeNode* node, int column, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null) {
      gtk_ctree_node_set_pixmap(&this, node, column, pixmap, mask);
   }
   void node_set_pixtext(CTreeNode* node, int column, char* text, ubyte spacing, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null) {
      gtk_ctree_node_set_pixtext(&this, node, column, text, spacing, pixmap, mask);
   }
   void node_set_row_data(CTreeNode* node, void* data) {
      gtk_ctree_node_set_row_data(&this, node, data);
   }
   void node_set_row_data_full(CTreeNode* node, void* data, GLib2.DestroyNotify destroy) {
      gtk_ctree_node_set_row_data_full(&this, node, data, destroy);
   }
   void node_set_row_style(CTreeNode* node, Style* style) {
      gtk_ctree_node_set_row_style(&this, node, style);
   }
   void node_set_selectable(CTreeNode* node, int selectable) {
      gtk_ctree_node_set_selectable(&this, node, selectable);
   }
   void node_set_shift(CTreeNode* node, int column, int vertical, int horizontal) {
      gtk_ctree_node_set_shift(&this, node, column, vertical, horizontal);
   }
   void node_set_text(CTreeNode* node, int column, char* text) {
      gtk_ctree_node_set_text(&this, node, column, text);
   }
   // Unintrospectable method: post_recursive() / gtk_ctree_post_recursive()
   void post_recursive(CTreeNode* node, CTreeFunc func, void* data) {
      gtk_ctree_post_recursive(&this, node, func, data);
   }
   // Unintrospectable method: post_recursive_to_depth() / gtk_ctree_post_recursive_to_depth()
   void post_recursive_to_depth(CTreeNode* node, int depth, CTreeFunc func, void* data) {
      gtk_ctree_post_recursive_to_depth(&this, node, depth, func, data);
   }
   // Unintrospectable method: pre_recursive() / gtk_ctree_pre_recursive()
   void pre_recursive(CTreeNode* node, CTreeFunc func, void* data) {
      gtk_ctree_pre_recursive(&this, node, func, data);
   }
   // Unintrospectable method: pre_recursive_to_depth() / gtk_ctree_pre_recursive_to_depth()
   void pre_recursive_to_depth(CTreeNode* node, int depth, CTreeFunc func, void* data) {
      gtk_ctree_pre_recursive_to_depth(&this, node, depth, func, data);
   }
   void real_select_recursive(CTreeNode* node, int state) {
      gtk_ctree_real_select_recursive(&this, node, state);
   }
   void remove_node(CTreeNode* node) {
      gtk_ctree_remove_node(&this, node);
   }
   void select(CTreeNode* node) {
      gtk_ctree_select(&this, node);
   }
   void select_recursive(CTreeNode* node) {
      gtk_ctree_select_recursive(&this, node);
   }
   // Unintrospectable method: set_drag_compare_func() / gtk_ctree_set_drag_compare_func()
   void set_drag_compare_func(CTreeCompareDragFunc cmp_func) {
      gtk_ctree_set_drag_compare_func(&this, cmp_func);
   }
   void set_expander_style(CTreeExpanderStyle expander_style) {
      gtk_ctree_set_expander_style(&this, expander_style);
   }
   void set_indent(int indent) {
      gtk_ctree_set_indent(&this, indent);
   }
   void set_line_style(CTreeLineStyle line_style) {
      gtk_ctree_set_line_style(&this, line_style);
   }
   void set_node_info(CTreeNode* node, char* text, ubyte spacing, Gdk2.Pixmap* pixmap_closed, Gdk2.Bitmap* mask_closed, Gdk2.Pixmap* pixmap_opened, Gdk2.Bitmap* mask_opened, int is_leaf, int expanded) {
      gtk_ctree_set_node_info(&this, node, text, spacing, pixmap_closed, mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
   }
   void set_show_stub(int show_stub) {
      gtk_ctree_set_show_stub(&this, show_stub);
   }
   void set_spacing(int spacing) {
      gtk_ctree_set_spacing(&this, spacing);
   }
   void sort_node(CTreeNode* node) {
      gtk_ctree_sort_node(&this, node);
   }
   void sort_recursive(CTreeNode* node) {
      gtk_ctree_sort_recursive(&this, node);
   }
   void toggle_expansion(CTreeNode* node) {
      gtk_ctree_toggle_expansion(&this, node);
   }
   void toggle_expansion_recursive(CTreeNode* node) {
      gtk_ctree_toggle_expansion_recursive(&this, node);
   }
   void unselect(CTreeNode* node) {
      gtk_ctree_unselect(&this, node);
   }
   void unselect_recursive(CTreeNode* node) {
      gtk_ctree_unselect_recursive(&this, node);
   }
   extern (C) alias static void function (CTree* this_, CTreeExpansionType* object, void* user_data=null) signal_change_focus_row_expansion;

   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:"change-focus-row-expansion", CB/*:signal_change_focus_row_expansion*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-focus-row-expansion",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Unintrospectable glib:signal: tree-collapse() / ()
   extern (C) alias static void function (CTree* this_, void* object, void* user_data=null) signal_tree_collapse;
   ulong signal_connect(string name:"tree-collapse", CB/*:signal_tree_collapse*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tree-collapse",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Unintrospectable glib:signal: tree-expand() / ()
   extern (C) alias static void function (CTree* this_, void* object, void* user_data=null) signal_tree_expand;
   ulong signal_connect(string name:"tree-expand", CB/*:signal_tree_expand*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tree-expand",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Unintrospectable glib:signal: tree-move() / ()
   extern (C) alias static void function (CTree* this_, void* object, void* p0, void* p1, void* user_data=null) signal_tree_move;
   ulong signal_connect(string name:"tree-move", CB/*:signal_tree_move*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tree-move",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Unintrospectable glib:signal: tree-select-row() / ()
   extern (C) alias static void function (CTree* this_, void* object, int p0, void* user_data=null) signal_tree_select_row;
   ulong signal_connect(string name:"tree-select-row", CB/*:signal_tree_select_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tree-select-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Unintrospectable glib:signal: tree-unselect-row() / ()
   extern (C) alias static void function (CTree* this_, void* object, int p0, void* user_data=null) signal_tree_unselect_row;
   ulong signal_connect(string name:"tree-unselect-row", CB/*:signal_tree_unselect_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tree-unselect-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CTreeClass {
   CListClass parent_class;
   extern (C) void function (CTree* ctree, CTreeNode* row, int column) tree_select_row;
   extern (C) void function (CTree* ctree, CTreeNode* row, int column) tree_unselect_row;
   extern (C) void function (CTree* ctree, CTreeNode* node) tree_expand;
   extern (C) void function (CTree* ctree, CTreeNode* node) tree_collapse;
   extern (C) void function (CTree* ctree, CTreeNode* node, CTreeNode* new_parent, CTreeNode* new_sibling) tree_move;
   extern (C) void function (CTree* ctree, CTreeExpansionType action) change_focus_row_expansion;
}

extern (C) alias int function (CTree* ctree, CTreeNode* source_node, CTreeNode* new_parent, CTreeNode* new_sibling) CTreeCompareDragFunc;

enum CTreeExpanderStyle {
   NONE = 0,
   SQUARE = 1,
   TRIANGLE = 2,
   CIRCULAR = 3
}
enum CTreeExpansionType {
   EXPAND = 0,
   EXPAND_RECURSIVE = 1,
   COLLAPSE = 2,
   COLLAPSE_RECURSIVE = 3,
   TOGGLE = 4,
   TOGGLE_RECURSIVE = 5
}
extern (C) alias void function (CTree* ctree, CTreeNode* node, void* data) CTreeFunc;

extern (C) alias int function (CTree* ctree, uint depth, GLib2.Node* gnode, CTreeNode* cnode, void* data) CTreeGNodeFunc;

enum CTreeLineStyle {
   NONE = 0,
   SOLID = 1,
   DOTTED = 2,
   TABBED = 3
}
struct CTreeNode {
   GLib2.List list;
}

enum CTreePos {
   BEFORE = 0,
   AS_CHILD = 1,
   AFTER = 2
}
struct CTreeRow {
   CListRow row;
   CTreeNode* parent, sibling, children;
   Gdk2.Pixmap* pixmap_closed;
   Gdk2.Bitmap* mask_closed;
   Gdk2.Pixmap* pixmap_opened;
   Gdk2.Bitmap* mask_opened;
   ushort level;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "is_leaf", 1,
   uint, "expanded", 1,
    uint, "__dummy32A", 30));
}

struct Calendar /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   Style* header_style, label_style;
   int month, year, selected_day;
   int[6] day_month, day;
   int num_marked_dates;
   int[31] marked_date;
   CalendarDisplayOptions display_flags;
   Gdk2.Color[31] marked_date_color;
   Gdk2.GC* gc, xor_gc;
   int focus_row, focus_col, highlight_row, highlight_col;
   CalendarPrivate* priv;
   char[32] grow_space;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;


   // Creates a new calendar, with the current date being selected.
   // RETURNS: a newly #GtkCalendar widget
   static Calendar* new_() {
      return gtk_calendar_new();
   }
   // Remove all visual markers.
   void clear_marks() {
      gtk_calendar_clear_marks(&this);
   }

   // Sets display options (whether to display the heading and the month headings).
   // <flags>: the display options to set.
   void display_options(CalendarDisplayOptions flags) {
      gtk_calendar_display_options(&this, flags);
   }

   // Does nothing. Previously locked the display of the calendar until
   // it was thawed with gtk_calendar_thaw().
   void freeze() {
      gtk_calendar_freeze(&this);
   }

   // Obtains the selected date from a #GtkCalendar.
   // <year>: location to store the year as a decimal number (e.g. 2011), or %NULL
   // <month>: location to store the month number (between 0 and 11), or %NULL
   // <day>: location to store the day number (between 1 and 31), or %NULL
   void get_date(/*out*/ uint* year=null, /*out*/ uint* month=null, /*out*/ uint* day=null) {
      gtk_calendar_get_date(&this, year, month, day);
   }

   // Queries the height of detail cells, in rows.
   // See #GtkCalendar:detail-width-chars.
   // RETURNS: The height of detail cells, in rows.
   int get_detail_height_rows() {
      return gtk_calendar_get_detail_height_rows(&this);
   }

   // Queries the width of detail cells, in characters.
   // See #GtkCalendar:detail-width-chars.
   // RETURNS: The width of detail cells, in characters.
   int get_detail_width_chars() {
      return gtk_calendar_get_detail_width_chars(&this);
   }

   // Returns the current display options of @calendar.
   // RETURNS: the display options.
   CalendarDisplayOptions get_display_options() {
      return gtk_calendar_get_display_options(&this);
   }

   // Places a visual marker on a particular day.
   // Note that this function always returns %TRUE, and you should
   // ignore the return value. In GTK+ 3, this function will not
   // return a value.
   // RETURNS: %TRUE, always
   // <day>: the day number to mark between 1 and 31.
   int mark_day(uint day) {
      return gtk_calendar_mark_day(&this, day);
   }

   // Selects a day from the current month.
   // <day>: the day number between 1 and 31, or 0 to unselect the currently selected day.
   void select_day(uint day) {
      gtk_calendar_select_day(&this, day);
   }

   // Shifts the calendar to a different month.
   // Note that this function always returns %TRUE, and you should
   // ignore the return value. In GTK+ 3, this function will not
   // return a value.
   // RETURNS: %TRUE, always
   // <month>: a month number between 0 and 11.
   // <year>: the year the month is in.
   int select_month(uint month, uint year) {
      return gtk_calendar_select_month(&this, month, year);
   }

   // Installs a function which provides Pango markup with detail information
   // for each day. Examples for such details are holidays or appointments. That
   // information is shown below each day when #GtkCalendar:show-details is set.
   // A tooltip containing with full detail information is provided, if the entire
   // text should not fit into the details area, or if #GtkCalendar:show-details
   // is not set.
   // The size of the details area can be restricted by setting the
   // #GtkCalendar:detail-width-chars and #GtkCalendar:detail-height-rows
   // properties.
   // <func>: a function providing details for each day.
   // <data>: data to pass to @func invokations.
   // <destroy>: a function for releasing @data.
   void set_detail_func(CalendarDetailFunc func, void* data, GLib2.DestroyNotify destroy) {
      gtk_calendar_set_detail_func(&this, func, data, destroy);
   }

   // Updates the height of detail cells.
   // See #GtkCalendar:detail-height-rows.
   // <rows>: detail height in rows.
   void set_detail_height_rows(int rows) {
      gtk_calendar_set_detail_height_rows(&this, rows);
   }

   // Updates the width of detail cells.
   // See #GtkCalendar:detail-width-chars.
   // <chars>: detail width in characters.
   void set_detail_width_chars(int chars) {
      gtk_calendar_set_detail_width_chars(&this, chars);
   }

   // Sets display options (whether to display the heading and the month  
   // headings).
   // <flags>: the display options to set
   void set_display_options(CalendarDisplayOptions flags) {
      gtk_calendar_set_display_options(&this, flags);
   }

   // Does nothing. Previously defrosted a calendar; all the changes made
   // since the last gtk_calendar_freeze() were displayed.
   void thaw() {
      gtk_calendar_thaw(&this);
   }

   // Removes the visual marker from a particular day.
   // Note that this function always returns %TRUE, and you should
   // ignore the return value. In GTK+ 3, this function will not
   // return a value.
   // RETURNS: %TRUE, always
   // <day>: the day number to unmark between 1 and 31.
   int unmark_day(uint day) {
      return gtk_calendar_unmark_day(&this, day);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_day_selected;

   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:"day-selected", CB/*:signal_day_selected*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"day-selected",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_day_selected_double_click;
   ulong signal_connect(string name:"day-selected-double-click", CB/*:signal_day_selected_double_click*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"day-selected-double-click",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the user clicks a button to change the selected month on a
   // calendar.
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_month_changed;
   ulong signal_connect(string name:"month-changed", CB/*:signal_month_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"month-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_next_month;
   ulong signal_connect(string name:"next-month", CB/*:signal_next_month*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"next-month",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_next_year;
   ulong signal_connect(string name:"next-year", CB/*:signal_next_year*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"next-year",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_prev_month;
   ulong signal_connect(string name:"prev-month", CB/*:signal_prev_month*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"prev-month",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Calendar* this_, void* user_data=null) signal_prev_year;
   ulong signal_connect(string name:"prev-year", CB/*:signal_prev_year*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"prev-year",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CalendarClass {
   WidgetClass parent_class;
   extern (C) void function (Calendar* calendar) month_changed;
   extern (C) void function (Calendar* calendar) day_selected;
   extern (C) void function (Calendar* calendar) day_selected_double_click;
   extern (C) void function (Calendar* calendar) prev_month;
   extern (C) void function (Calendar* calendar) next_month;
   extern (C) void function (Calendar* calendar) prev_year;
   extern (C) void function (Calendar* calendar) next_year;
}


// This kind of functions provide Pango markup with detail information for the
// specified day. Examples for such details are holidays or appointments. The
// function returns %NULL when no information is available.
// for the specified day, or %NULL.
// RETURNS: Newly allocated string with Pango markup with details
// <calendar>: a #GtkCalendar.
// <year>: the year for which details are needed.
// <month>: the month for which details are needed.
// <day>: the day of @month for which details are needed.
// <user_data>: the data passed with gtk_calendar_set_detail_func().
extern (C) alias char* /*new*/ function (Calendar* calendar, uint year, uint month, uint day, void* user_data) CalendarDetailFunc;

// These options can be used to influence the display and behaviour of a #GtkCalendar.
enum CalendarDisplayOptions {
   SHOW_HEADING = 1,
   SHOW_DAY_NAMES = 2,
   NO_MONTH_CHANGE = 4,
   SHOW_WEEK_NUMBERS = 8,
   WEEK_START_MONDAY = 16,
   SHOW_DETAILS = 32
}
struct CalendarPrivate {
}


// The type of the callback functions used for e.g. iterating over
// the children of a container, see gtk_container_foreach().
// <widget>: the widget to operate on
// <data>: user-supplied data
extern (C) alias void function (Widget* widget, void* data) Callback;

extern (C) alias void function (Object* object, void* data, uint n_args, Arg* args) CallbackMarshal;

struct Cell {
   CellType type;
   short vertical, horizontal;
   Style* style;

   union u {
      char* text;

      struct pm {
         Gdk2.Pixmap* pixmap;
         Gdk2.Bitmap* mask;
      }
;

      struct pt {
         char* text;
         ubyte spacing;
         Gdk2.Pixmap* pixmap;
         Gdk2.Bitmap* mask;
      }

      Widget* widget;
   }
}

struct CellEditable {
   // Emits the #GtkCellEditable::editing-done signal.
   void editing_done() {
      gtk_cell_editable_editing_done(&this);
   }
   // Emits the #GtkCellEditable::remove-widget signal.
   void remove_widget() {
      gtk_cell_editable_remove_widget(&this);
   }

   // Begins editing on a @cell_editable. @event is the #GdkEvent that began 
   // the editing process. It may be %NULL, in the instance that editing was 
   // initiated through programatic means.
   // <event>: A #GdkEvent, or %NULL
   void start_editing(Gdk2.Event* event=null) {
      gtk_cell_editable_start_editing(&this, event);
   }

   // This signal is a sign for the cell renderer to update its
   // value from the @cell_editable.
   // Implementations of #GtkCellEditable are responsible for
   // emitting this signal when they are done editing, e.g.
   // #GtkEntry is emitting it when the user presses Enter.
   // gtk_cell_editable_editing_done() is a convenience method
   // for emitting GtkCellEditable::editing-done.
   extern (C) alias static void function (CellEditable* this_, void* user_data=null) signal_editing_done;

   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:"editing-done", CB/*:signal_editing_done*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"editing-done",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is meant to indicate that the cell is finished
   // editing, and the widget may now be destroyed.
   // Implementations of #GtkCellEditable are responsible for
   // emitting this signal when they are done editing. It must
   // be emitted after the #GtkCellEditable::editing-done signal,
   // to give the cell renderer a chance to update the cell's value
   // before the widget is removed.
   // gtk_cell_editable_remove_widget() is a convenience method
   // for emitting GtkCellEditable::remove-widget.
   extern (C) alias static void function (CellEditable* this_, void* user_data=null) signal_remove_widget;
   ulong signal_connect(string name:"remove-widget", CB/*:signal_remove_widget*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"remove-widget",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CellEditableIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (CellEditable* cell_editable) editing_done;
   extern (C) void function (CellEditable* cell_editable) remove_widget;
   // <event>: A #GdkEvent, or %NULL
   extern (C) void function (CellEditable* cell_editable, Gdk2.Event* event=null) start_editing;
}

struct CellLayout {

   // Adds an attribute mapping to the list in @cell_layout. The @column is the
   // column of the model to get a value from, and the @attribute is the
   // parameter on @cell to be set from the value. So for example if column 2
   // of the model contains strings, you could have the "text" attribute of a
   // #GtkCellRendererText get its values from column 2.
   // <cell>: A #GtkCellRenderer.
   // <attribute>: An attribute on the renderer.
   // <column>: The column position on the model to get the attribute from.
   void add_attribute(CellRenderer* cell, char* attribute, int column) {
      gtk_cell_layout_add_attribute(&this, cell, attribute, column);
   }

   // Unsets all the mappings on all renderers on @cell_layout and
   // removes all renderers from @cell_layout.
   void clear() {
      gtk_cell_layout_clear(&this);
   }

   // Clears all existing attributes previously set with
   // gtk_cell_layout_set_attributes().
   // <cell>: A #GtkCellRenderer to clear the attribute mapping on.
   void clear_attributes(CellRenderer* cell) {
      gtk_cell_layout_clear_attributes(&this, cell);
   }

   // Returns the cell renderers which have been added to @cell_layout.
   // renderers has been newly allocated and should be freed with
   // g_list_free() when no longer needed.
   // RETURNS: a list of cell renderers. The list, but not the
   GLib2.List* /*new container*/ get_cells() {
      return gtk_cell_layout_get_cells(&this);
   }

   // Adds the @cell to the end of @cell_layout. If @expand is %FALSE, then the
   // divided evenly between cells for which @expand is %TRUE.
   // Note that reusing the same cell renderer is not supported.
   // <cell>: A #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @cell_layout.
   void pack_end(CellRenderer* cell, int expand) {
      gtk_cell_layout_pack_end(&this, cell, expand);
   }

   // Packs the @cell into the beginning of @cell_layout. If @expand is %FALSE,
   // then the @cell is allocated no more space than it needs. Any unused space
   // is divided evenly between cells for which @expand is %TRUE.
   // Note that reusing the same cell renderer is not supported.
   // <cell>: A #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @cell_layout.
   void pack_start(CellRenderer* cell, int expand) {
      gtk_cell_layout_pack_start(&this, cell, expand);
   }

   // Re-inserts @cell at @position. Note that @cell has already to be packed
   // into @cell_layout for this to function properly.
   // <cell>: A #GtkCellRenderer to reorder.
   // <position>: New position to insert @cell at.
   void reorder(CellRenderer* cell, int position) {
      gtk_cell_layout_reorder(&this, cell, position);
   }

   // Unintrospectable method: set_attributes() / gtk_cell_layout_set_attributes()
   // Sets the attributes in list as the attributes of @cell_layout. The
   // attributes should be in attribute/column order, as in
   // gtk_cell_layout_add_attribute(). All existing attributes are removed, and
   // replaced with the new attributes.
   // <cell>: A #GtkCellRenderer.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_cell_layout_set_attributes set_attributes; // Variadic
   +/

   // Sets the #GtkCellLayoutDataFunc to use for @cell_layout. This function
   // is used instead of the standard attributes mapping for setting the
   // column value, and should set the value of @cell_layout's cell renderer(s)
   // as appropriate. @func may be %NULL to remove and older one.
   // <cell>: A #GtkCellRenderer.
   // <func>: The #GtkCellLayoutDataFunc to use.
   // <func_data>: The user data for @func.
   // <destroy>: The destroy notification for @func_data.
   void set_cell_data_func(CellRenderer* cell, CellLayoutDataFunc func, void* func_data, GLib2.DestroyNotify destroy) {
      gtk_cell_layout_set_cell_data_func(&this, cell, func, func_data, destroy);
   }
}

extern (C) alias void function (CellLayout* cell_layout, CellRenderer* cell, TreeModel* tree_model, TreeIter* iter, void* data) CellLayoutDataFunc;

struct CellLayoutIface {
   GObject2.TypeInterface g_iface;

   // <cell>: A #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @cell_layout.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell, int expand) pack_start;

   // <cell>: A #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @cell_layout.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell, int expand) pack_end;
   extern (C) void function (CellLayout* cell_layout) clear;

   // <cell>: A #GtkCellRenderer.
   // <attribute>: An attribute on the renderer.
   // <column>: The column position on the model to get the attribute from.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell, char* attribute, int column) add_attribute;

   // <cell>: A #GtkCellRenderer.
   // <func>: The #GtkCellLayoutDataFunc to use.
   // <func_data>: The user data for @func.
   // <destroy>: The destroy notification for @func_data.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell, CellLayoutDataFunc func, void* func_data, GLib2.DestroyNotify destroy) set_cell_data_func;
   // <cell>: A #GtkCellRenderer to clear the attribute mapping on.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell) clear_attributes;

   // <cell>: A #GtkCellRenderer to reorder.
   // <position>: New position to insert @cell at.
   extern (C) void function (CellLayout* cell_layout, CellRenderer* cell, int position) reorder;
   // RETURNS: a list of cell renderers. The list, but not the
   extern (C) GLib2.List* /*new container*/ function (CellLayout* cell_layout) get_cells;
}

struct CellPixText {
   CellType type;
   short vertical, horizontal;
   Style* style;
   char* text;
   ubyte spacing;
   Gdk2.Pixmap* pixmap;
   Gdk2.Bitmap* mask;
}

struct CellPixmap {
   CellType type;
   short vertical, horizontal;
   Style* style;
   Gdk2.Pixmap* pixmap;
   Gdk2.Bitmap* mask;
}

struct CellRenderer /* : Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   Object parent;
   float xalign, yalign;
   int width, height;
   ushort xpad, ypad;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "mode", 2,
   uint, "visible", 1,
   uint, "is_expander", 1,
   uint, "is_expanded", 1,
   uint, "cell_background_set", 1,
   uint, "sensitive", 1,
   uint, "editing", 1,
    uint, "__dummy32A", 24));


   // Passes an activate event to the cell renderer for possible processing.  
   // Some cell renderers may use events; for example, #GtkCellRendererToggle 
   // toggles when it gets a mouse click.
   // RETURNS: %TRUE if the event was consumed/handled
   // <event>: a #GdkEvent
   // <widget>: widget that received the event
   // <path>: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
   // <background_area>: background area as passed to gtk_cell_renderer_render()
   // <cell_area>: cell area as passed to gtk_cell_renderer_render()
   // <flags>: render flags
   int activate(Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags) {
      return gtk_cell_renderer_activate(&this, event, widget, path, background_area, cell_area, flags);
   }

   // Causes the cell renderer to emit the #GtkCellRenderer::editing-canceled 
   // signal.  
   // This function is for use only by implementations of cell renderers that 
   // need to notify the client program that an editing process was canceled 
   // and the changes were not committed.
   void editing_canceled() {
      gtk_cell_renderer_editing_canceled(&this);
   }

   // Fills in @xalign and @yalign with the appropriate values of @cell.
   // <xalign>: location to fill in with the x alignment of the cell, or %NULL
   // <yalign>: location to fill in with the y alignment of the cell, or %NULL
   void get_alignment(/*out*/ float* xalign=null, /*out*/ float* yalign=null) {
      gtk_cell_renderer_get_alignment(&this, xalign, yalign);
   }

   // Fills in @width and @height with the appropriate size of @cell.
   // <width>: location to fill in with the fixed width of the cell, or %NULL
   // <height>: location to fill in with the fixed height of the cell, or %NULL
   void get_fixed_size(/*out*/ int* width=null, /*out*/ int* height=null) {
      gtk_cell_renderer_get_fixed_size(&this, width, height);
   }

   // Fills in @xpad and @ypad with the appropriate values of @cell.
   // <xpad>: location to fill in with the x padding of the cell, or %NULL
   // <ypad>: location to fill in with the y padding of the cell, or %NULL
   void get_padding(/*out*/ int* xpad=null, /*out*/ int* ypad=null) {
      gtk_cell_renderer_get_padding(&this, xpad, ypad);
   }

   // Returns the cell renderer's sensitivity.
   // RETURNS: %TRUE if the cell renderer is sensitive
   int get_sensitive() {
      return gtk_cell_renderer_get_sensitive(&this);
   }

   // Obtains the width and height needed to render the cell. Used by view 
   // widgets to determine the appropriate size for the cell_area passed to
   // gtk_cell_renderer_render().  If @cell_area is not %NULL, fills in the
   // x and y offsets (if set) of the cell relative to this location. 
   // Please note that the values set in @width and @height, as well as those 
   // in @x_offset and @y_offset are inclusive of the xpad and ypad properties.
   // <widget>: the widget the renderer is rendering to
   // <cell_area>: The area a cell will be allocated, or %NULL
   // <x_offset>: location to return x offset of cell relative to @cell_area, or %NULL
   // <y_offset>: location to return y offset of cell relative to @cell_area, or %NULL
   // <width>: location to return width needed to render a cell, or %NULL
   // <height>: location to return height needed to render a cell, or %NULL
   void get_size(Widget* widget, Gdk2.Rectangle* cell_area=null, /*out*/ int* x_offset=null, /*out*/ int* y_offset=null, /*out*/ int* width=null, /*out*/ int* height=null) {
      gtk_cell_renderer_get_size(&this, widget, cell_area, x_offset, y_offset, width, height);
   }

   // Returns the cell renderer's visibility.
   // RETURNS: %TRUE if the cell renderer is visible
   int get_visible() {
      return gtk_cell_renderer_get_visible(&this);
   }

   // Invokes the virtual render function of the #GtkCellRenderer. The three
   // passed-in rectangles are areas of @window. Most renderers will draw within
   // should be honored with respect to @cell_area. @background_area includes the
   // blank space around the cell, and also the area containing the tree expander;
   // so the @background_area rectangles for all cells tile to cover the entire
   // <window>: a #GdkDrawable to draw to
   // <widget>: the widget owning @window
   // <background_area>: entire cell area (including tree expanders and maybe padding on the sides)
   // <cell_area>: area normally rendered by a cell renderer
   // <expose_area>: area that actually needs updating
   // <flags>: flags that affect rendering
   void render(Gdk2.Window* window, Widget* widget, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, Gdk2.Rectangle* expose_area, CellRendererState flags) {
      gtk_cell_renderer_render(&this, window, widget, background_area, cell_area, expose_area, flags);
   }

   // Sets the renderer's alignment within its available space.
   // <xalign>: the x alignment of the cell renderer
   // <yalign>: the y alignment of the cell renderer
   void set_alignment(float xalign, float yalign) {
      gtk_cell_renderer_set_alignment(&this, xalign, yalign);
   }

   // Sets the renderer size to be explicit, independent of the properties set.
   // <width>: the width of the cell renderer, or -1
   // <height>: the height of the cell renderer, or -1
   void set_fixed_size(int width, int height) {
      gtk_cell_renderer_set_fixed_size(&this, width, height);
   }

   // Sets the renderer's padding.
   // <xpad>: the x padding of the cell renderer
   // <ypad>: the y padding of the cell renderer
   void set_padding(int xpad, int ypad) {
      gtk_cell_renderer_set_padding(&this, xpad, ypad);
   }

   // Sets the cell renderer's sensitivity.
   // <sensitive>: the sensitivity of the cell
   void set_sensitive(int sensitive) {
      gtk_cell_renderer_set_sensitive(&this, sensitive);
   }

   // Sets the cell renderer's visibility.
   // <visible>: the visibility of the cell
   void set_visible(int visible) {
      gtk_cell_renderer_set_visible(&this, visible);
   }

   // Passes an activate event to the cell renderer for possible processing.
   // RETURNS: A new #GtkCellEditable, or %NULL
   // <event>: a #GdkEvent
   // <widget>: widget that received the event
   // <path>: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
   // <background_area>: background area as passed to gtk_cell_renderer_render()
   // <cell_area>: cell area as passed to gtk_cell_renderer_render()
   // <flags>: render flags
   CellEditable* start_editing(Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags) {
      return gtk_cell_renderer_start_editing(&this, event, widget, path, background_area, cell_area, flags);
   }

   // Informs the cell renderer that the editing is stopped.
   // If @canceled is %TRUE, the cell renderer will emit the 
   // #GtkCellRenderer::editing-canceled signal. 
   // This function should be called by cell renderer implementations 
   // in response to the #GtkCellEditable::editing-done signal of 
   // #GtkCellEditable.
   // <canceled>: %TRUE if the editing has been canceled
   void stop_editing(int canceled) {
      gtk_cell_renderer_stop_editing(&this, canceled);
   }

   // This signal gets emitted when the user cancels the process of editing a
   // cell.  For example, an editable cell renderer could be written to cancel
   // editing when the user presses Escape.
   extern (C) alias static void function (CellRenderer* this_, void* user_data=null) signal_editing_canceled;

   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:"editing-canceled", CB/*:signal_editing_canceled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"editing-canceled",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal gets emitted when a cell starts to be edited.
   // The intended use of this signal is to do special setup
   // on @editable, e.g. adding a #GtkEntryCompletion or setting
   // up additional columns in a #GtkComboBox.
   // Note that GTK+ doesn't guarantee that cell renderers will
   // continue to use the same kind of widget for editing in future
   // releases, therefore you should check the type of @editable
   // before doing any specific setup, as in the following example:
   // |[
   // static void
   // text_editing_started (GtkCellRenderer *cell,
   // GtkCellEditable *editable,
   // const gchar     *path,
   // gpointer         data)
   // {
   // if (GTK_IS_ENTRY (editable)) 
   // {
   // GtkEntry *entry = GTK_ENTRY (editable);
   // /&ast; ... create a GtkEntryCompletion &ast;/
   // gtk_entry_set_completion (entry, completion);
   // }
   // }
   // ]|
   // <editable>: the #GtkCellEditable
   // <path>: the path identifying the edited cell
   extern (C) alias static void function (CellRenderer* this_, CellEditable* editable, char* path, void* user_data=null) signal_editing_started;
   ulong signal_connect(string name:"editing-started", CB/*:signal_editing_started*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"editing-started",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CellRendererAccel /* : CellRendererText */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderertext;
   CellRendererText parent;
   private uint accel_key;
   private Gdk2.ModifierType accel_mods;
   private uint keycode;
   private CellRendererAccelMode accel_mode;
   private Widget* edit_widget, grab_widget, sizing_label;


   // Creates a new #GtkCellRendererAccel.
   // RETURNS: the new cell renderer
   static CellRendererAccel* new_() {
      return gtk_cell_renderer_accel_new();
   }

   // Gets emitted when the user has removed the accelerator.
   // <path_string>: the path identifying the row of the edited cell
   extern (C) alias static void function (CellRendererAccel* this_, char* path_string, void* user_data=null) signal_accel_cleared;

   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:"accel-cleared", CB/*:signal_accel_cleared*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accel-cleared",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when the user has selected a new accelerator.
   // <path_string>: the path identifying the row of the edited cell
   // <accel_key>: the new accelerator keyval
   // <accel_mods>: the new acclerator modifier mask
   // <hardware_keycode>: the keycode of the new accelerator
   extern (C) alias static void function (CellRendererAccel* this_, char* path_string, c_uint accel_key, Gdk2.ModifierType* accel_mods, c_uint hardware_keycode, void* user_data=null) signal_accel_edited;
   ulong signal_connect(string name:"accel-edited", CB/*:signal_accel_edited*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accel-edited",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CellRendererAccelClass {
   CellRendererTextClass parent_class;
   extern (C) void function (CellRendererAccel* accel, char* path_string, uint accel_key, Gdk2.ModifierType accel_mods, uint hardware_keycode) accel_edited;
   extern (C) void function (CellRendererAccel* accel, char* path_string) accel_cleared;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum CellRendererAccelMode {
   GTK = 0,
   OTHER = 1
}
struct CellRendererClass {
   ObjectClass parent_class;

   // <widget>: the widget the renderer is rendering to
   // <cell_area>: The area a cell will be allocated, or %NULL
   // <x_offset>: location to return x offset of cell relative to @cell_area, or %NULL
   // <y_offset>: location to return y offset of cell relative to @cell_area, or %NULL
   // <width>: location to return width needed to render a cell, or %NULL
   // <height>: location to return height needed to render a cell, or %NULL
   extern (C) void function (CellRenderer* cell, Widget* widget, Gdk2.Rectangle* cell_area=null, /*out*/ int* x_offset=null, /*out*/ int* y_offset=null, /*out*/ int* width=null, /*out*/ int* height=null) get_size;

   // <window>: a #GdkDrawable to draw to
   // <widget>: the widget owning @window
   // <background_area>: entire cell area (including tree expanders and maybe padding on the sides)
   // <cell_area>: area normally rendered by a cell renderer
   // <expose_area>: area that actually needs updating
   // <flags>: flags that affect rendering
   extern (C) void function (CellRenderer* cell, Gdk2.Drawable* window, Widget* widget, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, Gdk2.Rectangle* expose_area, CellRendererState flags) render;

   // RETURNS: %TRUE if the event was consumed/handled
   // <event>: a #GdkEvent
   // <widget>: widget that received the event
   // <path>: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
   // <background_area>: background area as passed to gtk_cell_renderer_render()
   // <cell_area>: cell area as passed to gtk_cell_renderer_render()
   // <flags>: render flags
   extern (C) int function (CellRenderer* cell, Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags) activate;

   // RETURNS: A new #GtkCellEditable, or %NULL
   // <event>: a #GdkEvent
   // <widget>: widget that received the event
   // <path>: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
   // <background_area>: background area as passed to gtk_cell_renderer_render()
   // <cell_area>: cell area as passed to gtk_cell_renderer_render()
   // <flags>: render flags
   extern (C) CellEditable* function (CellRenderer* cell, Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags) start_editing;
   extern (C) void function (CellRenderer* cell) editing_canceled;
   extern (C) void function (CellRenderer* cell, CellEditable* editable, char* path) editing_started;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

struct CellRendererCombo /* : CellRendererText */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderertext;
   CellRendererText parent;
   TreeModel* model;
   int text_column;
   int has_entry;
   private uint focus_out_id;


   // Creates a new #GtkCellRendererCombo. 
   // Adjust how text is drawn using object properties. 
   // Object properties can be set globally (with g_object_set()). 
   // Also, with #GtkTreeViewColumn, you can bind a property to a value 
   // in a #GtkTreeModel. For example, you can bind the "text" property 
   // on the cell renderer to a string value in the model, thus rendering 
   // a different string in each row of the #GtkTreeView.
   // RETURNS: the new cell renderer
   static CellRendererCombo* new_() {
      return gtk_cell_renderer_combo_new();
   }

   // This signal is emitted each time after the user selected an item in
   // the combo box, either by using the mouse or the arrow keys.  Contrary
   // to GtkComboBox, GtkCellRendererCombo::changed is not emitted for
   // changes made to a selected item in the entry.  The argument @new_iter
   // corresponds to the newly selected item in the combo box and it is relative
   // to the GtkTreeModel set via the model property on GtkCellRendererCombo.
   // Note that as soon as you change the model displayed in the tree view,
   // the tree view will immediately cease the editing operating.  This
   // means that you most probably want to refrain from changing the model
   // until the combo cell renderer emits the edited or editing_canceled signal.
   // <path_string>: a string of the path identifying the edited cell (relative to the tree view model)
   // <new_iter>: the new iter selected in the combo box (relative to the combo box model)
   extern (C) alias static void function (CellRendererCombo* this_, char* path_string, TreeIter* new_iter, 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);
   }
}

struct CellRendererComboClass {
   CellRendererTextClass parent;
}

enum CellRendererMode {
   INERT = 0,
   ACTIVATABLE = 1,
   EDITABLE = 2
}
struct CellRendererPixbuf /* : CellRenderer */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderer;
   CellRenderer parent;
   private GdkPixbuf2.Pixbuf* pixbuf, pixbuf_expander_open, pixbuf_expander_closed;


   // Creates a new #GtkCellRendererPixbuf. Adjust rendering
   // parameters using object properties. Object properties can be set
   // globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
   // can bind a property to a value in a #GtkTreeModel. For example, you
   // can bind the "pixbuf" property on the cell renderer to a pixbuf value
   // in the model, thus rendering a different image in each row of the
   // #GtkTreeView.
   // RETURNS: the new cell renderer
   static CellRendererPixbuf* new_() {
      return gtk_cell_renderer_pixbuf_new();
   }
}

struct CellRendererPixbufClass {
   CellRendererClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CellRendererProgress /* : CellRenderer */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance cellrenderer;
   CellRenderer parent_instance;
   private CellRendererProgressPrivate* priv;


   // Creates a new #GtkCellRendererProgress.
   // RETURNS: the new cell renderer
   static CellRendererProgress* new_() {
      return gtk_cell_renderer_progress_new();
   }
}

struct CellRendererProgressClass {
   CellRendererClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CellRendererProgressPrivate {
}

struct CellRendererSpin /* : CellRendererText */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderertext;
   CellRendererText parent;


   // Creates a new #GtkCellRendererSpin.
   // RETURNS: a new #GtkCellRendererSpin
   static CellRendererSpin* new_() {
      return gtk_cell_renderer_spin_new();
   }
}

struct CellRendererSpinClass {
   CellRendererTextClass parent;
}

struct CellRendererSpinPrivate {
}


// GtkCellRendererSpinner renders a spinning animation in a cell, very
// similar to #GtkSpinner. It can often be used as an alternative
// to a #GtkCellRendererProgress for displaying indefinite activity,
// instead of actual progress.
// To start the animation in a cell, set the #GtkCellRendererSpinner:active
// property to %TRUE and increment the #GtkCellRendererSpinner:pulse property
// at regular intervals. The usual way to set the cell renderer properties
// for each cell is to bind them to columns in your tree model using e.g.
// gtk_tree_view_column_add_attribute().
struct CellRendererSpinner /* : CellRenderer */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderer;
   CellRenderer parent;
   CellRendererSpinnerPrivate* priv;


   // Returns a new cell renderer which will show a spinner to indicate
   // activity.
   // RETURNS: a new #GtkCellRenderer
   static CellRendererSpinner* new_() {
      return gtk_cell_renderer_spinner_new();
   }
}

struct CellRendererSpinnerClass {
   CellRendererClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CellRendererSpinnerPrivate {
}

enum CellRendererState {
   SELECTED = 1,
   PRELIT = 2,
   INSENSITIVE = 4,
   SORTED = 8,
   FOCUSED = 16
}
struct CellRendererText /* : CellRenderer */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderer;
   CellRenderer parent;
   private char* text;
   private Pango.FontDescription* font;
   private double font_scale;
   private Pango.Color foreground, background;
   private Pango.AttrList* extra_attrs;
   private Pango.Underline underline_style;
   private int rise, fixed_height_rows;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "strikethrough", 1,
   uint, "editable", 1,
   uint, "scale_set", 1,
   uint, "foreground_set", 1,
   uint, "background_set", 1,
   uint, "underline_set", 1,
   uint, "rise_set", 1,
   uint, "strikethrough_set", 1,
   uint, "editable_set", 1,
   uint, "calc_fixed_height", 1,
    uint, "__dummy32A", 22));


   // Creates a new #GtkCellRendererText. Adjust how text is drawn using
   // object properties. Object properties can be
   // set globally (with g_object_set()). Also, with #GtkTreeViewColumn,
   // you can bind a property to a value in a #GtkTreeModel. For example,
   // you can bind the "text" property on the cell renderer to a string
   // value in the model, thus rendering a different string in each row
   // of the #GtkTreeView
   // RETURNS: the new cell renderer
   static CellRendererText* new_() {
      return gtk_cell_renderer_text_new();
   }

   // Sets the height of a renderer to explicitly be determined by the "font" and
   // "y_pad" property set on it.  Further changes in these properties do not
   // affect the height, so they must be accompanied by a subsequent call to this
   // function.  Using this function is unflexible, and should really only be used
   // if calculating the size of a cell is too slow (ie, a massive number of cells
   // displayed).  If @number_of_rows is -1, then the fixed height is unset, and
   // the height is determined by the properties again.
   // <number_of_rows>: Number of rows of text each cell renderer is allocated, or -1
   void set_fixed_height_from_font(int number_of_rows) {
      gtk_cell_renderer_text_set_fixed_height_from_font(&this, number_of_rows);
   }

   // This signal is emitted after @renderer has been edited.
   // It is the responsibility of the application to update the model
   // and store @new_text at the position indicated by @path.
   // <path>: the path identifying the edited cell
   // <new_text>: the new text
   extern (C) alias static void function (CellRendererText* this_, char* path, char* new_text, void* user_data=null) signal_edited;

   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:"edited", CB/*:signal_edited*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"edited",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CellRendererTextClass {
   CellRendererClass parent_class;
   extern (C) void function (CellRendererText* cell_renderer_text, char* path, char* new_text) edited;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CellRendererToggle /* : CellRenderer */ {
   alias parent this;
   alias parent super_;
   alias parent cellrenderer;
   CellRenderer parent;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "active", 1,
   uint, "activatable", 1,
   uint, "radio", 1,
    uint, "__dummy32A", 29));


   // Creates a new #GtkCellRendererToggle. Adjust rendering
   // parameters using object properties. Object properties can be set
   // globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
   // can bind a property to a value in a #GtkTreeModel. For example, you
   // can bind the "active" property on the cell renderer to a boolean value
   // in the model, thus causing the check button to reflect the state of
   // the model.
   // RETURNS: the new cell renderer
   static CellRendererToggle* new_() {
      return gtk_cell_renderer_toggle_new();
   }

   // Returns whether the cell renderer is activatable. See
   // gtk_cell_renderer_toggle_set_activatable().
   // RETURNS: %TRUE if the cell renderer is activatable.
   int get_activatable() {
      return gtk_cell_renderer_toggle_get_activatable(&this);
   }

   // Returns whether the cell renderer is active. See
   // gtk_cell_renderer_toggle_set_active().
   // RETURNS: %TRUE if the cell renderer is active.
   int get_active() {
      return gtk_cell_renderer_toggle_get_active(&this);
   }

   // Returns whether we're rendering radio toggles rather than checkboxes.
   // RETURNS: %TRUE if we're rendering radio toggles rather than checkboxes
   int get_radio() {
      return gtk_cell_renderer_toggle_get_radio(&this);
   }

   // Makes the cell renderer activatable.
   // <setting>: the value to set.
   void set_activatable(int setting) {
      gtk_cell_renderer_toggle_set_activatable(&this, setting);
   }

   // Activates or deactivates a cell renderer.
   // <setting>: the value to set.
   void set_active(int setting) {
      gtk_cell_renderer_toggle_set_active(&this, setting);
   }

   // If @radio is %TRUE, the cell renderer renders a radio toggle
   // (i.e. a toggle in a group of mutually-exclusive toggles).
   // If %FALSE, it renders a check toggle (a standalone boolean option).
   // This can be set globally for the cell renderer, or changed just
   // before rendering each cell in the model (for #GtkTreeView, you set
   // up a per-row setting using #GtkTreeViewColumn to associate model
   // columns with cell renderer properties).
   // <radio>: %TRUE to make the toggle look like a radio button
   void set_radio(int radio) {
      gtk_cell_renderer_toggle_set_radio(&this, radio);
   }

   // The ::toggled signal is emitted when the cell is toggled.
   // <path>: string representation of #GtkTreePath describing the event location
   extern (C) alias static void function (CellRendererToggle* this_, char* path, void* user_data=null) signal_toggled;

   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:"toggled", CB/*:signal_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CellRendererToggleClass {
   CellRendererClass parent_class;
   extern (C) void function (CellRendererToggle* cell_renderer_toggle, char* path) toggled;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CellText {
   CellType type;
   short vertical, horizontal;
   Style* style;
   char* text;
}

enum CellType {
   EMPTY = 0,
   TEXT = 1,
   PIXMAP = 2,
   PIXTEXT = 3,
   WIDGET = 4
}
struct CellView /* : Widget */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance widget;
   Widget parent_instance;
   private CellViewPrivate* priv;


   // Creates a new #GtkCellView widget.
   // RETURNS: A newly created #GtkCellView widget.
   static CellView* new_() {
      return gtk_cell_view_new();
   }

   // Creates a new #GtkCellView widget, adds a #GtkCellRendererText 
   // to it, and makes it show @markup. The text can be
   // marked up with the <link linkend="PangoMarkupFormat">Pango text 
   // markup language</link>.
   // RETURNS: A newly created #GtkCellView widget.
   // <markup>: the text to display in the cell view
   static CellView* new_with_markup(char* markup) {
      return gtk_cell_view_new_with_markup(markup);
   }

   // Creates a new #GtkCellView widget, adds a #GtkCellRendererPixbuf 
   // to it, and makes its show @pixbuf.
   // RETURNS: A newly created #GtkCellView widget.
   // <pixbuf>: the image to display in the cell view
   static CellView* new_with_pixbuf(GdkPixbuf2.Pixbuf* pixbuf) {
      return gtk_cell_view_new_with_pixbuf(pixbuf);
   }

   // Creates a new #GtkCellView widget, adds a #GtkCellRendererText 
   // to it, and makes its show @text.
   // RETURNS: A newly created #GtkCellView widget.
   // <text>: the text to display in the cell view
   static CellView* new_with_text(char* text) {
      return gtk_cell_view_new_with_text(text);
   }

   // Unintrospectable method: get_cell_renderers() / gtk_cell_view_get_cell_renderers()
   // Returns the cell renderers which have been added to @cell_view.
   // renderers has been newly allocated and should be freed with
   // g_list_free() when no longer needed.
   // RETURNS: a list of cell renderers. The list, but not the
   GLib2.List* get_cell_renderers() {
      return gtk_cell_view_get_cell_renderers(&this);
   }

   // Returns a #GtkTreePath referring to the currently 
   // displayed row. If no row is currently displayed, 
   // %NULL is returned.
   // RETURNS: the currently displayed row or %NULL
   TreePath* /*new*/ get_displayed_row() {
      return gtk_cell_view_get_displayed_row(&this);
   }

   // Returns the model for @cell_view. If no model is used %NULL is
   // returned.
   // RETURNS: a #GtkTreeModel used or %NULL
   TreeModel* get_model() {
      return gtk_cell_view_get_model(&this);
   }

   // Sets @requisition to the size needed by @cell_view to display 
   // the model row pointed to by @path.
   // RETURNS: %TRUE
   // <path>: a #GtkTreePath
   // <requisition>: return location for the size
   int get_size_of_row(TreePath* path, /*out*/ Requisition* requisition) {
      return gtk_cell_view_get_size_of_row(&this, path, requisition);
   }

   // Sets the background color of @view.
   // <color>: the new background color
   void set_background_color(Gdk2.Color* color) {
      gtk_cell_view_set_background_color(&this, color);
   }

   // Sets the row of the model that is currently displayed
   // by the #GtkCellView. If the path is unset, then the
   // contents of the cellview "stick" at their last value;
   // this is not normally a desired result, but may be
   // a needed intermediate state if say, the model for
   // the #GtkCellView becomes temporarily empty.
   // <path>: a #GtkTreePath or %NULL to unset.
   void set_displayed_row(TreePath* path=null) {
      gtk_cell_view_set_displayed_row(&this, path);
   }

   // Sets the model for @cell_view.  If @cell_view already has a model
   // set, it will remove it before setting the new model.  If @model is
   // %NULL, then it will unset the old model.
   // <model>: a #GtkTreeModel
   void set_model(TreeModel* model=null) {
      gtk_cell_view_set_model(&this, model);
   }
}

struct CellViewClass {
   WidgetClass parent_class;
}

struct CellViewPrivate {
}

struct CellWidget {
   CellType type;
   short vertical, horizontal;
   Style* style;
   Widget* widget;
}

struct CheckButton /* : ToggleButton */ {
   alias toggle_button this;
   alias toggle_button super_;
   alias toggle_button togglebutton;
   ToggleButton toggle_button;

   static CheckButton* new_() {
      return gtk_check_button_new();
   }
   static CheckButton* new_with_label(char* label) {
      return gtk_check_button_new_with_label(label);
   }

   // Creates a new #GtkCheckButton containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the check button.
   // RETURNS: a new #GtkCheckButton
   // <label>: The text of the button, with an underscore in front of the mnemonic character
   static CheckButton* new_with_mnemonic(char* label) {
      return gtk_check_button_new_with_mnemonic(label);
   }
}

struct CheckButtonClass {
   ToggleButtonClass parent_class;
   extern (C) void function (CheckButton* check_button, Gdk2.Rectangle* area) draw_indicator;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct CheckMenuItem /* : MenuItem */ {
   alias menu_item this;
   alias menu_item super_;
   alias menu_item menuitem;
   MenuItem menu_item;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "active", 1,
   uint, "always_show_toggle", 1,
   uint, "inconsistent", 1,
   uint, "draw_as_radio", 1,
    uint, "__dummy32A", 28));

   static CheckMenuItem* new_() {
      return gtk_check_menu_item_new();
   }
   static CheckMenuItem* new_with_label(char* label) {
      return gtk_check_menu_item_new_with_label(label);
   }

   // Creates a new #GtkCheckMenuItem containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the menu item.
   // RETURNS: a new #GtkCheckMenuItem
   // <label>: The text of the button, with an underscore in front of the mnemonic character
   static CheckMenuItem* new_with_mnemonic(char* label) {
      return gtk_check_menu_item_new_with_mnemonic(label);
   }

   // Returns whether the check menu item is active. See
   // gtk_check_menu_item_set_active ().
   // RETURNS: %TRUE if the menu item is checked.
   int get_active() {
      return gtk_check_menu_item_get_active(&this);
   }

   // Returns whether @check_menu_item looks like a #GtkRadioMenuItem
   // RETURNS: Whether @check_menu_item looks like a #GtkRadioMenuItem
   int get_draw_as_radio() {
      return gtk_check_menu_item_get_draw_as_radio(&this);
   }

   // Retrieves the value set by gtk_check_menu_item_set_inconsistent().
   // RETURNS: %TRUE if inconsistent
   int get_inconsistent() {
      return gtk_check_menu_item_get_inconsistent(&this);
   }
   void set_active(int is_active) {
      gtk_check_menu_item_set_active(&this, is_active);
   }

   // Sets whether @check_menu_item is drawn like a #GtkRadioMenuItem
   // <draw_as_radio>: whether @check_menu_item is drawn like a #GtkRadioMenuItem
   void set_draw_as_radio(int draw_as_radio) {
      gtk_check_menu_item_set_draw_as_radio(&this, draw_as_radio);
   }

   // If the user has selected a range of elements (such as some text or
   // spreadsheet cells) that are affected by a boolean setting, and the
   // current values in that range are inconsistent, you may want to
   // display the check in an "in between" state. This function turns on
   // "in between" display.  Normally you would turn off the inconsistent
   // state again if the user explicitly selects a setting. This has to be
   // done manually, gtk_check_menu_item_set_inconsistent() only affects
   // visual appearance, it doesn't affect the semantics of the widget.
   // <setting>: %TRUE to display an "inconsistent" third state check
   void set_inconsistent(int setting) {
      gtk_check_menu_item_set_inconsistent(&this, setting);
   }
   void set_show_toggle(int always) {
      gtk_check_menu_item_set_show_toggle(&this, always);
   }
   void toggled() {
      gtk_check_menu_item_toggled(&this);
   }
   extern (C) alias static void function (CheckMenuItem* this_, void* user_data=null) signal_toggled;

   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:"toggled", CB/*:signal_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CheckMenuItemClass {
   MenuItemClass parent_class;
   extern (C) void function (CheckMenuItem* check_menu_item) toggled;
   extern (C) void function (CheckMenuItem* check_menu_item, Gdk2.Rectangle* area) draw_indicator;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Clipboard /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Returns the clipboard object for the given selection.
   // See gtk_clipboard_get_for_display() for complete details.
   // already exists, a new one will be created. Once a clipboard
   // object has been created, it is persistent and, since it is
   // owned by GTK+, must not be freed or unreffed.
   // RETURNS: the appropriate clipboard object. If no clipboard
   // <selection>: a #GdkAtom which identifies the clipboard to use
   static Clipboard* get(Gdk2.Atom selection) {
      return gtk_clipboard_get(selection);
   }

   // Returns the clipboard object for the given selection.
   // Cut/copy/paste menu items and keyboard shortcuts should use
   // the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection.
   // (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
   // for backwards compatibility reasons.)
   // The currently-selected object or text should be provided on the clipboard
   // identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
   // conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard
   // to the default clipboard, i.e. they copy the selection to what the
   // user sees as the clipboard.
   // (Passing #GDK_NONE is the same as using <literal>gdk_atom_intern
   // ("CLIPBOARD", FALSE)</literal>. See <ulink
   // url="http://www.freedesktop.org/Standards/clipboards-spec">
   // http://www.freedesktop.org/Standards/clipboards-spec</ulink>
   // for a detailed discussion of the "CLIPBOARD" vs. "PRIMARY"
   // selections under the X window system. On Win32 the
   // #GDK_SELECTION_PRIMARY clipboard is essentially ignored.)
   // It's possible to have arbitrary named clipboards; if you do invent
   // new clipboards, you should prefix the selection name with an
   // underscore (because the ICCCM requires that nonstandard atoms are
   // underscore-prefixed), and namespace it as well. For example,
   // if your application called "Foo" has a special-purpose
   // clipboard, you might call it "_FOO_SPECIAL_CLIPBOARD".
   // clipboard already exists, a new one will
   // be created. Once a clipboard object has
   // been created, it is persistent and, since
   // it is owned by GTK+, must not be freed or
   // unrefd.
   // RETURNS: the appropriate clipboard object. If no
   // <display>: the display for which the clipboard is to be retrieved or created
   // <selection>: a #GdkAtom which identifies the clipboard to use.
   static Clipboard* get_for_display(Gdk2.Display* display, Gdk2.Atom selection) {
      return gtk_clipboard_get_for_display(display, selection);
   }

   // Clears the contents of the clipboard. Generally this should only
   // be called between the time you call gtk_clipboard_set_with_owner()
   // or gtk_clipboard_set_with_data(),
   // and when the @clear_func you supplied is called. Otherwise, the
   // clipboard may be owned by someone else.
   void clear() {
      gtk_clipboard_clear(&this);
   }

   // Gets the #GdkDisplay associated with @clipboard
   // RETURNS: the #GdkDisplay associated with @clipboard
   Gdk2.Display* get_display() {
      return gtk_clipboard_get_display(&this);
   }

   // If the clipboard contents callbacks were set with 
   // gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or 
   // gtk_clipboard_clear() has not subsequently called, returns the owner set 
   // by gtk_clipboard_set_with_owner().
   // RETURNS: the owner of the clipboard, if any; otherwise %NULL.
   GObject2.Object* get_owner() {
      return gtk_clipboard_get_owner(&this);
   }

   // Unintrospectable method: request_contents() / gtk_clipboard_request_contents()
   // Requests the contents of clipboard as the given target.
   // When the results of the result are later received the supplied callback
   // will be called.
   // <target>: an atom representing the form into which the clipboard owner should convert the selection.
   // <callback>: A function to call when the results are received (or the retrieval fails). If the retrieval fails the length field of @selection_data will be negative.
   // <user_data>: user data to pass to @callback
   void request_contents(Gdk2.Atom target, ClipboardReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_contents(&this, target, callback, user_data);
   }

   // Unintrospectable method: request_image() / gtk_clipboard_request_image()
   // Requests the contents of the clipboard as image. When the image is
   // later received, it will be converted to a #GdkPixbuf, and
   // The @pixbuf parameter to @callback will contain the resulting 
   // #GdkPixbuf if the request succeeded, or %NULL if it failed. This 
   // could happen for various reasons, in particular if the clipboard 
   // was empty or if the contents of the clipboard could not be 
   // converted into an image.
   // <callback>: a function to call when the image is received, or the retrieval fails. (It will always be called one way or the other.)
   // <user_data>: user data to pass to @callback.
   void request_image(ClipboardImageReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_image(&this, callback, user_data);
   }

   // Unintrospectable method: request_rich_text() / gtk_clipboard_request_rich_text()
   // Requests the contents of the clipboard as rich text. When the rich
   // text is later received, @callback will be called.
   // The @text parameter to @callback will contain the resulting rich
   // text if the request succeeded, or %NULL if it failed. The @length
   // parameter will contain @text's length. This function can fail for
   // various reasons, in particular if the clipboard was empty or if the
   // contents of the clipboard could not be converted into rich text form.
   // <buffer>: a #GtkTextBuffer
   // <callback>: a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.)
   // <user_data>: user data to pass to @callback.
   void request_rich_text(TextBuffer* buffer, ClipboardRichTextReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_rich_text(&this, buffer, callback, user_data);
   }

   // Unintrospectable method: request_targets() / gtk_clipboard_request_targets()
   // Requests the contents of the clipboard as list of supported targets. 
   // When the list is later received, @callback will be called. 
   // The @targets parameter to @callback will contain the resulting targets if
   // the request succeeded, or %NULL if it failed.
   // <callback>: a function to call when the targets are received, or the retrieval fails. (It will always be called one way or the other.)
   // <user_data>: user data to pass to @callback.
   void request_targets(ClipboardTargetsReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_targets(&this, callback, user_data);
   }

   // Unintrospectable method: request_text() / gtk_clipboard_request_text()
   // Requests the contents of the clipboard as text. When the text is
   // later received, it will be converted to UTF-8 if necessary, and
   // The @text parameter to @callback will contain the resulting text if
   // the request succeeded, or %NULL if it failed. This could happen for
   // various reasons, in particular if the clipboard was empty or if the
   // contents of the clipboard could not be converted into text form.
   // <callback>: a function to call when the text is received, or the retrieval fails. (It will always be called one way or the other.)
   // <user_data>: user data to pass to @callback.
   void request_text(ClipboardTextReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_text(&this, callback, user_data);
   }

   // Unintrospectable method: request_uris() / gtk_clipboard_request_uris()
   // Requests the contents of the clipboard as URIs. When the URIs are
   // later received @callback will be called.
   // The @uris parameter to @callback will contain the resulting array of
   // URIs if the request succeeded, or %NULL if it failed. This could happen
   // for various reasons, in particular if the clipboard was empty or if the
   // contents of the clipboard could not be converted into URI form.
   // <callback>: a function to call when the URIs are received, or the retrieval fails. (It will always be called one way or the other.)
   // <user_data>: user data to pass to @callback.
   void request_uris(ClipboardURIReceivedFunc callback, void* user_data) {
      gtk_clipboard_request_uris(&this, callback, user_data);
   }

   // Hints that the clipboard data should be stored somewhere when the
   // application exits or when gtk_clipboard_store () is called.
   // This value is reset when the clipboard owner changes.
   // Where the clipboard data is stored is platform dependent,
   // see gdk_display_store_clipboard () for more information.
   // <targets>: array containing information about which forms should be stored or %NULL to indicate that all forms should be stored.
   // <n_targets>: number of elements in @targets
   void set_can_store(TargetEntry* targets, int n_targets) {
      gtk_clipboard_set_can_store(&this, targets, n_targets);
   }

   // Sets the contents of the clipboard to the given #GdkPixbuf. 
   // GTK+ will take responsibility for responding for requests 
   // for the image, and for converting the image into the 
   // requested format.
   // <pixbuf>: a #GdkPixbuf
   void set_image(GdkPixbuf2.Pixbuf* pixbuf) {
      gtk_clipboard_set_image(&this, pixbuf);
   }

   // Sets the contents of the clipboard to the given UTF-8 string. GTK+ will
   // make a copy of the text and take responsibility for responding
   // for requests for the text, and for converting the text into
   // the requested format.
   // <text>: a UTF-8 string.
   // <len>: length of @text, in bytes, or -1, in which case the length will be determined with <function>strlen()</function>.
   void set_text(char* text, int len) {
      gtk_clipboard_set_text(&this, text, len);
   }

   // Unintrospectable method: set_with_data() / gtk_clipboard_set_with_data()
   // Virtually sets the contents of the specified clipboard by providing
   // a list of supported formats for the clipboard data and a function
   // to call to get the actual data when it is requested.
   // the clipboard data failed the provided callback functions
   // will be ignored.
   // RETURNS: %TRUE if setting the clipboard data succeeded. If setting
   // <targets>: array containing information about the available forms for the clipboard data
   // <n_targets>: number of elements in @targets
   // <get_func>: function to call to get the actual clipboard data
   // <clear_func>: when the clipboard contents are set again, this function will be called, and @get_func will not be subsequently called.
   // <user_data>: user data to pass to @get_func and @clear_func.
   int set_with_data(TargetEntry* targets, uint n_targets, ClipboardGetFunc get_func, ClipboardClearFunc clear_func, void* user_data) {
      return gtk_clipboard_set_with_data(&this, targets, n_targets, get_func, clear_func, user_data);
   }

   // Unintrospectable method: set_with_owner() / gtk_clipboard_set_with_owner()
   // Virtually sets the contents of the specified clipboard by providing
   // a list of supported formats for the clipboard data and a function
   // to call to get the actual data when it is requested.
   // The difference between this function and gtk_clipboard_set_with_data()
   // is that instead of an generic @user_data pointer, a #GObject is passed
   // in. 
   // the clipboard data failed the provided callback functions
   // will be ignored.
   // RETURNS: %TRUE if setting the clipboard data succeeded. If setting
   // <targets>: array containing information about the available forms for the clipboard data
   // <n_targets>: number of elements in @targets
   // <get_func>: function to call to get the actual clipboard data
   // <clear_func>: when the clipboard contents are set again, this function will be called, and @get_func will not be subsequently called.
   // <owner>: an object that "owns" the data. This object will be passed to the callbacks when called.
   int set_with_owner(TargetEntry* targets, uint n_targets, ClipboardGetFunc get_func, ClipboardClearFunc clear_func, GObject2.Object* owner) {
      return gtk_clipboard_set_with_owner(&this, targets, n_targets, get_func, clear_func, owner);
   }

   // Stores the current clipboard data somewhere so that it will stay
   // around after the application has quit.
   void store() {
      gtk_clipboard_store(&this);
   }

   // Requests the contents of the clipboard using the given target.
   // This function waits for the data to be received using the main 
   // loop, so events, timeouts, etc, may be dispatched during the wait.
   // if retrieving the given target failed. If non-%NULL,
   // this value must be freed with gtk_selection_data_free() 
   // when you are finished with it.
   // RETURNS: a newly-allocated #GtkSelectionData object or %NULL
   // <target>: an atom representing the form into which the clipboard owner should convert the selection.
   SelectionData* /*new*/ wait_for_contents(Gdk2.Atom target) {
      return gtk_clipboard_wait_for_contents(&this, target);
   }

   // Requests the contents of the clipboard as image and converts
   // the result to a #GdkPixbuf. This function waits for
   // the data to be received using the main loop, so events,
   // timeouts, etc, may be dispatched during the wait.
   // be disposed with g_object_unref(), or %NULL if 
   // retrieving the selection data failed. (This 
   // could happen for various reasons, in particular 
   // if the clipboard was empty or if the contents of 
   // the clipboard could not be converted into an image.)
   // RETURNS: a newly-allocated #GdkPixbuf object which must
   GdkPixbuf2.Pixbuf* /*new*/ wait_for_image() {
      return gtk_clipboard_wait_for_image(&this);
   }

   // Requests the contents of the clipboard as rich text.  This function
   // waits for the data to be received using the main loop, so events,
   // timeouts, etc, may be dispatched during the wait.
   // newly-allocated binary block of data which must
   // be freed with g_free(), or %NULL if retrieving
   // the selection data failed. (This could happen
   // for various reasons, in particular if the
   // clipboard was empty or if the contents of the
   // clipboard could not be converted into text form.)
   // RETURNS: a
   // <buffer>: a #GtkTextBuffer
   // <format>: return location for the format of the returned data
   // <length>: return location for the length of the returned data
   ubyte* /*new*/ wait_for_rich_text(TextBuffer* buffer, Gdk2.Atom* format, /*out*/ size_t* length) {
      return gtk_clipboard_wait_for_rich_text(&this, buffer, format, length);
   }

   // Returns a list of targets that are present on the clipboard, or %NULL
   // if there aren't any targets available. The returned list must be 
   // freed with g_free().
   // This function waits for the data to be received using the main 
   // loop, so events, timeouts, etc, may be dispatched during the wait.
   // otherwise %FALSE.
   // RETURNS: %TRUE if any targets are present on the clipboard,
   // <targets>: location to store an array of targets. The result stored here must be freed with g_free().
   // <n_targets>: location to store number of items in @targets.
   int wait_for_targets(/*out*/ Gdk2.Atom** targets, /*out*/ int* n_targets) {
      return gtk_clipboard_wait_for_targets(&this, targets, n_targets);
   }

   // Requests the contents of the clipboard as text and converts
   // the result to UTF-8 if necessary. This function waits for
   // the data to be received using the main loop, so events,
   // timeouts, etc, may be dispatched during the wait.
   // be freed with g_free(), or %NULL if retrieving
   // the selection data failed. (This could happen
   // for various reasons, in particular if the
   // clipboard was empty or if the contents of the
   // clipboard could not be converted into text form.)
   // RETURNS: a newly-allocated UTF-8 string which must
   char* /*new*/ wait_for_text() {
      return gtk_clipboard_wait_for_text(&this);
   }

   // Requests the contents of the clipboard as URIs. This function waits
   // for the data to be received using the main loop, so events,
   // timeouts, etc, may be dispatched during the wait.
   // %NULL-terminated array of strings which must
   // be freed with g_strfreev(), or %NULL if
   // retrieving the selection data failed. (This
   // could happen for various reasons, in particular
   // if the clipboard was empty or if the contents of
   // the clipboard could not be converted into URI form.)
   // RETURNS: a newly-allocated
   char** /*new*/ wait_for_uris() {
      return gtk_clipboard_wait_for_uris(&this);
   }

   // Test to see if there is an image available to be pasted
   // This is done by requesting the TARGETS atom and checking
   // if it contains any of the supported image targets. This function 
   // waits for the data to be received using the main loop, so events, 
   // timeouts, etc, may be dispatched during the wait.
   // This function is a little faster than calling
   // gtk_clipboard_wait_for_image() since it doesn't need to retrieve
   // the actual image data.
   // RETURNS: %TRUE is there is an image available, %FALSE otherwise.
   int wait_is_image_available() {
      return gtk_clipboard_wait_is_image_available(&this);
   }

   // Test to see if there is rich text available to be pasted
   // This is done by requesting the TARGETS atom and checking
   // if it contains any of the supported rich text targets. This function
   // waits for the data to be received using the main loop, so events,
   // timeouts, etc, may be dispatched during the wait.
   // This function is a little faster than calling
   // gtk_clipboard_wait_for_rich_text() since it doesn't need to retrieve
   // the actual text.
   // RETURNS: %TRUE is there is rich text available, %FALSE otherwise.
   // <buffer>: a #GtkTextBuffer
   int wait_is_rich_text_available(TextBuffer* buffer) {
      return gtk_clipboard_wait_is_rich_text_available(&this, buffer);
   }

   // Checks if a clipboard supports pasting data of a given type. This
   // function can be used to determine if a "Paste" menu item should be
   // insensitive or not.
   // If you want to see if there's text available on the clipboard, use
   // gtk_clipboard_wait_is_text_available () instead.
   // RETURNS: %TRUE if the target is available, %FALSE otherwise.
   // <target>: A #GdkAtom indicating which target to look for.
   int wait_is_target_available(Gdk2.Atom target) {
      return gtk_clipboard_wait_is_target_available(&this, target);
   }

   // Test to see if there is text available to be pasted
   // This is done by requesting the TARGETS atom and checking
   // if it contains any of the supported text targets. This function 
   // waits for the data to be received using the main loop, so events, 
   // timeouts, etc, may be dispatched during the wait.
   // This function is a little faster than calling
   // gtk_clipboard_wait_for_text() since it doesn't need to retrieve
   // the actual text.
   // RETURNS: %TRUE is there is text available, %FALSE otherwise.
   int wait_is_text_available() {
      return gtk_clipboard_wait_is_text_available(&this);
   }

   // Test to see if there is a list of URIs available to be pasted
   // This is done by requesting the TARGETS atom and checking
   // if it contains the URI targets. This function
   // waits for the data to be received using the main loop, so events, 
   // timeouts, etc, may be dispatched during the wait.
   // This function is a little faster than calling
   // gtk_clipboard_wait_for_uris() since it doesn't need to retrieve
   // the actual URI data.
   // RETURNS: %TRUE is there is an URI list available, %FALSE otherwise.
   int wait_is_uris_available() {
      return gtk_clipboard_wait_is_uris_available(&this);
   }

   // The ::owner-change signal is emitted when GTK+ receives an
   // event that indicates that the ownership of the selection 
   // associated with @clipboard has changed.
   // <event>: the @GdkEventOwnerChange event
   extern (C) alias static void function (Clipboard* this_, Gdk2.Event* event, void* user_data=null) signal_owner_change;

   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:"owner-change", CB/*:signal_owner_change*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"owner-change",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

extern (C) alias void function (Clipboard* clipboard, void* user_data_or_owner) ClipboardClearFunc;

extern (C) alias void function (Clipboard* clipboard, SelectionData* selection_data, uint info, void* user_data_or_owner) ClipboardGetFunc;

extern (C) alias void function (Clipboard* clipboard, GdkPixbuf2.Pixbuf* pixbuf, void* data) ClipboardImageReceivedFunc;

extern (C) alias void function (Clipboard* clipboard, SelectionData* selection_data, void* data) ClipboardReceivedFunc;

extern (C) alias void function (Clipboard* clipboard, Gdk2.Atom format, ubyte* text, size_t length, void* data) ClipboardRichTextReceivedFunc;

extern (C) alias void function (Clipboard* clipboard, Gdk2.Atom* atoms, int n_atoms, void* data) ClipboardTargetsReceivedFunc;

extern (C) alias void function (Clipboard* clipboard, char* text, void* data) ClipboardTextReceivedFunc;

extern (C) alias void function (Clipboard* clipboard, char** uris, void* data) ClipboardURIReceivedFunc;

struct ColorButton /* : Button */ {
   alias button this;
   alias button super_;
   Button button;
   private ColorButtonPrivate* priv;


   // Creates a new color button. This returns a widget in the form of
   // a small button containing a swatch representing the current selected 
   // color. When the button is clicked, a color-selection dialog will open, 
   // allowing the user to select a color. The swatch will be updated to reflect 
   // the new color when the user finishes.
   // RETURNS: a new color button.
   static ColorButton* new_() {
      return gtk_color_button_new();
   }

   // Creates a new color button.
   // RETURNS: a new color button.
   // <color>: A #GdkColor to set the current color with.
   static ColorButton* new_with_color(Gdk2.Color* color) {
      return gtk_color_button_new_with_color(color);
   }

   // Returns the current alpha value.
   // RETURNS: an integer between 0 and 65535.
   ushort get_alpha() {
      return gtk_color_button_get_alpha(&this);
   }

   // Sets @color to be the current color in the #GtkColorButton widget.
   // <color>: a #GdkColor to fill in with the current color.
   void get_color(Gdk2.Color* color) {
      gtk_color_button_get_color(&this, color);
   }

   // Gets the title of the color selection dialog.
   // RETURNS: An internal string, do not free the return value
   char* get_title() {
      return gtk_color_button_get_title(&this);
   }

   // Does the color selection dialog use the alpha channel?
   // RETURNS: %TRUE if the color sample uses alpha channel, %FALSE if not.
   int get_use_alpha() {
      return gtk_color_button_get_use_alpha(&this);
   }

   // Sets the current opacity to be @alpha.
   // <alpha>: an integer between 0 and 65535.
   void set_alpha(ushort alpha) {
      gtk_color_button_set_alpha(&this, alpha);
   }

   // Sets the current color to be @color.
   // <color>: A #GdkColor to set the current color with.
   void set_color(Gdk2.Color* color) {
      gtk_color_button_set_color(&this, color);
   }

   // Sets the title for the color selection dialog.
   // <title>: String containing new window title.
   void set_title(char* title) {
      gtk_color_button_set_title(&this, title);
   }

   // Sets whether or not the color button should use the alpha channel.
   // <use_alpha>: %TRUE if color button should use alpha channel, %FALSE if not.
   void set_use_alpha(int use_alpha) {
      gtk_color_button_set_use_alpha(&this, use_alpha);
   }

   // The ::color-set signal is emitted when the user selects a color. 
   // When handling this signal, use gtk_color_button_get_color() and 
   // gtk_color_button_get_alpha() to find out which color was just selected.
   // Note that this signal is only emitted when the <emphasis>user</emphasis>
   // changes the color. If you need to react to programmatic color changes
   // as well, use the notify::color signal.
   extern (C) alias static void function (ColorButton* this_, void* user_data=null) signal_color_set;

   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:"color-set", CB/*:signal_color_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"color-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ColorButtonClass {
   ButtonClass parent_class;
   extern (C) void function (ColorButton* cp) color_set;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ColorButtonPrivate {
}

struct ColorSelection /* : VBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance vbox;
   VBox parent_instance;
   void* private_data;


   // Creates a new GtkColorSelection.
   // RETURNS: a new #GtkColorSelection
   static ColorSelection* new_() {
      return gtk_color_selection_new();
   }

   // Parses a color palette string; the string is a colon-separated
   // list of color names readable by gdk_color_parse().
   // RETURNS: %TRUE if a palette was successfully parsed.
   // <str>: a string encoding a color palette.
   // <colors>: return location for allocated array of #GdkColor.
   // <n_colors>: return location for length of array.
   static int palette_from_string(char* str, /*out*/ Gdk2.Color** colors, /*out*/ int* n_colors) {
      return gtk_color_selection_palette_from_string(str, colors, n_colors);
   }

   // Encodes a palette as a string, useful for persistent storage.
   // RETURNS: allocated string encoding the palette.
   // <colors>: an array of colors.
   // <n_colors>: length of the array.
   static char* /*new*/ palette_to_string(Gdk2.Color* colors, int n_colors) {
      return gtk_color_selection_palette_to_string(colors, n_colors);
   }

   // Unintrospectable function: set_change_palette_hook() / gtk_color_selection_set_change_palette_hook()
   // Installs a global function to be called whenever the user tries to
   // modify the palette in a color selection. This function should save
   // the new palette contents, and update the GtkSettings property
   // "gtk-color-palette" so all GtkColorSelection widgets will be modified.
   // Use gtk_color_selection_set_change_palette_with_screen_hook() instead.
   // RETURNS: the previous change palette hook (that was replaced).
   // <func>: a function to call when the custom palette needs saving.
   static ColorSelectionChangePaletteFunc set_change_palette_hook(ColorSelectionChangePaletteFunc func) {
      return gtk_color_selection_set_change_palette_hook(func);
   }

   // Unintrospectable function: set_change_palette_with_screen_hook() / gtk_color_selection_set_change_palette_with_screen_hook()
   // Installs a global function to be called whenever the user tries to
   // modify the palette in a color selection. This function should save
   // the new palette contents, and update the GtkSettings property
   // "gtk-color-palette" so all GtkColorSelection widgets will be modified.
   // RETURNS: the previous change palette hook (that was replaced).
   // <func>: a function to call when the custom palette needs saving.
   static ColorSelectionChangePaletteWithScreenFunc set_change_palette_with_screen_hook(ColorSelectionChangePaletteWithScreenFunc func) {
      return gtk_color_selection_set_change_palette_with_screen_hook(func);
   }

   // Sets @color to be the current color in the GtkColorSelection widget.
   // <color>: an array of 4 #gdouble to fill in with the current color.
   void get_color(double* color) {
      gtk_color_selection_get_color(&this, color);
   }

   // Returns the current alpha value.
   // RETURNS: an integer between 0 and 65535.
   ushort get_current_alpha() {
      return gtk_color_selection_get_current_alpha(&this);
   }

   // Sets @color to be the current color in the GtkColorSelection widget.
   // <color>: a #GdkColor to fill in with the current color.
   void get_current_color(/*out*/ Gdk2.Color* color) {
      gtk_color_selection_get_current_color(&this, color);
   }

   // Determines whether the colorsel has an opacity control.
   // RETURNS: %TRUE if the @colorsel has an opacity control.  %FALSE if it does't.
   int get_has_opacity_control() {
      return gtk_color_selection_get_has_opacity_control(&this);
   }

   // Determines whether the color selector has a color palette.
   // RETURNS: %TRUE if the selector has a palette.  %FALSE if it hasn't.
   int get_has_palette() {
      return gtk_color_selection_get_has_palette(&this);
   }

   // Returns the previous alpha value.
   // RETURNS: an integer between 0 and 65535.
   ushort get_previous_alpha() {
      return gtk_color_selection_get_previous_alpha(&this);
   }

   // Fills @color in with the original color value.
   // <color>: a #GdkColor to fill in with the original color value.
   void get_previous_color(/*out*/ Gdk2.Color* color) {
      gtk_color_selection_get_previous_color(&this, color);
   }

   // Gets the current state of the @colorsel.
   // if the selection has stopped.
   // RETURNS: %TRUE if the user is currently dragging a color around, and %FALSE
   int is_adjusting() {
      return gtk_color_selection_is_adjusting(&this);
   }

   // Sets the current color to be @color.  The first time this is called, it will
   // also set the original color to be @color too.
   // <color>: an array of 4 doubles specifying the red, green, blue and opacity to set the current color to.
   void set_color(double* color) {
      gtk_color_selection_set_color(&this, color);
   }

   // Sets the current opacity to be @alpha.  The first time this is called, it will
   // also set the original opacity to be @alpha too.
   // <alpha>: an integer between 0 and 65535.
   void set_current_alpha(ushort alpha) {
      gtk_color_selection_set_current_alpha(&this, alpha);
   }

   // Sets the current color to be @color.  The first time this is called, it will
   // also set the original color to be @color too.
   // <color>: A #GdkColor to set the current color with.
   void set_current_color(Gdk2.Color* color) {
      gtk_color_selection_set_current_color(&this, color);
   }

   // Sets the @colorsel to use or not use opacity.
   // <has_opacity>: %TRUE if @colorsel can set the opacity, %FALSE otherwise.
   void set_has_opacity_control(int has_opacity) {
      gtk_color_selection_set_has_opacity_control(&this, has_opacity);
   }

   // Shows and hides the palette based upon the value of @has_palette.
   // <has_palette>: %TRUE if palette is to be visible, %FALSE otherwise.
   void set_has_palette(int has_palette) {
      gtk_color_selection_set_has_palette(&this, has_palette);
   }

   // Sets the 'previous' alpha to be @alpha.  This function should be called with
   // some hesitations, as it might seem confusing to have that alpha change.
   // <alpha>: an integer between 0 and 65535.
   void set_previous_alpha(ushort alpha) {
      gtk_color_selection_set_previous_alpha(&this, alpha);
   }

   // Sets the 'previous' color to be @color.  This function should be called with
   // some hesitations, as it might seem confusing to have that color change.
   // Calling gtk_color_selection_set_current_color() will also set this color the first
   // time it is called.
   // <color>: a #GdkColor to set the previous color with.
   void set_previous_color(Gdk2.Color* color) {
      gtk_color_selection_set_previous_color(&this, color);
   }
   void set_update_policy(UpdateType policy) {
      gtk_color_selection_set_update_policy(&this, policy);
   }
   extern (C) alias static void function (ColorSelection* this_, void* user_data=null) signal_color_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:"color-changed", CB/*:signal_color_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"color-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

extern (C) alias void function (Gdk2.Color* colors, int n_colors) ColorSelectionChangePaletteFunc;

extern (C) alias void function (Gdk2.Screen* screen, Gdk2.Color* colors, int n_colors) ColorSelectionChangePaletteWithScreenFunc;

struct ColorSelectionClass {
   VBoxClass parent_class;
   extern (C) void function (ColorSelection* color_selection) color_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ColorSelectionDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   Widget* colorsel, ok_button, cancel_button, help_button;

   static ColorSelectionDialog* new_(char* title) {
      return gtk_color_selection_dialog_new(title);
   }

   // Retrieves the #GtkColorSelection widget embedded in the dialog.
   // RETURNS: the embedded #GtkColorSelection
   Widget* get_color_selection() {
      return gtk_color_selection_dialog_get_color_selection(&this);
   }
}

struct ColorSelectionDialogClass {
   DialogClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Combo /* : HBox */ {
   alias hbox this;
   alias hbox super_;
   HBox hbox;
   Widget* entry;
   private Widget* button, popup, popwin;
   Widget* list;
   private uint entry_change_id, list_change_id;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "value_in_list", 1,
   uint, "ok_if_empty", 1,
   uint, "case_sensitive", 1,
   uint, "use_arrows", 1,
   uint, "use_arrows_always", 1,
    uint, "__dummy32A", 27));
   private ushort current_button;
   private uint activate_id;

   static Combo* new_() {
      return gtk_combo_new();
   }
   void disable_activate() {
      gtk_combo_disable_activate(&this);
   }
   void set_case_sensitive(int val) {
      gtk_combo_set_case_sensitive(&this, val);
   }
   void set_item_string(Item* item, char* item_value) {
      gtk_combo_set_item_string(&this, item, item_value);
   }
   void set_popdown_strings(GLib2.List* strings) {
      gtk_combo_set_popdown_strings(&this, strings);
   }
   void set_use_arrows(int val) {
      gtk_combo_set_use_arrows(&this, val);
   }
   void set_use_arrows_always(int val) {
      gtk_combo_set_use_arrows_always(&this, val);
   }
   void set_value_in_list(int val, int ok_if_empty) {
      gtk_combo_set_value_in_list(&this, val, ok_if_empty);
   }
}


// A GtkComboBox is a widget that allows the user to choose from a list of
// valid choices. The GtkComboBox displays the selected choice. When
// activated, the GtkComboBox displays a popup which allows the user to
// make a new choice. The style in which the selected value is displayed,
// and the style of the popup is determined by the current theme. It may
// be similar to a Windows-style combo box.
// The GtkComboBox uses the model-view pattern; the list of valid choices
// is specified in the form of a tree model, and the display of the choices
// can be adapted to the data in the model by using cell renderers, as you
// would in a tree view. This is possible since GtkComboBox implements the
// #GtkCellLayout interface. The tree model holding the valid choices is
// not restricted to a flat list, it can be a real tree, and the popup will
// reflect the tree structure.
// To allow the user to enter values not in the model, the 'has-entry'
// property allows the GtkComboBox to contain a #GtkEntry. This entry
// can be accessed by calling gtk_bin_get_child() on the combo box.
// For a simple list of textual choices, the model-view API of GtkComboBox
// can be a bit overwhelming. In this case, #GtkComboBoxText offers a
// simple alternative. Both GtkComboBox and #GtkComboBoxText can contain
// an entry.
struct ComboBox /* : Bin */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance bin;
   Bin parent_instance;
   private ComboBoxPrivate* priv;


   // Creates a new empty #GtkComboBox.
   // RETURNS: A new #GtkComboBox.
   static ComboBox* new_() {
      return gtk_combo_box_new();
   }

   // Convenience function which constructs a new text combo box, which is a
   // #GtkComboBox just displaying strings. If you use this function to create
   // a text combo box, you should only manipulate its data source with the
   // gtk_combo_box_insert_text(), gtk_combo_box_prepend_text() and
   // gtk_combo_box_remove_text().
   // RETURNS: A new text combo box.
   static ComboBox* new_text() {
      return gtk_combo_box_new_text();
   }

   // Creates a new empty #GtkComboBox with an entry.
   // RETURNS: A new #GtkComboBox.
   static ComboBox* new_with_entry() {
      return gtk_combo_box_new_with_entry();
   }

   // Creates a new #GtkComboBox with the model initialized to @model.
   // RETURNS: A new #GtkComboBox.
   // <model>: A #GtkTreeModel.
   static ComboBox* new_with_model(TreeModel* model) {
      return gtk_combo_box_new_with_model(model);
   }

   // Creates a new empty #GtkComboBox with an entry
   // and with the model initialized to @model.
   // RETURNS: A new #GtkComboBox
   static ComboBox* new_with_model_and_entry(TreeModel* model) {
      return gtk_combo_box_new_with_model_and_entry(model);
   }

   // Appends @string to the list of strings stored in @combo_box. Note that
   // you can only use this function with combo boxes constructed with
   // gtk_combo_box_new_text().
   // <text>: A string
   void append_text(char* text) {
      gtk_combo_box_append_text(&this, text);
   }

   // Returns the index of the currently active item, or -1 if there's no
   // active item. If the model is a non-flat treemodel, and the active item 
   // is not an immediate child of the root of the tree, this function returns 
   // <literal>gtk_tree_path_get_indices (path)[0]</literal>, where 
   // <literal>path</literal> is the #GtkTreePath of the active item.
   // or -1 if there's no active item.
   // RETURNS: An integer which is the index of the currently active item,
   int get_active() {
      return gtk_combo_box_get_active(&this);
   }

   // Sets @iter to point to the current active item, if it exists.
   // RETURNS: %TRUE, if @iter was set
   // <iter>: The uninitialized #GtkTreeIter
   int get_active_iter(/*out*/ TreeIter* iter) {
      return gtk_combo_box_get_active_iter(&this, iter);
   }

   // Returns the currently active string in @combo_box or %NULL if none
   // is selected. Note that you can only use this function with combo
   // boxes constructed with gtk_combo_box_new_text() and with
   // #GtkComboBoxEntry<!-- -->s.
   // Must be freed with g_free().
   // gtk_combo_box_new_text() then you should now use #GtkComboBoxText and 
   // gtk_combo_box_text_get_active_text() instead. Or if you used this with a
   // #GtkComboBoxEntry then you should now use #GtkComboBox with 
   // #GtkComboBox:has-entry as %TRUE and use
   // gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combobox))).
   // RETURNS: a newly allocated string containing the currently active text.
   char* /*new*/ get_active_text() {
      return gtk_combo_box_get_active_text(&this);
   }

   // Gets the current value of the :add-tearoffs property.
   // RETURNS: the current value of the :add-tearoffs property.
   int get_add_tearoffs() {
      return gtk_combo_box_get_add_tearoffs(&this);
   }

   // Returns whether the combo box sets the dropdown button
   // sensitive or not when there are no items in the model.
   // is sensitive when the model is empty, %GTK_SENSITIVITY_OFF
   // if the button is always insensitive or
   // %GTK_SENSITIVITY_AUTO if it is only sensitive as long as
   // the model has one item to be selected.
   // RETURNS: %GTK_SENSITIVITY_ON if the dropdown button
   SensitivityType get_button_sensitivity() {
      return gtk_combo_box_get_button_sensitivity(&this);
   }

   // Returns the column with column span information for @combo_box.
   // RETURNS: the column span column.
   int get_column_span_column() {
      return gtk_combo_box_get_column_span_column(&this);
   }

   // Returns the column which @combo_box is using to get the strings
   // from to display in the internal entry.
   // RETURNS: A column in the data source model of @combo_box.
   int get_entry_text_column() {
      return gtk_combo_box_get_entry_text_column(&this);
   }

   // Returns whether the combo box grabs focus when it is clicked 
   // with the mouse. See gtk_combo_box_set_focus_on_click().
   // clicked with the mouse.
   // RETURNS: %TRUE if the combo box grabs focus when it is
   int get_focus_on_click() {
      return gtk_combo_box_get_focus_on_click(&this);
   }

   // Returns whether the combo box has an entry.
   // RETURNS: whether there is an entry in @combo_box.
   int get_has_entry() {
      return gtk_combo_box_get_has_entry(&this);
   }

   // Returns the #GtkTreeModel which is acting as data source for @combo_box.
   // during construction.
   // RETURNS: A #GtkTreeModel which was passed
   TreeModel* get_model() {
      return gtk_combo_box_get_model(&this);
   }

   // Gets the accessible object corresponding to the combo box's popup.
   // This function is mostly intended for use by accessibility technologies;
   // applications should have little use for it.
   // to the combo box's popup.
   // RETURNS: the accessible object corresponding
   Atk.Object* get_popup_accessible() {
      return gtk_combo_box_get_popup_accessible(&this);
   }

   // Unintrospectable method: get_row_separator_func() / gtk_combo_box_get_row_separator_func()
   // Returns the current row separator function.
   // RETURNS: the current row separator function.
   TreeViewRowSeparatorFunc get_row_separator_func() {
      return gtk_combo_box_get_row_separator_func(&this);
   }

   // Returns the column with row span information for @combo_box.
   // RETURNS: the row span column.
   int get_row_span_column() {
      return gtk_combo_box_get_row_span_column(&this);
   }

   // Gets the current title of the menu in tearoff mode. See
   // gtk_combo_box_set_add_tearoffs().
   // string which must not be freed.
   // RETURNS: the menu's title in tearoff mode. This is an internal copy of the
   char* get_title() {
      return gtk_combo_box_get_title(&this);
   }

   // Returns the wrap width which is used to determine the number of columns 
   // for the popup menu. If the wrap width is larger than 1, the combo box 
   // is in table mode.
   // RETURNS: the wrap width.
   int get_wrap_width() {
      return gtk_combo_box_get_wrap_width(&this);
   }

   // Inserts @string at @position in the list of strings stored in @combo_box.
   // Note that you can only use this function with combo boxes constructed
   // with gtk_combo_box_new_text().
   // <position>: An index to insert @text
   // <text>: A string
   void insert_text(int position, char* text) {
      gtk_combo_box_insert_text(&this, position, text);
   }

   // Hides the menu or dropdown list of @combo_box.
   // This function is mostly intended for use by accessibility technologies;
   // applications should have little use for it.
   void popdown() {
      gtk_combo_box_popdown(&this);
   }

   // Pops up the menu or dropdown list of @combo_box. 
   // This function is mostly intended for use by accessibility technologies;
   // applications should have little use for it.
   void popup() {
      gtk_combo_box_popup(&this);
   }

   // Prepends @string to the list of strings stored in @combo_box. Note that
   // you can only use this function with combo boxes constructed with
   // gtk_combo_box_new_text().
   // <text>: A string
   void prepend_text(char* text) {
      gtk_combo_box_prepend_text(&this, text);
   }

   // Removes the string at @position from @combo_box. Note that you can only use
   // this function with combo boxes constructed with gtk_combo_box_new_text().
   // <position>: Index of the item to remove
   void remove_text(int position) {
      gtk_combo_box_remove_text(&this, position);
   }

   // Sets the active item of @combo_box to be the item at @index.
   // <index_>: An index in the model passed during construction, or -1 to have no active item
   void set_active(int index_) {
      gtk_combo_box_set_active(&this, index_);
   }

   // Sets the current active item to be the one referenced by @iter, or
   // unsets the active item if @iter is %NULL.
   // <iter>: The #GtkTreeIter, or %NULL
   void set_active_iter(TreeIter* iter=null) {
      gtk_combo_box_set_active_iter(&this, iter);
   }

   // Sets whether the popup menu should have a tearoff 
   // menu item.
   // <add_tearoffs>: %TRUE to add tearoff menu items
   void set_add_tearoffs(int add_tearoffs) {
      gtk_combo_box_set_add_tearoffs(&this, add_tearoffs);
   }

   // Sets whether the dropdown button of the combo box should be
   // always sensitive (%GTK_SENSITIVITY_ON), never sensitive (%GTK_SENSITIVITY_OFF)
   // or only if there is at least one item to display (%GTK_SENSITIVITY_AUTO).
   // <sensitivity>: specify the sensitivity of the dropdown button
   void set_button_sensitivity(SensitivityType sensitivity) {
      gtk_combo_box_set_button_sensitivity(&this, sensitivity);
   }

   // Sets the column with column span information for @combo_box to be
   // how many columns an item should span.
   // <column_span>: A column in the model passed during construction
   void set_column_span_column(int column_span) {
      gtk_combo_box_set_column_span_column(&this, column_span);
   }

   // Sets the model column which @combo_box should use to get strings from
   // to be @text_column. The column @text_column in the model of @combo_box
   // must be of type %G_TYPE_STRING.
   // This is only relevant if @combo_box has been created with
   // #GtkComboBox:has-entry as %TRUE.
   // <text_column>: A column in @model to get the strings from for the internal entry
   void set_entry_text_column(int text_column) {
      gtk_combo_box_set_entry_text_column(&this, text_column);
   }

   // Sets whether the combo box will grab focus when it is clicked with 
   // the mouse. Making mouse clicks not grab focus is useful in places 
   // like toolbars where you don't want the keyboard focus removed from 
   // the main area of the application.
   // <focus_on_click>: whether the combo box grabs focus when clicked with the mouse
   void set_focus_on_click(int focus_on_click) {
      gtk_combo_box_set_focus_on_click(&this, focus_on_click);
   }

   // Sets the model used by @combo_box to be @model. Will unset a previously set
   // model (if applicable). If model is %NULL, then it will unset the model.
   // Note that this function does not clear the cell renderers, you have to 
   // call gtk_cell_layout_clear() yourself if you need to set up different 
   // cell renderers for the new model.
   // <model>: A #GtkTreeModel
   void set_model(TreeModel* model=null) {
      gtk_combo_box_set_model(&this, model);
   }

   // Sets the row separator function, which is used to determine
   // whether a row should be drawn as a separator. If the row separator
   // function is %NULL, no separators are drawn. This is the default value.
   // <func>: a #GtkTreeViewRowSeparatorFunc
   // <data>: user data to pass to @func, or %NULL
   // <destroy>: destroy notifier for @data, or %NULL
   void set_row_separator_func(TreeViewRowSeparatorFunc func, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_combo_box_set_row_separator_func(&this, func, data, destroy);
   }

   // Sets the column with row span information for @combo_box to be @row_span.
   // The row span column contains integers which indicate how many rows
   // an item should span.
   // <row_span>: A column in the model passed during construction.
   void set_row_span_column(int row_span) {
      gtk_combo_box_set_row_span_column(&this, row_span);
   }

   // Sets the menu's title in tearoff mode.
   // <title>: a title for the menu in tearoff mode
   void set_title(char* title) {
      gtk_combo_box_set_title(&this, title);
   }

   // Sets the wrap width of @combo_box to be @width. The wrap width is basically
   // the preferred number of columns when you want the popup to be layed out
   // in a table.
   // <width>: Preferred number of columns
   void set_wrap_width(int width) {
      gtk_combo_box_set_wrap_width(&this, width);
   }

   // The changed signal is emitted when the active
   // item is changed. The can be due to the user selecting
   // a different item from the list, or due to a 
   // call to gtk_combo_box_set_active_iter().
   // It will also be emitted while typing into a GtkComboBoxEntry, 
   // as well as when selecting an item from the GtkComboBoxEntry's list.
   extern (C) alias static void function (ComboBox* 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);
   }

   // The ::move-active signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to move the active selection.
   // <scroll_type>: a #GtkScrollType
   extern (C) alias static void function (ComboBox* this_, ScrollType* scroll_type, void* user_data=null) signal_move_active;
   ulong signal_connect(string name:"move-active", CB/*:signal_move_active*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-active",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::popdown signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to popdown the combo box list.
   // The default bindings for this signal are Alt+Up and Escape.
   extern (C) alias static c_int function (ComboBox* this_, void* user_data=null) signal_popdown;
   ulong signal_connect(string name:"popdown", CB/*:signal_popdown*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popdown",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::popup signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to popup the combo box list.
   // The default binding for this signal is Alt+Down.
   extern (C) alias static void function (ComboBox* this_, void* user_data=null) signal_popup;
   ulong signal_connect(string name:"popup", CB/*:signal_popup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popup",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ComboBoxClass {
   BinClass parent_class;
   extern (C) void function (ComboBox* combo_box) changed;
   // RETURNS: a newly allocated string containing the currently active text.
   extern (C) char* /*new*/ function (ComboBox* combo_box) get_active_text;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

struct ComboBoxEntry /* : ComboBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance combobox;
   ComboBox parent_instance;
   private ComboBoxEntryPrivate* priv;


   // Creates a new #GtkComboBoxEntry which has a #GtkEntry as child. After
   // construction, you should set a model using gtk_combo_box_set_model() and a
   // text column using gtk_combo_box_entry_set_text_column().
   // RETURNS: A new #GtkComboBoxEntry.
   static ComboBoxEntry* new_() {
      return gtk_combo_box_entry_new();
   }

   // Convenience function which constructs a new editable text combo box, which 
   // is a #GtkComboBoxEntry just displaying strings. If you use this function to
   // create a text combo box, you should only manipulate its data source with
   // gtk_combo_box_insert_text(), gtk_combo_box_prepend_text() and
   // gtk_combo_box_remove_text().
   // RETURNS: A new text #GtkComboBoxEntry.
   static ComboBoxEntry* new_text() {
      return gtk_combo_box_entry_new_text();
   }

   // Creates a new #GtkComboBoxEntry which has a #GtkEntry as child and a list
   // of strings as popup. You can get the #GtkEntry from a #GtkComboBoxEntry
   // using GTK_ENTRY (GTK_BIN (combo_box_entry)->child). To add and remove
   // strings from the list, just modify @model using its data manipulation
   // API.
   // RETURNS: A new #GtkComboBoxEntry.
   // <model>: A #GtkTreeModel.
   // <text_column>: A column in @model to get the strings from.
   static ComboBoxEntry* new_with_model(TreeModel* model, int text_column) {
      return gtk_combo_box_entry_new_with_model(model, text_column);
   }

   // Returns the column which @entry_box is using to get the strings from.
   // RETURNS: A column in the data source model of @entry_box.
   int get_text_column() {
      return gtk_combo_box_entry_get_text_column(&this);
   }

   // Sets the model column which @entry_box should use to get strings from
   // to be @text_column.
   // <text_column>: A column in @model to get the strings from.
   void set_text_column(int text_column) {
      gtk_combo_box_entry_set_text_column(&this, text_column);
   }
}

struct ComboBoxEntryClass {
   ComboBoxClass parent_class;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

struct ComboBoxEntryPrivate {
}

struct ComboBoxPrivate {
}


// A GtkComboBoxText is a simple variant of #GtkComboBox that hides
// the model-view complexity for simple text-only use cases.
// To create a GtkComboBoxText, use gtk_combo_box_text_new() or
// gtk_combo_box_text_new_with_entry().
// You can add items to a GtkComboBoxText with
// gtk_combo_box_text_append_text(), gtk_combo_box_text_insert_text()
// or gtk_combo_box_text_prepend_text() and remove options with
// gtk_combo_box_text_remove().
// If the GtkComboBoxText contains an entry (via the 'has-entry' property),
// its contents can be retrieved using gtk_combo_box_text_get_active_text().
// The entry itself can be accessed by calling gtk_bin_get_child() on the
// combo box.
// <refsect2 id="GtkComboBoxText-BUILDER-UI">
// <title>GtkComboBoxText as GtkBuildable</title>
// <para>
// The GtkComboBoxText implementation of the GtkBuildable interface
// supports adding items directly using the &lt;items&gt element
// and specifying &lt;item&gt; elements for each item. Each &lt;item&gt;
// element supports the regular translation attributes "translatable",
// "context" and "comments".
// </para>
// <example>
// <title>A UI definition fragment specifying GtkComboBoxText items</title>
// <programlisting><![CDATA[
// <object class="GtkComboBoxText">
// <items>
// <item translatable="yes">Factory</item>
// <item translatable="yes">Home</item>
// <item translatable="yes">Subway</item>
// </items>
// </object>
// ]]></programlisting>
// </example>
// </refsect2>
struct ComboBoxText /* : ComboBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance combobox;
   ComboBox parent_instance;
   private ComboBoxTextPrivate* priv;


   // Creates a new #GtkComboBoxText, which is a #GtkComboBox just displaying
   // strings. See gtk_combo_box_entry_new_with_text().
   // RETURNS: A new #GtkComboBoxText
   static ComboBoxText* new_() {
      return gtk_combo_box_text_new();
   }

   // Creates a new #GtkComboBoxText, which is a #GtkComboBox just displaying
   // strings. The combo box created by this function has an entry.
   // RETURNS: a new #GtkComboBoxText
   static ComboBoxText* new_with_entry() {
      return gtk_combo_box_text_new_with_entry();
   }

   // Appends @string to the list of strings stored in @combo_box.
   // <text>: A string
   void append_text(char* text) {
      gtk_combo_box_text_append_text(&this, text);
   }

   // Returns the currently active string in @combo_box, or %NULL
   // if none is selected. If @combo_box contains an entry, this
   // function will return its contents (which will not necessarily
   // be an item from the list).
   // active text. Must be freed with g_free().
   // RETURNS: a newly allocated string containing the currently
   char* /*new*/ get_active_text() {
      return gtk_combo_box_text_get_active_text(&this);
   }

   // Inserts @string at @position in the list of strings stored in @combo_box.
   // <position>: An index to insert @text
   // <text>: A string
   void insert_text(int position, char* text) {
      gtk_combo_box_text_insert_text(&this, position, text);
   }

   // Prepends @string to the list of strings stored in @combo_box.
   // <text>: A string
   void prepend_text(char* text) {
      gtk_combo_box_text_prepend_text(&this, text);
   }

   // Removes the string at @position from @combo_box.
   // <position>: Index of the item to remove
   void remove(int position) {
      gtk_combo_box_text_remove(&this, position);
   }
}

struct ComboBoxTextClass {
   ComboBoxClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ComboBoxTextPrivate {
}

struct ComboClass {
   HBoxClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Container /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   Widget* focus_child;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "border_width", 16,
   uint, "need_resize", 1,
   uint, "resize_mode", 2,
   uint, "reallocate_redraws", 1,
   uint, "has_focus_chain", 1,
    uint, "__dummy32A", 11));


   // Adds @widget to @container. Typically used for simple containers
   // such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated
   // layout containers such as #GtkBox or #GtkTable, this function will
   // pick default packing parameters that may not be correct.  So
   // consider functions such as gtk_box_pack_start() and
   // gtk_table_attach() as an alternative to gtk_container_add() in
   // those cases. A widget may be added to only one container at a time;
   // you can't place the same widget inside two different containers.
   // <widget>: a widget to be placed inside @container
   void add(Widget* widget) {
      gtk_container_add(&this, widget);
   }

   // Unintrospectable method: add_with_properties() / gtk_container_add_with_properties()
   // Adds @widget to @container, setting child properties at the same time.
   // See gtk_container_add() and gtk_container_child_set() for more details.
   // <widget>: a widget to be placed inside @container
   // <first_prop_name>: the name of the first child property to set
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_container_add_with_properties add_with_properties; // Variadic
   +/
   void check_resize() {
      gtk_container_check_resize(&this);
   }

   // Unintrospectable method: child_get() / gtk_container_child_get()
   // Gets the values of one or more child properties for @child and @container.
   // <child>: a widget which is a child of @container
   // <first_prop_name>: the name of the first property to get
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_container_child_get child_get; // Variadic
   +/

   // Gets the value of a child property for @child and @container.
   // <child>: a widget which is a child of @container
   // <property_name>: the name of the property to get
   // <value>: a location to return the value
   void child_get_property(Widget* child, char* property_name, GObject2.Value* value) {
      gtk_container_child_get_property(&this, child, property_name, value);
   }

   // Unintrospectable method: child_get_valist() / gtk_container_child_get_valist()
   // Gets the values of one or more child properties for @child and @container.
   // <child>: a widget which is a child of @container
   // <first_property_name>: the name of the first property to get
   // <var_args>: return location for the first property, followed optionally by more name/return location pairs, followed by %NULL
   void child_get_valist(Widget* child, char* first_property_name, va_list var_args) {
      gtk_container_child_get_valist(&this, child, first_property_name, var_args);
   }

   // Unintrospectable method: child_set() / gtk_container_child_set()
   // Sets one or more child properties for @child and @container.
   // <child>: a widget which is a child of @container
   // <first_prop_name>: the name of the first property to set
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_container_child_set child_set; // Variadic
   +/

   // Sets a child property for @child and @container.
   // <child>: a widget which is a child of @container
   // <property_name>: the name of the property to set
   // <value>: the value to set the property to
   void child_set_property(Widget* child, char* property_name, GObject2.Value* value) {
      gtk_container_child_set_property(&this, child, property_name, value);
   }

   // Unintrospectable method: child_set_valist() / gtk_container_child_set_valist()
   // Sets one or more child properties for @child and @container.
   // <child>: a widget which is a child of @container
   // <first_property_name>: the name of the first property to set
   // <var_args>: a %NULL-terminated list of property names and values, starting with @first_prop_name
   void child_set_valist(Widget* child, char* first_property_name, va_list var_args) {
      gtk_container_child_set_valist(&this, child, first_property_name, var_args);
   }

   // Returns the type of the children supported by the container.
   // Note that this may return %G_TYPE_NONE to indicate that no more
   // children can be added, e.g. for a #GtkPaned which already has two 
   // children.
   // RETURNS: a #GType.
   Type child_type() {
      return gtk_container_child_type(&this);
   }

   // Unintrospectable method: forall() / gtk_container_forall()
   // Invokes @callback on each child of @container, including children
   // that are considered "internal" (implementation details of the
   // container). "Internal" children generally weren't added by the user
   // of the container, but were added by the container implementation
   // itself.  Most applications should use gtk_container_foreach(),
   // rather than gtk_container_forall().
   // <callback>: a callback
   // <callback_data>: callback user data
   void forall(Callback callback, void* callback_data) {
      gtk_container_forall(&this, callback, callback_data);
   }

   // Invokes @callback on each non-internal child of @container. See
   // gtk_container_forall() for details on what constitutes an
   // "internal" child.  Most applications should use
   // gtk_container_foreach(), rather than gtk_container_forall().
   // <callback>: a callback
   // <callback_data>: callback user data
   void foreach_(Callback callback, void* callback_data) {
      gtk_container_foreach(&this, callback, callback_data);
   }
   // Unintrospectable method: foreach_full() / gtk_container_foreach_full()
   void foreach_full(Callback callback, CallbackMarshal marshal, void* callback_data, GLib2.DestroyNotify notify) {
      gtk_container_foreach_full(&this, callback, marshal, callback_data, notify);
   }

   // Retrieves the border width of the container. See
   // gtk_container_set_border_width().
   // RETURNS: the current border width
   uint get_border_width() {
      return gtk_container_get_border_width(&this);
   }

   // Returns the container's non-internal children. See
   // gtk_container_forall() for details on what constitutes an "internal" child.
   // RETURNS: a newly-allocated list of the container's non-internal children.
   GLib2.List* /*new container*/ get_children() {
      return gtk_container_get_children(&this);
   }

   // Retrieves the focus chain of the container, if one has been
   // set explicitly. If no focus chain has been explicitly
   // set, GTK+ computes the focus chain based on the positions
   // of the children. In that case, GTK+ stores %NULL in
   // has been set explicitly.
   // RETURNS: %TRUE if the focus chain of the container
   // <focusable_widgets>: location to store the focus chain of the container, or %NULL. You should free this list using g_list_free() when you are done with it, however no additional reference count is added to the individual widgets in the focus chain.
   int get_focus_chain(/*out*/ GLib2.List** focusable_widgets) {
      return gtk_container_get_focus_chain(&this, focusable_widgets);
   }

   // Returns the current focus child widget inside @container. This is not the
   // currently focused widget. That can be obtained by calling
   // gtk_window_get_focus().
   // focus inside @container when the @conatiner is focussed,
   // or %NULL if none is set.
   // RETURNS: The child widget which will receive the
   Widget* get_focus_child() {
      return gtk_container_get_focus_child(&this);
   }

   // Retrieves the horizontal focus adjustment for the container. See
   // gtk_container_set_focus_hadjustment ().
   // none has been set.
   // RETURNS: the horizontal focus adjustment, or %NULL if
   Adjustment* get_focus_hadjustment() {
      return gtk_container_get_focus_hadjustment(&this);
   }

   // Retrieves the vertical focus adjustment for the container. See
   // gtk_container_set_focus_vadjustment().
   // none has been set.
   // RETURNS: the vertical focus adjustment, or %NULL if
   Adjustment* get_focus_vadjustment() {
      return gtk_container_get_focus_vadjustment(&this);
   }

   // Returns the resize mode for the container. See
   // gtk_container_set_resize_mode ().
   // RETURNS: the current resize mode
   ResizeMode get_resize_mode() {
      return gtk_container_get_resize_mode(&this);
   }

   // When a container receives an expose event, it must send synthetic
   // expose events to all children that don't have their own #GdkWindows.
   // This function provides a convenient way of doing this. A container,
   // when it receives an expose event, calls gtk_container_propagate_expose()
   // once for each child, passing in the event the container received.
   // gtk_container_propagate_expose() takes care of deciding whether
   // an expose event needs to be sent to the child, intersecting
   // the event's area with the child area, and sending the event.
   // In most cases, a container can simply either simply inherit the
   // #GtkWidget::expose implementation from #GtkContainer, or, do some drawing
   // and then chain to the ::expose implementation from #GtkContainer.
   // Note that the ::expose-event signal has been replaced by a ::draw
   // signal in GTK+ 3, and consequently, gtk_container_propagate_expose()
   // has been replaced by gtk_container_propagate_draw().
   // The <link linkend="http://library.gnome.org/devel/gtk3/3.0/gtk-migrating-2-to-3.html">GTK+ 3 migration guide</link>
   // for hints on how to port from ::expose-event to ::draw.
   // <child>: a child of @container
   // <event>: a expose event sent to container
   void propagate_expose(Widget* child, Gdk2.EventExpose* event) {
      gtk_container_propagate_expose(&this, child, event);
   }

   // Removes @widget from @container. @widget must be inside @container.
   // Note that @container will own a reference to @widget, and that this
   // may be the last reference held; so removing a widget from its
   // container can destroy that widget. If you want to use @widget
   // again, you need to add a reference to it while it's not inside
   // a container, using g_object_ref(). If you don't want to use @widget
   // again it's usually more efficient to simply destroy it directly
   // using gtk_widget_destroy() since this will remove it from the
   // container and help break any circular reference count cycles.
   // <widget>: a current child of @container
   void remove(Widget* widget) {
      gtk_container_remove(&this, widget);
   }
   void resize_children() {
      gtk_container_resize_children(&this);
   }

   // Sets the border width of the container.
   // The border width of a container is the amount of space to leave
   // around the outside of the container. The only exception to this is
   // #GtkWindow; because toplevel windows can't leave space outside,
   // they leave the space inside. The border is added on all sides of
   // the container. To add space to only one side, one approach is to
   // create a #GtkAlignment widget, call gtk_widget_set_size_request()
   // to give it a size, and place it on the side of the container as
   // a spacer.
   // <border_width>: amount of blank space to leave <emphasis>outside</emphasis> the container. Valid values are in the range 0-65535 pixels.
   void set_border_width(uint border_width) {
      gtk_container_set_border_width(&this, border_width);
   }

   // Sets a focus chain, overriding the one computed automatically by GTK+.
   // In principle each widget in the chain should be a descendant of the 
   // container, but this is not enforced by this method, since it's allowed 
   // to set the focus chain before you pack the widgets, or have a widget 
   // in the chain that isn't always packed. The necessary checks are done 
   // when the focus chain is actually traversed.
   // <focusable_widgets>: the new focus chain
   void set_focus_chain(GLib2.List* focusable_widgets) {
      gtk_container_set_focus_chain(&this, focusable_widgets);
   }

   // Sets, or unsets if @child is %NULL, the focused child of @container.
   // This function emits the GtkContainer::set_focus_child signal of
   // default behaviour by overriding the class closure of this signal.
   // This is function is mostly meant to be used by widgets. Applications can use
   // gtk_widget_grab_focus() to manualy set the focus to a specific widget.
   // <child>: a #GtkWidget, or %NULL
   void set_focus_child(Widget* child=null) {
      gtk_container_set_focus_child(&this, child);
   }

   // Hooks up an adjustment to focus handling in a container, so when a child 
   // of the container is focused, the adjustment is scrolled to show that 
   // widget. This function sets the horizontal alignment. 
   // See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining 
   // the adjustment and gtk_container_set_focus_vadjustment() for setting
   // the vertical adjustment.
   // The adjustments have to be in pixel units and in the same coordinate 
   // system as the allocation for immediate children of the container.
   // <adjustment>: an adjustment which should be adjusted when the focus is moved among the descendents of @container
   void set_focus_hadjustment(Adjustment* adjustment) {
      gtk_container_set_focus_hadjustment(&this, adjustment);
   }

   // Hooks up an adjustment to focus handling in a container, so when a 
   // child of the container is focused, the adjustment is scrolled to 
   // show that widget. This function sets the vertical alignment. See 
   // gtk_scrolled_window_get_vadjustment() for a typical way of obtaining 
   // the adjustment and gtk_container_set_focus_hadjustment() for setting
   // the horizontal adjustment.
   // The adjustments have to be in pixel units and in the same coordinate 
   // system as the allocation for immediate children of the container.
   // <adjustment>: an adjustment which should be adjusted when the focus is moved among the descendents of @container
   void set_focus_vadjustment(Adjustment* adjustment) {
      gtk_container_set_focus_vadjustment(&this, adjustment);
   }

   // Sets the @reallocate_redraws flag of the container to the given value.
   // Containers requesting reallocation redraws get automatically
   // redrawn if any of their children changed allocation.
   // <needs_redraws>: the new value for the container's @reallocate_redraws flag
   void set_reallocate_redraws(int needs_redraws) {
      gtk_container_set_reallocate_redraws(&this, needs_redraws);
   }

   // Sets the resize mode for the container.
   // The resize mode of a container determines whether a resize request 
   // will be passed to the container's parent, queued for later execution
   // or executed immediately.
   // <resize_mode>: the new resize mode
   void set_resize_mode(ResizeMode resize_mode) {
      gtk_container_set_resize_mode(&this, resize_mode);
   }
   // Removes a focus chain explicitly set with gtk_container_set_focus_chain().
   void unset_focus_chain() {
      gtk_container_unset_focus_chain(&this);
   }
   extern (C) alias static void function (Container* this_, Widget* object, void* user_data=null) signal_add;

   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:"add", CB/*:signal_add*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"add",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Container* this_, void* user_data=null) signal_check_resize;
   ulong signal_connect(string name:"check-resize", CB/*:signal_check_resize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"check-resize",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Container* this_, Widget* object, void* user_data=null) signal_remove;
   ulong signal_connect(string name:"remove", CB/*:signal_remove*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"remove",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Container* this_, Widget* object, void* user_data=null) signal_set_focus_child;
   ulong signal_connect(string name:"set-focus-child", CB/*:signal_set_focus_child*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-focus-child",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ContainerClass {
   WidgetClass parent_class;
   // <widget>: a widget to be placed inside @container
   extern (C) void function (Container* container, Widget* widget) add;
   // <widget>: a current child of @container
   extern (C) void function (Container* container, Widget* widget) remove;
   extern (C) void function (Container* container) check_resize;
   // Unintrospectable functionp: forall() / ()
   extern (C) void function (Container* container, int include_internals, Callback callback, void* callback_data) forall;
   extern (C) void function (Container* container, Widget* widget) set_focus_child;
   // RETURNS: a #GType.
   extern (C) Type function (Container* container) child_type;
   extern (C) char* /*new*/ function (Container* container, Widget* child) composite_name;
   extern (C) void function (Container* container, Widget* child, uint property_id, GObject2.Value* value, GObject2.ParamSpec* pspec) set_child_property;
   extern (C) void function (Container* container, Widget* child, uint property_id, GObject2.Value* value, GObject2.ParamSpec* pspec) get_child_property;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;


   // Finds a child property of a container class by name.
   // RETURNS: the #GParamSpec of the child property or %NULL if @class has no child property with that name.
   // <property_name>: the name of the child property to find
   GObject2.ParamSpec* find_child_property(char* property_name) {
      return gtk_container_class_find_child_property(&this, property_name);
   }

   // Installs a child property on a container class.
   // <property_id>: the id for the property
   // <pspec>: the #GParamSpec for the property
   void install_child_property(uint property_id, GObject2.ParamSpec* pspec) {
      gtk_container_class_install_child_property(&this, property_id, pspec);
   }

   // Returns all child properties of a container class.
   // RETURNS: a newly allocated %NULL-terminated array of #GParamSpec*. The array must be freed with g_free().
   // <n_properties>: location to return the number of child properties found
   GObject2.ParamSpec** /*new container*/ list_child_properties(/*out*/ uint* n_properties) {
      return gtk_container_class_list_child_properties(&this, n_properties);
   }
}

enum CornerType {
   TOP_LEFT = 0,
   BOTTOM_LEFT = 1,
   TOP_RIGHT = 2,
   BOTTOM_RIGHT = 3
}
struct Curve /* : DrawingArea */ {
   alias graph this;
   alias graph super_;
   alias graph drawingarea;
   DrawingArea graph;
   int cursor_type;
   float min_x, max_x, min_y, max_y;
   Gdk2.Pixmap* pixmap;
   CurveType curve_type;
   int height, grab_point, last, num_points;
   Gdk2.Point* point;
   int num_ctlpoints;
   float* ctlpoint;

   static Curve* new_() {
      return gtk_curve_new();
   }
   void get_vector(int veclen, float vector) {
      gtk_curve_get_vector(&this, veclen, vector);
   }
   void reset() {
      gtk_curve_reset(&this);
   }
   void set_curve_type(CurveType type) {
      gtk_curve_set_curve_type(&this, type);
   }
   void set_gamma(float gamma_) {
      gtk_curve_set_gamma(&this, gamma_);
   }
   void set_range(float min_x, float max_x, float min_y, float max_y) {
      gtk_curve_set_range(&this, min_x, max_x, min_y, max_y);
   }
   void set_vector(int veclen, float vector) {
      gtk_curve_set_vector(&this, veclen, vector);
   }
   extern (C) alias static void function (Curve* this_, void* user_data=null) signal_curve_type_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:"curve-type-changed", CB/*:signal_curve_type_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"curve-type-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct CurveClass {
   DrawingAreaClass parent_class;
   extern (C) void function (Curve* curve) curve_type_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum CurveType {
   LINEAR = 0,
   SPLINE = 1,
   FREE = 2
}
enum DebugFlag {
   MISC = 1,
   PLUGSOCKET = 2,
   TEXT = 4,
   TREE = 8,
   UPDATES = 16,
   KEYBINDINGS = 32,
   MULTIHEAD = 64,
   MODULES = 128,
   GEOMETRY = 256,
   ICONTHEME = 512,
   PRINTING = 1024,
   BUILDER = 2048
}
enum DeleteType {
   CHARS = 0,
   WORD_ENDS = 1,
   WORDS = 2,
   DISPLAY_LINES = 3,
   DISPLAY_LINE_ENDS = 4,
   PARAGRAPH_ENDS = 5,
   PARAGRAPHS = 6,
   WHITESPACE = 7
}
enum DestDefaults {
   MOTION = 1,
   HIGHLIGHT = 2,
   DROP = 4,
   ALL = 7
}
extern (C) alias void function (void* data) DestroyNotify;

struct Dialog /* : Window */ {
   alias window this;
   alias window super_;
   Window window;
   Widget* vbox, action_area;
   private Widget* separator;

   static Dialog* new_() {
      return gtk_dialog_new();
   }

   // Unintrospectable constructor: new_with_buttons() / gtk_dialog_new_with_buttons()
   // Creates a new #GtkDialog with title @title (or %NULL for the default
   // title; see gtk_window_set_title()) and transient parent @parent (or
   // %NULL for none; see gtk_window_set_transient_for()). The @flags
   // argument can be used to make the dialog modal (#GTK_DIALOG_MODAL)
   // and/or to have it destroyed along with its transient parent
   // (#GTK_DIALOG_DESTROY_WITH_PARENT). After @flags, button
   // text/response ID pairs should be listed, with a %NULL pointer ending
   // the list. Button text can be either a stock ID such as
   // #GTK_STOCK_OK, or some arbitrary text. A response ID can be
   // any positive number, or one of the values in the #GtkResponseType
   // enumeration. If the user clicks one of these dialog buttons,
   // #GtkDialog will emit the #GtkDialog::response signal with the corresponding
   // response ID. If a #GtkDialog receives the #GtkWidget::delete-event signal, 
   // it will emit ::response with a response ID of #GTK_RESPONSE_DELETE_EVENT.
   // However, destroying a dialog does not emit the ::response signal;
   // so be careful relying on ::response when using the 
   // #GTK_DIALOG_DESTROY_WITH_PARENT flag. Buttons are from left to right,
   // so the first button in the list will be the leftmost button in the dialog.
   // Here's a simple example:
   // |[
   // GtkWidget *dialog = gtk_dialog_new_with_buttons ("My dialog",
   // main_app_window,
   // GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
   // GTK_STOCK_OK,
   // GTK_RESPONSE_ACCEPT,
   // GTK_STOCK_CANCEL,
   // GTK_RESPONSE_REJECT,
   // NULL);
   // ]|
   // RETURNS: a new #GtkDialog
   // <title>: Title of the dialog, or %NULL
   // <parent>: Transient parent of the dialog, or %NULL
   // <flags>: from #GtkDialogFlags
   // <first_button_text>: stock ID or text to go in first button, or %NULL
   alias gtk_dialog_new_with_buttons new_with_buttons; // Variadic

   // Adds an activatable widget to the action area of a #GtkDialog,
   // connecting a signal handler that will emit the #GtkDialog::response 
   // signal on the dialog when the widget is activated. The widget is 
   // appended to the end of the dialog's action area. If you want to add a
   // non-activatable widget, simply pack it into the @action_area field 
   // of the #GtkDialog struct.
   // <child>: an activatable widget
   // <response_id>: response ID for @child
   void add_action_widget(Widget* child, int response_id) {
      gtk_dialog_add_action_widget(&this, child, response_id);
   }

   // Adds a button with the given text (or a stock button, if @button_text is a
   // stock ID) and sets things up so that clicking the button will emit the
   // #GtkDialog::response signal with the given @response_id. The button is 
   // appended to the end of the dialog's action area. The button widget is 
   // returned, but usually you don't need it.
   // RETURNS: the button widget that was added
   // <button_text>: text of button, or stock ID
   // <response_id>: response ID for the button
   Widget* add_button(char* button_text, int response_id) {
      return gtk_dialog_add_button(&this, button_text, response_id);
   }

   // Unintrospectable method: add_buttons() / gtk_dialog_add_buttons()
   // Adds more buttons, same as calling gtk_dialog_add_button()
   // repeatedly.  The variable argument list should be %NULL-terminated
   // as with gtk_dialog_new_with_buttons(). Each button must have both
   // text and response ID.
   // <first_button_text>: button text or stock ID
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_dialog_add_buttons add_buttons; // Variadic
   +/

   // Returns the action area of @dialog.
   // RETURNS: the action area.
   Widget* get_action_area() {
      return gtk_dialog_get_action_area(&this);
   }

   // Returns the content area of @dialog.
   // RETURNS: the content area #GtkVBox.
   Widget* get_content_area() {
      return gtk_dialog_get_content_area(&this);
   }

   // Accessor for whether the dialog has a separator.
   // RETURNS: %TRUE if the dialog has a separator
   int get_has_separator() {
      return gtk_dialog_get_has_separator(&this);
   }

   // Gets the response id of a widget in the action area
   // of a dialog.
   // if @widget doesn't have a response id set.
   // RETURNS: the response id of @widget, or %GTK_RESPONSE_NONE
   // <widget>: a widget in the action area of @dialog
   int get_response_for_widget(Widget* widget) {
      return gtk_dialog_get_response_for_widget(&this, widget);
   }

   // Gets the widget button that uses the given response ID in the action area
   // of a dialog.
   // RETURNS: the @widget button that uses the given @response_id, or %NULL.
   // <response_id>: the response ID used by the @dialog widget
   Widget* get_widget_for_response(int response_id) {
      return gtk_dialog_get_widget_for_response(&this, response_id);
   }

   // Emits the #GtkDialog::response signal with the given response ID. 
   // Used to indicate that the user has responded to the dialog in some way;
   // typically either you or gtk_dialog_run() will be monitoring the
   // ::response signal and take appropriate action.
   // <response_id>: response ID
   void response(int response_id) {
      gtk_dialog_response(&this, response_id);
   }

   // Blocks in a recursive main loop until the @dialog either emits the
   // #GtkDialog::response signal, or is destroyed. If the dialog is 
   // destroyed during the call to gtk_dialog_run(), gtk_dialog_run() returns 
   // #GTK_RESPONSE_NONE. Otherwise, it returns the response ID from the 
   // ::response signal emission.
   // Before entering the recursive main loop, gtk_dialog_run() calls
   // gtk_widget_show() on the dialog for you. Note that you still
   // need to show any children of the dialog yourself.
   // During gtk_dialog_run(), the default behavior of #GtkWidget::delete-event 
   // is disabled; if the dialog receives ::delete_event, it will not be
   // destroyed as windows usually are, and gtk_dialog_run() will return
   // #GTK_RESPONSE_DELETE_EVENT. Also, during gtk_dialog_run() the dialog 
   // will be modal. You can force gtk_dialog_run() to return at any time by
   // calling gtk_dialog_response() to emit the ::response signal. Destroying 
   // the dialog during gtk_dialog_run() is a very bad idea, because your 
   // post-run code won't know whether the dialog was destroyed or not.
   // After gtk_dialog_run() returns, you are responsible for hiding or
   // destroying the dialog if you wish to do so.
   // Typical usage of this function might be:
   // |[
   // gint result = gtk_dialog_run (GTK_DIALOG (dialog));
   // switch (result)
   // {
   // case GTK_RESPONSE_ACCEPT:
   // do_application_specific_something ();
   // break;
   // default:
   // do_nothing_since_dialog_was_cancelled ();
   // break;
   // }
   // gtk_widget_destroy (dialog);
   // ]|
   // Note that even though the recursive main loop gives the effect of a
   // modal dialog (it prevents the user from interacting with other 
   // windows in the same window group while the dialog is run), callbacks 
   // such as timeouts, IO channel watches, DND drops, etc, <emphasis>will</emphasis> 
   // be triggered during a gtk_dialog_run() call.
   // RETURNS: response ID
   int run() {
      return gtk_dialog_run(&this);
   }

   // Unintrospectable method: set_alternative_button_order() / gtk_dialog_set_alternative_button_order()
   // Sets an alternative button order. If the 
   // #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, 
   // the dialog buttons are reordered according to the order of the 
   // response ids passed to this function.
   // By default, GTK+ dialogs use the button order advocated by the Gnome 
   // <ulink url="http://developer.gnome.org/projects/gup/hig/2.0/">Human 
   // Interface Guidelines</ulink> with the affirmative button at the far 
   // right, and the cancel button left of it. But the builtin GTK+ dialogs
   // and #GtkMessageDialog<!-- -->s do provide an alternative button order,
   // which is more suitable on some platforms, e.g. Windows.
   // Use this function after adding all the buttons to your dialog, as the 
   // following example shows:
   // |[
   // cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
   // GTK_STOCK_CANCEL,
   // GTK_RESPONSE_CANCEL);
   // ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
   // GTK_STOCK_OK,
   // GTK_RESPONSE_OK);
   // gtk_widget_grab_default (ok_button);
   // help_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
   // GTK_STOCK_HELP,
   // GTK_RESPONSE_HELP);
   // gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
   // GTK_RESPONSE_OK,
   // GTK_RESPONSE_CANCEL,
   // GTK_RESPONSE_HELP,
   // -1);
   // ]|
   // <first_response_id>: a response id used by one @dialog's buttons
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_dialog_set_alternative_button_order set_alternative_button_order; // Variadic
   +/

   // Sets an alternative button order. If the 
   // #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, 
   // the dialog buttons are reordered according to the order of the 
   // response ids in @new_order.
   // See gtk_dialog_set_alternative_button_order() for more information.
   // This function is for use by language bindings.
   // <n_params>: the number of response ids in @new_order
   // <new_order>: an array of response ids of
   void set_alternative_button_order_from_array(int n_params, int* new_order) {
      gtk_dialog_set_alternative_button_order_from_array(&this, n_params, new_order);
   }

   // Sets the last widget in the dialog's action area with the given @response_id
   // as the default widget for the dialog. Pressing "Enter" normally activates
   // the default widget.
   // <response_id>: a response ID
   void set_default_response(int response_id) {
      gtk_dialog_set_default_response(&this, response_id);
   }

   // Sets whether the dialog has a separator above the buttons.
   // <setting>: %TRUE to have a separator
   void set_has_separator(int setting) {
      gtk_dialog_set_has_separator(&this, setting);
   }

   // Calls <literal>gtk_widget_set_sensitive (widget, @setting)</literal> 
   // for each widget in the dialog's action area with the given @response_id.
   // A convenient way to sensitize/desensitize dialog buttons.
   // <response_id>: a response ID
   // <setting>: %TRUE for sensitive
   void set_response_sensitive(int response_id, int setting) {
      gtk_dialog_set_response_sensitive(&this, response_id, setting);
   }

   // The ::close signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user uses a keybinding to close
   // the dialog.
   // The default binding for this signal is the Escape key.
   extern (C) alias static void function (Dialog* this_, void* user_data=null) signal_close;

   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", CB/*:signal_close*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"close",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when an action widget is clicked, the dialog receives a 
   // delete event, or the application programmer calls gtk_dialog_response(). 
   // On a delete event, the response ID is #GTK_RESPONSE_DELETE_EVENT. 
   // Otherwise, it depends on which action widget was clicked.
   // <response_id>: the response ID
   extern (C) alias static void function (Dialog* this_, int response_id, void* user_data=null) signal_response;
   ulong signal_connect(string name:"response", CB/*:signal_response*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"response",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct DialogClass {
   WindowClass parent_class;
   // <response_id>: response ID
   extern (C) void function (Dialog* dialog, int response_id) response;
   extern (C) void function (Dialog* dialog) close;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum DialogFlags {
   MODAL = 1,
   DESTROY_WITH_PARENT = 2,
   NO_SEPARATOR = 4
}
enum DirectionType {
   TAB_FORWARD = 0,
   TAB_BACKWARD = 1,
   UP = 2,
   DOWN = 3,
   LEFT = 4,
   RIGHT = 5
}
union DitherInfo {
   ushort[2] s;
   ubyte[4] c;
}

enum DragResult {
   SUCCESS = 0,
   NO_TARGET = 1,
   USER_CANCELLED = 2,
   TIMEOUT_EXPIRED = 3,
   GRAB_BROKEN = 4,
   ERROR = 5
}
struct DrawingArea /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   void* draw_data;

   static DrawingArea* new_() {
      return gtk_drawing_area_new();
   }
   void size(int width, int height) {
      gtk_drawing_area_size(&this, width, height);
   }
}

struct DrawingAreaClass {
   WidgetClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Editable {

   // Copies the contents of the currently selected content in the editable and
   // puts it on the clipboard.
   void copy_clipboard() {
      gtk_editable_copy_clipboard(&this);
   }

   // Removes the contents of the currently selected content in the editable and
   // puts it on the clipboard.
   void cut_clipboard() {
      gtk_editable_cut_clipboard(&this);
   }

   // Deletes the currently selected text of the editable.
   // This call doesn't do anything if there is no selected text.
   void delete_selection() {
      gtk_editable_delete_selection(&this);
   }

   // Deletes a sequence of characters. The characters that are deleted are 
   // those characters at positions from @start_pos up to, but not including 
   // are those from @start_pos to the end of the text.
   // Note that the positions are specified in characters, not bytes.
   // <start_pos>: start position
   // <end_pos>: end position
   void delete_text(int start_pos, int end_pos) {
      gtk_editable_delete_text(&this, start_pos, end_pos);
   }

   // Retrieves a sequence of characters. The characters that are retrieved 
   // are those characters at positions from @start_pos up to, but not 
   // including @end_pos. If @end_pos is negative, then the the characters 
   // retrieved are those characters from @start_pos to the end of the text.
   // Note that positions are specified in characters, not bytes.
   // string. This string is allocated by the #GtkEditable
   // implementation and should be freed by the caller.
   // RETURNS: a pointer to the contents of the widget as a
   // <start_pos>: start of text
   // <end_pos>: end of text
   char* /*new*/ get_chars(int start_pos, int end_pos) {
      return gtk_editable_get_chars(&this, start_pos, end_pos);
   }

   // Retrieves whether @editable is editable. See
   // gtk_editable_set_editable().
   // RETURNS: %TRUE if @editable is editable.
   int get_editable() {
      return gtk_editable_get_editable(&this);
   }

   // Retrieves the current position of the cursor relative to the start
   // of the content of the editable. 
   // Note that this position is in characters, not in bytes.
   // RETURNS: the cursor position
   int get_position() {
      return gtk_editable_get_position(&this);
   }

   // Retrieves the selection bound of the editable. start_pos will be filled
   // with the start of the selection and @end_pos with end. If no text was
   // selected both will be identical and %FALSE will be returned.
   // Note that positions are specified in characters, not bytes.
   // RETURNS: %TRUE if an area is selected, %FALSE otherwise
   // <start_pos>: location to store the starting position, or %NULL
   // <end_pos>: location to store the end position, or %NULL
   int get_selection_bounds(/*out*/ int* start_pos=null, /*out*/ int* end_pos=null) {
      return gtk_editable_get_selection_bounds(&this, start_pos, end_pos);
   }

   // Inserts @new_text_length bytes of @new_text into the contents of the
   // widget, at position @position.
   // Note that the position is in characters, not in bytes. 
   // The function updates @position to point after the newly inserted text.
   // <new_text>: the text to append
   // <new_text_length>: the length of the text in bytes, or -1
   // <position>: location of the position text will be inserted at
   void insert_text(char* new_text, int new_text_length, /*inout*/ int* position) {
      gtk_editable_insert_text(&this, new_text, new_text_length, position);
   }

   // Pastes the content of the clipboard to the current position of the
   // cursor in the editable.
   void paste_clipboard() {
      gtk_editable_paste_clipboard(&this);
   }

   // Selects a region of text. The characters that are selected are 
   // those characters at positions from @start_pos up to, but not 
   // including @end_pos. If @end_pos is negative, then the the 
   // characters selected are those characters from @start_pos to 
   // the end of the text.
   // Note that positions are specified in characters, not bytes.
   // <start_pos>: start of region
   // <end_pos>: end of region
   void select_region(int start_pos, int end_pos) {
      gtk_editable_select_region(&this, start_pos, end_pos);
   }

   // Determines if the user can edit the text in the editable
   // widget or not.
   // <is_editable>: %TRUE if the user is allowed to edit the text in the widget
   void set_editable(int is_editable) {
      gtk_editable_set_editable(&this, is_editable);
   }

   // Sets the cursor position in the editable to the given value.
   // The cursor is displayed before the character with the given (base 0) 
   // index in the contents of the editable. The value must be less than or 
   // equal to the number of characters in the editable. A value of -1 
   // indicates that the position should be set after the last character 
   // of the editable. Note that @position is in characters, not in bytes.
   // <position>: the position of the cursor
   void set_position(int position) {
      gtk_editable_set_position(&this, position);
   }

   // The ::changed signal is emitted at the end of a single
   // user-visible operation on the contents of the #GtkEditable.
   // E.g., a paste operation that replaces the contents of the
   // selection will cause only one signal emission (even though it
   // is implemented by first deleting the selection, then inserting
   // the new content, and may cause multiple ::notify::text signals
   // to be emitted).
   extern (C) alias static void function (Editable* 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);
   }

   // This signal is emitted when text is deleted from
   // the widget by the user. The default handler for
   // this signal will normally be responsible for deleting
   // the text, so by connecting to this signal and then
   // stopping the signal with g_signal_stop_emission(), it
   // is possible to modify the range of deleted text, or
   // prevent it from being deleted entirely. The @start_pos
   // and @end_pos parameters are interpreted as for
   // gtk_editable_delete_text().
   // <start_pos>: the starting position
   // <end_pos>: the end position
   extern (C) alias static void function (Editable* this_, int start_pos, int end_pos, void* user_data=null) signal_delete_text;
   ulong signal_connect(string name:"delete-text", CB/*:signal_delete_text*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-text",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when text is inserted into
   // the widget by the user. The default handler for
   // this signal will normally be responsible for inserting
   // the text, so by connecting to this signal and then
   // stopping the signal with g_signal_stop_emission(), it
   // is possible to modify the inserted text, or prevent
   // it from being inserted entirely.
   // <new_text>: the new text to insert
   // <new_text_length>: the length of the new text, in bytes, or -1 if new_text is nul-terminated
   // <position>: the position, in characters, at which to insert the new text. this is an in-out parameter.  After the signal emission is finished, it should point after the newly inserted text.
   extern (C) alias static void function (Editable* this_, char* new_text, int new_text_length, /*inout*/ int position, void* user_data=null) signal_insert_text;
   ulong signal_connect(string name:"insert-text", CB/*:signal_insert_text*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-text",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct EditableClass {
   GObject2.TypeInterface base_iface;
   extern (C) void function (Editable* editable, char* text, int length, int* position) insert_text;
   extern (C) void function (Editable* editable, int start_pos, int end_pos) delete_text;
   extern (C) void function (Editable* editable) changed;
   extern (C) void function (Editable* editable, char* text, int length, int* position) do_insert_text;
   extern (C) void function (Editable* editable, int start_pos, int end_pos) do_delete_text;
   extern (C) char* /*new*/ function (Editable* editable, int start_pos, int end_pos) get_chars;
   extern (C) void function (Editable* editable, int start_pos, int end_pos) set_selection_bounds;
   extern (C) int function (Editable* editable, int* start_pos, int* end_pos) get_selection_bounds;
   extern (C) void function (Editable* editable, int position) set_position;
   extern (C) int function (Editable* editable) get_position;
}

struct Entry /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   char* text;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "editable", 1,
   uint, "visible", 1,
   uint, "overwrite_mode", 1,
   uint, "in_drag", 1,
    uint, "__dummy32A", 28));
   ushort text_length, text_max_length;
   private Gdk2.Window* text_area;
   private IMContext* im_context;
   private Widget* popup_menu;
   private int current_pos, selection_bound;
   private Pango.Layout* cached_layout;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "cache_includes_preedit", 1,
   uint, "need_im_reset", 1,
   uint, "has_frame", 1,
   uint, "activates_default", 1,
   uint, "cursor_visible", 1,
   uint, "in_click", 1,
   uint, "is_cell_renderer", 1,
   uint, "editing_canceled", 1,
   uint, "mouse_cursor_obscured", 1,
   uint, "select_words", 1,
   uint, "select_lines", 1,
   uint, "resolved_dir", 4,
   uint, "truncate_multiline", 1,
    uint, "__dummy32B", 16));
   private uint button, blink_timeout, recompute_idle;
   private int scroll_offset, ascent, descent;
   private ushort x_text_size, x_n_bytes, preedit_length, preedit_cursor;
   private int dnd_position, drag_start_x, drag_start_y;
   private dchar invisible_char;
   private int width_chars;


   // Creates a new entry.
   // RETURNS: a new #GtkEntry.
   static Entry* new_() {
      return gtk_entry_new();
   }

   // Creates a new entry with the specified text buffer.
   // RETURNS: a new #GtkEntry
   // <buffer>: The buffer to use for the new #GtkEntry.
   static Entry* new_with_buffer(EntryBuffer* buffer) {
      return gtk_entry_new_with_buffer(buffer);
   }

   // Creates a new #GtkEntry widget with the given maximum length.
   // RETURNS: a new #GtkEntry
   // <max>: the maximum length of the entry, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536.
   static Entry* new_with_max_length(int max) {
      return gtk_entry_new_with_max_length(max);
   }

   // Appends the given text to the contents of the widget.
   // <text>: the text to append
   void append_text(char* text) {
      gtk_entry_append_text(&this, text);
   }

   // Retrieves the value set by gtk_entry_set_activates_default().
   // RETURNS: %TRUE if the entry will activate the default widget
   int get_activates_default() {
      return gtk_entry_get_activates_default(&this);
   }

   // Gets the value set by gtk_entry_set_alignment().
   // RETURNS: the alignment
   float get_alignment() {
      return gtk_entry_get_alignment(&this);
   }

   // Get the #GtkEntryBuffer object which holds the text for
   // this widget.
   // RETURNS: A #GtkEntryBuffer object.
   EntryBuffer* get_buffer() {
      return gtk_entry_get_buffer(&this);
   }

   // Returns the auxiliary completion object currently in use by @entry.
   // in use by @entry.
   // RETURNS: The auxiliary completion object currently
   EntryCompletion* get_completion() {
      return gtk_entry_get_completion(&this);
   }

   // Returns the index of the icon which is the source of the current
   // DND operation, or -1.
   // This function is meant to be used in a #GtkWidget::drag-data-get
   // callback.
   // DND operation, or -1.
   // RETURNS: index of the icon which is the source of the current
   int get_current_icon_drag_source() {
      return gtk_entry_get_current_icon_drag_source(&this);
   }

   // Retrieves the horizontal cursor adjustment for the entry. 
   // See gtk_entry_set_cursor_hadjustment().
   // if none has been set.
   // RETURNS: the horizontal cursor adjustment, or %NULL
   Adjustment* get_cursor_hadjustment() {
      return gtk_entry_get_cursor_hadjustment(&this);
   }

   // Gets the value set by gtk_entry_set_has_frame().
   // RETURNS: whether the entry has a beveled frame
   int get_has_frame() {
      return gtk_entry_get_has_frame(&this);
   }

   // Returns whether the icon is activatable.
   // RETURNS: %TRUE if the icon is activatable.
   // <icon_pos>: Icon position
   int get_icon_activatable(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_activatable(&this, icon_pos);
   }

   // Finds the icon at the given position and return its index.
   // If @x, @y doesn't lie inside an icon, -1 is returned.
   // This function is intended for use in a #GtkWidget::query-tooltip
   // signal handler.
   // RETURNS: the index of the icon at the given position, or -1
   // <x>: the x coordinate of the position to find
   // <y>: the y coordinate of the position to find
   int get_icon_at_pos(int x, int y) {
      return gtk_entry_get_icon_at_pos(&this, x, y);
   }

   // Retrieves the #GIcon used for the icon, or %NULL if there is
   // no icon or if the icon was set by some other method (e.g., by
   // stock, pixbuf, or icon name).
   // or if the icon is not a #GIcon
   // RETURNS: A #GIcon, or %NULL if no icon is set
   // <icon_pos>: Icon position
   Gio2.Icon* get_icon_gicon(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_gicon(&this, icon_pos);
   }

   // Retrieves the icon name used for the icon, or %NULL if there is
   // no icon or if the icon was set by some other method (e.g., by
   // pixbuf, stock or gicon).
   // wasn't set from an icon name
   // RETURNS: An icon name, or %NULL if no icon is set or if the icon
   // <icon_pos>: Icon position
   char* get_icon_name(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_name(&this, icon_pos);
   }

   // Retrieves the image used for the icon.
   // Unlike the other methods of setting and getting icon data, this
   // method will work regardless of whether the icon was set using a
   // #GdkPixbuf, a #GIcon, a stock item, or an icon name.
   // set for this position.
   // RETURNS: A #GdkPixbuf, or %NULL if no icon is
   // <icon_pos>: Icon position
   GdkPixbuf2.Pixbuf* get_icon_pixbuf(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_pixbuf(&this, icon_pos);
   }

   // Returns whether the icon appears sensitive or insensitive.
   // RETURNS: %TRUE if the icon is sensitive.
   // <icon_pos>: Icon position
   int get_icon_sensitive(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_sensitive(&this, icon_pos);
   }

   // Retrieves the stock id used for the icon, or %NULL if there is
   // no icon or if the icon was set by some other method (e.g., by
   // pixbuf, icon name or gicon).
   // wasn't set from a stock id
   // RETURNS: A stock id, or %NULL if no icon is set or if the icon
   // <icon_pos>: Icon position
   char* get_icon_stock(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_stock(&this, icon_pos);
   }

   // Gets the type of representation being used by the icon
   // to store image data. If the icon has no image data,
   // the return value will be %GTK_IMAGE_EMPTY.
   // RETURNS: image representation being used
   // <icon_pos>: Icon position
   ImageType get_icon_storage_type(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_storage_type(&this, icon_pos);
   }

   // Gets the contents of the tooltip on the icon at the specified 
   // position in @entry.
   // with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. Free the returned string
   // <icon_pos>: the icon position
   char* /*new*/ get_icon_tooltip_markup(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_tooltip_markup(&this, icon_pos);
   }

   // Gets the contents of the tooltip on the icon at the specified 
   // position in @entry.
   // with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. Free the returned string
   // <icon_pos>: the icon position
   char* /*new*/ get_icon_tooltip_text(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_tooltip_text(&this, icon_pos);
   }

   // Returns the #GdkWindow which contains the entry's icon at
   // entry in an expose-event callback because it enables the callback
   // to distinguish between the text window and entry's icon windows.
   // See also gtk_entry_get_text_window().
   // Note that GTK+ 3 does not have this function anymore; it has
   // been replaced by gtk_entry_get_icon_area().
   // RETURNS: the entry's icon window at @icon_pos.
   // <icon_pos>: Icon position
   Gdk2.Window* get_icon_window(EntryIconPosition icon_pos) {
      return gtk_entry_get_icon_window(&this, icon_pos);
   }

   // This function returns the entry's #GtkEntry:inner-border property. See
   // gtk_entry_set_inner_border() for more information.
   // RETURNS: the entry's #GtkBorder, or %NULL if none was set.
   Border* get_inner_border() {
      return gtk_entry_get_inner_border(&this);
   }

   // Retrieves the character displayed in place of the real characters
   // for entries with visibility set to false. See gtk_entry_set_invisible_char().
   // show invisible text at all.
   // RETURNS: the current invisible char, or 0, if the entry does not
   dchar get_invisible_char() {
      return gtk_entry_get_invisible_char(&this);
   }

   // Gets the #PangoLayout used to display the entry.
   // The layout is useful to e.g. convert text positions to
   // pixel positions, in combination with gtk_entry_get_layout_offsets().
   // The returned layout is owned by the entry and must not be 
   // modified or freed by the caller.
   // Keep in mind that the layout text may contain a preedit string, so
   // gtk_entry_layout_index_to_text_index() and
   // gtk_entry_text_index_to_layout_index() are needed to convert byte
   // indices in the layout to byte indices in the entry contents.
   // RETURNS: the #PangoLayout for this entry
   Pango.Layout* get_layout() {
      return gtk_entry_get_layout(&this);
   }

   // Obtains the position of the #PangoLayout used to render text
   // in the entry, in widget coordinates. Useful if you want to line
   // up the text in an entry with some other text, e.g. when using the
   // entry to implement editable cells in a sheet widget.
   // Also useful to convert mouse events into coordinates inside the
   // #PangoLayout, e.g. to take some action if some part of the entry text
   // is clicked.
   // Note that as the user scrolls around in the entry the offsets will
   // change; you'll need to connect to the "notify::scroll-offset"
   // signal to track this. Remember when using the #PangoLayout
   // functions you need to convert to and from pixels using
   // PANGO_PIXELS() or #PANGO_SCALE.
   // Keep in mind that the layout text may contain a preedit string, so
   // gtk_entry_layout_index_to_text_index() and
   // gtk_entry_text_index_to_layout_index() are needed to convert byte
   // indices in the layout to byte indices in the entry contents.
   // <x>: location to store X offset of layout, or %NULL
   // <y>: location to store Y offset of layout, or %NULL
   void get_layout_offsets(/*out*/ int* x=null, /*out*/ int* y=null) {
      gtk_entry_get_layout_offsets(&this, x, y);
   }

   // Retrieves the maximum allowed length of the text in
   // This is equivalent to:
   // <informalexample><programlisting>
   // gtk_entry_buffer_get_max_length (gtk_entry_get_buffer (entry));
   // </programlisting></informalexample>
   // in #GtkEntry, or 0 if there is no maximum.
   // RETURNS: the maximum allowed number of characters
   int get_max_length() {
      return gtk_entry_get_max_length(&this);
   }

   // Gets the value set by gtk_entry_set_overwrite_mode().
   // RETURNS: whether the text is overwritten when typing.
   int get_overwrite_mode() {
      return gtk_entry_get_overwrite_mode(&this);
   }

   // Returns the current fraction of the task that's been completed.
   // See gtk_entry_set_progress_fraction().
   // RETURNS: a fraction from 0.0 to 1.0
   double get_progress_fraction() {
      return gtk_entry_get_progress_fraction(&this);
   }

   // Retrieves the pulse step set with gtk_entry_set_progress_pulse_step().
   // RETURNS: a fraction from 0.0 to 1.0
   double get_progress_pulse_step() {
      return gtk_entry_get_progress_pulse_step(&this);
   }

   // Retrieves the contents of the entry widget.
   // See also gtk_editable_get_chars().
   // This is equivalent to:
   // <informalexample><programlisting>
   // gtk_entry_buffer_get_text (gtk_entry_get_buffer (entry));
   // </programlisting></informalexample>
   // string. This string points to internally allocated
   // storage in the widget and must not be freed, modified or
   // stored.
   // RETURNS: a pointer to the contents of the widget as a
   char* get_text() {
      return gtk_entry_get_text(&this);
   }

   // Retrieves the current length of the text in
   // This is equivalent to:
   // <informalexample><programlisting>
   // gtk_entry_buffer_get_length (gtk_entry_get_buffer (entry));
   // </programlisting></informalexample>
   // in #GtkEntry, or 0 if there are none.
   // RETURNS: the current number of characters
   ushort get_text_length() {
      return gtk_entry_get_text_length(&this);
   }

   // Returns the #GdkWindow which contains the text. This function is
   // useful when drawing something to the entry in an expose-event
   // callback because it enables the callback to distinguish between
   // the text window and entry's icon windows.
   // See also gtk_entry_get_icon_window().
   // Note that GTK+ 3 does not have this function anymore; it has
   // been replaced by gtk_entry_get_text_area().
   // RETURNS: the entry's text window.
   Gdk2.Window* get_text_window() {
      return gtk_entry_get_text_window(&this);
   }

   // Retrieves whether the text in @entry is visible. See
   // gtk_entry_set_visibility().
   // RETURNS: %TRUE if the text is currently visible
   int get_visibility() {
      return gtk_entry_get_visibility(&this);
   }

   // Gets the value set by gtk_entry_set_width_chars().
   // RETURNS: number of chars to request space for, or negative if unset
   int get_width_chars() {
      return gtk_entry_get_width_chars(&this);
   }

   // Allow the #GtkEntry input method to internally handle key press
   // and release events. If this function returns %TRUE, then no further
   // processing should be done for this key event. See
   // gtk_im_context_filter_keypress().
   // Note that you are expected to call this function from your handler
   // when overriding key event handling. This is needed in the case when
   // you need to insert your own key handling between the input method
   // and the default key event handling of the #GtkEntry.
   // See gtk_text_view_reset_im_context() for an example of use.
   // RETURNS: %TRUE if the input method handled the key event.
   // <event>: the key event
   int im_context_filter_keypress(Gdk2.EventKey* event) {
      return gtk_entry_im_context_filter_keypress(&this, event);
   }

   // Converts from a position in the entry contents (returned
   // by gtk_entry_get_text()) to a position in the
   // entry's #PangoLayout (returned by gtk_entry_get_layout(),
   // with text retrieved via pango_layout_get_text()).
   // RETURNS: byte index into the entry contents
   // <layout_index>: byte index into the entry layout text
   int layout_index_to_text_index(int layout_index) {
      return gtk_entry_layout_index_to_text_index(&this, layout_index);
   }

   // Prepends the given text to the contents of the widget.
   // <text>: the text to prepend
   void prepend_text(char* text) {
      gtk_entry_prepend_text(&this, text);
   }

   // Indicates that some progress is made, but you don't know how much.
   // Causes the entry's progress indicator to enter "activity mode,"
   // where a block bounces back and forth. Each call to
   // gtk_entry_progress_pulse() causes the block to move by a little bit
   // (the amount of movement per pulse is determined by
   // gtk_entry_set_progress_pulse_step()).
   void progress_pulse() {
      gtk_entry_progress_pulse(&this);
   }

   // Reset the input method context of the entry if needed.
   // This can be necessary in the case where modifying the buffer
   // would confuse on-going input method behavior.
   void reset_im_context() {
      gtk_entry_reset_im_context(&this);
   }

   // Selects a region of text. The characters that are selected are 
   // those characters at positions from @start_pos up to, but not 
   // including @end_pos. If @end_pos is negative, then the the characters 
   // selected will be those characters from @start_pos to the end of 
   // the text.
   // <start>: the starting position
   // <end>: the end position
   void select_region(int start, int end) {
      gtk_entry_select_region(&this, start, end);
   }

   // If @setting is %TRUE, pressing Enter in the @entry will activate the default
   // widget for the window containing the entry. This usually means that
   // the dialog box containing the entry will be closed, since the default
   // widget is usually one of the dialog buttons.
   // (For experts: if @setting is %TRUE, the entry calls
   // gtk_window_activate_default() on the window containing the entry, in
   // the default handler for the #GtkWidget::activate signal.)
   // <setting>: %TRUE to activate window's default widget on Enter keypress
   void set_activates_default(int setting) {
      gtk_entry_set_activates_default(&this, setting);
   }

   // Sets the alignment for the contents of the entry. This controls
   // the horizontal positioning of the contents when the displayed
   // text is shorter than the width of the entry.
   // <xalign>: The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts
   void set_alignment(float xalign) {
      gtk_entry_set_alignment(&this, xalign);
   }

   // Set the #GtkEntryBuffer object which holds the text for
   // this widget.
   // <buffer>: a #GtkEntryBuffer
   void set_buffer(EntryBuffer* buffer) {
      gtk_entry_set_buffer(&this, buffer);
   }

   // Sets @completion to be the auxiliary completion object to use with @entry.
   // All further configuration of the completion mechanism is done on
   // <completion>: The #GtkEntryCompletion or %NULL
   void set_completion(EntryCompletion* completion=null) {
      gtk_entry_set_completion(&this, completion);
   }

   // Hooks up an adjustment to the cursor position in an entry, so that when 
   // the cursor is moved, the adjustment is scrolled to show that position. 
   // See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining 
   // the adjustment.
   // The adjustment has to be in pixel units and in the same coordinate system 
   // as the entry.
   // <adjustment>: an adjustment which should be adjusted when the cursor is moved, or %NULL
   void set_cursor_hadjustment(Adjustment* adjustment) {
      gtk_entry_set_cursor_hadjustment(&this, adjustment);
   }

   // Determines if the user can edit the text in the editable
   // widget or not.
   // <editable>: %TRUE if the user is allowed to edit the text in the widget
   void set_editable(int editable) {
      gtk_entry_set_editable(&this, editable);
   }

   // Sets whether the entry has a beveled frame around it.
   // <setting>: new value
   void set_has_frame(int setting) {
      gtk_entry_set_has_frame(&this, setting);
   }

   // Sets whether the icon is activatable.
   // <icon_pos>: Icon position
   // <activatable>: %TRUE if the icon should be activatable
   void set_icon_activatable(EntryIconPosition icon_pos, int activatable) {
      gtk_entry_set_icon_activatable(&this, icon_pos, activatable);
   }

   // Sets up the icon at the given position so that GTK+ will start a drag
   // operation when the user clicks and drags the icon.
   // To handle the drag operation, you need to connect to the usual
   // #GtkWidget::drag-data-get (or possibly #GtkWidget::drag-data-delete)
   // signal, and use gtk_entry_get_current_icon_drag_source() in
   // your signal handler to find out if the drag was started from
   // an icon.
   // By default, GTK+ uses the icon as the drag icon. You can use the 
   // #GtkWidget::drag-begin signal to set a different icon. Note that you 
   // have to use g_signal_connect_after() to ensure that your signal handler
   // gets executed after the default handler.
   // <icon_pos>: icon position
   // <target_list>: the targets (data formats) in which the data can be provided
   // <actions>: a bitmask of the allowed drag actions
   void set_icon_drag_source(EntryIconPosition icon_pos, TargetList* target_list, Gdk2.DragAction actions) {
      gtk_entry_set_icon_drag_source(&this, icon_pos, target_list, actions);
   }

   // Sets the icon shown in the entry at the specified position
   // from the current icon theme.
   // If the icon isn't known, a "broken image" icon will be displayed
   // instead.
   // If @icon is %NULL, no icon will be shown in the specified position.
   // <icon_pos>: The position at which to set the icon
   // <icon>: The icon to set, or %NULL
   void set_icon_from_gicon(EntryIconPosition icon_pos, Gio2.Icon* icon=null) {
      gtk_entry_set_icon_from_gicon(&this, icon_pos, icon);
   }

   // Sets the icon shown in the entry at the specified position
   // from the current icon theme.
   // If the icon name isn't known, a "broken image" icon will be displayed
   // instead.
   // If @icon_name is %NULL, no icon will be shown in the specified position.
   // <icon_pos>: The position at which to set the icon
   // <icon_name>: An icon name, or %NULL
   void set_icon_from_icon_name(EntryIconPosition icon_pos, char* icon_name=null) {
      gtk_entry_set_icon_from_icon_name(&this, icon_pos, icon_name);
   }

   // Sets the icon shown in the specified position using a pixbuf.
   // If @pixbuf is %NULL, no icon will be shown in the specified position.
   // <icon_pos>: Icon position
   // <pixbuf>: A #GdkPixbuf, or %NULL
   void set_icon_from_pixbuf(EntryIconPosition icon_pos, GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_entry_set_icon_from_pixbuf(&this, icon_pos, pixbuf);
   }

   // Sets the icon shown in the entry at the specified position from
   // a stock image.
   // If @stock_id is %NULL, no icon will be shown in the specified position.
   // <icon_pos>: Icon position
   // <stock_id>: The name of the stock item, or %NULL
   void set_icon_from_stock(EntryIconPosition icon_pos, char* stock_id=null) {
      gtk_entry_set_icon_from_stock(&this, icon_pos, stock_id);
   }

   // Sets the sensitivity for the specified icon.
   // <icon_pos>: Icon position
   // <sensitive>: Specifies whether the icon should appear sensitive or insensitive
   void set_icon_sensitive(EntryIconPosition icon_pos, int sensitive) {
      gtk_entry_set_icon_sensitive(&this, icon_pos, sensitive);
   }

   // Sets @tooltip as the contents of the tooltip for the icon at
   // the specified position. @tooltip is assumed to be marked up with
   // the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
   // Use %NULL for @tooltip to remove an existing tooltip.
   // See also gtk_widget_set_tooltip_markup() and 
   // gtk_enty_set_icon_tooltip_text().
   // <icon_pos>: the icon position
   // <tooltip>: the contents of the tooltip for the icon, or %NULL
   void set_icon_tooltip_markup(EntryIconPosition icon_pos, char* tooltip=null) {
      gtk_entry_set_icon_tooltip_markup(&this, icon_pos, tooltip);
   }

   // Sets @tooltip as the contents of the tooltip for the icon
   // at the specified position.
   // Use %NULL for @tooltip to remove an existing tooltip.
   // See also gtk_widget_set_tooltip_text() and 
   // gtk_entry_set_icon_tooltip_markup().
   // <icon_pos>: the icon position
   // <tooltip>: the contents of the tooltip for the icon, or %NULL
   void set_icon_tooltip_text(EntryIconPosition icon_pos, char* tooltip=null) {
      gtk_entry_set_icon_tooltip_text(&this, icon_pos, tooltip);
   }

   // Sets %entry's inner-border property to %border, or clears it if %NULL
   // is passed. The inner-border is the area around the entry's text, but
   // inside its frame.
   // If set, this property overrides the inner-border style property.
   // Overriding the style-provided border is useful when you want to do
   // in-place editing of some text in a canvas or list widget, where
   // pixel-exact positioning of the entry is important.
   // <border>: a #GtkBorder, or %NULL
   void set_inner_border(Border* border=null) {
      gtk_entry_set_inner_border(&this, border);
   }

   // Sets the character to use in place of the actual text when
   // gtk_entry_set_visibility() has been called to set text visibility
   // to %FALSE. i.e. this is the character used in "password mode" to
   // show the user how many characters have been typed. By default, GTK+
   // picks the best invisible char available in the current font. If you
   // set the invisible char to 0, then the user will get no feedback
   // at all; there will be no text on the screen as they type.
   // <ch>: a Unicode character
   void set_invisible_char(dchar ch) {
      gtk_entry_set_invisible_char(&this, ch);
   }

   // Sets the maximum allowed length of the contents of the widget. If
   // the current contents are longer than the given length, then they
   // will be truncated to fit.
   // This is equivalent to:
   // <informalexample><programlisting>
   // gtk_entry_buffer_set_max_length (gtk_entry_get_buffer (entry), max);
   // </programlisting></informalexample>
   // <max>: the maximum length of the entry, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536.
   void set_max_length(int max) {
      gtk_entry_set_max_length(&this, max);
   }

   // Sets whether the text is overwritten when typing in the #GtkEntry.
   // <overwrite>: new value
   void set_overwrite_mode(int overwrite) {
      gtk_entry_set_overwrite_mode(&this, overwrite);
   }

   // Sets the cursor position in an entry to the given value.
   // <position>: the position of the cursor. The cursor is displayed before the character with the given (base 0) index in the widget. The value must be less than or equal to the number of characters in the widget. A value of -1 indicates that the position should be set after the last character in the entry. Note that this position is in characters, not in bytes.
   void set_position(int position) {
      gtk_entry_set_position(&this, position);
   }

   // Causes the entry's progress indicator to "fill in" the given
   // fraction of the bar. The fraction should be between 0.0 and 1.0,
   // inclusive.
   // <fraction>: fraction of the task that's been completed
   void set_progress_fraction(double fraction) {
      gtk_entry_set_progress_fraction(&this, fraction);
   }

   // Sets the fraction of total entry width to move the progress
   // bouncing block for each call to gtk_entry_progress_pulse().
   // <fraction>: fraction between 0.0 and 1.0
   void set_progress_pulse_step(double fraction) {
      gtk_entry_set_progress_pulse_step(&this, fraction);
   }

   // Sets the text in the widget to the given
   // value, replacing the current contents.
   // See gtk_entry_buffer_set_text().
   // <text>: the new text
   void set_text(char* text) {
      gtk_entry_set_text(&this, text);
   }

   // Sets whether the contents of the entry are visible or not. 
   // When visibility is set to %FALSE, characters are displayed 
   // as the invisible char, and will also appear that way when 
   // the text in the entry widget is copied elsewhere.
   // By default, GTK+ picks the best invisible character available
   // in the current font, but it can be changed with
   // gtk_entry_set_invisible_char().
   // <visible>: %TRUE if the contents of the entry are displayed as plaintext
   void set_visibility(int visible) {
      gtk_entry_set_visibility(&this, visible);
   }

   // Changes the size request of the entry to be about the right size
   // for @n_chars characters. Note that it changes the size
   // <emphasis>request</emphasis>, the size can still be affected by
   // how you pack the widget into containers. If @n_chars is -1, the
   // size reverts to the default entry size.
   // <n_chars>: width in chars
   void set_width_chars(int n_chars) {
      gtk_entry_set_width_chars(&this, n_chars);
   }

   // Converts from a position in the entry's #PangoLayout (returned by
   // gtk_entry_get_layout()) to a position in the entry contents
   // (returned by gtk_entry_get_text()).
   // RETURNS: byte index into the entry layout text
   // <text_index>: byte index into the entry contents
   int text_index_to_layout_index(int text_index) {
      return gtk_entry_text_index_to_layout_index(&this, text_index);
   }

   // Unsets the invisible char previously set with
   // gtk_entry_set_invisible_char(). So that the
   // default invisible char is used again.
   void unset_invisible_char() {
      gtk_entry_unset_invisible_char(&this);
   }

   // A  <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user activates the entry.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control activation 
   // programmatically.
   // The default bindings for this signal are all forms of the Enter key.
   extern (C) alias static void function (Entry* this_, 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);
   }

   // The ::backspace signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user asks for it.
   // The default bindings for this signal are
   // Backspace and Shift-Backspace.
   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_backspace;
   ulong signal_connect(string name:"backspace", CB/*:signal_backspace*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"backspace",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::copy-clipboard signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to copy the selection to the clipboard.
   // The default bindings for this signal are
   // Ctrl-c and Ctrl-Insert.
   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_copy_clipboard;
   ulong signal_connect(string name:"copy-clipboard", CB/*:signal_copy_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"copy-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::cut-clipboard signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to cut the selection to the clipboard.
   // The default bindings for this signal are
   // Ctrl-x and Shift-Delete.
   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_cut_clipboard;
   ulong signal_connect(string name:"cut-clipboard", CB/*:signal_cut_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cut-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::delete-from-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates a text deletion.
   // If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection
   // if there is one, otherwise it deletes the requested number
   // of characters.
   // The default bindings for this signal are
   // Delete for deleting a character and Ctrl-Delete for
   // deleting a word.
   // <type>: the granularity of the deletion, as a #GtkDeleteType
   // <count>: the number of @type units to delete
   extern (C) alias static void function (Entry* this_, DeleteType* type, int count, void* user_data=null) signal_delete_from_cursor;
   ulong signal_connect(string name:"delete-from-cursor", CB/*:signal_delete_from_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-from-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::icon-press signal is emitted when an activatable icon
   // is clicked.
   // <icon_pos>: The position of the clicked icon
   // <event>: the button press event
   extern (C) alias static void function (Entry* this_, EntryIconPosition* icon_pos, Gdk2.Event* event, void* user_data=null) signal_icon_press;
   ulong signal_connect(string name:"icon-press", CB/*:signal_icon_press*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"icon-press",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::icon-release signal is emitted on the button release from a
   // mouse click over an activatable icon.
   // <icon_pos>: The position of the clicked icon
   // <event>: the button release event
   extern (C) alias static void function (Entry* this_, EntryIconPosition* icon_pos, Gdk2.Event* event, void* user_data=null) signal_icon_release;
   ulong signal_connect(string name:"icon-release", CB/*:signal_icon_release*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"icon-release",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::insert-at-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates the insertion of a
   // fixed string at the cursor.
   // This signal has no default bindings.
   // <string>: the string to insert
   extern (C) alias static void function (Entry* this_, char* string_, void* user_data=null) signal_insert_at_cursor;
   ulong signal_connect(string name:"insert-at-cursor", CB/*:signal_insert_at_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-at-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates a cursor movement.
   // If the cursor is not visible in @entry, this signal causes
   // the viewport to be moved instead.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control the cursor
   // programmatically.
   // The default bindings for this signal come in two variants,
   // the variant with the Shift modifier extends the selection,
   // the variant without the Shift modifer does not.
   // There are too many key combinations to list them all here.
   // <itemizedlist>
   // <listitem>Arrow keys move by individual characters/lines</listitem>
   // <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
   // <listitem>Home/End keys move to the ends of the buffer</listitem>
   // </itemizedlist>
   // <step>: the granularity of the move, as a #GtkMovementStep
   // <count>: the number of @step units to move
   // <extend_selection>: %TRUE if the move should extend the selection
   extern (C) alias static void function (Entry* this_, MovementStep* step, int count, c_int extend_selection, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::paste-clipboard signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to paste the contents of the clipboard
   // into the text view.
   // The default bindings for this signal are
   // Ctrl-v and Shift-Insert.
   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_paste_clipboard;
   ulong signal_connect(string name:"paste-clipboard", CB/*:signal_paste_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"paste-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::populate-popup signal gets emitted before showing the 
   // context menu of the entry. 
   // If you need to add items to the context menu, connect
   // to this signal and append your menuitems to the @menu.
   // <menu>: the menu that is being populated
   extern (C) alias static void function (Entry* this_, Menu* menu, void* user_data=null) signal_populate_popup;
   ulong signal_connect(string name:"populate-popup", CB/*:signal_populate_popup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"populate-popup",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // If an input method is used, the typed text will not immediately
   // be committed to the buffer. So if you are interested in the text,
   // connect to this signal.
   // <preedit>: the current preedit string
   extern (C) alias static void function (Entry* this_, char* preedit, void* user_data=null) signal_preedit_changed;
   ulong signal_connect(string name:"preedit-changed", CB/*:signal_preedit_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preedit-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::toggle-overwrite signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to toggle the overwrite mode of the entry.
   // The default bindings for this signal is Insert.
   extern (C) alias static void function (Entry* this_, void* user_data=null) signal_toggle_overwrite;
   ulong signal_connect(string name:"toggle-overwrite", CB/*:signal_toggle_overwrite*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-overwrite",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// The #GtkEntryBuffer class contains the actual text displayed in a
// #GtkEntry widget.
// A single #GtkEntryBuffer object can be shared by multiple #GtkEntry
// widgets which will then share the same text content, but not the cursor
// position, visibility attributes, icon etc.
// #GtkEntryBuffer may be derived from. Such a derived class might allow
// text to be stored in an alternate location, such as non-pageable memory,
// useful in the case of important passwords. Or a derived class could 
// integrate with an application's concept of undo/redo.
struct EntryBuffer /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private EntryBufferPrivate* priv;


   // Create a new GtkEntryBuffer object.
   // Optionally, specify initial text to set in the buffer.
   // RETURNS: A new GtkEntryBuffer object.
   // <initial_chars>: initial buffer text, or %NULL
   // <n_initial_chars>: number of characters in @initial_chars, or -1
   static EntryBuffer* /*new*/ new_(char* initial_chars, int n_initial_chars) {
      return gtk_entry_buffer_new(initial_chars, n_initial_chars);
   }

   // Deletes a sequence of characters from the buffer. @n_chars characters are
   // deleted starting at @position. If @n_chars is negative, then all characters
   // until the end of the text are deleted.
   // If @position or @n_chars are out of bounds, then they are coerced to sane
   // values.
   // Note that the positions are specified in characters, not bytes.
   // RETURNS: The number of characters deleted.
   // <position>: position at which to delete text
   // <n_chars>: number of characters to delete
   uint delete_text(uint position, int n_chars) {
      return gtk_entry_buffer_delete_text(&this, position, n_chars);
   }

   // Used when subclassing #GtkEntryBuffer
   // <position>: position at which text was deleted
   // <n_chars>: number of characters deleted
   void emit_deleted_text(uint position, uint n_chars) {
      gtk_entry_buffer_emit_deleted_text(&this, position, n_chars);
   }

   // Used when subclassing #GtkEntryBuffer
   // <position>: position at which text was inserted
   // <chars>: text that was inserted
   // <n_chars>: number of characters inserted
   void emit_inserted_text(uint position, char* chars, uint n_chars) {
      gtk_entry_buffer_emit_inserted_text(&this, position, chars, n_chars);
   }

   // Retrieves the length in bytes of the buffer.
   // See gtk_entry_buffer_get_length().
   // RETURNS: The byte length of the buffer.
   size_t get_bytes() {
      return gtk_entry_buffer_get_bytes(&this);
   }

   // Retrieves the length in characters of the buffer.
   // RETURNS: The number of characters in the buffer.
   uint get_length() {
      return gtk_entry_buffer_get_length(&this);
   }

   // Retrieves the maximum allowed length of the text in
   // in #GtkEntryBuffer, or 0 if there is no maximum.
   // RETURNS: the maximum allowed number of characters
   int get_max_length() {
      return gtk_entry_buffer_get_max_length(&this);
   }

   // Retrieves the contents of the buffer.
   // The memory pointer returned by this call will not change
   // unless this object emits a signal, or is finalized.
   // string. This string points to internally allocated
   // storage in the buffer and must not be freed, modified or
   // stored.
   // RETURNS: a pointer to the contents of the widget as a
   char* get_text() {
      return gtk_entry_buffer_get_text(&this);
   }

   // Inserts @n_chars characters of @chars into the contents of the
   // buffer, at position @position.
   // If @n_chars is negative, then characters from chars will be inserted
   // until a null-terminator is found. If @position or @n_chars are out of
   // bounds, or the maximum buffer text length is exceeded, then they are
   // coerced to sane values.
   // Note that the position and length are in characters, not in bytes.
   // RETURNS: The number of characters actually inserted.
   // <position>: the position at which to insert text.
   // <chars>: the text to insert into the buffer.
   // <n_chars>: the length of the text in characters, or -1
   uint insert_text(uint position, char* chars, int n_chars) {
      return gtk_entry_buffer_insert_text(&this, position, chars, n_chars);
   }

   // Sets the maximum allowed length of the contents of the buffer. If
   // the current contents are longer than the given length, then they
   // will be truncated to fit.
   // <max_length>: the maximum length of the entry buffer, or 0 for no maximum. (other than the maximum length of entries.) The value passed in will be clamped to the range 0-65536.
   void set_max_length(int max_length) {
      gtk_entry_buffer_set_max_length(&this, max_length);
   }

   // Sets the text in the buffer.
   // This is roughly equivalent to calling gtk_entry_buffer_delete_text()
   // and gtk_entry_buffer_insert_text().
   // Note that @n_chars is in characters, not in bytes.
   // <chars>: the new text
   // <n_chars>: the number of characters in @text, or -1
   void set_text(char* chars, int n_chars) {
      gtk_entry_buffer_set_text(&this, chars, n_chars);
   }

   // This signal is emitted after text is deleted from the buffer.
   // <position>: the position the text was deleted at.
   // <n_chars>: The number of characters that were deleted.
   extern (C) alias static void function (EntryBuffer* this_, c_uint position, c_uint n_chars, void* user_data=null) signal_deleted_text;

   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:"deleted-text", CB/*:signal_deleted_text*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"deleted-text",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted after text is inserted into the buffer.
   // <position>: the position the text was inserted at.
   // <chars>: The text that was inserted.
   // <n_chars>: The number of characters that were inserted.
   extern (C) alias static void function (EntryBuffer* this_, c_uint position, char* chars, c_uint n_chars, void* user_data=null) signal_inserted_text;
   ulong signal_connect(string name:"inserted-text", CB/*:signal_inserted_text*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"inserted-text",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct EntryBufferClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (EntryBuffer* buffer, uint position, char* chars, uint n_chars) inserted_text;
   extern (C) void function (EntryBuffer* buffer, uint position, uint n_chars) deleted_text;
   extern (C) char* function (EntryBuffer* buffer, size_t* n_bytes) get_text;
   // RETURNS: The number of characters in the buffer.
   extern (C) uint function (EntryBuffer* buffer) get_length;

   // RETURNS: The number of characters actually inserted.
   // <position>: the position at which to insert text.
   // <chars>: the text to insert into the buffer.
   // <n_chars>: the length of the text in characters, or -1
   extern (C) uint function (EntryBuffer* buffer, uint position, char* chars, uint n_chars) insert_text;

   // RETURNS: The number of characters deleted.
   // <position>: position at which to delete text
   // <n_chars>: number of characters to delete
   extern (C) uint function (EntryBuffer* buffer, uint position, uint n_chars) delete_text;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
}

struct EntryBufferPrivate {
}

struct EntryClass {
   WidgetClass parent_class;
   extern (C) void function (Entry* entry, Menu* menu) populate_popup;
   extern (C) void function (Entry* entry) activate;
   extern (C) void function (Entry* entry, MovementStep step, int count, int extend_selection) move_cursor;
   extern (C) void function (Entry* entry, char* str) insert_at_cursor;
   extern (C) void function (Entry* entry, DeleteType type, int count) delete_from_cursor;
   extern (C) void function (Entry* entry) backspace;
   extern (C) void function (Entry* entry) cut_clipboard;
   extern (C) void function (Entry* entry) copy_clipboard;
   extern (C) void function (Entry* entry) paste_clipboard;
   extern (C) void function (Entry* entry) toggle_overwrite;
   extern (C) void function (Entry* entry, int* x, int* y, int* width, int* height) get_text_area_size;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

struct EntryCompletion /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private EntryCompletionPrivate* priv;


   // Creates a new #GtkEntryCompletion object.
   // RETURNS: A newly created #GtkEntryCompletion object.
   static EntryCompletion* /*new*/ new_() {
      return gtk_entry_completion_new();
   }

   // Requests a completion operation, or in other words a refiltering of the
   // current list with completions, using the current key. The completion list
   // view will be updated accordingly.
   void complete() {
      gtk_entry_completion_complete(&this);
   }

   // Deletes the action at @index_ from @completion's action list.
   // <index_>: The index of the item to Delete.
   void delete_action(int index_) {
      gtk_entry_completion_delete_action(&this, index_);
   }

   // Get the original text entered by the user that triggered
   // the completion or %NULL if there's no completion ongoing.
   // RETURNS: the prefix for the current completion
   char* get_completion_prefix() {
      return gtk_entry_completion_get_completion_prefix(&this);
   }

   // Gets the entry @completion has been attached to.
   // RETURNS: The entry @completion has been attached to.
   Widget* get_entry() {
      return gtk_entry_completion_get_entry(&this);
   }

   // Returns whether the common prefix of the possible completions should
   // be automatically inserted in the entry.
   // RETURNS: %TRUE if inline completion is turned on
   int get_inline_completion() {
      return gtk_entry_completion_get_inline_completion(&this);
   }

   // Returns %TRUE if inline-selection mode is turned on.
   // RETURNS: %TRUE if inline-selection mode is on
   int get_inline_selection() {
      return gtk_entry_completion_get_inline_selection(&this);
   }

   // Returns the minimum key length as set for @completion.
   // RETURNS: The currently used minimum key length.
   int get_minimum_key_length() {
      return gtk_entry_completion_get_minimum_key_length(&this);
   }

   // Returns the model the #GtkEntryCompletion is using as data source.
   // Returns %NULL if the model is unset.
   // is currently being used.
   // RETURNS: A #GtkTreeModel, or %NULL if none
   TreeModel* get_model() {
      return gtk_entry_completion_get_model(&this);
   }

   // Returns whether the completions should be presented in a popup window.
   // RETURNS: %TRUE if popup completion is turned on
   int get_popup_completion() {
      return gtk_entry_completion_get_popup_completion(&this);
   }

   // Returns whether the  completion popup window will be resized to the 
   // width of the entry.
   // the entry
   // RETURNS: %TRUE if the popup window will be resized to the width of
   int get_popup_set_width() {
      return gtk_entry_completion_get_popup_set_width(&this);
   }

   // Returns whether the completion popup window will appear even if there is
   // only a single match. 
   // number of matches.
   // RETURNS: %TRUE if the popup window will appear regardless of the
   int get_popup_single_match() {
      return gtk_entry_completion_get_popup_single_match(&this);
   }

   // Returns the column in the model of @completion to get strings from.
   // RETURNS: the column containing the strings
   int get_text_column() {
      return gtk_entry_completion_get_text_column(&this);
   }

   // Inserts an action in @completion's action item list at position @index_
   // with markup @markup.
   // <index_>: The index of the item to insert.
   // <markup>: Markup of the item to insert.
   void insert_action_markup(int index_, char* markup) {
      gtk_entry_completion_insert_action_markup(&this, index_, markup);
   }

   // Inserts an action in @completion's action item list at position @index_
   // with text @text. If you want the action item to have markup, use
   // gtk_entry_completion_insert_action_markup().
   // <index_>: The index of the item to insert.
   // <text>: Text of the item to insert.
   void insert_action_text(int index_, char* text) {
      gtk_entry_completion_insert_action_text(&this, index_, text);
   }
   // Requests a prefix insertion.
   void insert_prefix() {
      gtk_entry_completion_insert_prefix(&this);
   }

   // Sets whether the common prefix of the possible completions should
   // be automatically inserted in the entry.
   // <inline_completion>: %TRUE to do inline completion
   void set_inline_completion(int inline_completion) {
      gtk_entry_completion_set_inline_completion(&this, inline_completion);
   }

   // Sets whether it is possible to cycle through the possible completions
   // inside the entry.
   // <inline_selection>: %TRUE to do inline selection
   void set_inline_selection(int inline_selection) {
      gtk_entry_completion_set_inline_selection(&this, inline_selection);
   }

   // Sets the match function for @completion to be @func. The match function
   // is used to determine if a row should or should not be in the completion
   // list.
   // <func>: The #GtkEntryCompletionMatchFunc to use.
   // <func_data>: The user data for @func.
   // <func_notify>: Destroy notifier for @func_data.
   void set_match_func(EntryCompletionMatchFunc func, void* func_data, GLib2.DestroyNotify func_notify) {
      gtk_entry_completion_set_match_func(&this, func, func_data, func_notify);
   }

   // Requires the length of the search key for @completion to be at least
   // key takes a lot of time and will come up with meaningless results anyway
   // (ie, a too large dataset).
   // <length>: The minimum length of the key in order to start completing.
   void set_minimum_key_length(int length) {
      gtk_entry_completion_set_minimum_key_length(&this, length);
   }

   // Sets the model for a #GtkEntryCompletion. If @completion already has
   // a model set, it will remove it before setting the new model.
   // If model is %NULL, then it will unset the model.
   // <model>: The #GtkTreeModel.
   void set_model(TreeModel* model=null) {
      gtk_entry_completion_set_model(&this, model);
   }

   // Sets whether the completions should be presented in a popup window.
   // <popup_completion>: %TRUE to do popup completion
   void set_popup_completion(int popup_completion) {
      gtk_entry_completion_set_popup_completion(&this, popup_completion);
   }

   // Sets whether the completion popup window will be resized to be the same
   // width as the entry.
   // <popup_set_width>: %TRUE to make the width of the popup the same as the entry
   void set_popup_set_width(int popup_set_width) {
      gtk_entry_completion_set_popup_set_width(&this, popup_set_width);
   }

   // Sets whether the completion popup window will appear even if there is
   // only a single match. You may want to set this to %FALSE if you
   // are using <link linkend="GtkEntryCompletion--inline-completion">inline
   // completion</link>.
   // <popup_single_match>: %TRUE if the popup should appear even for a single match
   void set_popup_single_match(int popup_single_match) {
      gtk_entry_completion_set_popup_single_match(&this, popup_single_match);
   }

   // completion list with just strings. This function will set up @completion
   // to have a list displaying all (and just) strings in the completion list,
   // and to get those strings from @column in the model of @completion.
   // This functions creates and adds a #GtkCellRendererText for the selected 
   // column. If you need to set the text column, but don't want the cell 
   // renderer, use g_object_set() to set the ::text_column property directly.
   // <column>: The column in the model of @completion to get strings from.
   void set_text_column(int column) {
      gtk_entry_completion_set_text_column(&this, column);
   }

   // Gets emitted when an action is activated.
   // <index>: the index of the activated action
   extern (C) alias static void function (EntryCompletion* this_, int index, 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);
   }

   // Gets emitted when a match from the cursor is on a match
   // of the list.The default behaviour is to replace the contents
   // of the entry with the contents of the text column in the row 
   // pointed to by @iter.
   // RETURNS: %TRUE if the signal has been handled
   // <model>: the #GtkTreeModel containing the matches
   // <iter>: a #GtkTreeIter positioned at the selected match
   extern (C) alias static c_int function (EntryCompletion* this_, TreeModel* model, TreeIter* iter, void* user_data=null) signal_cursor_on_match;
   ulong signal_connect(string name:"cursor-on-match", CB/*:signal_cursor_on_match*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cursor-on-match",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when the inline autocompletion is triggered. 
   // The default behaviour is to make the entry display the 
   // whole prefix and select the newly inserted part.
   // Applications may connect to this signal in order to insert only a
   // smaller part of the @prefix into the entry - e.g. the entry used in
   // the #GtkFileChooser inserts only the part of the prefix up to the 
   // next '/'.
   // RETURNS: %TRUE if the signal has been handled
   // <prefix>: the common prefix of all possible completions
   extern (C) alias static c_int function (EntryCompletion* this_, char* prefix, void* user_data=null) signal_insert_prefix;
   ulong signal_connect(string name:"insert-prefix", CB/*:signal_insert_prefix*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-prefix",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when a match from the list is selected. 
   // The default behaviour is to replace the contents of the 
   // entry with the contents of the text column in the row 
   // pointed to by @iter.
   // RETURNS: %TRUE if the signal has been handled
   // <model>: the #GtkTreeModel containing the matches
   // <iter>: a #GtkTreeIter positioned at the selected match
   extern (C) alias static c_int function (EntryCompletion* this_, TreeModel* model, TreeIter* iter, void* user_data=null) signal_match_selected;
   ulong signal_connect(string name:"match-selected", CB/*:signal_match_selected*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"match-selected",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct EntryCompletionClass {
   GObject2.ObjectClass parent_class;
   extern (C) int function (EntryCompletion* completion, TreeModel* model, TreeIter* iter) match_selected;
   extern (C) void function (EntryCompletion* completion, int index_) action_activated;
   extern (C) int function (EntryCompletion* completion, char* prefix) insert_prefix;
   extern (C) int function (EntryCompletion* completion, TreeModel* model, TreeIter* iter) cursor_on_match;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
}

extern (C) alias int function (EntryCompletion* completion, char* key, TreeIter* iter, void* user_data) EntryCompletionMatchFunc;

struct EntryCompletionPrivate {
}

enum EntryIconPosition {
   PRIMARY = 0,
   SECONDARY = 1
}
struct EventBox /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;

   static EventBox* new_() {
      return gtk_event_box_new();
   }

   // Returns whether the event box window is above or below the
   // windows of its child. See gtk_event_box_set_above_child() for
   // details.
   // of its child.
   // RETURNS: %TRUE if the event box window is above the window
   int get_above_child() {
      return gtk_event_box_get_above_child(&this);
   }

   // Returns whether the event box has a visible window.
   // See gtk_event_box_set_visible_window() for details.
   // RETURNS: %TRUE if the event box window is visible
   int get_visible_window() {
      return gtk_event_box_get_visible_window(&this);
   }

   // Set whether the event box window is positioned above the windows of its child,
   // as opposed to below it. If the window is above, all events inside the
   // event box will go to the event box. If the window is below, events
   // in windows of child widgets will first got to that widget, and then
   // to its parents.
   // The default is to keep the window below the child.
   // <above_child>: %TRUE if the event box window is above the windows of its child
   void set_above_child(int above_child) {
      gtk_event_box_set_above_child(&this, above_child);
   }

   // Set whether the event box uses a visible or invisible child
   // window. The default is to use visible windows.
   // In an invisible window event box, the window that the
   // event box creates is a %GDK_INPUT_ONLY window, which 
   // means that it is invisible and only serves to receive
   // events.
   // A visible window event box creates a visible (%GDK_INPUT_OUTPUT)
   // window that acts as the parent window for all the widgets  
   // contained in the event box.
   // You should generally make your event box invisible if
   // you just want to trap events. Creating a visible window
   // may cause artifacts that are visible to the user, especially
   // if the user is using a theme with gradients or pixmaps.
   // The main reason to create a non input-only event box is if
   // you want to set the background to a different color or
   // draw on it.
   // <note><para>
   // There is one unexpected issue for an invisible event box that has its
   // window below the child. (See gtk_event_box_set_above_child().)
   // Since the input-only window is not an ancestor window of any windows
   // that descendent widgets of the event box create, events on these 
   // windows aren't propagated up by the windowing system, but only by GTK+.
   // The practical effect of this is if an event isn't in the event
   // mask for the descendant window (see gtk_widget_add_events()),  
   // it won't be received by the event box. 
   // </para><para>
   // This problem doesn't occur for visible event boxes, because in
   // that case, the event box window is actually the ancestor of the
   // descendant windows, not just at the same place on the screen.
   // </para></note>
   // <visible_window>: boolean value
   void set_visible_window(int visible_window) {
      gtk_event_box_set_visible_window(&this, visible_window);
   }
}

struct EventBoxClass {
   BinClass parent_class;
}

struct Expander /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   ExpanderPrivate* priv;


   // Creates a new expander using @label as the text of the label.
   // RETURNS: a new #GtkExpander widget.
   // <label>: the text of the label
   static Expander* new_(char* label) {
      return gtk_expander_new(label);
   }

   // Creates a new expander using @label as the text of the label.
   // If characters in @label are preceded by an underscore, they are underlined.
   // If you need a literal underscore character in a label, use '__' (two 
   // underscores). The first underlined character represents a keyboard 
   // accelerator called a mnemonic.
   // Pressing Alt and that key activates the button.
   // RETURNS: a new #GtkExpander widget.
   // <label>: the text of the label with an underscore in front of the mnemonic character
   static Expander* new_with_mnemonic(char* label=null) {
      return gtk_expander_new_with_mnemonic(label);
   }

   // Queries a #GtkExpander and returns its current state. Returns %TRUE
   // if the child widget is revealed.
   // See gtk_expander_set_expanded().
   // RETURNS: the current state of the expander.
   int get_expanded() {
      return gtk_expander_get_expanded(&this);
   }

   // Fetches the text from a label widget including any embedded
   // underlines indicating mnemonics and Pango markup, as set by
   // gtk_expander_set_label(). If the label text has not been set the
   // return value will be %NULL. This will be the case if you create an
   // empty button with gtk_button_new() to use as a container.
   // Note that this function behaved differently in versions prior to
   // 2.14 and used to return the label text stripped of embedded
   // underlines indicating mnemonics and Pango markup. This problem can
   // be avoided by fetching the label text directly from the label
   // widget.
   // by the widget and must not be modified or freed.
   // RETURNS: The text of the label widget. This string is owned
   char* get_label() {
      return gtk_expander_get_label(&this);
   }

   // Returns whether the label widget will fill all available horizontal
   // space allocated to @expander.
   // space
   // RETURNS: %TRUE if the label widget will fill all available horizontal
   int get_label_fill() {
      return gtk_expander_get_label_fill(&this);
   }

   // Retrieves the label widget for the frame. See
   // gtk_expander_set_label_widget().
   // or %NULL if there is none.
   // RETURNS: the label widget,
   Widget* get_label_widget() {
      return gtk_expander_get_label_widget(&this);
   }

   // Gets the value set by gtk_expander_set_spacing().
   // RETURNS: spacing between the expander and child.
   int get_spacing() {
      return gtk_expander_get_spacing(&this);
   }

   // Returns whether the label's text is interpreted as marked up with
   // the <link linkend="PangoMarkupFormat">Pango text markup
   // language</link>. See gtk_expander_set_use_markup ().
   // RETURNS: %TRUE if the label's text will be parsed for markup
   int get_use_markup() {
      return gtk_expander_get_use_markup(&this);
   }

   // Returns whether an embedded underline in the expander label indicates a
   // mnemonic. See gtk_expander_set_use_underline().
   // indicates the mnemonic accelerator keys.
   // RETURNS: %TRUE if an embedded underline in the expander label
   int get_use_underline() {
      return gtk_expander_get_use_underline(&this);
   }

   // Sets the state of the expander. Set to %TRUE, if you want
   // the child widget to be revealed, and %FALSE if you want the
   // child widget to be hidden.
   // <expanded>: whether the child widget is revealed
   void set_expanded(int expanded) {
      gtk_expander_set_expanded(&this, expanded);
   }

   // Sets the text of the label of the expander to @label.
   // This will also clear any previously set labels.
   // <label>: a string
   void set_label(char* label=null) {
      gtk_expander_set_label(&this, label);
   }

   // Sets whether the label widget should fill all available horizontal space
   // allocated to @expander.
   // <label_fill>: %TRUE if the label should should fill all available horizontal space
   void set_label_fill(int label_fill) {
      gtk_expander_set_label_fill(&this, label_fill);
   }

   // Set the label widget for the expander. This is the widget
   // that will appear embedded alongside the expander arrow.
   // <label_widget>: the new label widget
   void set_label_widget(Widget* label_widget=null) {
      gtk_expander_set_label_widget(&this, label_widget);
   }

   // Sets the spacing field of @expander, which is the number of pixels to
   // place between expander and the child.
   // <spacing>: distance between the expander and child in pixels.
   void set_spacing(int spacing) {
      gtk_expander_set_spacing(&this, spacing);
   }

   // Sets whether the text of the label contains markup in <link
   // linkend="PangoMarkupFormat">Pango's text markup
   // language</link>. See gtk_label_set_markup().
   // <use_markup>: %TRUE if the label's text should be parsed for markup
   void set_use_markup(int use_markup) {
      gtk_expander_set_use_markup(&this, use_markup);
   }

   // If true, an underline in the text of the expander label indicates
   // the next character should be used for the mnemonic accelerator key.
   // <use_underline>: %TRUE if underlines in the text indicate mnemonics
   void set_use_underline(int use_underline) {
      gtk_expander_set_use_underline(&this, use_underline);
   }
   extern (C) alias static void function (Expander* this_, 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);
   }
}

struct ExpanderClass {
   BinClass parent_class;
   extern (C) void function (Expander* expander) activate;
}

struct ExpanderPrivate {
}

enum ExpanderStyle {
   COLLAPSED = 0,
   SEMI_COLLAPSED = 1,
   SEMI_EXPANDED = 2,
   EXPANDED = 3
}

// #GtkFileChooser is an interface that can be implemented by file
// selection widgets.  In GTK+, the main objects that implement this
// interface are #GtkFileChooserWidget, #GtkFileChooserDialog, and
// #GtkFileChooserButton.  You do not need to write an object that
// implements the #GtkFileChooser interface unless you are trying to
// adapt an existing file selector to expose a standard programming
// interface.
// #GtkFileChooser allows for shortcuts to various places in the filesystem.
// In the default implementation these are displayed in the left pane. It
// may be a bit confusing at first that these shortcuts come from various
// sources and in various flavours, so lets explain the terminology here:
// <variablelist>
// <varlistentry>
// <term>Bookmarks</term>
// <listitem>
// are created by the user, by dragging folders from the
// right pane to the left pane, or by using the "Add". Bookmarks
// can be renamed and deleted by the user.
// </listitem>
// </varlistentry>
// <varlistentry>
// <term>Shortcuts</term>
// <listitem>
// can be provided by the application or by the underlying filesystem
// abstraction (e.g. both the gnome-vfs and the Windows filesystems
// provide "Desktop" shortcuts). Shortcuts cannot be modified by the
// user.
// </listitem>
// </varlistentry>
// <varlistentry>
// <term>Volumes</term>
// <listitem>
// are provided by the underlying filesystem abstraction. They are
// the "roots" of the filesystem.
// </listitem>
// </varlistentry>
// </variablelist>
// <refsect2 id="gtkfilechooser-encodings">
// <title>File Names and Encodings</title>
// When the user is finished selecting files in a
// #GtkFileChooser, your program can get the selected names
// either as filenames or as URIs.  For URIs, the normal escaping
// rules are applied if the URI contains non-ASCII characters.
// However, filenames are <emphasis>always</emphasis> returned in
// the character set specified by the
// <envar>G_FILENAME_ENCODING</envar> environment variable.
// Please see the Glib documentation for more details about this
// variable.
// <note>
// This means that while you can pass the result of
// gtk_file_chooser_get_filename() to
// <function>open(2)</function> or
// <function>fopen(3)</function>, you may not be able to
// directly set it as the text of a #GtkLabel widget unless you
// convert it first to UTF-8, which all GTK+ widgets expect.
// You should use g_filename_to_utf8() to convert filenames
// into strings that can be passed to GTK+ widgets.
// </note>
// </refsect2>
// <refsect2 id="gtkfilechooser-preview">
// <title>Adding a Preview Widget</title>
// <para>
// You can add a custom preview widget to a file chooser and then
// get notification about when the preview needs to be updated.
// To install a preview widget, use
// gtk_file_chooser_set_preview_widget().  Then, connect to the
// #GtkFileChooser::update-preview signal to get notified when
// you need to update the contents of the preview.
// </para>
// <para>
// Your callback should use
// gtk_file_chooser_get_preview_filename() to see what needs
// previewing.  Once you have generated the preview for the
// corresponding file, you must call
// gtk_file_chooser_set_preview_widget_active() with a boolean
// flag that indicates whether your callback could successfully
// generate a preview.
// </para>
// <example id="example-gtkfilechooser-preview">
// <title>Sample Usage</title>
// <programlisting>
// {
// GtkImage *preview;
// ...
// preview = gtk_image_new (<!-- -->);
// gtk_file_chooser_set_preview_widget (my_file_chooser, preview);
// g_signal_connect (my_file_chooser, "update-preview",
// G_CALLBACK (update_preview_cb), preview);
// }
// static void
// update_preview_cb (GtkFileChooser *file_chooser, gpointer data)
// {
// GtkWidget *preview;
// char *filename;
// GdkPixbuf *pixbuf;
// gboolean have_preview;
// preview = GTK_WIDGET (data);
// filename = gtk_file_chooser_get_preview_filename (file_chooser);
// pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL);
// have_preview = (pixbuf != NULL);
// g_free (filename);
// gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
// if (pixbuf)
// g_object_unref (pixbuf);
// gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview);
// }
// </programlisting>
// </example>
// </refsect2>
// <refsect2 id="gtkfilechooser-extra">
// <title>Adding Extra Widgets</title>
// <para>
// You can add extra widgets to a file chooser to provide options
// that are not present in the default design.  For example, you
// can add a toggle button to give the user the option to open a
// file in read-only mode.  You can use
// gtk_file_chooser_set_extra_widget() to insert additional
// widgets in a file chooser.
// </para>
// <example id="example-gtkfilechooser-extra">
// <title>Sample Usage</title>
// <programlisting>
// GtkWidget *toggle;
// ...
// toggle = gtk_check_button_new_with_label ("Open file read-only");
// gtk_widget_show (toggle);
// gtk_file_chooser_set_extra_widget (my_file_chooser, toggle);
// }
// </programlisting>
// </example>
// <note>
// If you want to set more than one extra widget in the file
// chooser, you can a container such as a #GtkVBox or a #GtkTable
// and include your widgets in it.  Then, set the container as
// the whole extra widget.
// </note>
// </refsect2>
// <refsect2 id="gtkfilechooser-key-bindings">
// <title>Key Bindings</title>
// <para>
// Internally, GTK+ implements a file chooser's graphical user
// interface with the private
// <classname>GtkFileChooserDefaultClass</classname>.  This
// widget has several <link linkend="gtk-Bindings">key
// bindings</link> and their associated signals.  This section
// describes the available key binding signals.
// </para>
// <example id="gtkfilechooser-key-binding-example">
// <title>GtkFileChooser key binding example</title>
// <para>
// The default keys that activate the key-binding signals in
// <classname>GtkFileChooserDefaultClass</classname> are as
// follows:
// </para>
// <informaltable>
// <tgroup cols="2">
// <tbody>
// <row>
// <entry>Signal name</entry>
// <entry>Default key combinations</entry>
// </row>
// <row>
// <entry>location-popup</entry>
// <entry>
// <keycombo><keycap>Control</keycap><keycap>L</keycap></keycombo> (empty path);
// <keycap>/</keycap> (path of "/")
// <footnote>
// Both the individual <keycap>/</keycap> key and the
// numeric keypad's "divide" key are supported.
// </footnote>;
// <keycap>~</keycap> (path of "~")
// </entry>
// </row>
// <row>
// <entry>up-folder</entry>
// <entry>
// <keycombo><keycap>Alt</keycap><keycap>Up</keycap></keycombo>;
// <keycombo><keycap>Alt</keycap><keycap>Shift</keycap><keycap>Up</keycap></keycombo>
// <footnote>
// Both the individual Up key and the numeric
// keypad's Up key are supported.
// </footnote>;
// <keycap>Backspace</keycap>
// </entry>
// </row>
// <row>
// <entry>down-folder</entry>
// <entry>
// <keycombo><keycap>Alt</keycap><keycap>Down</keycap></keycombo>;
// <keycombo><keycap>Alt</keycap><keycap>Shift</keycap><keycap>Down</keycap></keycombo>
// <footnote>
// Both the individual Down key and the numeric
// keypad's Down key are supported.
// </footnote>
// </entry>
// </row>
// <row>
// <entry>home-folder</entry>
// <entry><keycombo><keycap>Alt</keycap><keycap>Home</keycap></keycombo></entry>
// </row>
// <row>
// <entry>desktop-folder</entry>
// <entry><keycombo><keycap>Alt</keycap><keycap>D</keycap></keycombo></entry>
// </row>
// <row>
// <entry>quick-bookmark</entry>
// <entry><keycombo><keycap>Alt</keycap><keycap>1</keycap></keycombo> through <keycombo><keycap>Alt</keycap><keycap>0</keycap></keycombo></entry>
// </row>
// </tbody>
// </tgroup>
// </informaltable>
// <para>
// You can change these defaults to something else.  For
// example, to add a <keycap>Shift</keycap> modifier to a few
// of the default bindings, you can include the following
// fragment in your <filename>.gtkrc-3.0</filename> file:
// </para>
// <programlisting>
// binding "my-own-gtkfilechooser-bindings" {
// bind "&lt;Alt&gt;&lt;Shift&gt;Up" {
// "up-folder" ()
// }
// bind "&lt;Alt&gt;&lt;Shift&gt;Down" {
// "down-folder" ()
// }
// bind "&lt;Alt&gt;&lt;Shift&gt;Home" {
// "home-folder" ()
// }
// }
// class "GtkFileChooserDefault" binding "my-own-gtkfilechooser-bindings"
// </programlisting>
// </example>
// <refsect3 id="GtkFileChooserDefault-location-popup">
// <title>The &quot;GtkFileChooserDefault::location-popup&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// const char            *path,
// <link linkend="gpointer">gpointer</link>      user_data);
// </programlisting>
// <para>
// This is used to make the file chooser show a "Location"
// dialog which the user can use to manually type the name of
// the file he wishes to select.  The
// <parameter>path</parameter> argument is a string that gets
// put in the text entry for the file name.  By default this is bound to
// <keycombo><keycap>Control</keycap><keycap>L</keycap></keycombo>
// with a <parameter>path</parameter> string of "" (the empty
// string).  It is also bound to <keycap>/</keycap> with a
// <parameter>path</parameter> string of "<literal>/</literal>"
// (a slash):  this lets you type <keycap>/</keycap> and
// immediately type a path name.  On Unix systems, this is bound to
// <keycap>~</keycap> (tilde) with a <parameter>path</parameter> string
// of "~" itself for access to home directories.
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>path</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// default contents for the text entry for the file name
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// <note>
// You can create your own bindings for the
// #GtkFileChooserDefault::location-popup signal with custom
// <parameter>path</parameter> strings, and have a crude form
// of easily-to-type bookmarks.  For example, say you access
// the path <filename>/home/username/misc</filename> very
// frequently.  You could then create an <keycombo>
// <keycap>Alt</keycap> <keycap>M</keycap> </keycombo>
// shortcut by including the following in your
// <filename>.gtkrc-3.0</filename>:
// <programlisting>
// binding "misc-shortcut" {
// bind "&lt;Alt&gt;M" {
// "location-popup" ("/home/username/misc")
// }
// }
// class "GtkFileChooserDefault" binding "misc-shortcut"
// </programlisting>
// </note>
// </refsect3>
// <refsect3 id="GtkFileChooserDefault-up-folder">
// <title>The &quot;GtkFileChooserDefault::up-folder&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// <link linkend="gpointer">gpointer</link> user_data);
// </programlisting>
// <para>
// This is used to make the file chooser go to the parent of
// the current folder in the file hierarchy.  By default this
// is bound to <keycap>Backspace</keycap> and
// <keycombo><keycap>Alt</keycap><keycap>Up</keycap></keycombo>
// (the Up key in the numeric keypad also works).
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// </refsect3>
// <refsect3 id="GtkFileChooserDefault-down-folder">
// <title>The &quot;GtkFileChooserDefault::down-folder&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// <link linkend="gpointer">gpointer</link> user_data);
// </programlisting>
// <para>
// This is used to make the file chooser go to a child of the
// current folder in the file hierarchy.  The subfolder that
// will be used is displayed in the path bar widget of the file
// chooser.  For example, if the path bar is showing
// "/foo/<emphasis>bar/</emphasis>baz", then this will cause
// the file chooser to switch to the "baz" subfolder.  By
// default this is bound to
// <keycombo><keycap>Alt</keycap><keycap>Down</keycap></keycombo>
// (the Down key in the numeric keypad also works).
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// </refsect3>
// <refsect3 id="GtkFileChooserDefault-home-folder">
// <title>The &quot;GtkFileChooserDefault::home-folder&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// <link linkend="gpointer">gpointer</link> user_data);
// </programlisting>
// <para>
// This is used to make the file chooser show the user's home
// folder in the file list.  By default this is bound to
// <keycombo><keycap>Alt</keycap><keycap>Home</keycap></keycombo>
// (the Home key in the numeric keypad also works).
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// </refsect3>
// <refsect3 id="GtkFileChooserDefault-desktop-folder">
// <title>The &quot;GtkFileChooserDefault::desktop-folder&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// <link linkend="gpointer">gpointer</link> user_data);
// </programlisting>
// <para>
// This is used to make the file chooser show the user's Desktop
// folder in the file list.  By default this is bound to
// <keycombo><keycap>Alt</keycap><keycap>D</keycap></keycombo>.
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// </refsect3>
// <refsect3 id="GtkFileChooserDefault-quick-bookmark">
// <title>The &quot;GtkFileChooserDefault::quick-bookmark&quot; signal</title>
// <programlisting>
// void user_function (GtkFileChooserDefault *chooser,
// gint bookmark_index,
// <link linkend="gpointer">gpointer</link> user_data);
// </programlisting>
// <para>
// This is used to make the file chooser switch to the bookmark
// specified in the <parameter>bookmark_index</parameter> parameter.
// For example, if you have three bookmarks, you can pass 0, 1, 2 to
// this signal to switch to each of them, respectively.  By default this is bound to
// <keycombo><keycap>Alt</keycap><keycap>1</keycap></keycombo>,
// <keycombo><keycap>Alt</keycap><keycap>2</keycap></keycombo>,
// etc. until
// <keycombo><keycap>Alt</keycap><keycap>0</keycap></keycombo>.  Note
// that in the default binding,
// that <keycombo><keycap>Alt</keycap><keycap>1</keycap></keycombo> is
// actually defined to switch to the bookmark at index 0, and so on
// successively;
// <keycombo><keycap>Alt</keycap><keycap>0</keycap></keycombo> is
// defined to switch to the bookmark at index 10.
// </para>
// <variablelist role="params">
// <varlistentry>
// <term><parameter>chooser</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// the object which received the signal.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>bookmark_indes</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// index of the bookmark to switch to; the indices start at 0.
// </simpara>
// </listitem>
// </varlistentry>
// <varlistentry>
// <term><parameter>user_data</parameter>&nbsp;:</term>
// <listitem>
// <simpara>
// user data set when the signal handler was connected.
// </simpara>
// </listitem>
// </varlistentry>
// </variablelist>
// </refsect3>
// </refsect2>
struct FileChooser {

   // Adds @filter to the list of filters that the user can select between.
   // When a filter is selected, only files that are passed by that
   // filter are displayed. 
   // Note that the @chooser takes ownership of the filter, so you have to 
   // ref and sink it if you want to keep a reference.
   // <filter>: a #GtkFileFilter
   void add_filter(FileFilter* filter) {
      gtk_file_chooser_add_filter(&this, filter);
   }

   // Adds a folder to be displayed with the shortcut folders in a file chooser.
   // Note that shortcut folders do not get saved, as they are provided by the
   // application.  For example, you can use this to add a
   // "/usr/share/mydrawprogram/Clipart" folder to the volume list.
   // otherwise.  In the latter case, the @error will be set as appropriate.
   // RETURNS: %TRUE if the folder could be added successfully, %FALSE
   // <folder>: filename of the folder to add
   int add_shortcut_folder(char* folder, GLib2.Error** error=null) {
      return gtk_file_chooser_add_shortcut_folder(&this, folder, error);
   }

   // Adds a folder URI to be displayed with the shortcut folders in a file
   // chooser.  Note that shortcut folders do not get saved, as they are provided
   // by the application.  For example, you can use this to add a
   // "file:///usr/share/mydrawprogram/Clipart" folder to the volume list.
   // otherwise.  In the latter case, the @error will be set as appropriate.
   // RETURNS: %TRUE if the folder could be added successfully, %FALSE
   // <uri>: URI of the folder to add
   int add_shortcut_folder_uri(char* uri, GLib2.Error** error=null) {
      return gtk_file_chooser_add_shortcut_folder_uri(&this, uri, error);
   }

   // Gets the type of operation that the file chooser is performing; see
   // gtk_file_chooser_set_action().
   // RETURNS: the action that the file selector is performing
   FileChooserAction get_action() {
      return gtk_file_chooser_get_action(&this);
   }

   // Gets whether file choser will offer to create new folders.
   // See gtk_file_chooser_set_create_folders().
   // RETURNS: %TRUE if the New Folder button should be displayed.
   int get_create_folders() {
      return gtk_file_chooser_get_create_folders(&this);
   }

   // Gets the current folder of @chooser as a local filename.
   // See gtk_file_chooser_set_current_folder().
   // Note that this is the folder that the file chooser is currently displaying
   // (e.g. "/home/username/Documents"), which is <emphasis>not the same</emphasis>
   // as the currently-selected folder if the chooser is in
   // %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
   // (e.g. "/home/username/Documents/selected-folder/".  To get the
   // currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
   // usual way to get the selection.
   // or %NULL if the current path cannot be represented as a local
   // filename.  Free with g_free().  This function will also return
   // %NULL if the file chooser was unable to load the last folder that
   // was requested from it; for example, as would be for calling
   // gtk_file_chooser_set_current_folder() on a nonexistent folder.
   // RETURNS: the full path of the current folder,
   char* /*new*/ get_current_folder() {
      return gtk_file_chooser_get_current_folder(&this);
   }

   // Gets the current folder of @chooser as #GFile.
   // See gtk_file_chooser_get_current_folder_uri().
   // RETURNS: the #GFile for the current folder.
   Gio2.File* /*new*/ get_current_folder_file() {
      return gtk_file_chooser_get_current_folder_file(&this);
   }

   // Gets the current folder of @chooser as an URI.
   // See gtk_file_chooser_set_current_folder_uri().
   // Note that this is the folder that the file chooser is currently displaying
   // (e.g. "file:///home/username/Documents"), which is <emphasis>not the same</emphasis>
   // as the currently-selected folder if the chooser is in
   // %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
   // (e.g. "file:///home/username/Documents/selected-folder/".  To get the
   // currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
   // usual way to get the selection.
   // function will also return %NULL if the file chooser was unable to load the
   // last folder that was requested from it; for example, as would be for calling
   // gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
   // RETURNS: the URI for the current folder.  Free with g_free().  This
   char* /*new*/ get_current_folder_uri() {
      return gtk_file_chooser_get_current_folder_uri(&this);
   }

   // Queries whether a file chooser is set to confirm for overwriting when the user
   // types a file name that already exists.
   // %FALSE otherwise.
   // RETURNS: %TRUE if the file chooser will present a confirmation dialog;
   int get_do_overwrite_confirmation() {
      return gtk_file_chooser_get_do_overwrite_confirmation(&this);
   }

   // Gets the current preview widget; see
   // gtk_file_chooser_set_extra_widget().
   // RETURNS: the current extra widget, or %NULL
   Widget* get_extra_widget() {
      return gtk_file_chooser_get_extra_widget(&this);
   }

   // Gets the #GFile for the currently selected file in
   // the file selector. If multiple files are selected,
   // one of the files will be returned at random.
   // If the file chooser is in folder mode, this function returns the selected
   // folder.
   // use g_object_unref() to release it.
   // RETURNS: a selected #GFile. You own the returned file;
   Gio2.File* /*new*/ get_file() {
      return gtk_file_chooser_get_file(&this);
   }

   // Gets the filename for the currently selected file in
   // the file selector. If multiple files are selected,
   // one of the filenames will be returned at random.
   // If the file chooser is in folder mode, this function returns the selected
   // folder.
   // if no file is selected, or the selected file can't
   // be represented with a local filename. Free with g_free().
   // RETURNS: The currently selected filename, or %NULL
   char* /*new*/ get_filename() {
      return gtk_file_chooser_get_filename(&this);
   }

   // Lists all the selected files and subfolders in the current folder of
   // folder cannot be represented as local filenames they will be ignored. (See
   // gtk_file_chooser_get_uris())
   // containing the filenames of all selected files and subfolders in
   // the current folder. Free the returned list with g_slist_free(),
   // and the filenames with g_free().
   // RETURNS: a #GSList
   GLib2.SList* /*new*/ get_filenames() {
      return gtk_file_chooser_get_filenames(&this);
   }

   // Lists all the selected files and subfolders in the current folder of @chooser
   // as #GFile. An internal function, see gtk_file_chooser_get_uris().
   // containing a #GFile for each selected file and subfolder in the
   // current folder.  Free the returned list with g_slist_free(), and
   // the files with g_object_unref().
   // RETURNS: a #GSList
   GLib2.SList* /*new*/ get_files() {
      return gtk_file_chooser_get_files(&this);
   }

   // Gets the current filter; see gtk_file_chooser_set_filter().
   // RETURNS: the current filter, or %NULL
   FileFilter* get_filter() {
      return gtk_file_chooser_get_filter(&this);
   }

   // Gets whether only local files can be selected in the
   // file selector. See gtk_file_chooser_set_local_only()
   // RETURNS: %TRUE if only local files can be selected.
   int get_local_only() {
      return gtk_file_chooser_get_local_only(&this);
   }

   // Gets the #GFile that should be previewed in a custom preview
   // Internal function, see gtk_file_chooser_get_preview_uri().
   // or %NULL if no file is selected. Free with g_object_unref().
   // RETURNS: the #GFile for the file to preview,
   Gio2.File* /*new*/ get_preview_file() {
      return gtk_file_chooser_get_preview_file(&this);
   }

   // Gets the filename that should be previewed in a custom preview
   // widget. See gtk_file_chooser_set_preview_widget().
   // no file is selected, or if the selected file cannot be represented
   // as a local filename. Free with g_free()
   // RETURNS: the filename to preview, or %NULL if
   char* /*new*/ get_preview_filename() {
      return gtk_file_chooser_get_preview_filename(&this);
   }

   // Gets the URI that should be previewed in a custom preview
   // widget. See gtk_file_chooser_set_preview_widget().
   // selected. Free with g_free().
   // RETURNS: the URI for the file to preview, or %NULL if no file is
   char* /*new*/ get_preview_uri() {
      return gtk_file_chooser_get_preview_uri(&this);
   }

   // Gets the current preview widget; see
   // gtk_file_chooser_set_preview_widget().
   // RETURNS: the current preview widget, or %NULL
   Widget* get_preview_widget() {
      return gtk_file_chooser_get_preview_widget(&this);
   }

   // Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
   // should be shown for the current filename. See
   // gtk_file_chooser_set_preview_widget_active().
   // RETURNS: %TRUE if the preview widget is active for the current filename.
   int get_preview_widget_active() {
      return gtk_file_chooser_get_preview_widget_active(&this);
   }

   // Gets whether multiple files can be selected in the file
   // selector. See gtk_file_chooser_set_select_multiple().
   // RETURNS: %TRUE if multiple files can be selected.
   int get_select_multiple() {
      return gtk_file_chooser_get_select_multiple(&this);
   }

   // Gets whether hidden files and folders are displayed in the file selector.   
   // See gtk_file_chooser_set_show_hidden().
   // RETURNS: %TRUE if hidden files and folders are displayed.
   int get_show_hidden() {
      return gtk_file_chooser_get_show_hidden(&this);
   }

   // Gets the URI for the currently selected file in
   // the file selector. If multiple files are selected,
   // one of the filenames will be returned at random.
   // If the file chooser is in folder mode, this function returns the selected
   // folder.
   // if no file is selected. Free with g_free()
   // RETURNS: The currently selected URI, or %NULL
   char* /*new*/ get_uri() {
      return gtk_file_chooser_get_uri(&this);
   }

   // Lists all the selected files and subfolders in the current folder of
   // files and subfolders in the current folder. Free the returned list
   // with g_slist_free(), and the filenames with g_free().
   // RETURNS: a #GSList containing the URIs of all selected
   GLib2.SList* /*new*/ get_uris() {
      return gtk_file_chooser_get_uris(&this);
   }

   // Gets whether a stock label should be drawn with the name of the previewed
   // file.  See gtk_file_chooser_set_use_preview_label().
   // name of the previewed file, %FALSE otherwise.
   // RETURNS: %TRUE if the file chooser is set to display a label with the
   int get_use_preview_label() {
      return gtk_file_chooser_get_use_preview_label(&this);
   }

   // Lists the current set of user-selectable filters; see
   // gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
   // #GSList containing the current set of user selectable filters. The
   // contents of the list are owned by GTK+, but you must free the list
   // itself with g_slist_free() when you are done with it.
   // RETURNS: a
   GLib2.SList* /*new container*/ list_filters() {
      return gtk_file_chooser_list_filters(&this);
   }

   // Queries the list of shortcut folders in the file chooser, as set by
   // gtk_file_chooser_add_shortcut_folder_uri().
   // URIs, or %NULL if there are no shortcut folders.  Free the returned
   // list with g_slist_free(), and the URIs with g_free().
   // RETURNS: A list of folder
   GLib2.SList* /*new*/ list_shortcut_folder_uris() {
      return gtk_file_chooser_list_shortcut_folder_uris(&this);
   }

   // Queries the list of shortcut folders in the file chooser, as set by
   // gtk_file_chooser_add_shortcut_folder().
   // folder filenames, or %NULL if there are no shortcut folders.  Free
   // the returned list with g_slist_free(), and the filenames with
   // g_free().
   // RETURNS: A list of
   GLib2.SList* /*new*/ list_shortcut_folders() {
      return gtk_file_chooser_list_shortcut_folders(&this);
   }

   // Removes @filter from the list of filters that the user can select between.
   // <filter>: a #GtkFileFilter
   void remove_filter(FileFilter* filter) {
      gtk_file_chooser_remove_filter(&this, filter);
   }

   // Removes a folder from a file chooser's list of shortcut folders.
   // In the latter case, the @error will be set as appropriate.
   // RETURNS: %TRUE if the operation succeeds, %FALSE otherwise.
   // <folder>: filename of the folder to remove
   int remove_shortcut_folder(char* folder, GLib2.Error** error=null) {
      return gtk_file_chooser_remove_shortcut_folder(&this, folder, error);
   }

   // Removes a folder URI from a file chooser's list of shortcut folders.
   // In the latter case, the @error will be set as appropriate.
   // RETURNS: %TRUE if the operation succeeds, %FALSE otherwise.
   // <uri>: URI of the folder to remove
   int remove_shortcut_folder_uri(char* uri, GLib2.Error** error=null) {
      return gtk_file_chooser_remove_shortcut_folder_uri(&this, uri, error);
   }
   // Selects all the files in the current folder of a file chooser.
   void select_all() {
      gtk_file_chooser_select_all(&this);
   }

   // Selects the file referred to by @file. An internal function. See
   // _gtk_file_chooser_select_uri().
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the path was
   // <file>: the file to select
   int select_file(Gio2.File* file, GLib2.Error** error=null) {
      return gtk_file_chooser_select_file(&this, file, error);
   }

   // Selects a filename. If the file name isn't in the current
   // folder of @chooser, then the current folder of @chooser will
   // be changed to the folder containing @filename.
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the file was
   // <filename>: the filename to select
   int select_filename(char* filename) {
      return gtk_file_chooser_select_filename(&this, filename);
   }

   // Selects the file to by @uri. If the URI doesn't refer to a
   // file in the current folder of @chooser, then the current folder of
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the URI was
   // <uri>: the URI to select
   int select_uri(char* uri) {
      return gtk_file_chooser_select_uri(&this, uri);
   }

   // Sets the type of operation that the chooser is performing; the
   // user interface is adapted to suit the selected action. For example,
   // an option to create a new folder might be shown if the action is
   // %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
   // %GTK_FILE_CHOOSER_ACTION_OPEN.
   // <action>: the action that the file selector is performing
   void set_action(FileChooserAction action) {
      gtk_file_chooser_set_action(&this, action);
   }

   // Sets whether file choser will offer to create new folders.
   // This is only relevant if the action is not set to be 
   // %GTK_FILE_CHOOSER_ACTION_OPEN.
   // <create_folders>: %TRUE if the New Folder button should be displayed
   void set_create_folders(int create_folders) {
      gtk_file_chooser_set_create_folders(&this, create_folders);
   }

   // Sets the current folder for @chooser from a local filename.
   // The user will be shown the full contents of the current folder,
   // plus user interface elements for navigating to other folders.
   // otherwise.
   // RETURNS: %TRUE if the folder could be changed successfully, %FALSE
   // <filename>: the full path of the new current folder
   int set_current_folder(char* filename) {
      return gtk_file_chooser_set_current_folder(&this, filename);
   }

   // Sets the current folder for @chooser from a #GFile.
   // Internal function, see gtk_file_chooser_set_current_folder_uri().
   // otherwise.
   // RETURNS: %TRUE if the folder could be changed successfully, %FALSE
   // <file>: the #GFile for the new folder
   int set_current_folder_file(Gio2.File* file, GLib2.Error** error=null) {
      return gtk_file_chooser_set_current_folder_file(&this, file, error);
   }

   // Sets the current folder for @chooser from an URI.
   // The user will be shown the full contents of the current folder,
   // plus user interface elements for navigating to other folders.
   // otherwise.
   // RETURNS: %TRUE if the folder could be changed successfully, %FALSE
   // <uri>: the URI for the new current folder
   int set_current_folder_uri(char* uri) {
      return gtk_file_chooser_set_current_folder_uri(&this, uri);
   }

   // Sets the current name in the file selector, as if entered
   // by the user. Note that the name passed in here is a UTF-8
   // string rather than a filename. This function is meant for
   // such uses as a suggested name in a "Save As..." dialog.
   // If you want to preselect a particular existing file, you should use
   // gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
   // Please see the documentation for those functions for an example of using
   // gtk_file_chooser_set_current_name() as well.
   // <name>: the filename to use, as a UTF-8 string
   void set_current_name(char* name) {
      gtk_file_chooser_set_current_name(&this, name);
   }

   // Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
   // a confirmation dialog if the user types a file name that already exists.  This
   // is %FALSE by default.
   // Regardless of this setting, the @chooser will emit the
   // #GtkFileChooser::confirm-overwrite signal when appropriate.
   // If all you need is the stock confirmation dialog, set this property to %TRUE.
   // You can override the way confirmation is done by actually handling the
   // #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
   // for the details.
   // <do_overwrite_confirmation>: whether to confirm overwriting in save mode
   void set_do_overwrite_confirmation(int do_overwrite_confirmation) {
      gtk_file_chooser_set_do_overwrite_confirmation(&this, do_overwrite_confirmation);
   }

   // Sets an application-supplied widget to provide extra options to the user.
   // <extra_widget>: widget for extra options
   void set_extra_widget(Widget* extra_widget) {
      gtk_file_chooser_set_extra_widget(&this, extra_widget);
   }

   // Sets @file as the current filename for the file chooser, by changing
   // to the file's parent folder and actually selecting the file in list.  If
   // the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file's base name
   // will also appear in the dialog's file name entry.
   // If the file name isn't in the current folder of @chooser, then the current
   // folder of @chooser will be changed to the folder containing @filename. This
   // is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
   // gtk_file_chooser_select_filename().
   // Note that the file must exist, or nothing will be done except
   // for the directory change.
   // If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog,
   // you should use this function if you already have a file name to which the
   // user may save; for example, when the user opens an existing file and then
   // does <guimenuitem>File/Save As...</guimenuitem> on it.  If you don't have
   // a file name already &mdash; for example, if the user just created a new
   // file and is saving it for the first time, do not call this function.
   // Instead, use something similar to this:
   // |[
   // if (document_is_new)
   // {
   // /&ast; the user just created a new document &ast;/
   // gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
   // gtk_file_chooser_set_current_name (chooser, "Untitled document");
   // }
   // else
   // {
   // /&ast; the user edited an existing document &ast;/
   // gtk_file_chooser_set_file (chooser, existing_file);
   // }
   // ]|
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the file was
   // <file>: the #GFile to set as current
   int set_file(Gio2.File* file, GLib2.Error** error=null) {
      return gtk_file_chooser_set_file(&this, file, error);
   }

   // Sets @filename as the current filename for the file chooser, by changing
   // to the file's parent folder and actually selecting the file in list.  If
   // the @chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file's base name
   // will also appear in the dialog's file name entry.
   // If the file name isn't in the current folder of @chooser, then the current
   // folder of @chooser will be changed to the folder containing @filename. This
   // is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
   // gtk_file_chooser_select_filename().
   // Note that the file must exist, or nothing will be done except
   // for the directory change.
   // If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog,
   // you should use this function if you already have a file name to which the 
   // user may save; for example, when the user opens an existing file and then 
   // does <guimenuitem>File/Save As...</guimenuitem> on it.  If you don't have 
   // a file name already &mdash; for example, if the user just created a new 
   // file and is saving it for the first time, do not call this function.  
   // Instead, use something similar to this:
   // |[
   // if (document_is_new)
   // {
   // /&ast; the user just created a new document &ast;/
   // gtk_file_chooser_set_current_folder (chooser, default_folder_for_saving);
   // gtk_file_chooser_set_current_name (chooser, "Untitled document");
   // }
   // else
   // {
   // /&ast; the user edited an existing document &ast;/ 
   // gtk_file_chooser_set_filename (chooser, existing_filename);
   // }
   // ]|
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the file was
   // <filename>: the filename to set as current
   int set_filename(char* filename) {
      return gtk_file_chooser_set_filename(&this, filename);
   }

   // Sets the current filter; only the files that pass the
   // filter will be displayed. If the user-selectable list of filters
   // is non-empty, then the filter should be one of the filters
   // in that list. Setting the current filter when the list of
   // filters is empty is useful if you want to restrict the displayed
   // set of files without letting the user change it.
   // <filter>: a #GtkFileFilter
   void set_filter(FileFilter* filter) {
      gtk_file_chooser_set_filter(&this, filter);
   }

   // Sets whether only local files can be selected in the
   // file selector. If @local_only is %TRUE (the default),
   // then the selected file are files are guaranteed to be
   // accessible through the operating systems native file
   // file system and therefore the application only
   // needs to worry about the filename functions in
   // #GtkFileChooser, like gtk_file_chooser_get_filename(),
   // rather than the URI functions like
   // gtk_file_chooser_get_uri(),
   // <local_only>: %TRUE if only local files can be selected
   void set_local_only(int local_only) {
      gtk_file_chooser_set_local_only(&this, local_only);
   }

   // Sets an application-supplied widget to use to display a custom preview
   // of the currently selected file. To implement a preview, after setting the
   // preview widget, you connect to the #GtkFileChooser::update-preview
   // signal, and call gtk_file_chooser_get_preview_filename() or
   // gtk_file_chooser_get_preview_uri() on each change. If you can
   // display a preview of the new file, update your widget and
   // set the preview active using gtk_file_chooser_set_preview_widget_active().
   // Otherwise, set the preview inactive.
   // When there is no application-supplied preview widget, or the
   // application-supplied preview widget is not active, the file chooser
   // may display an internally generated preview of the current file or
   // it may display no preview at all.
   // <preview_widget>: widget for displaying preview.
   void set_preview_widget(Widget* preview_widget) {
      gtk_file_chooser_set_preview_widget(&this, preview_widget);
   }

   // Sets whether the preview widget set by
   // gtk_file_chooser_set_preview_widget() should be shown for the
   // current filename. When @active is set to false, the file chooser
   // may display an internally generated preview of the current file
   // or it may display no preview at all. See
   // gtk_file_chooser_set_preview_widget() for more details.
   // <active>: whether to display the user-specified preview widget
   void set_preview_widget_active(int active) {
      gtk_file_chooser_set_preview_widget_active(&this, active);
   }

   // Sets whether multiple files can be selected in the file selector.  This is
   // only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
   // %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
   // <select_multiple>: %TRUE if multiple files can be selected.
   void set_select_multiple(int select_multiple) {
      gtk_file_chooser_set_select_multiple(&this, select_multiple);
   }

   // Sets whether hidden files and folders are displayed in the file selector.
   // <show_hidden>: %TRUE if hidden files and folders should be displayed.
   void set_show_hidden(int show_hidden) {
      gtk_file_chooser_set_show_hidden(&this, show_hidden);
   }

   // Sets the file referred to by @uri as the current file for the file chooser,
   // by changing to the URI's parent folder and actually selecting the URI in the
   // list.  If the @chooser is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI's base
   // name will also appear in the dialog's file name entry.
   // If the URI isn't in the current folder of @chooser, then the current folder
   // of @chooser will be changed to the folder containing @uri. This is equivalent
   // to a sequence of gtk_file_chooser_unselect_all() followed by
   // gtk_file_chooser_select_uri().
   // Note that the URI must exist, or nothing will be done except for the 
   // directory change.
   // If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog,
   // you should use this function if you already have a file name to which the 
   // user may save; for example, when the user opens an existing file and then 
   // does <guimenuitem>File/Save As...</guimenuitem> on it.  If you don't have 
   // a file name already &mdash; for example, if the user just created a new 
   // file and is saving it for the first time, do not call this function.  
   // Instead, use something similar to this:
   // |[
   // if (document_is_new)
   // {
   // /&ast; the user just created a new document &ast;/
   // gtk_file_chooser_set_current_folder_uri (chooser, default_folder_for_saving);
   // gtk_file_chooser_set_current_name (chooser, "Untitled document");
   // }
   // else
   // {
   // /&ast; the user edited an existing document &ast;/ 
   // gtk_file_chooser_set_uri (chooser, existing_uri);
   // }
   // ]|
   // selected successfully, %FALSE otherwise.
   // RETURNS: %TRUE if both the folder could be changed and the URI was
   // <uri>: the URI to set as current
   int set_uri(char* uri) {
      return gtk_file_chooser_set_uri(&this, uri);
   }

   // Sets whether the file chooser should display a stock label with the name of
   // the file that is being previewed; the default is %TRUE.  Applications that
   // want to draw the whole preview area themselves should set this to %FALSE and
   // display the name themselves in their preview widget.
   // <use_label>: whether to display a stock label with the name of the previewed file
   void set_use_preview_label(int use_label) {
      gtk_file_chooser_set_use_preview_label(&this, use_label);
   }
   // Unselects all the files in the current folder of a file chooser.
   void unselect_all() {
      gtk_file_chooser_unselect_all(&this);
   }

   // Unselects the file referred to by @file. If the file is not in the current
   // directory, does not exist, or is otherwise not currently selected, does nothing.
   // <file>: a #GFile
   void unselect_file(Gio2.File* file) {
      gtk_file_chooser_unselect_file(&this, file);
   }

   // Unselects a currently selected filename. If the filename
   // is not in the current directory, does not exist, or
   // is otherwise not currently selected, does nothing.
   // <filename>: the filename to unselect
   void unselect_filename(char* filename) {
      gtk_file_chooser_unselect_filename(&this, filename);
   }

   // Unselects the file referred to by @uri. If the file
   // is not in the current directory, does not exist, or
   // is otherwise not currently selected, does nothing.
   // <uri>: the URI to unselect
   void unselect_uri(char* uri) {
      gtk_file_chooser_unselect_uri(&this, uri);
   }

   // This signal gets emitted whenever it is appropriate to present a
   // confirmation dialog when the user has selected a file name that
   // already exists.  The signal only gets emitted when the file
   // chooser is in %GTK_FILE_CHOOSER_ACTION_SAVE mode.
   // Most applications just need to turn on the
   // #GtkFileChooser:do-overwrite-confirmation property (or call the
   // gtk_file_chooser_set_do_overwrite_confirmation() function), and
   // they will automatically get a stock confirmation dialog.
   // Applications which need to customize this behavior should do
   // that, and also connect to the #GtkFileChooser::confirm-overwrite
   // signal.
   // A signal handler for this signal must return a
   // #GtkFileChooserConfirmation value, which indicates the action to
   // take.  If the handler determines that the user wants to select a
   // different filename, it should return
   // %GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN.  If it determines
   // that the user is satisfied with his choice of file name, it
   // should return %GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME.
   // On the other hand, if it determines that the stock confirmation
   // dialog should be used, it should return
   // %GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM. The following example
   // illustrates this.
   // <example id="gtkfilechooser-confirmation">
   // <title>Custom confirmation</title>
   // <programlisting>
   // static GtkFileChooserConfirmation
   // confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data)
   // {
   // char *uri;
   // uri = gtk_file_chooser_get_uri (chooser);
   // if (is_uri_read_only (uri))
   // {
   // if (user_wants_to_replace_read_only_file (uri))
   // return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
   // else
   // return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN;
   // } else
   // return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog
   // }
   // ...
   // chooser = gtk_file_chooser_dialog_new (...);
   // gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
   // g_signal_connect (chooser, "confirm-overwrite",
   // G_CALLBACK (confirm_overwrite_callback), NULL);
   // if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT)
   // save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
   // gtk_widget_destroy (chooser);
   // </programlisting>
   // </example>
   // action to take after emitting the signal.
   // RETURNS: a #GtkFileChooserConfirmation value that indicates which
   extern (C) alias static FileChooserConfirmation* function (FileChooser* this_, void* user_data=null) signal_confirm_overwrite;

   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:"confirm-overwrite", CB/*:signal_confirm_overwrite*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"confirm-overwrite",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the current folder in a #GtkFileChooser
   // changes.  This can happen due to the user performing some action that
   // changes folders, such as selecting a bookmark or visiting a folder on the
   // file list.  It can also happen as a result of calling a function to
   // explicitly change the current folder in a file chooser.
   // Normally you do not need to connect to this signal, unless you need to keep
   // track of which folder a file chooser is showing.
   // gtk_file_chooser_get_current_folder(),
   // gtk_file_chooser_set_current_folder_uri(),
   // gtk_file_chooser_get_current_folder_uri().
   extern (C) alias static void function (FileChooser* this_, void* user_data=null) signal_current_folder_changed;
   ulong signal_connect(string name:"current-folder-changed", CB/*:signal_current_folder_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"current-folder-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the user "activates" a file in the file
   // chooser.  This can happen by double-clicking on a file in the file list, or
   // by pressing <keycap>Enter</keycap>.
   // Normally you do not need to connect to this signal.  It is used internally
   // by #GtkFileChooserDialog to know when to activate the default button in the
   // dialog.
   // gtk_file_chooser_get_filenames(), gtk_file_chooser_get_uri(),
   // gtk_file_chooser_get_uris().
   extern (C) alias static void function (FileChooser* this_, void* user_data=null) signal_file_activated;
   ulong signal_connect(string name:"file-activated", CB/*:signal_file_activated*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"file-activated",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when there is a change in the set of selected files
   // in a #GtkFileChooser.  This can happen when the user modifies the selection
   // with the mouse or the keyboard, or when explicitly calling functions to
   // change the selection.
   // Normally you do not need to connect to this signal, as it is easier to wait
   // for the file chooser to finish running, and then to get the list of
   // selected files using the functions mentioned below.
   // gtk_file_chooser_unselect_filename(), gtk_file_chooser_get_filename(),
   // gtk_file_chooser_get_filenames(), gtk_file_chooser_select_uri(),
   // gtk_file_chooser_unselect_uri(), gtk_file_chooser_get_uri(),
   // gtk_file_chooser_get_uris().
   extern (C) alias static void function (FileChooser* this_, void* user_data=null) signal_selection_changed;
   ulong signal_connect(string name:"selection-changed", CB/*:signal_selection_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the preview in a file chooser should be
   // regenerated.  For example, this can happen when the currently selected file
   // changes.  You should use this signal if you want your file chooser to have
   // a preview widget.
   // Once you have installed a preview widget with
   // gtk_file_chooser_set_preview_widget(), you should update it when this
   // signal is emitted.  You can use the functions
   // gtk_file_chooser_get_preview_filename() or
   // gtk_file_chooser_get_preview_uri() to get the name of the file to preview.
   // Your widget may not be able to preview all kinds of files; your callback
   // must call gtk_file_chooser_set_preview_widget_active() to inform the file
   // chooser about whether the preview was generated successfully or not.
   // Please see the example code in <xref linkend="gtkfilechooser-preview"/>.
   // gtk_file_chooser_set_preview_widget_active(),
   // gtk_file_chooser_set_use_preview_label(),
   // gtk_file_chooser_get_preview_filename(),
   // gtk_file_chooser_get_preview_uri().
   extern (C) alias static void function (FileChooser* this_, void* user_data=null) signal_update_preview;
   ulong signal_connect(string name:"update-preview", CB/*:signal_update_preview*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"update-preview",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}


// Describes whether a #GtkFileChooser is being used to open existing files
// or to save to a possibly new file.
enum FileChooserAction {
   OPEN = 0,
   SAVE = 1,
   SELECT_FOLDER = 2,
   CREATE_FOLDER = 3
}
struct FileChooserButton /* : HBox */ {
   alias parent this;
   alias parent super_;
   alias parent hbox;
   HBox parent;
   private FileChooserButtonPrivate* priv;


   // Creates a new file-selecting button widget.
   // RETURNS: a new button widget.
   // <title>: the title of the browse dialog.
   // <action>: the open mode for the widget.
   static FileChooserButton* new_(char* title, FileChooserAction action) {
      return gtk_file_chooser_button_new(title, action);
   }

   // Creates a new file-selecting button widget using @backend.
   // RETURNS: a new button widget.
   // <title>: the title of the browse dialog.
   // <action>: the open mode for the widget.
   // <backend>: the name of the #GtkFileSystem backend to use.
   static FileChooserButton* new_with_backend(char* title, FileChooserAction action, char* backend) {
      return gtk_file_chooser_button_new_with_backend(title, action, backend);
   }

   // Creates a #GtkFileChooserButton widget which uses @dialog as its
   // file-picking window.
   // Note that @dialog must be a #GtkDialog (or subclass) which
   // implements the #GtkFileChooser interface and must not have
   // %GTK_DIALOG_DESTROY_WITH_PARENT set.
   // Also note that the dialog needs to have its confirmative button
   // added with response %GTK_RESPONSE_ACCEPT or %GTK_RESPONSE_OK in
   // order for the button to take over the file selected in the dialog.
   // RETURNS: a new button widget.
   // <dialog>: the widget to use as dialog
   static FileChooserButton* new_with_dialog(Widget* dialog) {
      return gtk_file_chooser_button_new_with_dialog(dialog);
   }

   // Returns whether the button grabs focus when it is clicked with the mouse.
   // See gtk_file_chooser_button_set_focus_on_click().
   // the mouse.
   // RETURNS: %TRUE if the button grabs focus when it is clicked with
   int get_focus_on_click() {
      return gtk_file_chooser_button_get_focus_on_click(&this);
   }

   // Retrieves the title of the browse dialog used by @button. The returned value
   // should not be modified or freed.
   // RETURNS: a pointer to the browse dialog's title.
   char* get_title() {
      return gtk_file_chooser_button_get_title(&this);
   }

   // Retrieves the width in characters of the @button widget's entry and/or label.
   // RETURNS: an integer width (in characters) that the button will use to size itself.
   int get_width_chars() {
      return gtk_file_chooser_button_get_width_chars(&this);
   }

   // Sets whether the button will grab focus when it is clicked with the mouse.
   // Making mouse clicks not grab focus is useful in places like toolbars where
   // you don't want the keyboard focus removed from the main area of the
   // application.
   // <focus_on_click>: whether the button grabs focus when clicked with the mouse
   void set_focus_on_click(int focus_on_click) {
      gtk_file_chooser_button_set_focus_on_click(&this, focus_on_click);
   }

   // Modifies the @title of the browse dialog used by @button.
   // <title>: the new browse dialog title.
   void set_title(char* title) {
      gtk_file_chooser_button_set_title(&this, title);
   }

   // Sets the width (in characters) that @button will use to @n_chars.
   // <n_chars>: the new width, in characters.
   void set_width_chars(int n_chars) {
      gtk_file_chooser_button_set_width_chars(&this, n_chars);
   }

   // The ::file-set signal is emitted when the user selects a file.
   // Note that this signal is only emitted when the <emphasis>user</emphasis>
   // changes the file.
   extern (C) alias static void function (FileChooserButton* this_, void* user_data=null) signal_file_set;

   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:"file-set", CB/*:signal_file_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"file-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct FileChooserButtonClass {
   private HBoxClass parent_class;
   extern (C) void function (FileChooserButton* fc) file_set;
   private void* __gtk_reserved1, __gtk_reserved2, __gtk_reserved3, __gtk_reserved4, __gtk_reserved5, __gtk_reserved6, __gtk_reserved7;
}

struct FileChooserButtonPrivate {
}


// Used as a return value of handlers for the
// #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
// value determines whether the file chooser will present the stock
// confirmation dialog, accept the user's choice of a filename, or
// let the user choose another filename.
enum FileChooserConfirmation /* Version 2.8 */ {
   CONFIRM = 0,
   ACCEPT_FILENAME = 1,
   SELECT_AGAIN = 2
}
struct FileChooserDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   FileChooserDialogPrivate* priv;


   // Unintrospectable constructor: new() / gtk_file_chooser_dialog_new()
   // Creates a new #GtkFileChooserDialog.  This function is analogous to
   // gtk_dialog_new_with_buttons().
   // RETURNS: a new #GtkFileChooserDialog
   // <title>: Title of the dialog, or %NULL
   // <parent>: Transient parent of the dialog, or %NULL
   // <action>: Open or save mode for the dialog
   // <first_button_text>: stock ID or text to go in the first button, or %NULL
   alias gtk_file_chooser_dialog_new new_; // Variadic

   // Unintrospectable constructor: new_with_backend() / gtk_file_chooser_dialog_new_with_backend()
   // Creates a new #GtkFileChooserDialog with a specified backend. This is
   // especially useful if you use gtk_file_chooser_set_local_only() to allow
   // non-local files and you use a more expressive vfs, such as gnome-vfs,
   // to load files.
   // RETURNS: a new #GtkFileChooserDialog
   // <title>: Title of the dialog, or %NULL
   // <parent>: Transient parent of the dialog, or %NULL
   // <action>: Open or save mode for the dialog
   // <backend>: The name of the specific filesystem backend to use.
   // <first_button_text>: stock ID or text to go in the first button, or %NULL
   alias gtk_file_chooser_dialog_new_with_backend new_with_backend; // Variadic
}

struct FileChooserDialogClass {
   DialogClass parent_class;
}

struct FileChooserDialogPrivate {
}


// These identify the various errors that can occur while calling
// #GtkFileChooser functions.
enum FileChooserError {
   NONEXISTENT = 0,
   BAD_FILENAME = 1,
   ALREADY_EXISTS = 2,
   INCOMPLETE_HOSTNAME = 3
}
struct FileChooserWidget /* : VBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance vbox;
   VBox parent_instance;
   FileChooserWidgetPrivate* priv;


   // Creates a new #GtkFileChooserWidget.  This is a file chooser widget that can
   // be embedded in custom windows, and it is the same widget that is used by
   // #GtkFileChooserDialog.
   // RETURNS: a new #GtkFileChooserWidget
   // <action>: Open or save mode for the widget
   static FileChooserWidget* new_(FileChooserAction action) {
      return gtk_file_chooser_widget_new(action);
   }

   // Creates a new #GtkFileChooserWidget with a specified backend.  This is
   // especially useful if you use gtk_file_chooser_set_local_only() to allow
   // non-local files.  This is a file chooser widget that can be embedded in
   // custom windows and it is the same widget that is used by
   // #GtkFileChooserDialog.
   // RETURNS: a new #GtkFileChooserWidget
   // <action>: Open or save mode for the widget
   // <backend>: The name of the specific filesystem backend to use.
   static FileChooserWidget* new_with_backend(FileChooserAction action, char* backend) {
      return gtk_file_chooser_widget_new_with_backend(action, backend);
   }
}

struct FileChooserWidgetClass {
   VBoxClass parent_class;
}

struct FileChooserWidgetPrivate {
}

struct FileFilter /* : Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   Object method_parent;


   // Creates a new #GtkFileFilter with no rules added to it.
   // Such a filter doesn't accept any files, so is not
   // particularly useful until you add rules with
   // gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(),
   // or gtk_file_filter_add_custom(). To create a filter
   // that accepts any file, use:
   // |[
   // GtkFileFilter *filter = gtk_file_filter_new ();
   // gtk_file_filter_add_pattern (filter, "*");
   // ]|
   // RETURNS: a new #GtkFileFilter
   static FileFilter* new_() {
      return gtk_file_filter_new();
   }

   // Adds rule to a filter that allows files based on a custom callback
   // function. The bitfield @needed which is passed in provides information
   // about what sorts of information that the filter function needs;
   // this allows GTK+ to avoid retrieving expensive information when
   // it isn't needed by the filter.
   // <needed>: bitfield of flags indicating the information that the custom filter function needs.
   // <func>: callback function; if the function returns %TRUE, then the file will be displayed.
   // <data>: data to pass to @func
   // <notify>: function to call to free @data when it is no longer needed.
   void add_custom(FileFilterFlags needed, FileFilterFunc func, void* data, GLib2.DestroyNotify notify) {
      gtk_file_filter_add_custom(&this, needed, func, data, notify);
   }

   // Adds a rule allowing a given mime type to @filter.
   // <mime_type>: name of a MIME type
   void add_mime_type(char* mime_type) {
      gtk_file_filter_add_mime_type(&this, mime_type);
   }

   // Adds a rule allowing a shell style glob to a filter.
   // <pattern>: a shell style glob
   void add_pattern(char* pattern) {
      gtk_file_filter_add_pattern(&this, pattern);
   }

   // Adds a rule allowing image files in the formats supported
   // by GdkPixbuf.
   void add_pixbuf_formats() {
      gtk_file_filter_add_pixbuf_formats(&this);
   }

   // Tests whether a file should be displayed according to @filter.
   // The #GtkFileFilterInfo structure @filter_info should include
   // the fields returned from gtk_file_filter_get_needed().
   // This function will not typically be used by applications; it
   // is intended principally for use in the implementation of
   // #GtkFileChooser.
   // RETURNS: %TRUE if the file should be displayed
   // <filter_info>: a #GtkFileFilterInfo structure containing information about a file.
   int filter(FileFilterInfo* filter_info) {
      return gtk_file_filter_filter(&this, filter_info);
   }

   // Gets the human-readable name for the filter. See gtk_file_filter_set_name().
   // or %NULL. This value is owned by GTK+ and must not
   // be modified or freed.
   // RETURNS: The human-readable name of the filter,
   char* get_name() {
      return gtk_file_filter_get_name(&this);
   }

   // Gets the fields that need to be filled in for the structure
   // passed to gtk_file_filter_filter()
   // This function will not typically be used by applications; it
   // is intended principally for use in the implementation of
   // #GtkFileChooser.
   // calling gtk_file_filter_filter()
   // RETURNS: bitfield of flags indicating needed fields when
   FileFilterFlags get_needed() {
      return gtk_file_filter_get_needed(&this);
   }

   // Sets the human-readable name of the filter; this is the string
   // that will be displayed in the file selector user interface if
   // there is a selectable list of filters.
   // <name>: the human-readable-name for the filter, or %NULL to remove any existing name.
   void set_name(char* name=null) {
      gtk_file_filter_set_name(&this, name);
   }
}

enum FileFilterFlags {
   FILENAME = 1,
   URI = 2,
   DISPLAY_NAME = 4,
   MIME_TYPE = 8
}
extern (C) alias int function (FileFilterInfo* filter_info, void* data) FileFilterFunc;

struct FileFilterInfo {
   FileFilterFlags contains;
   char* filename, uri, display_name, mime_type;
}

struct FileSelection /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   Widget* dir_list, file_list, selection_entry, selection_text, main_vbox, ok_button, cancel_button, help_button, history_pulldown, history_menu;
   GLib2.List* history_list;
   Widget* fileop_dialog, fileop_entry;
   char* fileop_file;
   void* cmpl_state;
   Widget* fileop_c_dir, fileop_del_file, fileop_ren_file, button_area, action_area;
   private void*[0] selected_names;
   private char* last_selected;

   static FileSelection* new_(char* title) {
      return gtk_file_selection_new(title);
   }
   void complete(char* pattern) {
      gtk_file_selection_complete(&this, pattern);
   }

   // This function returns the selected filename in the GLib file name
   // encoding. To convert to UTF-8, call g_filename_to_utf8(). The
   // returned string points to a statically allocated buffer and should
   // be copied if you plan to keep it around.
   // If no file is selected then the selected directory path is returned.
   // RETURNS: currently-selected filename in the on-disk encoding.
   char* get_filename() {
      return gtk_file_selection_get_filename(&this);
   }

   // Determines whether or not the user is allowed to select multiple files in
   // the file list. See gtk_file_selection_set_select_multiple().
   // file list
   // RETURNS: %TRUE if the user is allowed to select multiple files in the
   int get_select_multiple() {
      return gtk_file_selection_get_select_multiple(&this);
   }

   // Unintrospectable method: get_selections() / gtk_file_selection_get_selections()
   // Retrieves the list of file selections the user has made in the dialog box.
   // This function is intended for use when the user can select multiple files
   // in the file list. 
   // The filenames are in the GLib file name encoding. To convert to
   // UTF-8, call g_filename_to_utf8() on each string.
   // g_strfreev() to free it.
   // RETURNS: a newly-allocated %NULL-terminated array of strings. Use
   char** get_selections() {
      return gtk_file_selection_get_selections(&this);
   }
   void hide_fileop_buttons() {
      gtk_file_selection_hide_fileop_buttons(&this);
   }

   // Sets a default path for the file requestor. If @filename includes a
   // directory path, then the requestor will open with that path as its
   // current working directory.
   // This has the consequence that in order to open the requestor with a 
   // working directory and an empty filename, @filename must have a trailing
   // directory separator.
   // The encoding of @filename is preferred GLib file name encoding, which
   // may not be UTF-8. See g_filename_from_utf8().
   // <filename>: a string to set as the default file name.
   void set_filename(char* filename) {
      gtk_file_selection_set_filename(&this, filename);
   }

   // Sets whether the user is allowed to select multiple files in the file list.
   // Use gtk_file_selection_get_selections () to get the list of selected files.
   // <select_multiple>: whether or not the user is allowed to select multiple files in the file list.
   void set_select_multiple(int select_multiple) {
      gtk_file_selection_set_select_multiple(&this, select_multiple);
   }
   void show_fileop_buttons() {
      gtk_file_selection_show_fileop_buttons(&this);
   }
}

struct FileSelectionClass {
   DialogClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Fixed /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children;

   static Fixed* new_() {
      return gtk_fixed_new();
   }

   // Gets whether the #GtkFixed has its own #GdkWindow.
   // See gtk_fixed_set_has_window().
   // RETURNS: %TRUE if @fixed has its own window.
   int get_has_window() {
      return gtk_fixed_get_has_window(&this);
   }
   void move(Widget* widget, int x, int y) {
      gtk_fixed_move(&this, widget, x, y);
   }
   void put(Widget* widget, int x, int y) {
      gtk_fixed_put(&this, widget, x, y);
   }

   // Sets whether a #GtkFixed widget is created with a separate
   // #GdkWindow for @widget->window or not. (By default, it will be
   // created with no separate #GdkWindow). This function must be called
   // while the #GtkFixed is not realized, for instance, immediately after the
   // window is created.
   // This function was added to provide an easy migration path for
   // older applications which may expect #GtkFixed to have a separate window.
   // <has_window>: %TRUE if a separate window should be created
   void set_has_window(int has_window) {
      gtk_fixed_set_has_window(&this, has_window);
   }
}

struct FixedChild {
   Widget* widget;
   int x, y;
}

struct FixedClass {
   ContainerClass parent_class;
}

struct FontButton /* : Button */ {
   alias button this;
   alias button super_;
   Button button;
   private FontButtonPrivate* priv;


   // Creates a new font picker widget.
   // RETURNS: a new font picker widget.
   static FontButton* new_() {
      return gtk_font_button_new();
   }

   // Creates a new font picker widget.
   // RETURNS: a new font picker widget.
   // <fontname>: Name of font to display in font selection dialog
   static FontButton* new_with_font(char* fontname) {
      return gtk_font_button_new_with_font(fontname);
   }

   // Retrieves the name of the currently selected font. This name includes
   // style and size information as well. If you want to render something
   // with the font, use this string with pango_font_description_from_string() .
   // If you're interested in peeking certain values (family name,
   // style, size, weight) just query these properties from the
   // #PangoFontDescription object.
   // RETURNS: an internal copy of the font name which must not be freed.
   char* get_font_name() {
      return gtk_font_button_get_font_name(&this);
   }

   // Returns whether the font size will be shown in the label.
   // RETURNS: whether the font size will be shown in the label.
   int get_show_size() {
      return gtk_font_button_get_show_size(&this);
   }

   // Returns whether the name of the font style will be shown in the label.
   // RETURNS: whether the font style will be shown in the label.
   int get_show_style() {
      return gtk_font_button_get_show_style(&this);
   }

   // Retrieves the title of the font selection dialog.
   // RETURNS: an internal copy of the title string which must not be freed.
   char* get_title() {
      return gtk_font_button_get_title(&this);
   }

   // Returns whether the selected font is used in the label.
   // RETURNS: whether the selected font is used in the label.
   int get_use_font() {
      return gtk_font_button_get_use_font(&this);
   }

   // Returns whether the selected size is used in the label.
   // RETURNS: whether the selected size is used in the label.
   int get_use_size() {
      return gtk_font_button_get_use_size(&this);
   }

   // Sets or updates the currently-displayed font in font picker dialog.
   // font selection dialog exists, otherwise %FALSE.
   // RETURNS: Return value of gtk_font_selection_dialog_set_font_name() if the
   // <fontname>: Name of font to display in font selection dialog
   int set_font_name(char* fontname) {
      return gtk_font_button_set_font_name(&this, fontname);
   }

   // If @show_size is %TRUE, the font size will be displayed along with the name of the selected font.
   // <show_size>: %TRUE if font size should be displayed in dialog.
   void set_show_size(int show_size) {
      gtk_font_button_set_show_size(&this, show_size);
   }

   // If @show_style is %TRUE, the font style will be displayed along with name of the selected font.
   // <show_style>: %TRUE if font style should be displayed in label.
   void set_show_style(int show_style) {
      gtk_font_button_set_show_style(&this, show_style);
   }

   // Sets the title for the font selection dialog.
   // <title>: a string containing the font selection dialog title
   void set_title(char* title) {
      gtk_font_button_set_title(&this, title);
   }

   // If @use_font is %TRUE, the font name will be written using the selected font.
   // <use_font>: If %TRUE, font name will be written using font chosen.
   void set_use_font(int use_font) {
      gtk_font_button_set_use_font(&this, use_font);
   }

   // If @use_size is %TRUE, the font name will be written using the selected size.
   // <use_size>: If %TRUE, font name will be written using the selected size.
   void set_use_size(int use_size) {
      gtk_font_button_set_use_size(&this, use_size);
   }

   // The ::font-set signal is emitted when the user selects a font. 
   // When handling this signal, use gtk_font_button_get_font_name() 
   // to find out which font was just selected.
   // Note that this signal is only emitted when the <emphasis>user</emphasis>
   // changes the font. If you need to react to programmatic font changes
   // as well, use the notify::font-name signal.
   extern (C) alias static void function (FontButton* this_, void* user_data=null) signal_font_set;

   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:"font-set", CB/*:signal_font_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"font-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct FontButtonClass {
   ButtonClass parent_class;
   extern (C) void function (FontButton* gfp) font_set;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct FontButtonPrivate {
}

struct FontSelection /* : VBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance vbox;
   VBox parent_instance;
   Widget* font_entry, family_list, font_style_entry, face_list, size_entry, size_list, pixels_button, points_button, filter_button, preview_entry;
   Pango.FontFamily* family;
   Pango.FontFace* face;
   int size;
   Gdk2.Font* font;


   // Creates a new #GtkFontSelection.
   // RETURNS: a n ew #GtkFontSelection
   static FontSelection* new_() {
      return gtk_font_selection_new();
   }

   // Gets the #PangoFontFace representing the selected font group
   // details (i.e. family, slant, weight, width, etc).
   // selected font group details. The returned object is owned by
   // RETURNS: A #PangoFontFace representing the
   Pango.FontFace* get_face() {
      return gtk_font_selection_get_face(&this);
   }

   // This returns the #GtkTreeView which lists all styles available for
   // the selected font. For example, 'Regular', 'Bold', etc.
   // RETURNS: A #GtkWidget that is part of @fontsel
   Widget* get_face_list() {
      return gtk_font_selection_get_face_list(&this);
   }

   // Gets the #PangoFontFamily representing the selected font family.
   // selected font family. Font families are a collection of font
   // faces. The returned object is owned by @fontsel and must not
   // be modified or freed.
   // RETURNS: A #PangoFontFamily representing the
   Pango.FontFamily* get_family() {
      return gtk_font_selection_get_family(&this);
   }

   // This returns the #GtkTreeView that lists font families, for
   // example, 'Sans', 'Serif', etc.
   // RETURNS: A #GtkWidget that is part of @fontsel
   Widget* get_family_list() {
      return gtk_font_selection_get_family_list(&this);
   }

   // Gets the currently-selected font.
   // RETURNS: A #GdkFont.
   Gdk2.Font* /*new*/ get_font() {
      return gtk_font_selection_get_font(&this);
   }

   // Gets the currently-selected font name. 
   // Note that this can be a different string than what you set with 
   // gtk_font_selection_set_font_name(), as the font selection widget may 
   // normalize font names and thus return a string with a different structure. 
   // For example, "Helvetica Italic Bold 12" could be normalized to 
   // "Helvetica Bold Italic 12". Use pango_font_description_equal()
   // if you want to compare two font descriptions.
   // no font is selected. You must free this string with g_free().
   // RETURNS: A string with the name of the current font, or %NULL if
   char* /*new*/ get_font_name() {
      return gtk_font_selection_get_font_name(&this);
   }

   // This returns the #GtkEntry used to display the font as a preview.
   // RETURNS: A #GtkWidget that is part of @fontsel
   Widget* get_preview_entry() {
      return gtk_font_selection_get_preview_entry(&this);
   }

   // Gets the text displayed in the preview area.
   // This string is owned by the widget and should not be 
   // modified or freed
   // RETURNS: the text displayed in the preview area.
   char* get_preview_text() {
      return gtk_font_selection_get_preview_text(&this);
   }

   // The selected font size.
   // or -1 if no font size is selected.
   // RETURNS: A n integer representing the selected font size,
   int get_size() {
      return gtk_font_selection_get_size(&this);
   }

   // This returns the #GtkEntry used to allow the user to edit the font
   // number manually instead of selecting it from the list of font sizes.
   // RETURNS: A #GtkWidget that is part of @fontsel
   Widget* get_size_entry() {
      return gtk_font_selection_get_size_entry(&this);
   }

   // This returns the #GtkTreeeView used to list font sizes.
   // RETURNS: A #GtkWidget that is part of @fontsel
   Widget* get_size_list() {
      return gtk_font_selection_get_size_list(&this);
   }

   // Sets the currently-selected font. 
   // Note that the @fontsel needs to know the screen in which it will appear 
   // for this to work; this can be guaranteed by simply making sure that the 
   // such font exists or if the @fontsel doesn't belong to a particular 
   // screen yet.
   // RETURNS: %TRUE if the font could be set successfully; %FALSE if no
   // <fontname>: a font name like "Helvetica 12" or "Times Bold 18"
   int set_font_name(char* fontname) {
      return gtk_font_selection_set_font_name(&this, fontname);
   }

   // Sets the text displayed in the preview area.
   // The @text is used to show how the selected font looks.
   // <text>: the text to display in the preview area
   void set_preview_text(char* text) {
      gtk_font_selection_set_preview_text(&this, text);
   }
}

struct FontSelectionClass {
   VBoxClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct FontSelectionDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   private Widget* fontsel, main_vbox, action_area;
   Widget* ok_button, apply_button, cancel_button;
   private int dialog_width;
   private int auto_resize;


   // Creates a new #GtkFontSelectionDialog.
   // RETURNS: a new #GtkFontSelectionDialog
   // <title>: the title of the dialog window
   static FontSelectionDialog* new_(char* title) {
      return gtk_font_selection_dialog_new(title);
   }

   // Unintrospectable method: get_apply_button() / gtk_font_selection_dialog_get_apply_button()
   // Obtains a button. The button doesn't have any function.
   // RETURNS: a #GtkWidget
   Widget* get_apply_button() {
      return gtk_font_selection_dialog_get_apply_button(&this);
   }

   // Gets the 'Cancel' button.
   // for the 'Cancel' button.
   // RETURNS: the #GtkWidget used in the dialog
   Widget* get_cancel_button() {
      return gtk_font_selection_dialog_get_cancel_button(&this);
   }

   // Gets the currently-selected font.
   // currently selected font in the dialog, or %NULL if no font is selected
   // RETURNS: the #GdkFont from the #GtkFontSelection for the
   Gdk2.Font* /*new*/ get_font() {
      return gtk_font_selection_dialog_get_font(&this);
   }

   // Gets the currently-selected font name.
   // Note that this can be a different string than what you set with 
   // gtk_font_selection_dialog_set_font_name(), as the font selection widget
   // may normalize font names and thus return a string with a different 
   // structure. For example, "Helvetica Italic Bold 12" could be normalized 
   // to "Helvetica Bold Italic 12".  Use pango_font_description_equal()
   // if you want to compare two font descriptions.
   // font is selected. You must free this string with g_free().
   // RETURNS: A string with the name of the current font, or %NULL if no
   char* /*new*/ get_font_name() {
      return gtk_font_selection_dialog_get_font_name(&this);
   }

   // Retrieves the #GtkFontSelection widget embedded in the dialog.
   // RETURNS: the embedded #GtkFontSelection
   Widget* get_font_selection() {
      return gtk_font_selection_dialog_get_font_selection(&this);
   }

   // Gets the 'OK' button.
   // for the 'OK' button.
   // RETURNS: the #GtkWidget used in the dialog
   Widget* get_ok_button() {
      return gtk_font_selection_dialog_get_ok_button(&this);
   }

   // Gets the text displayed in the preview area.
   // This string is owned by the widget and should not be 
   // modified or freed
   // RETURNS: the text displayed in the preview area.
   char* get_preview_text() {
      return gtk_font_selection_dialog_get_preview_text(&this);
   }

   // Sets the currently selected font.
   // RETURNS: %TRUE if the font selected in @fsd is now the
   // <fontname>: a font name like "Helvetica 12" or "Times Bold 18"
   int set_font_name(char* fontname) {
      return gtk_font_selection_dialog_set_font_name(&this, fontname);
   }

   // Sets the text displayed in the preview area.
   // <text>: the text to display in the preview area
   void set_preview_text(char* text) {
      gtk_font_selection_dialog_set_preview_text(&this, text);
   }
}

struct FontSelectionDialogClass {
   DialogClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Frame /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   Widget* label_widget;
   short shadow_type;
   float label_xalign, label_yalign;
   Allocation child_allocation;


   // Creates a new #GtkFrame, with optional label @label.
   // If @label is %NULL, the label is omitted.
   // RETURNS: a new #GtkFrame widget
   // <label>: the text to use as the label of the frame
   static Frame* new_(char* label) {
      return gtk_frame_new(label);
   }

   // If the frame's label widget is a #GtkLabel, returns the
   // text in the label widget. (The frame will have a #GtkLabel
   // for the label widget if a non-%NULL argument was passed
   // to gtk_frame_new().)
   // was no label widget or the lable widget was not
   // a #GtkLabel. This string is owned by GTK+ and
   // must not be modified or freed.
   // RETURNS: the text in the label, or %NULL if there
   char* get_label() {
      return gtk_frame_get_label(&this);
   }

   // Retrieves the X and Y alignment of the frame's label. See
   // gtk_frame_set_label_align().
   // <xalign>: location to store X alignment of frame's label, or %NULL
   // <yalign>: location to store X alignment of frame's label, or %NULL
   void get_label_align(/*out*/ float* xalign=null, /*out*/ float* yalign=null) {
      gtk_frame_get_label_align(&this, xalign, yalign);
   }

   // Retrieves the label widget for the frame. See
   // gtk_frame_set_label_widget().
   // RETURNS: the label widget, or %NULL if there is none.
   Widget* get_label_widget() {
      return gtk_frame_get_label_widget(&this);
   }

   // Retrieves the shadow type of the frame. See
   // gtk_frame_set_shadow_type().
   // RETURNS: the current shadow type of the frame.
   ShadowType get_shadow_type() {
      return gtk_frame_get_shadow_type(&this);
   }

   // Sets the text of the label. If @label is %NULL,
   // the current label is removed.
   // <label>: the text to use as the label of the frame
   void set_label(char* label=null) {
      gtk_frame_set_label(&this, label);
   }

   // Sets the alignment of the frame widget's label. The
   // default values for a newly created frame are 0.0 and 0.5.
   // <xalign>: The position of the label along the top edge of the widget. A value of 0.0 represents left alignment; 1.0 represents right alignment.
   // <yalign>: The y alignment of the label. A value of 0.0 aligns under the frame; 1.0 aligns above the frame. If the values are exactly 0.0 or 1.0 the gap in the frame won't be painted because the label will be completely above or below the frame.
   void set_label_align(float xalign, float yalign) {
      gtk_frame_set_label_align(&this, xalign, yalign);
   }

   // Sets the label widget for the frame. This is the widget that
   // will appear embedded in the top edge of the frame as a
   // title.
   // <label_widget>: the new label widget
   void set_label_widget(Widget* label_widget) {
      gtk_frame_set_label_widget(&this, label_widget);
   }

   // Sets the shadow type for @frame.
   // <type>: the new #GtkShadowType
   void set_shadow_type(ShadowType type) {
      gtk_frame_set_shadow_type(&this, type);
   }
}

struct FrameClass {
   BinClass parent_class;
   extern (C) void function (Frame* frame, Allocation* allocation) compute_child_allocation;
}

extern (C) alias int function (void* data) Function;

struct GammaCurve /* : VBox */ {
   alias vbox this;
   alias vbox super_;
   VBox vbox;
   Widget* table, curve;
   Widget*[5] button;
   float gamma;
   Widget* gamma_dialog, gamma_text;

   static GammaCurve* new_() {
      return gtk_gamma_curve_new();
   }
}

struct GammaCurveClass {
   VBoxClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// #GtkHBox is a container that organizes child widgets into a single row.
// Use the #GtkBox packing interface to determine the arrangement,
// spacing, width, and alignment of #GtkHBox children.
// All children are allocated the same height.
struct HBox /* : Box */ {
   alias box this;
   alias box super_;
   Box box;


   // Creates a new #GtkHBox.
   // RETURNS: a new #GtkHBox.
   // <homogeneous>: %TRUE if all children are to be given equal space allotments.
   // <spacing>: the number of pixels to place by default between children.
   static HBox* new_(int homogeneous, int spacing) {
      return gtk_hbox_new(homogeneous, spacing);
   }
}

struct HBoxClass {
   BoxClass parent_class;
}

struct HButtonBox /* : ButtonBox */ {
   alias button_box this;
   alias button_box super_;
   alias button_box buttonbox;
   ButtonBox button_box;

   static HButtonBox* new_() {
      return gtk_hbutton_box_new();
   }
   static ButtonBoxStyle get_layout_default() {
      return gtk_hbutton_box_get_layout_default();
   }
   static int get_spacing_default() {
      return gtk_hbutton_box_get_spacing_default();
   }
   static void set_layout_default(ButtonBoxStyle layout) {
      gtk_hbutton_box_set_layout_default(layout);
   }
   static void set_spacing_default(int spacing) {
      gtk_hbutton_box_set_spacing_default(spacing);
   }
}

struct HButtonBoxClass {
   ButtonBoxClass parent_class;
}

struct HPaned /* : Paned */ {
   alias paned this;
   alias paned super_;
   Paned paned;

   static HPaned* new_() {
      return gtk_hpaned_new();
   }
}

struct HPanedClass {
   PanedClass parent_class;
}

struct HRuler /* : Ruler */ {
   alias ruler this;
   alias ruler super_;
   Ruler ruler;

   static HRuler* new_() {
      return gtk_hruler_new();
   }
}

struct HRulerClass {
   RulerClass parent_class;
}

struct HSV /* : Widget */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance widget;
   Widget parent_instance;
   void* priv;


   // Creates a new HSV color selector.
   // RETURNS: A newly-created HSV color selector.
   static HSV* new_() {
      return gtk_hsv_new();
   }

   // Converts a color from HSV space to RGB.
   // Input values must be in the [0.0, 1.0] range; 
   // output values will be in the same range.
   // <h>: Hue
   // <s>: Saturation
   // <v>: Value
   // <r>: Return value for the red component
   // <g>: Return value for the green component
   // <b>: Return value for the blue component
   static void to_rgb(double h, double s, double v, /*out*/ double* r, /*out*/ double* g, /*out*/ double* b) {
      gtk_hsv_to_rgb(h, s, v, r, g, b);
   }

   // Queries the current color in an HSV color selector.
   // Returned values will be in the [0.0, 1.0] range.
   // <h>: Return value for the hue
   // <s>: Return value for the saturation
   // <v>: Return value for the value
   void get_color(/*out*/ double* h, /*out*/ double* s, /*out*/ double* v) {
      gtk_hsv_get_color(&this, h, s, v);
   }

   // Queries the size and ring width of an HSV color selector.
   // <size>: Return value for the diameter of the hue ring
   // <ring_width>: Return value for the width of the hue ring
   void get_metrics(/*out*/ int* size, /*out*/ int* ring_width) {
      gtk_hsv_get_metrics(&this, size, ring_width);
   }

   // An HSV color selector can be said to be adjusting if multiple rapid
   // changes are being made to its value, for example, when the user is 
   // adjusting the value with the mouse. This function queries whether 
   // the HSV color selector is being adjusted or not.
   // since they may be transitory, or %FALSE if they should consider
   // the color value status to be final.
   // RETURNS: %TRUE if clients can ignore changes to the color value,
   int is_adjusting() {
      return gtk_hsv_is_adjusting(&this);
   }

   // Sets the current color in an HSV color selector.
   // Color component values must be in the [0.0, 1.0] range.
   // <h>: Hue
   // <s>: Saturation
   // <v>: Value
   void set_color(double h, double s, double v) {
      gtk_hsv_set_color(&this, h, s, v);
   }

   // Sets the size and ring width of an HSV color selector.
   // <size>: Diameter for the hue ring
   // <ring_width>: Width of the hue ring
   void set_metrics(int size, int ring_width) {
      gtk_hsv_set_metrics(&this, size, ring_width);
   }
   extern (C) alias static void function (HSV* 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);
   }
   extern (C) alias static void function (HSV* this_, DirectionType* object, void* user_data=null) signal_move;
   ulong signal_connect(string name:"move", CB/*:signal_move*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct HSVClass {
   WidgetClass parent_class;
   extern (C) void function (HSV* hsv) changed;
   extern (C) void function (HSV* hsv, DirectionType type) move;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct HScale /* : Scale */ {
   alias scale this;
   alias scale super_;
   Scale scale;

   static HScale* new_(Adjustment* adjustment) {
      return gtk_hscale_new(adjustment);
   }

   // Creates a new horizontal scale widget that lets the user input a
   // number between @min and @max (including @min and @max) with the
   // increment @step.  @step must be nonzero; it's the distance the
   // slider moves when using the arrow keys to adjust the scale value.
   // Note that the way in which the precision is derived works best if @step
   // is a power of ten. If the resulting precision is not suitable for your
   // needs, use gtk_scale_set_digits() to correct it.
   // RETURNS: a new #GtkHScale
   // <min>: minimum value
   // <max>: maximum value
   // <step>: step increment (tick size) used with keyboard shortcuts
   static HScale* new_with_range(double min, double max, double step) {
      return gtk_hscale_new_with_range(min, max, step);
   }
}

struct HScaleClass {
   ScaleClass parent_class;
}

struct HScrollbar /* : Scrollbar */ {
   alias scrollbar this;
   alias scrollbar super_;
   Scrollbar scrollbar;


   // Creates a new horizontal scrollbar.
   // RETURNS: the new #GtkHScrollbar
   // <adjustment>: the #GtkAdjustment to use, or %NULL to create a new adjustment
   static HScrollbar* new_(Adjustment* adjustment=null) {
      return gtk_hscrollbar_new(adjustment);
   }
}

struct HScrollbarClass {
   ScrollbarClass parent_class;
}

struct HSeparator /* : Separator */ {
   alias separator this;
   alias separator super_;
   Separator separator;

   static HSeparator* new_() {
      return gtk_hseparator_new();
   }
}

struct HSeparatorClass {
   SeparatorClass parent_class;
}

struct HandleBox /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   Gdk2.Window* bin_window, float_window;
   ShadowType shadow_type;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "handle_position", 2,
   uint, "float_window_mapped", 1,
   uint, "child_detached", 1,
   uint, "in_drag", 1,
   uint, "shrink_on_detach", 1,
   int, "snap_edge", 3,
    uint, "__dummy32A", 23));
   int deskoff_x, deskoff_y;
   Allocation attach_allocation, float_allocation;

   static HandleBox* new_() {
      return gtk_handle_box_new();
   }

   // Whether the handlebox's child is currently detached.
   // RETURNS: %TRUE if the child is currently detached, otherwise %FALSE
   int get_child_detached() {
      return gtk_handle_box_get_child_detached(&this);
   }

   // Gets the handle position of the handle box. See
   // gtk_handle_box_set_handle_position().
   // RETURNS: the current handle position.
   PositionType get_handle_position() {
      return gtk_handle_box_get_handle_position(&this);
   }

   // Gets the type of shadow drawn around the handle box. See
   // gtk_handle_box_set_shadow_type().
   // RETURNS: the type of shadow currently drawn around the handle box.
   ShadowType get_shadow_type() {
      return gtk_handle_box_get_shadow_type(&this);
   }

   // Gets the edge used for determining reattachment of the handle box. See
   // gtk_handle_box_set_snap_edge().
   // is determined (as per default) from the handle position.
   // RETURNS: the edge used for determining reattachment, or (GtkPositionType)-1 if this
   PositionType get_snap_edge() {
      return gtk_handle_box_get_snap_edge(&this);
   }
   void set_handle_position(PositionType position) {
      gtk_handle_box_set_handle_position(&this, position);
   }
   void set_shadow_type(ShadowType type) {
      gtk_handle_box_set_shadow_type(&this, type);
   }
   void set_snap_edge(PositionType edge) {
      gtk_handle_box_set_snap_edge(&this, edge);
   }
   extern (C) alias static void function (HandleBox* this_, Widget* object, void* user_data=null) signal_child_attached;

   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:"child-attached", CB/*:signal_child_attached*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"child-attached",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (HandleBox* this_, Widget* object, void* user_data=null) signal_child_detached;
   ulong signal_connect(string name:"child-detached", CB/*:signal_child_detached*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"child-detached",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct HandleBoxClass {
   BinClass parent_class;
   extern (C) void function (HandleBox* handle_box, Widget* child) child_attached;
   extern (C) void function (HandleBox* handle_box, Widget* child) child_detached;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// #GtkIMContext defines the interface for GTK+ input methods. An input method
// is used by GTK+ text input widgets like #GtkEntry to map from key events to
// Unicode character strings.
// The user may change the current input method via a context menu, unless the   
// #GtkSettings:gtk-show-input-method-menu GtkSettings property is set to FALSE. 
// The default input method can be set programmatically via the 
// #GtkSettings:gtk-im-module GtkSettings property. Alternatively, you may set 
// the GTK_IM_MODULE environment variable as documented in #gtk-running.
// The #GtkEntry #GtkEntry:im-module and #GtkTextView #GtkTextView:im-module 
// properties may also be used to set input methods for specific widget 
// instances. For instance, a certain entry widget might be expected to contain 
// certain characters which would be easier to input with a certain input 
// method.
// An input method may consume multiple key events in sequence and finally
// output the composed result. This is called preediting, and an input method
// may provide feedback about this process by displaying the intermediate
// composition states as preedit text. For instance, the default GTK+ input
// method implements the input of arbitrary Unicode code points by holding down
// the Control and Shift keys and then typing "U" followed by the hexadecimal
// digits of the code point.  When releasing the Control and Shift keys,
// preediting ends and the character is inserted as text. Ctrl+Shift+u20AC for
// example results in the € sign.
// Additional input methods can be made available for use by GTK+ widgets as
// loadable modules. An input method module is a small shared library which
// implements a subclass of #GtkIMContext or #GtkIMContextSimple and exports
// these four functions:
// <informalexample><programlisting>
// void im_module_init(#GTypeModule *module);
// </programlisting></informalexample>
// This function should register the #GType of the #GtkIMContext subclass which
// implements the input method by means of g_type_module_register_type(). Note
// that g_type_register_static() cannot be used as the type needs to be
// registered dynamically.
// <informalexample><programlisting>
// void im_module_exit(void);
// </programlisting></informalexample>
// Here goes any cleanup code your input method might require on module unload.
// <informalexample><programlisting>
// void im_module_list(const #GtkIMContextInfo ***contexts, int *n_contexts)
// {
// *contexts = info_list;
// *n_contexts = G_N_ELEMENTS (info_list);
// }
// </programlisting></informalexample>
// This function returns the list of input methods provided by the module. The
// example implementation above shows a common solution and simply returns a
// pointer to statically defined array of #GtkIMContextInfo items for each
// provided input method.
// <informalexample><programlisting>
// #GtkIMContext * im_module_create(const #gchar *context_id);
// </programlisting></informalexample>
// This function should return a pointer to a newly created instance of the
// #GtkIMContext subclass identified by @context_id. The context ID is the same
// as specified in the #GtkIMContextInfo array returned by im_module_list().
// After a new loadable input method module has been installed on the system,
// the configuration file <filename>gtk.immodules</filename> needs to be
// regenerated by <link linkend="gtk-query-immodules-2.0">gtk-query-immodules-2.0</link>,
// in order for the new input method to become available to GTK+ applications.
struct IMContext /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;


   // Asks the widget that the input context is attached to to delete
   // characters around the cursor position by emitting the
   // GtkIMContext::delete_surrounding signal. Note that @offset and @n_chars
   // are in characters not in bytes which differs from the usage other
   // places in #GtkIMContext.
   // In order to use this function, you should first call
   // gtk_im_context_get_surrounding() to get the current context, and
   // call this function immediately afterwards to make sure that you
   // know what you are deleting. You should also account for the fact
   // that even if the signal was handled, the input context might not
   // have deleted all the characters that were requested to be deleted.
   // This function is used by an input method that wants to make
   // subsitutions in the existing text in response to new input. It is
   // not useful for applications.
   // RETURNS: %TRUE if the signal was handled.
   // <offset>: offset from cursor position in chars; a negative value means start before the cursor.
   // <n_chars>: number of characters to delete.
   int delete_surrounding(int offset, int n_chars) {
      return gtk_im_context_delete_surrounding(&this, offset, n_chars);
   }

   // Allow an input method to internally handle key press and release 
   // events. If this function returns %TRUE, then no further processing
   // should be done for this key event.
   // RETURNS: %TRUE if the input method handled the key event.
   // <event>: the key event
   int filter_keypress(Gdk2.EventKey* event) {
      return gtk_im_context_filter_keypress(&this, event);
   }

   // Notify the input method that the widget to which this
   // input context corresponds has gained focus. The input method
   // may, for example, change the displayed feedback to reflect
   // this change.
   void focus_in() {
      gtk_im_context_focus_in(&this);
   }

   // Notify the input method that the widget to which this
   // input context corresponds has lost focus. The input method
   // may, for example, change the displayed feedback or reset the contexts
   // state to reflect this change.
   void focus_out() {
      gtk_im_context_focus_out(&this);
   }

   // Retrieve the current preedit string for the input context,
   // and a list of attributes to apply to the string.
   // This string should be displayed inserted at the insertion
   // point.
   // <str>: location to store the retrieved string. The string retrieved must be freed with g_free().
   // <attrs>: location to store the retrieved attribute list.  When you are done with this list, you must unreference it with pango_attr_list_unref().
   // <cursor_pos>: location to store position of cursor (in characters) within the preedit string.
   void get_preedit_string(/*out*/ char** str, /*out*/ Pango.AttrList** attrs, /*out*/ int* cursor_pos) {
      gtk_im_context_get_preedit_string(&this, str, attrs, cursor_pos);
   }

   // Retrieves context around the insertion point. Input methods
   // typically want context in order to constrain input text based on
   // existing text; this is important for languages such as Thai where
   // only some sequences of characters are allowed.
   // This function is implemented by emitting the
   // GtkIMContext::retrieve_surrounding signal on the input method; in
   // response to this signal, a widget should provide as much context as
   // is available, up to an entire paragraph, by calling
   // gtk_im_context_set_surrounding(). Note that there is no obligation
   // for a widget to respond to the ::retrieve_surrounding signal, so input
   // methods must be prepared to function without context.
   // you must free the result stored in *text.
   // RETURNS: %TRUE if surrounding text was provided; in this case
   // <text>: location to store a UTF-8 encoded string of text holding context around the insertion point. If the function returns %TRUE, then you must free the result stored in this location with g_free().
   // <cursor_index>: (out) location to store byte index of the insertion cursor within @text.
   int get_surrounding(/*out*/ char** text, int* cursor_index) {
      return gtk_im_context_get_surrounding(&this, text, cursor_index);
   }

   // Notify the input method that a change such as a change in cursor
   // position has been made. This will typically cause the input
   // method to clear the preedit state.
   void reset() {
      gtk_im_context_reset(&this);
   }

   // Set the client window for the input context; this is the
   // #GdkWindow in which the input appears. This window is
   // used in order to correctly position status windows, and may
   // also be used for purposes internal to the input method.
   // <window>: the client window. This may be %NULL to indicate that the previous client window no longer exists.
   void set_client_window(Gdk2.Window* window=null) {
      gtk_im_context_set_client_window(&this, window);
   }

   // Notify the input method that a change in cursor 
   // position has been made. The location is relative to the client
   // window.
   // <area>: new location
   void set_cursor_location(Gdk2.Rectangle* area) {
      gtk_im_context_set_cursor_location(&this, area);
   }

   // Sets surrounding context around the insertion point and preedit
   // string. This function is expected to be called in response to the
   // GtkIMContext::retrieve_surrounding signal, and will likely have no
   // effect if called at other times.
   // <text>: text surrounding the insertion point, as UTF-8. the preedit string should not be included within
   // <len>: the length of @text, or -1 if @text is nul-terminated
   // <cursor_index>: the byte index of the insertion cursor within @text.
   void set_surrounding(char* text, int len, int cursor_index) {
      gtk_im_context_set_surrounding(&this, text, len, cursor_index);
   }

   // Sets whether the IM context should use the preedit string
   // to display feedback. If @use_preedit is FALSE (default
   // is TRUE), then the IM context may use some other method to display
   // feedback, such as displaying it in a child of the root window.
   // <use_preedit>: whether the IM context should use the preedit string.
   void set_use_preedit(int use_preedit) {
      gtk_im_context_set_use_preedit(&this, use_preedit);
   }

   // The ::commit signal is emitted when a complete input sequence
   // has been entered by the user. This can be a single character
   // immediately after a key press or the final result of preediting.
   // <str>: the completed character(s) entered by the user
   extern (C) alias static void function (IMContext* this_, char* str, void* user_data=null) signal_commit;

   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:"commit", CB/*:signal_commit*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"commit",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::delete-surrounding signal is emitted when the input method
   // needs to delete all or part of the context surrounding the cursor.
   // RETURNS: %TRUE if the signal was handled.
   // <offset>: the character offset from the cursor position of the text to be deleted. A negative value indicates a position before the cursor.
   // <n_chars>: the number of characters to be deleted
   extern (C) alias static c_int function (IMContext* this_, int offset, int n_chars, void* user_data=null) signal_delete_surrounding;
   ulong signal_connect(string name:"delete-surrounding", CB/*:signal_delete_surrounding*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-surrounding",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::preedit-changed signal is emitted whenever the preedit sequence
   // currently being entered has changed.  It is also emitted at the end of
   // a preedit sequence, in which case
   // gtk_im_context_get_preedit_string() returns the empty string.
   extern (C) alias static void function (IMContext* this_, void* user_data=null) signal_preedit_changed;
   ulong signal_connect(string name:"preedit-changed", CB/*:signal_preedit_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preedit-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::preedit-end signal is emitted when a preediting sequence
   // has been completed or canceled.
   extern (C) alias static void function (IMContext* this_, void* user_data=null) signal_preedit_end;
   ulong signal_connect(string name:"preedit-end", CB/*:signal_preedit_end*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preedit-end",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::preedit-start signal is emitted when a new preediting sequence
   // starts.
   extern (C) alias static void function (IMContext* this_, void* user_data=null) signal_preedit_start;
   ulong signal_connect(string name:"preedit-start", CB/*:signal_preedit_start*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preedit-start",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::retrieve-surrounding signal is emitted when the input method
   // requires the context surrounding the cursor.  The callback should set
   // the input method surrounding context by calling the
   // gtk_im_context_set_surrounding() method.
   // RETURNS: %TRUE if the signal was handled.
   extern (C) alias static c_int function (IMContext* this_, void* user_data=null) signal_retrieve_surrounding;
   ulong signal_connect(string name:"retrieve-surrounding", CB/*:signal_retrieve_surrounding*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"retrieve-surrounding",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct IMContextClass {
   private ObjectClass parent_class;
   extern (C) void function (IMContext* context) preedit_start;
   extern (C) void function (IMContext* context) preedit_end;
   extern (C) void function (IMContext* context) preedit_changed;
   extern (C) void function (IMContext* context, char* str) commit;
   extern (C) int function (IMContext* context) retrieve_surrounding;

   // RETURNS: %TRUE if the signal was handled.
   // <offset>: offset from cursor position in chars; a negative value means start before the cursor.
   // <n_chars>: number of characters to delete.
   extern (C) int function (IMContext* context, int offset, int n_chars) delete_surrounding;
   // <window>: the client window. This may be %NULL to indicate that the previous client window no longer exists.
   extern (C) void function (IMContext* context, Gdk2.Window* window=null) set_client_window;

   // <str>: location to store the retrieved string. The string retrieved must be freed with g_free().
   // <attrs>: location to store the retrieved attribute list.  When you are done with this list, you must unreference it with pango_attr_list_unref().
   // <cursor_pos>: location to store position of cursor (in characters) within the preedit string.
   extern (C) void function (IMContext* context, /*out*/ char** str, /*out*/ Pango.AttrList** attrs, /*out*/ int* cursor_pos) get_preedit_string;

   // RETURNS: %TRUE if the input method handled the key event.
   // <event>: the key event
   extern (C) int function (IMContext* context, Gdk2.EventKey* event) filter_keypress;
   extern (C) void function (IMContext* context) focus_in;
   extern (C) void function (IMContext* context) focus_out;
   extern (C) void function (IMContext* context) reset;
   // <area>: new location
   extern (C) void function (IMContext* context, Gdk2.Rectangle* area) set_cursor_location;
   // <use_preedit>: whether the IM context should use the preedit string.
   extern (C) void function (IMContext* context, int use_preedit) set_use_preedit;

   // <text>: text surrounding the insertion point, as UTF-8. the preedit string should not be included within
   // <len>: the length of @text, or -1 if @text is nul-terminated
   // <cursor_index>: the byte index of the insertion cursor within @text.
   extern (C) void function (IMContext* context, char* text, int len, int cursor_index) set_surrounding;

   // RETURNS: %TRUE if surrounding text was provided; in this case
   // <text>: location to store a UTF-8 encoded string of text holding context around the insertion point. If the function returns %TRUE, then you must free the result stored in this location with g_free().
   // <cursor_index>: (out) location to store byte index of the insertion cursor within @text.
   extern (C) int function (IMContext* context, /*out*/ char** text, int* cursor_index) get_surrounding;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
}

// Bookkeeping information about a loadable input method.
struct IMContextInfo {
   char* context_id, context_name, domain, domain_dirname, default_locales;
}

struct IMContextSimple /* : IMContext */ {
   alias object this;
   alias object super_;
   alias object imcontext;
   IMContext object;
   GLib2.SList* tables;
   uint[8] compose_buffer;
   dchar tentative_match;
   int tentative_match_len;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "in_hex_sequence", 1,
   uint, "modifiers_dropped", 1,
    uint, "__dummy32A", 30));


   // Creates a new #GtkIMContextSimple.
   // RETURNS: a new #GtkIMContextSimple.
   static IMContextSimple* /*new*/ new_() {
      return gtk_im_context_simple_new();
   }

   // Adds an additional table to search to the input context.
   // Each row of the table consists of @max_seq_len key symbols
   // followed by two #guint16 interpreted as the high and low
   // words of a #gunicode value. Tables are searched starting
   // from the last added.
   // The table must be sorted in dictionary order on the
   // numeric value of the key symbol fields. (Values beyond
   // the length of the sequence should be zero.)
   // <data>: the table
   // <max_seq_len>: Maximum length of a sequence in the table (cannot be greater than #GTK_MAX_COMPOSE_LEN)
   // <n_seqs>: number of sequences in the table
   void add_table(ushort* data, int max_seq_len, int n_seqs) {
      gtk_im_context_simple_add_table(&this, data, max_seq_len, n_seqs);
   }
}

struct IMContextSimpleClass {
   IMContextClass parent_class;
}

struct IMMulticontext /* : IMContext */ {
   alias object this;
   alias object super_;
   alias object imcontext;
   IMContext object;
   IMContext* slave;
   IMMulticontextPrivate* priv;
   char* context_id;


   // Creates a new #GtkIMMulticontext.
   // RETURNS: a new #GtkIMMulticontext.
   static IMMulticontext* /*new*/ new_() {
      return gtk_im_multicontext_new();
   }

   // Add menuitems for various available input methods to a menu;
   // the menuitems, when selected, will switch the input method
   // for the context and the global default input method.
   // <menushell>: a #GtkMenuShell
   void append_menuitems(MenuShell* menushell) {
      gtk_im_multicontext_append_menuitems(&this, menushell);
   }

   // Gets the id of the currently active slave of the @context.
   // RETURNS: the id of the currently active slave
   char* get_context_id() {
      return gtk_im_multicontext_get_context_id(&this);
   }

   // Sets the context id for @context.
   // This causes the currently active slave of @context to be
   // replaced by the slave corresponding to the new context id.
   // <context_id>: the id to use
   void set_context_id(char* context_id) {
      gtk_im_multicontext_set_context_id(&this, context_id);
   }
}

struct IMMulticontextClass {
   IMContextClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct IMMulticontextPrivate {
}

enum IMPreeditStyle {
   NOTHING = 0,
   CALLBACK = 1,
   NONE = 2
}
enum IMStatusStyle {
   NOTHING = 0,
   CALLBACK = 1,
   NONE = 2
}
enum int INPUT_ERROR = -1;
enum int INTERFACE_AGE = 8;
struct IconFactory /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   GLib2.HashTable* icons;


   // Creates a new #GtkIconFactory. An icon factory manages a collection
   // of #GtkIconSet<!-- -->s; a #GtkIconSet manages a set of variants of a
   // particular icon (i.e. a #GtkIconSet contains variants for different
   // sizes and widget states). Icons in an icon factory are named by a
   // stock ID, which is a simple string identifying the icon. Each
   // #GtkStyle has a list of #GtkIconFactory<!-- -->s derived from the current
   // theme; those icon factories are consulted first when searching for
   // an icon. If the theme doesn't set a particular icon, GTK+ looks for
   // the icon in a list of default icon factories, maintained by
   // gtk_icon_factory_add_default() and
   // gtk_icon_factory_remove_default(). Applications with icons should
   // add a default icon factory with their icons, which will allow
   // themes to override the icons for the application.
   // RETURNS: a new #GtkIconFactory
   static IconFactory* /*new*/ new_() {
      return gtk_icon_factory_new();
   }

   // Looks for an icon in the list of default icon factories.  For
   // display to the user, you should use gtk_style_lookup_icon_set() on
   // the #GtkStyle for the widget that will display the icon, instead of
   // using this function directly, so that themes are taken into
   // account.
   // RETURNS: a #GtkIconSet, or %NULL
   // <stock_id>: an icon name
   static IconSet* lookup_default(char* stock_id) {
      return gtk_icon_factory_lookup_default(stock_id);
   }

   // Adds the given @icon_set to the icon factory, under the name
   // e.g. "myapp-whatever-icon".  Normally applications create a
   // #GtkIconFactory, then add it to the list of default factories with
   // gtk_icon_factory_add_default(). Then they pass the @stock_id to
   // widgets such as #GtkImage to display the icon. Themes can provide
   // an icon with the same name (such as "myapp-whatever-icon") to
   // override your application's default icons. If an icon already
   // existed in @factory for @stock_id, it is unreferenced and replaced
   // with the new @icon_set.
   // <stock_id>: icon name
   // <icon_set>: icon set
   void add(char* stock_id, IconSet* icon_set) {
      gtk_icon_factory_add(&this, stock_id, icon_set);
   }

   // Adds an icon factory to the list of icon factories searched by
   // gtk_style_lookup_icon_set(). This means that, for example,
   // gtk_image_new_from_stock() will be able to find icons in @factory.
   // There will normally be an icon factory added for each library or
   // application that comes with icons. The default icon factories
   // can be overridden by themes.
   void add_default() {
      gtk_icon_factory_add_default(&this);
   }

   // Looks up @stock_id in the icon factory, returning an icon set
   // if found, otherwise %NULL. For display to the user, you should
   // use gtk_style_lookup_icon_set() on the #GtkStyle for the
   // widget that will display the icon, instead of using this
   // function directly, so that themes are taken into account.
   // RETURNS: icon set of @stock_id.
   // <stock_id>: an icon name
   IconSet* lookup(char* stock_id) {
      return gtk_icon_factory_lookup(&this, stock_id);
   }

   // Removes an icon factory from the list of default icon
   // factories. Not normally used; you might use it for a library that
   // can be unloaded or shut down.
   void remove_default() {
      gtk_icon_factory_remove_default(&this);
   }
}

struct IconFactoryClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct IconInfo {

   // Creates a #GtkIconInfo for a #GdkPixbuf.
   // RETURNS: a #GtkIconInfo
   // <icon_theme>: a #GtkIconTheme
   // <pixbuf>: the pixbuf to wrap in a #GtkIconInfo
   static IconInfo* /*new*/ new_for_pixbuf(IconTheme* icon_theme, GdkPixbuf2.Pixbuf* pixbuf) {
      return gtk_icon_info_new_for_pixbuf(icon_theme, pixbuf);
   }

   // Make a copy of a #GtkIconInfo.
   // RETURNS: the new GtkIconInfo
   IconInfo* /*new*/ copy() {
      return gtk_icon_info_copy(&this);
   }
   // Free a #GtkIconInfo and associated information
   void free() {
      gtk_icon_info_free(&this);
   }

   // Fetches the set of attach points for an icon. An attach point
   // is a location in the icon that can be used as anchor points for attaching
   // emblems or overlays to the icon.
   // RETURNS: %TRUE if there are any attach points for the icon.
   // <points>: (array length=n_points) (out): location to store pointer to an array of points, or %NULL free the array of points with g_free().
   // <n_points>: location to store the number of points in @points, or %NULL
   int get_attach_points(Gdk2.Point** points=null, int* n_points=null) {
      return gtk_icon_info_get_attach_points(&this, points, n_points);
   }

   // Gets the base size for the icon. The base size
   // is a size for the icon that was specified by
   // the icon theme creator. This may be different
   // than the actual size of image; an example of
   // this is small emblem icons that can be attached
   // to a larger icon. These icons will be given
   // the same base size as the larger icons to which
   // they are attached.
   // size is known for the icon.
   // RETURNS: the base size, or 0, if no base
   int get_base_size() {
      return gtk_icon_info_get_base_size(&this);
   }

   // Gets the built-in image for this icon, if any. To allow
   // GTK+ to use built in icon images, you must pass the
   // %GTK_ICON_LOOKUP_USE_BUILTIN to
   // gtk_icon_theme_lookup_icon().
   // extra reference is added to the returned pixbuf, so if
   // you want to keep it around, you must use g_object_ref().
   // The returned image must not be modified.
   // RETURNS: the built-in image pixbuf, or %NULL. No
   GdkPixbuf2.Pixbuf* get_builtin_pixbuf() {
      return gtk_icon_info_get_builtin_pixbuf(&this);
   }

   // Gets the display name for an icon. A display name is a
   // string to be used in place of the icon name in a user
   // visible context like a list of icons.
   // the icon doesn't have a specified display name. This value
   // is owned @icon_info and must not be modified or free.
   // RETURNS: the display name for the icon or %NULL, if
   char* get_display_name() {
      return gtk_icon_info_get_display_name(&this);
   }

   // Gets the coordinates of a rectangle within the icon
   // that can be used for display of information such
   // as a preview of the contents of a text file.
   // See gtk_icon_info_set_raw_coordinates() for further
   // information about the coordinate system.
   // RETURNS: %TRUE if the icon has an embedded rectangle
   // <rectangle>: #GdkRectangle in which to store embedded rectangle coordinates; coordinates are only stored when this function returns %TRUE.
   int get_embedded_rect(/*out*/ Gdk2.Rectangle* rectangle) {
      return gtk_icon_info_get_embedded_rect(&this, rectangle);
   }

   // Gets the filename for the icon. If the
   // %GTK_ICON_LOOKUP_USE_BUILTIN flag was passed
   // to gtk_icon_theme_lookup_icon(), there may be
   // no filename if a builtin icon is returned; in this
   // case, you should use gtk_icon_info_get_builtin_pixbuf().
   // if gtk_icon_info_get_builtin_pixbuf() should
   // be used instead. The return value is owned by
   // GTK+ and should not be modified or freed.
   // RETURNS: the filename for the icon, or %NULL
   char* get_filename() {
      return gtk_icon_info_get_filename(&this);
   }

   // Renders an icon previously looked up in an icon theme using
   // gtk_icon_theme_lookup_icon(); the size will be based on the size
   // passed to gtk_icon_theme_lookup_icon(). Note that the resulting
   // pixbuf may not be exactly this size; an icon theme may have icons
   // that differ slightly from their nominal sizes, and in addition GTK+
   // will avoid scaling icons that it considers sufficiently close to the
   // requested size or for which the source image would have to be scaled
   // up too far. (This maintains sharpness.). This behaviour can be changed
   // by passing the %GTK_ICON_LOOKUP_FORCE_SIZE flag when obtaining
   // the #GtkIconInfo. If this flag has been specified, the pixbuf
   // returned by this function will be scaled to the exact size.
   // created icon or a new reference to an internal icon, so you must
   // not modify the icon. Use g_object_unref() to release your reference
   // to the icon.
   // RETURNS: the rendered icon; this may be a newly
   GdkPixbuf2.Pixbuf* /*new*/ load_icon(GLib2.Error** error=null) {
      return gtk_icon_info_load_icon(&this, error);
   }

   // Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect()
   // and gtk_icon_info_get_attach_points() should be returned in their
   // original form as specified in the icon theme, instead of scaled
   // appropriately for the pixbuf returned by gtk_icon_info_load_icon().
   // Raw coordinates are somewhat strange; they are specified to be with
   // respect to the unscaled pixmap for PNG and XPM icons, but for SVG
   // icons, they are in a 1000x1000 coordinate space that is scaled
   // to the final size of the icon.  You can determine if the icon is an SVG
   // icon by using gtk_icon_info_get_filename(), and seeing if it is non-%NULL
   // and ends in '.svg'.
   // This function is provided primarily to allow compatibility wrappers
   // for older API's, and is not expected to be useful for applications.
   // <raw_coordinates>: whether the coordinates of embedded rectangles and attached points should be returned in their original (unscaled) form.
   void set_raw_coordinates(int raw_coordinates) {
      gtk_icon_info_set_raw_coordinates(&this, raw_coordinates);
   }
}

// Used to specify options for gtk_icon_theme_lookup_icon()
enum IconLookupFlags {
   NO_SVG = 1,
   FORCE_SVG = 2,
   USE_BUILTIN = 4,
   GENERIC_FALLBACK = 8,
   FORCE_SIZE = 16
}
struct IconSet {

   // Creates a new #GtkIconSet. A #GtkIconSet represents a single icon
   // in various sizes and widget states. It can provide a #GdkPixbuf
   // for a given size and state on request, and automatically caches
   // some of the rendered #GdkPixbuf objects.
   // Normally you would use gtk_widget_render_icon() instead of
   // using #GtkIconSet directly. The one case where you'd use
   // #GtkIconSet is to create application-specific icon sets to place in
   // a #GtkIconFactory.
   // RETURNS: a new #GtkIconSet
   static IconSet* /*new*/ new_() {
      return gtk_icon_set_new();
   }

   // Creates a new #GtkIconSet with @pixbuf as the default/fallback
   // source image. If you don't add any additional #GtkIconSource to the
   // icon set, all variants of the icon will be created from @pixbuf,
   // using scaling, pixelation, etc. as required to adjust the icon size
   // or make the icon look insensitive/prelighted.
   // RETURNS: a new #GtkIconSet
   // <pixbuf>: a #GdkPixbuf
   static IconSet* /*new*/ new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf) {
      return gtk_icon_set_new_from_pixbuf(pixbuf);
   }

   // Icon sets have a list of #GtkIconSource, which they use as base
   // icons for rendering icons in different states and sizes. Icons are
   // scaled, made to look insensitive, etc. in
   // gtk_icon_set_render_icon(), but #GtkIconSet needs base images to
   // work with. The base images and when to use them are described by
   // a #GtkIconSource.
   // This function copies @source, so you can reuse the same source immediately
   // without affecting the icon set.
   // to Previous Page" icon might point in a different direction in
   // Hebrew and in English; it might look different when insensitive;
   // and it might change size depending on toolbar mode (small/large
   // icons). So a single icon set would contain all those variants of
   // the icon, and you might add a separate source for each one.
   // You should nearly always add a "default" icon source with all
   // fields wildcarded, which will be used as a fallback if no more
   // specific source matches. #GtkIconSet always prefers more specific
   // icon sources to more generic icon sources. The order in which you
   // add the sources to the icon set does not matter.
   // gtk_icon_set_new_from_pixbuf() creates a new icon set with a
   // default icon source based on the given pixbuf.
   // <source>: a #GtkIconSource
   void add_source(IconSource* source) {
      gtk_icon_set_add_source(&this, source);
   }

   // Copies @icon_set by value.
   // RETURNS: a new #GtkIconSet identical to the first.
   IconSet* /*new*/ copy() {
      return gtk_icon_set_copy(&this);
   }

   // Obtains a list of icon sizes this icon set can render. The returned
   // array must be freed with g_free().
   // <sizes>: return location for array of sizes
   // <n_sizes>: location to store number of elements in returned array
   void get_sizes(/*out*/ /*POINTER*/ int* sizes, /*out*/ int* n_sizes) {
      gtk_icon_set_get_sizes(&this, sizes, n_sizes);
   }

   // Increments the reference count on @icon_set.
   // RETURNS: @icon_set.
   IconSet* /*new*/ ref_() {
      return gtk_icon_set_ref(&this);
   }

   // Renders an icon using gtk_style_render_icon(). In most cases,
   // gtk_widget_render_icon() is better, since it automatically provides
   // most of the arguments from the current widget settings.  This
   // function never returns %NULL; if the icon can't be rendered
   // (perhaps because an image file fails to load), a default "missing
   // image" icon will be returned instead.
   // RETURNS: a #GdkPixbuf to be displayed
   // <style>: a #GtkStyle associated with @widget, or %NULL
   // <direction>: text direction
   // <state>: widget state
   // <size>: icon size. A size of (GtkIconSize)-1 means render at the size of the source and don't scale.
   // <widget>: widget that will display the icon, or %NULL. The only use that is typically made of this is to determine the appropriate #GdkScreen.
   // <detail>: detail to pass to the theme engine, or %NULL. Note that passing a detail of anything but %NULL will disable caching.
   GdkPixbuf2.Pixbuf* /*new*/ render_icon(Style* style, TextDirection direction, StateType state, int size, Widget* widget=null, char* detail=null) {
      return gtk_icon_set_render_icon(&this, style, direction, state, size, widget, detail);
   }

   // Decrements the reference count on @icon_set, and frees memory
   // if the reference count reaches 0.
   void unref() {
      gtk_icon_set_unref(&this);
   }
}

enum IconSize {
   INVALID = 0,
   MENU = 1,
   SMALL_TOOLBAR = 2,
   LARGE_TOOLBAR = 3,
   BUTTON = 4,
   DND = 5,
   DIALOG = 6
}
struct IconSource {

   // Creates a new #GtkIconSource. A #GtkIconSource contains a #GdkPixbuf (or
   // image filename) that serves as the base image for one or more of the
   // icons in a #GtkIconSet, along with a specification for which icons in the
   // icon set will be based on that pixbuf or image file. An icon set contains
   // a set of icons that represent "the same" logical concept in different states,
   // different global text directions, and different sizes.
   // So for example a web browser's "Back to Previous Page" icon might
   // point in a different direction in Hebrew and in English; it might
   // look different when insensitive; and it might change size depending
   // on toolbar mode (small/large icons). So a single icon set would
   // contain all those variants of the icon. #GtkIconSet contains a list
   // of #GtkIconSource from which it can derive specific icon variants in
   // the set.
   // In the simplest case, #GtkIconSet contains one source pixbuf from
   // which it derives all variants. The convenience function
   // gtk_icon_set_new_from_pixbuf() handles this case; if you only have
   // one source pixbuf, just use that function.
   // If you want to use a different base pixbuf for different icon
   // variants, you create multiple icon sources, mark which variants
   // they'll be used to create, and add them to the icon set with
   // gtk_icon_set_add_source().
   // By default, the icon source has all parameters wildcarded. That is,
   // the icon source will be used as the base icon for any desired text
   // direction, widget state, or icon size.
   // RETURNS: a new #GtkIconSource
   static IconSource* /*new*/ new_() {
      return gtk_icon_source_new();
   }

   // Creates a copy of @source; mostly useful for language bindings.
   // RETURNS: a new #GtkIconSource
   IconSource* /*new*/ copy() {
      return gtk_icon_source_copy(&this);
   }

   // Frees a dynamically-allocated icon source, along with its
   // filename, size, and pixbuf fields if those are not %NULL.
   void free() {
      gtk_icon_source_free(&this);
   }

   // Obtains the text direction this icon source applies to. The return
   // value is only useful/meaningful if the text direction is <emphasis>not</emphasis>
   // wildcarded.
   // RETURNS: text direction this source matches
   TextDirection get_direction() {
      return gtk_icon_source_get_direction(&this);
   }

   // Gets the value set by gtk_icon_source_set_direction_wildcarded().
   // RETURNS: %TRUE if this icon source is a base for any text direction variant
   int get_direction_wildcarded() {
      return gtk_icon_source_get_direction_wildcarded(&this);
   }

   // Retrieves the source filename, or %NULL if none is set. The
   // filename is not a copy, and should not be modified or expected to
   // persist beyond the lifetime of the icon source.
   // or freed.
   // RETURNS: image filename. This string must not be modified
   char* get_filename() {
      return gtk_icon_source_get_filename(&this);
   }

   // Retrieves the source icon name, or %NULL if none is set. The
   // icon_name is not a copy, and should not be modified or expected to
   // persist beyond the lifetime of the icon source.
   // RETURNS: icon name. This string must not be modified or freed.
   char* get_icon_name() {
      return gtk_icon_source_get_icon_name(&this);
   }

   // Retrieves the source pixbuf, or %NULL if none is set.
   // In addition, if a filename source is in use, this
   // function in some cases will return the pixbuf from
   // loaded from the filename. This is, for example, true
   // for the GtkIconSource passed to the GtkStyle::render_icon()
   // virtual function. The reference count on the pixbuf is
   // not incremented.
   // RETURNS: source pixbuf
   GdkPixbuf2.Pixbuf* get_pixbuf() {
      return gtk_icon_source_get_pixbuf(&this);
   }

   // Obtains the icon size this source applies to. The return value
   // is only useful/meaningful if the icon size is <emphasis>not</emphasis> wildcarded.
   // RETURNS: icon size this source matches.
   int get_size() {
      return gtk_icon_source_get_size(&this);
   }

   // Gets the value set by gtk_icon_source_set_size_wildcarded().
   // RETURNS: %TRUE if this icon source is a base for any icon size variant
   int get_size_wildcarded() {
      return gtk_icon_source_get_size_wildcarded(&this);
   }

   // Obtains the widget state this icon source applies to. The return
   // value is only useful/meaningful if the widget state is <emphasis>not</emphasis>
   // wildcarded.
   // RETURNS: widget state this source matches
   StateType get_state() {
      return gtk_icon_source_get_state(&this);
   }

   // Gets the value set by gtk_icon_source_set_state_wildcarded().
   // RETURNS: %TRUE if this icon source is a base for any widget state variant
   int get_state_wildcarded() {
      return gtk_icon_source_get_state_wildcarded(&this);
   }

   // Sets the text direction this icon source is intended to be used
   // with.
   // Setting the text direction on an icon source makes no difference
   // if the text direction is wildcarded. Therefore, you should usually
   // call gtk_icon_source_set_direction_wildcarded() to un-wildcard it
   // in addition to calling this function.
   // <direction>: text direction this source applies to
   void set_direction(TextDirection direction) {
      gtk_icon_source_set_direction(&this, direction);
   }

   // If the text direction is wildcarded, this source can be used
   // as the base image for an icon in any #GtkTextDirection.
   // If the text direction is not wildcarded, then the
   // text direction the icon source applies to should be set
   // with gtk_icon_source_set_direction(), and the icon source
   // will only be used with that text direction.
   // #GtkIconSet prefers non-wildcarded sources (exact matches) over
   // wildcarded sources, and will use an exact match when possible.
   // <setting>: %TRUE to wildcard the text direction
   void set_direction_wildcarded(int setting) {
      gtk_icon_source_set_direction_wildcarded(&this, setting);
   }

   // Sets the name of an image file to use as a base image when creating
   // icon variants for #GtkIconSet. The filename must be absolute.
   // <filename>: image file to use
   void set_filename(char* filename) {
      gtk_icon_source_set_filename(&this, filename);
   }

   // Sets the name of an icon to look up in the current icon theme
   // to use as a base image when creating icon variants for #GtkIconSet.
   // <icon_name>: name of icon to use
   void set_icon_name(char* icon_name=null) {
      gtk_icon_source_set_icon_name(&this, icon_name);
   }

   // Sets a pixbuf to use as a base image when creating icon variants
   // for #GtkIconSet.
   // <pixbuf>: pixbuf to use as a source
   void set_pixbuf(GdkPixbuf2.Pixbuf* pixbuf) {
      gtk_icon_source_set_pixbuf(&this, pixbuf);
   }

   // Sets the icon size this icon source is intended to be used
   // with.
   // Setting the icon size on an icon source makes no difference
   // if the size is wildcarded. Therefore, you should usually
   // call gtk_icon_source_set_size_wildcarded() to un-wildcard it
   // in addition to calling this function.
   // <size>: icon size this source applies to
   void set_size(int size) {
      gtk_icon_source_set_size(&this, size);
   }

   // If the icon size is wildcarded, this source can be used as the base
   // image for an icon of any size.  If the size is not wildcarded, then
   // the size the source applies to should be set with
   // gtk_icon_source_set_size() and the icon source will only be used
   // with that specific size.
   // #GtkIconSet prefers non-wildcarded sources (exact matches) over
   // wildcarded sources, and will use an exact match when possible.
   // #GtkIconSet will normally scale wildcarded source images to produce
   // an appropriate icon at a given size, but will not change the size
   // of source images that match exactly.
   // <setting>: %TRUE to wildcard the widget state
   void set_size_wildcarded(int setting) {
      gtk_icon_source_set_size_wildcarded(&this, setting);
   }

   // Sets the widget state this icon source is intended to be used
   // with.
   // Setting the widget state on an icon source makes no difference
   // if the state is wildcarded. Therefore, you should usually
   // call gtk_icon_source_set_state_wildcarded() to un-wildcard it
   // in addition to calling this function.
   // <state>: widget state this source applies to
   void set_state(StateType state) {
      gtk_icon_source_set_state(&this, state);
   }

   // If the widget state is wildcarded, this source can be used as the
   // base image for an icon in any #GtkStateType.  If the widget state
   // is not wildcarded, then the state the source applies to should be
   // set with gtk_icon_source_set_state() and the icon source will
   // only be used with that specific state.
   // #GtkIconSet prefers non-wildcarded sources (exact matches) over
   // wildcarded sources, and will use an exact match when possible.
   // #GtkIconSet will normally transform wildcarded source images to
   // produce an appropriate icon for a given state, for example
   // lightening an image on prelight, but will not modify source images
   // that match exactly.
   // <setting>: %TRUE to wildcard the widget state
   void set_state_wildcarded(int setting) {
      gtk_icon_source_set_state_wildcarded(&this, setting);
   }
}

struct IconTheme /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private IconThemePrivate* priv;


   // Creates a new icon theme object. Icon theme objects are used
   // to lookup up an icon by name in a particular icon theme.
   // Usually, you'll want to use gtk_icon_theme_get_default()
   // or gtk_icon_theme_get_for_screen() rather than creating
   // a new icon theme object for scratch.
   // RETURNS: the newly created #GtkIconTheme object.
   static IconTheme* /*new*/ new_() {
      return gtk_icon_theme_new();
   }

   // Registers a built-in icon for icon theme lookups. The idea
   // of built-in icons is to allow an application or library
   // that uses themed icons to function requiring files to
   // be present in the file system. For instance, the default
   // images for all of GTK+'s stock icons are registered
   // as built-icons.
   // In general, if you use gtk_icon_theme_add_builtin_icon()
   // you should also install the icon in the icon theme, so
   // that the icon is generally available.
   // This function will generally be used with pixbufs loaded
   // via gdk_pixbuf_new_from_inline().
   // <icon_name>: the name of the icon to register
   // <size>: the size at which to register the icon (different images can be registered for the same icon name at different sizes.)
   // <pixbuf>: #GdkPixbuf that contains the image to use for @icon_name.
   static void add_builtin_icon(char* icon_name, int size, GdkPixbuf2.Pixbuf* pixbuf) {
      gtk_icon_theme_add_builtin_icon(icon_name, size, pixbuf);
   }

   // Gets the icon theme for the default screen. See
   // gtk_icon_theme_get_for_screen().
   // the default screen. This icon theme is associated with
   // the screen and can be used as long as the screen
   // is open. Do not ref or unref it.
   // RETURNS: A unique #GtkIconTheme associated with
   static IconTheme* get_default() {
      return gtk_icon_theme_get_default();
   }

   // Gets the icon theme object associated with @screen; if this
   // function has not previously been called for the given
   // screen, a new icon theme object will be created and
   // associated with the screen. Icon theme objects are
   // fairly expensive to create, so using this function
   // is usually a better choice than calling than gtk_icon_theme_new()
   // and setting the screen yourself; by using this function
   // a single icon theme object will be shared between users.
   // the given screen. This icon theme is associated with
   // the screen and can be used as long as the screen
   // is open. Do not ref or unref it.
   // RETURNS: A unique #GtkIconTheme associated with
   // <screen>: a #GdkScreen
   static IconTheme* get_for_screen(Gdk2.Screen* screen) {
      return gtk_icon_theme_get_for_screen(screen);
   }

   // Appends a directory to the search path. 
   // See gtk_icon_theme_set_search_path().
   // <path>: directory name to append to the icon path
   void append_search_path(char* path) {
      gtk_icon_theme_append_search_path(&this, path);
   }

   // Looks up a named icon and returns a structure containing
   // information such as the filename of the icon. The icon
   // can then be rendered into a pixbuf using
   // gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon()
   // combines these two steps if all you need is the pixbuf.)
   // If @icon_names contains more than one name, this function 
   // tries them all in the given order before falling back to 
   // inherited icon themes.
   // about the icon, or %NULL if the icon wasn't found. Free with
   // gtk_icon_info_free()
   // RETURNS: a #GtkIconInfo structure containing information
   // <icon_names>: %NULL-terminated array of icon names to lookup
   // <size>: desired icon size
   // <flags>: flags modifying the behavior of the icon lookup
   IconInfo* /*new*/ choose_icon(char* icon_names, int size, IconLookupFlags flags) {
      return gtk_icon_theme_choose_icon(&this, icon_names, size, flags);
   }

   // Gets the name of an icon that is representative of the
   // current theme (for instance, to use when presenting
   // a list of themes to the user.)
   // Free with g_free().
   // RETURNS: the name of an example icon or %NULL.
   char* /*new*/ get_example_icon_name() {
      return gtk_icon_theme_get_example_icon_name(&this);
   }

   // Returns an array of integers describing the sizes at which
   // the icon is available without scaling. A size of -1 means 
   // that the icon is available in a scalable format. The array 
   // is zero-terminated.
   // describing the sizes at which the icon is available. The array
   // should be freed with g_free() when it is no longer needed.
   // RETURNS: An newly allocated array
   // <icon_name>: the name of an icon
   int* get_icon_sizes(char* icon_name) {
      return gtk_icon_theme_get_icon_sizes(&this, icon_name);
   }

   // Gets the current search path. See gtk_icon_theme_set_search_path().
   // <path>: (array length=n_elements) (out): location to store a list of icon theme path directories or %NULL The stored value should be freed with g_strfreev().
   // <n_elements>: location to store number of elements in @path, or %NULL
   void get_search_path(char** path, int* n_elements) {
      gtk_icon_theme_get_search_path(&this, path, n_elements);
   }

   // Checks whether an icon theme includes an icon
   // for a particular name.
   // icon for @icon_name.
   // RETURNS: %TRUE if @icon_theme includes an
   // <icon_name>: the name of an icon
   int has_icon(char* icon_name) {
      return gtk_icon_theme_has_icon(&this, icon_name);
   }

   // Gets the list of contexts available within the current
   // hierarchy of icon themes
   // contexts in the theme. You must first free each element
   // in the list with g_free(), then free the list itself
   // with g_list_free().
   // RETURNS: a #GList list holding the names of all the
   GLib2.List* /*new*/ list_contexts() {
      return gtk_icon_theme_list_contexts(&this);
   }

   // Lists the icons in the current icon theme. Only a subset
   // of the icons can be listed by providing a context string.
   // The set of values for the context string is system dependent,
   // but will typically include such values as "Applications" and
   // "MimeTypes".
   // holding the names of all the icons in the theme. You must first
   // free each element in the list with g_free(), then free the list
   // itself with g_list_free().
   // RETURNS: a #GList list
   // <context>: a string identifying a particular type of icon, or %NULL to list all icons.
   GLib2.List* /*new*/ list_icons(char* context) {
      return gtk_icon_theme_list_icons(&this, context);
   }

   // Looks up an icon in an icon theme, scales it to the given size
   // and renders it into a pixbuf. This is a convenience function;
   // if more details about the icon are needed, use
   // gtk_icon_theme_lookup_icon() followed by gtk_icon_info_load_icon().
   // Note that you probably want to listen for icon theme changes and
   // update the icon. This is usually done by connecting to the 
   // GtkWidget::style-set signal. If for some reason you do not want to
   // update the icon when the icon theme changes, you should consider
   // using gdk_pixbuf_copy() to make a private copy of the pixbuf
   // returned by this function. Otherwise GTK+ may need to keep the old 
   // icon theme loaded, which would be a waste of memory.
   // created icon or a new reference to an internal icon, so you must not modify
   // the icon. Use g_object_unref() to release your reference to the
   // icon. %NULL if the icon isn't found.
   // RETURNS: the rendered icon; this may be a newly
   // <icon_name>: the name of the icon to lookup
   // <size>: the desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon().
   // <flags>: flags modifying the behavior of the icon lookup
   GdkPixbuf2.Pixbuf* /*new*/ load_icon(char* icon_name, int size, IconLookupFlags flags, GLib2.Error** error=null) {
      return gtk_icon_theme_load_icon(&this, icon_name, size, flags, error);
   }

   // Looks up an icon and returns a structure containing
   // information such as the filename of the icon. 
   // The icon can then be rendered into a pixbuf using
   // gtk_icon_info_load_icon().
   // information about the icon, or %NULL if the icon 
   // wasn't found. Free with gtk_icon_info_free()
   // RETURNS: a #GtkIconInfo structure containing
   // <icon>: the #GIcon to look up
   // <size>: desired icon size
   // <flags>: flags modifying the behavior of the icon lookup
   IconInfo* /*new*/ lookup_by_gicon(Gio2.Icon* icon, int size, IconLookupFlags flags) {
      return gtk_icon_theme_lookup_by_gicon(&this, icon, size, flags);
   }

   // Looks up a named icon and returns a structure containing
   // information such as the filename of the icon. The icon
   // can then be rendered into a pixbuf using
   // gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon()
   // combines these two steps if all you need is the pixbuf.)
   // about the icon, or %NULL if the icon wasn't found. Free with
   // gtk_icon_info_free()
   // RETURNS: a #GtkIconInfo structure containing information
   // <icon_name>: the name of the icon to lookup
   // <size>: desired icon size
   // <flags>: flags modifying the behavior of the icon lookup
   IconInfo* /*new*/ lookup_icon(char* icon_name, int size, IconLookupFlags flags) {
      return gtk_icon_theme_lookup_icon(&this, icon_name, size, flags);
   }

   // Prepends a directory to the search path. 
   // See gtk_icon_theme_set_search_path().
   // <path>: directory name to prepend to the icon path
   void prepend_search_path(char* path) {
      gtk_icon_theme_prepend_search_path(&this, path);
   }

   // Checks to see if the icon theme has changed; if it has, any
   // currently cached information is discarded and will be reloaded
   // next time @icon_theme is accessed.
   // to be reloaded.
   // RETURNS: %TRUE if the icon theme has changed and needed
   int rescan_if_needed() {
      return gtk_icon_theme_rescan_if_needed(&this);
   }

   // Sets the name of the icon theme that the #GtkIconTheme object uses
   // overriding system configuration. This function cannot be called
   // on the icon theme objects returned from gtk_icon_theme_get_default()
   // and gtk_icon_theme_get_for_screen().
   // <theme_name>: name of icon theme to use instead of configured theme, or %NULL to unset a previously set custom theme
   void set_custom_theme(char* theme_name) {
      gtk_icon_theme_set_custom_theme(&this, theme_name);
   }

   // Sets the screen for an icon theme; the screen is used
   // to track the user's currently configured icon theme,
   // which might be different for different screens.
   // <screen>: a #GdkScreen
   void set_screen(Gdk2.Screen* screen) {
      gtk_icon_theme_set_screen(&this, screen);
   }

   // Sets the search path for the icon theme object. When looking
   // for an icon theme, GTK+ will search for a subdirectory of
   // one or more of the directories in @path with the same name
   // as the icon theme. (Themes from multiple of the path elements
   // are combined to allow themes to be extended by adding icons
   // in the user's home directory.)
   // In addition if an icon found isn't found either in the current
   // icon theme or the default icon theme, and an image file with
   // the right name is found directly in one of the elements of
   // (This is legacy feature, and new icons should be put
   // into the default icon theme, which is called DEFAULT_THEME_NAME,
   // rather than directly on the icon path.)
   // <path>: array of directories that are searched for icon themes
   // <n_elements>: number of elements in @path.
   void set_search_path(char* path, int n_elements) {
      gtk_icon_theme_set_search_path(&this, path, n_elements);
   }

   // Emitted when the current icon theme is switched or GTK+ detects
   // that a change has occurred in the contents of the current
   // icon theme.
   extern (C) alias static void function (IconTheme* 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);
   }
}

struct IconThemeClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (IconTheme* icon_theme) changed;
}

// Error codes for GtkIconTheme operations.
enum IconThemeError {
   NOT_FOUND = 0,
   FAILED = 1
}
struct IconThemePrivate {
}

struct IconView /* : Container */ {
   alias parent this;
   alias parent super_;
   alias parent container;
   Container parent;
   IconViewPrivate* priv;


   // Creates a new #GtkIconView widget
   // RETURNS: A newly created #GtkIconView widget
   static IconView* new_() {
      return gtk_icon_view_new();
   }

   // Creates a new #GtkIconView widget with the model @model.
   // RETURNS: A newly created #GtkIconView widget.
   // <model>: The model.
   static IconView* new_with_model(TreeModel* model) {
      return gtk_icon_view_new_with_model(model);
   }

   // Converts widget coordinates to coordinates for the bin_window,
   // as expected by e.g. gtk_icon_view_get_path_at_pos().
   // <wx>: X coordinate relative to the widget
   // <wy>: Y coordinate relative to the widget
   // <bx>: return location for bin_window X coordinate
   // <by>: return location for bin_window Y coordinate
   void convert_widget_to_bin_window_coords(int wx, int wy, /*out*/ int* bx, /*out*/ int* by) {
      gtk_icon_view_convert_widget_to_bin_window_coords(&this, wx, wy, bx, by);
   }

   // Creates a #GdkPixmap representation of the item at @path.
   // This image is used for a drag icon.
   // RETURNS: a newly-allocated pixmap of the drag icon.
   // <path>: a #GtkTreePath in @icon_view
   Gdk2.Pixmap* /*new*/ create_drag_icon(TreePath* path) {
      return gtk_icon_view_create_drag_icon(&this, path);
   }

   // Turns @icon_view into a drop destination for automatic DND. Calling this
   // method sets #GtkIconView:reorderable to %FALSE.
   // <targets>: the table of targets that the drag will support
   // <n_targets>: the number of items in @targets
   // <actions>: the bitmask of possible actions for a drag to this widget
   void enable_model_drag_dest(TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
      gtk_icon_view_enable_model_drag_dest(&this, targets, n_targets, actions);
   }

   // Turns @icon_view into a drag source for automatic DND. Calling this
   // method sets #GtkIconView:reorderable to %FALSE.
   // <start_button_mask>: Mask of allowed buttons to start drag
   // <targets>: the table of targets that the drag will support
   // <n_targets>: the number of items in @targets
   // <actions>: the bitmask of possible actions for a drag from this widget
   void enable_model_drag_source(Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
      gtk_icon_view_enable_model_drag_source(&this, start_button_mask, targets, n_targets, actions);
   }

   // Returns the value of the ::column-spacing property.
   // RETURNS: the space between columns
   int get_column_spacing() {
      return gtk_icon_view_get_column_spacing(&this);
   }

   // Returns the value of the ::columns property.
   // RETURNS: the number of columns, or -1
   int get_columns() {
      return gtk_icon_view_get_columns(&this);
   }

   // Fills in @path and @cell with the current cursor path and cell. 
   // If the cursor isn't currently set, then *@path will be %NULL.  
   // If no cell currently has focus, then *@cell will be %NULL.
   // The returned #GtkTreePath must be freed with gtk_tree_path_free().
   // RETURNS: %TRUE if the cursor is set.
   // <path>: Return location for the current cursor path, or %NULL
   // <cell>: Return location the current focus cell, or %NULL
   int get_cursor(TreePath** path=null, CellRenderer** cell=null) {
      return gtk_icon_view_get_cursor(&this, path, cell);
   }

   // Determines the destination item for a given position.
   // RETURNS: whether there is an item at the given position.
   // <drag_x>: the position to determine the destination item for
   // <drag_y>: the position to determine the destination item for
   // <path>: Return location for the path of the item, or %NULL.
   // <pos>: Return location for the drop position, or %NULL
   int get_dest_item_at_pos(int drag_x, int drag_y, TreePath** path=null, IconViewDropPosition* pos=null) {
      return gtk_icon_view_get_dest_item_at_pos(&this, drag_x, drag_y, path, pos);
   }

   // Gets information about the item that is highlighted for feedback.
   // <path>: Return location for the path of the highlighted item, or %NULL.
   // <pos>: Return location for the drop position, or %NULL
   void get_drag_dest_item(TreePath** path=null, IconViewDropPosition* pos=null) {
      gtk_icon_view_get_drag_dest_item(&this, path, pos);
   }

   // Finds the path at the point (@x, @y), relative to bin_window coordinates.
   // In contrast to gtk_icon_view_get_path_at_pos(), this function also 
   // obtains the cell at the specified position. The returned path should
   // be freed with gtk_tree_path_free().
   // See gtk_icon_view_convert_widget_to_bin_window_coords() for converting
   // widget coordinates to bin_window coordinates.
   // RETURNS: %TRUE if an item exists at the specified position
   // <x>: The x position to be identified
   // <y>: The y position to be identified
   // <path>: Return location for the path, or %NULL
   // <cell>: Return location for the renderer responsible for the cell at (@x, @y), or %NULL
   int get_item_at_pos(int x, int y, TreePath** path, CellRenderer** cell) {
      return gtk_icon_view_get_item_at_pos(&this, x, y, path, cell);
   }

   // Gets the column in which the item @path is currently
   // displayed. Column numbers start at 0.
   // RETURNS: The column in which the item is displayed
   // <path>: the #GtkTreePath of the item
   int get_item_column(TreePath* path) {
      return gtk_icon_view_get_item_column(&this, path);
   }

   // Returns the value of the ::item-orientation property which determines
   // whether the labels are drawn beside the icons instead of below.
   // RETURNS: the relative position of texts and icons
   Orientation get_item_orientation() {
      return gtk_icon_view_get_item_orientation(&this);
   }

   // Returns the value of the ::item-padding property.
   // RETURNS: the padding around items
   int get_item_padding() {
      return gtk_icon_view_get_item_padding(&this);
   }

   // Gets the row in which the item @path is currently
   // displayed. Row numbers start at 0.
   // RETURNS: The row in which the item is displayed
   // <path>: the #GtkTreePath of the item
   int get_item_row(TreePath* path) {
      return gtk_icon_view_get_item_row(&this, path);
   }

   // Returns the value of the ::item-width property.
   // RETURNS: the width of a single item, or -1
   int get_item_width() {
      return gtk_icon_view_get_item_width(&this);
   }

   // Returns the value of the ::margin property.
   // RETURNS: the space at the borders
   int get_margin() {
      return gtk_icon_view_get_margin(&this);
   }

   // Returns the column with markup text for @icon_view.
   // RETURNS: the markup column, or -1 if it's unset.
   int get_markup_column() {
      return gtk_icon_view_get_markup_column(&this);
   }

   // Returns the model the #GtkIconView is based on.  Returns %NULL if the
   // model is unset.
   // currently being used.
   // RETURNS: A #GtkTreeModel, or %NULL if none is
   TreeModel* get_model() {
      return gtk_icon_view_get_model(&this);
   }

   // Returns the value of the ::orientation property which determines 
   // whether the labels are drawn beside the icons instead of below.
   // RETURNS: the relative position of texts and icons
   Orientation get_orientation() {
      return gtk_icon_view_get_orientation(&this);
   }

   // Finds the path at the point (@x, @y), relative to bin_window coordinates.
   // See gtk_icon_view_get_item_at_pos(), if you are also interested in
   // the cell at the specified position. 
   // See gtk_icon_view_convert_widget_to_bin_window_coords() for converting
   // widget coordinates to bin_window coordinates.
   // if no icon exists at that position.
   // RETURNS: The #GtkTreePath corresponding to the icon or %NULL
   // <x>: The x position to be identified
   // <y>: The y position to be identified
   TreePath* /*new*/ get_path_at_pos(int x, int y) {
      return gtk_icon_view_get_path_at_pos(&this, x, y);
   }

   // Returns the column with pixbufs for @icon_view.
   // RETURNS: the pixbuf column, or -1 if it's unset.
   int get_pixbuf_column() {
      return gtk_icon_view_get_pixbuf_column(&this);
   }

   // Retrieves whether the user can reorder the list via drag-and-drop. 
   // See gtk_icon_view_set_reorderable().
   // RETURNS: %TRUE if the list can be reordered.
   int get_reorderable() {
      return gtk_icon_view_get_reorderable(&this);
   }

   // Returns the value of the ::row-spacing property.
   // RETURNS: the space between rows
   int get_row_spacing() {
      return gtk_icon_view_get_row_spacing(&this);
   }

   // Creates a list of paths of all selected items. Additionally, if you are
   // planning on modifying the model after calling this function, you may
   // want to convert the returned list into a list of #GtkTreeRowReference<!-- -->s.
   // To do this, you can use gtk_tree_row_reference_new().
   // To free the return value, use:
   // |[
   // g_list_foreach (list, (GFunc)gtk_tree_path_free, NULL);
   // g_list_free (list);
   // ]|
   // RETURNS: A #GList containing a #GtkTreePath for each selected row.
   GLib2.List* /*new*/ get_selected_items() {
      return gtk_icon_view_get_selected_items(&this);
   }

   // Gets the selection mode of the @icon_view.
   // RETURNS: the current selection mode
   SelectionMode get_selection_mode() {
      return gtk_icon_view_get_selection_mode(&this);
   }

   // Returns the value of the ::spacing property.
   // RETURNS: the space between cells
   int get_spacing() {
      return gtk_icon_view_get_spacing(&this);
   }

   // Returns the column with text for @icon_view.
   // RETURNS: the text column, or -1 if it's unset.
   int get_text_column() {
      return gtk_icon_view_get_text_column(&this);
   }

   // Returns the column of @icon_view's model which is being used for
   // displaying tooltips on @icon_view's rows.
   // used, or -1 if this is disabled.
   // RETURNS: the index of the tooltip column that is currently being
   int get_tooltip_column() {
      return gtk_icon_view_get_tooltip_column(&this);
   }

   // This function is supposed to be used in a #GtkWidget::query-tooltip
   // signal handler for #GtkIconView.  The @x, @y and @keyboard_tip values
   // which are received in the signal handler, should be passed to this
   // function without modification.
   // The return value indicates whether there is an icon view item at the given
   // coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
   // tooltips the item returned will be the cursor item. When %TRUE, then any of
   // that row and the corresponding model. @x and @y will always be converted
   // to be relative to @icon_view's bin_window if @keyboard_tooltip is %FALSE.
   // RETURNS: whether or not the given tooltip context points to a item
   // <x>: the x coordinate (relative to widget coordinates)
   // <y>: the y coordinate (relative to widget coordinates)
   // <keyboard_tip>: whether this is a keyboard tooltip or not
   // <model>: a pointer to receive a #GtkTreeModel or %NULL
   // <path>: a pointer to receive a #GtkTreePath or %NULL
   // <iter>: a pointer to receive a #GtkTreeIter or %NULL
   int get_tooltip_context(/*inout*/ int* x, /*inout*/ int* y, int keyboard_tip, /*out*/ TreeModel** model=null, /*out*/ TreePath** path=null, /*out*/ TreeIter* iter=null) {
      return gtk_icon_view_get_tooltip_context(&this, x, y, keyboard_tip, model, path, iter);
   }

   // Sets @start_path and @end_path to be the first and last visible path. 
   // Note that there may be invisible paths in between.
   // Both paths should be freed with gtk_tree_path_free() after use.
   // RETURNS: %TRUE, if valid paths were placed in @start_path and @end_path
   // <start_path>: Return location for start of region, or %NULL
   // <end_path>: Return location for end of region, or %NULL
   int get_visible_range(TreePath** start_path=null, TreePath** end_path=null) {
      return gtk_icon_view_get_visible_range(&this, start_path, end_path);
   }

   // Activates the item determined by @path.
   // <path>: The #GtkTreePath to be activated
   void item_activated(TreePath* path) {
      gtk_icon_view_item_activated(&this, path);
   }

   // Returns %TRUE if the icon pointed to by @path is currently
   // selected. If @path does not point to a valid location, %FALSE is returned.
   // RETURNS: %TRUE if @path is selected.
   // <path>: A #GtkTreePath to check selection on.
   int path_is_selected(TreePath* path) {
      return gtk_icon_view_path_is_selected(&this, path);
   }

   // Moves the alignments of @icon_view to the position specified by @path.  
   // where @column is placed.  Both are expected to be between 0.0 and 1.0. 
   // 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means 
   // center.
   // If @use_align is %FALSE, then the alignment arguments are ignored, and the
   // tree does the minimum amount of work to scroll the item onto the screen.
   // This means that the item will be scrolled to the edge closest to its current
   // position.  If the item is currently visible on the screen, nothing is done.
   // This function only works if the model is set, and @path is a valid row on 
   // the model. If the model changes before the @icon_view is realized, the 
   // centered path will be modified to reflect this change.
   // <path>: The path of the item to move to.
   // <use_align>: whether to use alignment arguments, or %FALSE.
   // <row_align>: The vertical alignment of the item specified by @path.
   // <col_align>: The horizontal alignment of the item specified by @path.
   void scroll_to_path(TreePath* path, int use_align, float row_align, float col_align) {
      gtk_icon_view_scroll_to_path(&this, path, use_align, row_align, col_align);
   }

   // Selects all the icons. @icon_view must has its selection mode set
   // to #GTK_SELECTION_MULTIPLE.
   void select_all() {
      gtk_icon_view_select_all(&this);
   }

   // Selects the row at @path.
   // <path>: The #GtkTreePath to be selected.
   void select_path(TreePath* path) {
      gtk_icon_view_select_path(&this, path);
   }

   // Calls a function for each selected icon. Note that the model or
   // selection cannot be modified from within this function.
   // <func>: The function to call for each selected icon.
   // <data>: User data to pass to the function.
   void selected_foreach(IconViewForeachFunc func, void* data) {
      gtk_icon_view_selected_foreach(&this, func, data);
   }

   // Sets the ::column-spacing property which specifies the space 
   // which is inserted between the columns of the icon view.
   // <column_spacing>: the column spacing
   void set_column_spacing(int column_spacing) {
      gtk_icon_view_set_column_spacing(&this, column_spacing);
   }

   // Sets the ::columns property which determines in how
   // many columns the icons are arranged. If @columns is
   // -1, the number of columns will be chosen automatically 
   // to fill the available area.
   // <columns>: the number of columns
   void set_columns(int columns) {
      gtk_icon_view_set_columns(&this, columns);
   }

   // Sets the current keyboard focus to be at @path, and selects it.  This is
   // useful when you want to focus the user's attention on a particular item.
   // If @cell is not %NULL, then focus is given to the cell specified by 
   // it. Additionally, if @start_editing is %TRUE, then editing should be 
   // started in the specified cell.  
   // This function is often followed by <literal>gtk_widget_grab_focus 
   // (icon_view)</literal> in order to give keyboard focus to the widget.  
   // Please note that editing can only happen when the widget is realized.
   // <path>: A #GtkTreePath
   // <cell>: One of the cell renderers of @icon_view, or %NULL
   // <start_editing>: %TRUE if the specified cell should start being edited.
   void set_cursor(TreePath* path, CellRenderer* cell, int start_editing) {
      gtk_icon_view_set_cursor(&this, path, cell, start_editing);
   }

   // Sets the item that is highlighted for feedback.
   // <path>: The path of the item to highlight, or %NULL.
   // <pos>: Specifies where to drop, relative to the item
   void set_drag_dest_item(TreePath* path, IconViewDropPosition pos) {
      gtk_icon_view_set_drag_dest_item(&this, path, pos);
   }

   // Sets the ::item-orientation property which determines whether
   // the labels are drawn beside the icons instead of below.
   // <orientation>: the relative position of texts and icons
   void set_item_orientation(Orientation orientation) {
      gtk_icon_view_set_item_orientation(&this, orientation);
   }

   // Sets the #GtkIconView:item-padding property which specifies the padding
   // around each of the icon view's items.
   // <item_padding>: the item padding
   void set_item_padding(int item_padding) {
      gtk_icon_view_set_item_padding(&this, item_padding);
   }

   // Sets the ::item-width property which specifies the width 
   // to use for each item. If it is set to -1, the icon view will 
   // automatically determine a suitable item size.
   // <item_width>: the width for each item
   void set_item_width(int item_width) {
      gtk_icon_view_set_item_width(&this, item_width);
   }

   // Sets the ::margin property which specifies the space 
   // which is inserted at the top, bottom, left and right 
   // of the icon view.
   // <margin>: the margin
   void set_margin(int margin) {
      gtk_icon_view_set_margin(&this, margin);
   }

   // Sets the column with markup information for @icon_view to be
   // If the markup column is set to something, it overrides
   // the text column set by gtk_icon_view_set_text_column().
   // <column>: A column in the currently used model, or -1 to display no text
   void set_markup_column(int column) {
      gtk_icon_view_set_markup_column(&this, column);
   }

   // Sets the model for a #GtkIconView.
   // If the @icon_view already has a model set, it will remove
   // it before setting the new model.  If @model is %NULL, then
   // it will unset the old model.
   // <model>: The model.
   void set_model(TreeModel* model=null) {
      gtk_icon_view_set_model(&this, model);
   }

   // Sets the ::orientation property which determines whether the labels 
   // are drawn beside the icons instead of below.
   // <orientation>: the relative position of texts and icons
   void set_orientation(Orientation orientation) {
      gtk_icon_view_set_orientation(&this, orientation);
   }

   // Sets the column with pixbufs for @icon_view to be @column. The pixbuf
   // column must be of type #GDK_TYPE_PIXBUF
   // <column>: A column in the currently used model, or -1 to disable
   void set_pixbuf_column(int column) {
      gtk_icon_view_set_pixbuf_column(&this, column);
   }

   // This function is a convenience function to allow you to reorder models that
   // support the #GtkTreeDragSourceIface and the #GtkTreeDragDestIface.  Both
   // #GtkTreeStore and #GtkListStore support these.  If @reorderable is %TRUE, then
   // the user can reorder the model by dragging and dropping rows.  The
   // developer can listen to these changes by connecting to the model's
   // row_inserted and row_deleted signals. The reordering is implemented by setting up
   // the icon view as a drag source and destination. Therefore, drag and
   // drop can not be used in a reorderable view for any other purpose.
   // This function does not give you any degree of control over the order -- any
   // reordering is allowed.  If more control is needed, you should probably
   // handle drag and drop manually.
   // <reorderable>: %TRUE, if the list of items can be reordered.
   void set_reorderable(int reorderable) {
      gtk_icon_view_set_reorderable(&this, reorderable);
   }

   // Sets the ::row-spacing property which specifies the space 
   // which is inserted between the rows of the icon view.
   // <row_spacing>: the row spacing
   void set_row_spacing(int row_spacing) {
      gtk_icon_view_set_row_spacing(&this, row_spacing);
   }

   // Sets the selection mode of the @icon_view.
   // <mode>: The selection mode
   void set_selection_mode(SelectionMode mode) {
      gtk_icon_view_set_selection_mode(&this, mode);
   }

   // Sets the ::spacing property which specifies the space 
   // which is inserted between the cells (i.e. the icon and 
   // the text) of an item.
   // <spacing>: the spacing
   void set_spacing(int spacing) {
      gtk_icon_view_set_spacing(&this, spacing);
   }

   // Sets the column with text for @icon_view to be @column. The text
   // column must be of type #G_TYPE_STRING.
   // <column>: A column in the currently used model, or -1 to display no text
   void set_text_column(int column) {
      gtk_icon_view_set_text_column(&this, column);
   }

   // Sets the tip area of @tooltip to the area which @cell occupies in
   // the item pointed to by @path. See also gtk_tooltip_set_tip_area().
   // See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
   // <tooltip>: a #GtkTooltip
   // <path>: a #GtkTreePath
   // <cell>: a #GtkCellRenderer or %NULL
   void set_tooltip_cell(Tooltip* tooltip, TreePath* path, CellRenderer* cell=null) {
      gtk_icon_view_set_tooltip_cell(&this, tooltip, path, cell);
   }

   // If you only plan to have simple (text-only) tooltips on full items, you
   // can use this function to have #GtkIconView handle these automatically
   // for you. @column should be set to the column in @icon_view's model
   // containing the tooltip texts, or -1 to disable this feature.
   // When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
   // <column>: an integer, which is a valid column number for @icon_view's model
   void set_tooltip_column(int column) {
      gtk_icon_view_set_tooltip_column(&this, column);
   }

   // Sets the tip area of @tooltip to be the area covered by the item at @path.
   // See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
   // See also gtk_tooltip_set_tip_area().
   // <tooltip>: a #GtkTooltip
   // <path>: a #GtkTreePath
   void set_tooltip_item(Tooltip* tooltip, TreePath* path) {
      gtk_icon_view_set_tooltip_item(&this, tooltip, path);
   }
   // Unselects all the icons.
   void unselect_all() {
      gtk_icon_view_unselect_all(&this);
   }

   // Unselects the row at @path.
   // <path>: The #GtkTreePath to be unselected.
   void unselect_path(TreePath* path) {
      gtk_icon_view_unselect_path(&this, path);
   }

   // Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
   // method sets #GtkIconView:reorderable to %FALSE.
   void unset_model_drag_dest() {
      gtk_icon_view_unset_model_drag_dest(&this);
   }

   // Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
   // method sets #GtkIconView:reorderable to %FALSE.
   void unset_model_drag_source() {
      gtk_icon_view_unset_model_drag_source(&this);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user activates the currently 
   // focused item. 
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control activation
   // programmatically.
   // The default bindings for this signal are Space, Return and Enter.
   extern (C) alias static c_int function (IconView* this_, void* user_data=null) signal_activate_cursor_item;

   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-cursor-item", CB/*:signal_activate_cursor_item*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-cursor-item",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::item-activated signal is emitted when the method
   // gtk_icon_view_item_activated() is called or the user double 
   // clicks an item. It is also emitted when a non-editable item
   // pressed.
   // <path>: the #GtkTreePath for the activated item
   extern (C) alias static void function (IconView* this_, TreePath* path, void* user_data=null) signal_item_activated;
   ulong signal_connect(string name:"item-activated", CB/*:signal_item_activated*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"item-activated",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates a cursor movement.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control the cursor
   // programmatically.
   // The default bindings for this signal include
   // <itemizedlist>
   // <listitem>Arrow keys which move by individual steps</listitem>
   // <listitem>Home/End keys which move to the first/last item</listitem>
   // <listitem>PageUp/PageDown which move by "pages"</listitem>
   // </itemizedlist>
   // All of these will extend the selection when combined with
   // the Shift modifier.
   // <step>: the granularity of the move, as a #GtkMovementStep
   // <count>: the number of @step units to move
   extern (C) alias static c_int function (IconView* this_, MovementStep* step, int count, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user selects all items.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control selection
   // programmatically.
   // The default binding for this signal is Ctrl-a.
   extern (C) alias static void function (IconView* this_, void* user_data=null) signal_select_all;
   ulong signal_connect(string name:"select-all", CB/*:signal_select_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user selects the item that is currently
   // focused.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control selection
   // programmatically.
   // There is no default binding for this signal.
   extern (C) alias static void function (IconView* this_, void* user_data=null) signal_select_cursor_item;
   ulong signal_connect(string name:"select-cursor-item", CB/*:signal_select_cursor_item*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-cursor-item",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::selection-changed signal is emitted when the selection
   // (i.e. the set of selected items) changes.
   extern (C) alias static void function (IconView* this_, void* user_data=null) signal_selection_changed;
   ulong signal_connect(string name:"selection-changed", CB/*:signal_selection_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Set the scroll adjustments for the icon view. Usually scrolled containers
   // like #GtkScrolledWindow will emit this signal to connect two instances
   // of #GtkScrollbar to the scroll directions of the #GtkIconView.
   extern (C) alias static void function (IconView* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;
   ulong signal_connect(string name:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user toggles whether the currently
   // focused item is selected or not. The exact effect of this 
   // depend on the selection mode.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control selection
   // programmatically.
   // There is no default binding for this signal is Ctrl-Space.
   extern (C) alias static void function (IconView* this_, void* user_data=null) signal_toggle_cursor_item;
   ulong signal_connect(string name:"toggle-cursor-item", CB/*:signal_toggle_cursor_item*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-cursor-item",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user unselects all items.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control selection
   // programmatically.
   // The default binding for this signal is Ctrl-Shift-a.
   extern (C) alias static void function (IconView* this_, void* user_data=null) signal_unselect_all;
   ulong signal_connect(string name:"unselect-all", CB/*:signal_unselect_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct IconViewClass {
   ContainerClass parent_class;
   extern (C) void function (IconView* icon_view, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
   // <path>: The #GtkTreePath to be activated
   extern (C) void function (IconView* icon_view, TreePath* path) item_activated;
   extern (C) void function (IconView* icon_view) selection_changed;
   extern (C) void function (IconView* icon_view) select_all;
   extern (C) void function (IconView* icon_view) unselect_all;
   extern (C) void function (IconView* icon_view) select_cursor_item;
   extern (C) void function (IconView* icon_view) toggle_cursor_item;
   extern (C) int function (IconView* icon_view, MovementStep step, int count) move_cursor;
   extern (C) int function (IconView* icon_view) activate_cursor_item;
}

enum IconViewDropPosition {
   NO_DROP = 0,
   DROP_INTO = 1,
   DROP_LEFT = 2,
   DROP_RIGHT = 3,
   DROP_ABOVE = 4,
   DROP_BELOW = 5
}
extern (C) alias void function (IconView* icon_view, TreePath* path, void* data) IconViewForeachFunc;

struct IconViewPrivate {
}


// The #GtkImage widget displays an image. Various kinds of object
// can be displayed as an image; most typically, you would load a
// #GdkPixbuf ("pixel buffer") from a file, and then display that.
// There's a convenience function to do this, gtk_image_new_from_file(),
// used as follows:
// <informalexample><programlisting>
// GtkWidget *image;
// image = gtk_image_new_from_file ("myfile.png");
// </programlisting></informalexample>
// If the file isn't loaded successfully, the image will contain a
// "broken image" icon similar to that used in many web browsers.
// If you want to handle errors in loading the file yourself,
// for example by displaying an error message, then load the image with
// gdk_pixbuf_new_from_file(), then create the #GtkImage with
// gtk_image_new_from_pixbuf().
// The image file may contain an animation, if so the #GtkImage will
// display an animation (#GdkPixbufAnimation) instead of a static image.
// #GtkImage is a subclass of #GtkMisc, which implies that you can
// align it (center, left, right) and add padding to it, using
// #GtkMisc methods.
// #GtkImage is a "no window" widget (has no #GdkWindow of its own),
// so by default does not receive events. If you want to receive events
// on the image, such as button clicks, place the image inside a
// #GtkEventBox, then connect to the event signals on the event box.
// <example>
// <title>Handling button press events on a
// <structname>GtkImage</structname>.</title>
// <programlisting>
// static gboolean
// button_press_callback (GtkWidget      *event_box,
// GdkEventButton *event,
// gpointer        data)
// {
// g_print ("Event box clicked at coordinates &percnt;f,&percnt;f\n",
// event->x, event->y);
// /<!---->* Returning TRUE means we handled the event, so the signal
// * emission should be stopped (don't call any further
// * callbacks that may be connected). Return FALSE
// * to continue invoking callbacks.
// *<!---->/
// return TRUE;
// }
// static GtkWidget*
// create_image (void)
// {
// GtkWidget *image;
// GtkWidget *event_box;
// image = gtk_image_new_from_file ("myfile.png");
// event_box = gtk_event_box_new (<!-- -->);
// gtk_container_add (GTK_CONTAINER (event_box), image);
// g_signal_connect (G_OBJECT (event_box),
// "button_press_event",
// G_CALLBACK (button_press_callback),
// image);
// return image;
// }
// </programlisting>
// </example>
// When handling events on the event box, keep in mind that coordinates
// in the image may be different from event box coordinates due to
// the alignment and padding settings on the image (see #GtkMisc).
// The simplest way to solve this is to set the alignment to 0.0
// (left/top), and set the padding to zero. Then the origin of
// the image will be the same as the origin of the event box.
// Sometimes an application will want to avoid depending on external data
// files, such as image files. GTK+ comes with a program to avoid this,
// called <application>gdk-pixbuf-csource</application>. This program
// allows you to convert an image into a C variable declaration, which
// can then be loaded into a #GdkPixbuf using
// gdk_pixbuf_new_from_inline().
struct Image /* : Misc */ {
   alias misc this;
   alias misc super_;
   Misc misc;
   ImageType storage_type;

   union data {
      ImagePixmapData pixmap;
      ImageImageData image;
      ImagePixbufData pixbuf;
      ImageStockData stock;
      ImageIconSetData icon_set;
      ImageAnimationData anim;
      ImageIconNameData name;
      ImageGIconData gicon;
   }

   Gdk2.Bitmap* mask;
   IconSize icon_size;


   // Creates a new empty #GtkImage widget.
   // RETURNS: a newly created #GtkImage widget.
   static Image* new_() {
      return gtk_image_new();
   }

   // Creates a #GtkImage displaying the given animation.
   // The #GtkImage does not assume a reference to the
   // animation; you still need to unref it if you own references.
   // #GtkImage will add its own reference rather than adopting yours.
   // Note that the animation frames are shown using a timeout with
   // #G_PRIORITY_DEFAULT. When using animations to indicate busyness,
   // keep in mind that the animation will only be shown if the main loop
   // is not busy with something that has a higher priority.
   // RETURNS: a new #GtkImage widget
   // <animation>: an animation
   static Image* new_from_animation(GdkPixbuf2.PixbufAnimation* animation) {
      return gtk_image_new_from_animation(animation);
   }

   // Creates a new #GtkImage displaying the file @filename. If the file
   // isn't found or can't be loaded, the resulting #GtkImage will
   // display a "broken image" icon. This function never returns %NULL,
   // it always returns a valid #GtkImage widget.
   // If the file contains an animation, the image will contain an
   // animation.
   // If you need to detect failures to load the file, use
   // gdk_pixbuf_new_from_file() to load the file yourself, then create
   // the #GtkImage from the pixbuf. (Or for animations, use
   // gdk_pixbuf_animation_new_from_file()).
   // The storage type (gtk_image_get_storage_type()) of the returned
   // image is not defined, it will be whatever is appropriate for
   // displaying the file.
   // RETURNS: a new #GtkImage
   // <filename>: a filename
   static Image* new_from_file(char* filename) {
      return gtk_image_new_from_file(filename);
   }

   // Creates a #GtkImage displaying an icon from the current icon theme.
   // If the icon name isn't known, a "broken image" icon will be
   // displayed instead.  If the current icon theme is changed, the icon
   // will be updated appropriately.
   // RETURNS: a new #GtkImage displaying the themed icon
   // <icon>: an icon
   // <size>: a stock icon size
   static Image* new_from_gicon(Gio2.Icon* icon, int size) {
      return gtk_image_new_from_gicon(icon, size);
   }

   // Creates a #GtkImage displaying an icon from the current icon theme.
   // If the icon name isn't known, a "broken image" icon will be
   // displayed instead.  If the current icon theme is changed, the icon
   // will be updated appropriately.
   // RETURNS: a new #GtkImage displaying the themed icon
   // <icon_name>: an icon name
   // <size>: a stock icon size
   static Image* new_from_icon_name(char* icon_name, int size) {
      return gtk_image_new_from_icon_name(icon_name, size);
   }

   // Creates a #GtkImage displaying an icon set. Sample stock sizes are
   // #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using
   // this function, usually it's better to create a #GtkIconFactory, put
   // your icon sets in the icon factory, add the icon factory to the
   // list of default factories with gtk_icon_factory_add_default(), and
   // then use gtk_image_new_from_stock(). This will allow themes to
   // override the icon you ship with your application.
   // The #GtkImage does not assume a reference to the
   // icon set; you still need to unref it if you own references.
   // #GtkImage will add its own reference rather than adopting yours.
   // RETURNS: a new #GtkImage
   // <icon_set>: a #GtkIconSet
   // <size>: a stock icon size
   static Image* new_from_icon_set(IconSet* icon_set, int size) {
      return gtk_image_new_from_icon_set(icon_set, size);
   }

   // Creates a #GtkImage widget displaying a @image with a @mask.
   // A #GdkImage is a client-side image buffer in the pixel format of the
   // current display. The #GtkImage does not assume a reference to the
   // image or mask; you still need to unref them if you own references.
   // #GtkImage will add its own reference rather than adopting yours.
   // RETURNS: a new #GtkImage
   // <image>: a #GdkImage, or %NULL
   // <mask>: a #GdkBitmap, or %NULL
   static Image* new_from_image(Gdk2.Image* image=null, Gdk2.Bitmap* mask=null) {
      return gtk_image_new_from_image(image, mask);
   }

   // Creates a new #GtkImage displaying @pixbuf.
   // The #GtkImage does not assume a reference to the
   // pixbuf; you still need to unref it if you own references.
   // #GtkImage will add its own reference rather than adopting yours.
   // Note that this function just creates an #GtkImage from the pixbuf. The
   // #GtkImage created will not react to state changes. Should you want that, 
   // you should use gtk_image_new_from_icon_set().
   // RETURNS: a new #GtkImage
   // <pixbuf>: a #GdkPixbuf, or %NULL
   static Image* new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf=null) {
      return gtk_image_new_from_pixbuf(pixbuf);
   }

   // Creates a #GtkImage widget displaying @pixmap with a @mask.
   // A #GdkPixmap is a server-side image buffer in the pixel format of the
   // current display. The #GtkImage does not assume a reference to the
   // pixmap or mask; you still need to unref them if you own references.
   // #GtkImage will add its own reference rather than adopting yours.
   // RETURNS: a new #GtkImage
   // <pixmap>: a #GdkPixmap, or %NULL
   // <mask>: a #GdkBitmap, or %NULL
   static Image* new_from_pixmap(Gdk2.Pixmap* pixmap=null, Gdk2.Bitmap* mask=null) {
      return gtk_image_new_from_pixmap(pixmap, mask);
   }

   // Creates a #GtkImage displaying a stock icon. Sample stock icon
   // names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. Sample stock sizes
   // are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock
   // icon name isn't known, the image will be empty.
   // You can register your own stock icon names, see
   // gtk_icon_factory_add_default() and gtk_icon_factory_add().
   // RETURNS: a new #GtkImage displaying the stock icon
   // <stock_id>: a stock icon name
   // <size>: a stock icon size
   static Image* new_from_stock(char* stock_id, int size) {
      return gtk_image_new_from_stock(stock_id, size);
   }
   // Resets the image to be empty.
   void clear() {
      gtk_image_clear(&this);
   }

   // Gets the #GtkImage.
   // <val>: return location for a #GdkImage
   // <mask>: a #GdkBitmap that indicates which parts of the image should be transparent.
   void get(Gdk2.Image** val, Gdk2.Bitmap** mask) {
      gtk_image_get(&this, val, mask);
   }

   // Gets the #GdkPixbufAnimation being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_ANIMATION (see gtk_image_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned animation.
   // the image is empty
   // RETURNS: the displayed animation, or %NULL if
   GdkPixbuf2.PixbufAnimation* get_animation() {
      return gtk_image_get_animation(&this);
   }

   // Gets the #GIcon and size being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_GICON (see gtk_image_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned #GIcon.
   // <gicon>: place to store a #GIcon, or %NULL
   // <size>: place to store an icon size, or %NULL
   void get_gicon(/*out*/ Gio2.Icon** gicon=null, /*out*/ /*POINTER*/ int* size=null) {
      gtk_image_get_gicon(&this, gicon, size);
   }

   // Gets the icon name and size being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_ICON_NAME (see gtk_image_get_storage_type()).
   // The returned string is owned by the #GtkImage and should not
   // be freed.
   // <icon_name>: place to store an icon name, or %NULL
   // <size>: place to store an icon size, or %NULL
   void get_icon_name(/*out*/ char** icon_name=null, /*out*/ /*POINTER*/ int* size=null) {
      gtk_image_get_icon_name(&this, icon_name, size);
   }

   // Gets the icon set and size being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()).
   // <icon_set>: location to store a #GtkIconSet, or %NULL
   // <size>: location to store a stock icon size, or %NULL
   void get_icon_set(/*out*/ IconSet** icon_set=null, /*out*/ /*POINTER*/ int* size=null) {
      gtk_image_get_icon_set(&this, icon_set, size);
   }

   // Gets the #GdkImage and mask being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_IMAGE (see gtk_image_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned image and mask.
   // <gdk_image>: return location for a #GtkImage, or %NULL
   // <mask>: return location for a #GdkBitmap, or %NULL
   void get_image(/*out*/ Gdk2.Image** gdk_image=null, /*out*/ Gdk2.Bitmap** mask=null) {
      gtk_image_get_image(&this, gdk_image, mask);
   }

   // Gets the #GdkPixbuf being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned pixbuf.
   // the image is empty
   // RETURNS: the displayed pixbuf, or %NULL if
   GdkPixbuf2.Pixbuf* get_pixbuf() {
      return gtk_image_get_pixbuf(&this);
   }

   // Gets the pixel size used for named icons.
   // RETURNS: the pixel size used for named icons.
   int get_pixel_size() {
      return gtk_image_get_pixel_size(&this);
   }

   // Gets the pixmap and mask being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_PIXMAP (see gtk_image_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned pixmap and mask.
   // <pixmap>: location to store the pixmap, or %NULL
   // <mask>: location to store the mask, or %NULL
   void get_pixmap(/*out*/ Gdk2.Pixmap** pixmap=null, /*out*/ Gdk2.Bitmap** mask=null) {
      gtk_image_get_pixmap(&this, pixmap, mask);
   }

   // Gets the stock icon name and size being displayed by the #GtkImage.
   // The storage type of the image must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()).
   // The returned string is owned by the #GtkImage and should not
   // be freed.
   // <stock_id>: place to store a stock icon name, or %NULL
   // <size>: place to store a stock icon size, or %NULL
   void get_stock(/*out*/ char** stock_id=null, /*out*/ /*POINTER*/ int* size=null) {
      gtk_image_get_stock(&this, stock_id, size);
   }

   // Gets the type of representation being used by the #GtkImage
   // to store image data. If the #GtkImage has no image data,
   // the return value will be %GTK_IMAGE_EMPTY.
   // RETURNS: image representation being used
   ImageType get_storage_type() {
      return gtk_image_get_storage_type(&this);
   }

   // Sets the #GtkImage.
   // <val>: a #GdkImage
   // <mask>: a #GdkBitmap that indicates which parts of the image should be transparent.
   void set(Gdk2.Image* val, Gdk2.Bitmap* mask) {
      gtk_image_set(&this, val, mask);
   }

   // Causes the #GtkImage to display the given animation (or display
   // nothing, if you set the animation to %NULL).
   // <animation>: the #GdkPixbufAnimation
   void set_from_animation(GdkPixbuf2.PixbufAnimation* animation) {
      gtk_image_set_from_animation(&this, animation);
   }

   // See gtk_image_new_from_file() for details.
   // <filename>: a filename or %NULL
   void set_from_file(char* filename=null) {
      gtk_image_set_from_file(&this, filename);
   }

   // See gtk_image_new_from_gicon() for details.
   // <icon>: an icon
   // <size>: an icon size
   void set_from_gicon(Gio2.Icon* icon, int size) {
      gtk_image_set_from_gicon(&this, icon, size);
   }

   // See gtk_image_new_from_icon_name() for details.
   // <icon_name>: an icon name
   // <size>: an icon size
   void set_from_icon_name(char* icon_name, int size) {
      gtk_image_set_from_icon_name(&this, icon_name, size);
   }

   // See gtk_image_new_from_icon_set() for details.
   // <icon_set>: a #GtkIconSet
   // <size>: a stock icon size
   void set_from_icon_set(IconSet* icon_set, int size) {
      gtk_image_set_from_icon_set(&this, icon_set, size);
   }

   // See gtk_image_new_from_image() for details.
   // <gdk_image>: a #GdkImage or %NULL
   // <mask>: a #GdkBitmap or %NULL
   void set_from_image(Gdk2.Image* gdk_image=null, Gdk2.Bitmap* mask=null) {
      gtk_image_set_from_image(&this, gdk_image, mask);
   }

   // See gtk_image_new_from_pixbuf() for details.
   // <pixbuf>: a #GdkPixbuf or %NULL
   void set_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_image_set_from_pixbuf(&this, pixbuf);
   }

   // See gtk_image_new_from_pixmap() for details.
   // <pixmap>: a #GdkPixmap or %NULL
   // <mask>: a #GdkBitmap or %NULL
   void set_from_pixmap(Gdk2.Pixmap* pixmap=null, Gdk2.Bitmap* mask=null) {
      gtk_image_set_from_pixmap(&this, pixmap, mask);
   }

   // See gtk_image_new_from_stock() for details.
   // <stock_id>: a stock icon name
   // <size>: a stock icon size
   void set_from_stock(char* stock_id, int size) {
      gtk_image_set_from_stock(&this, stock_id, size);
   }

   // Sets the pixel size to use for named icons. If the pixel size is set
   // to a value != -1, it is used instead of the icon size set by
   // gtk_image_set_from_icon_name().
   // <pixel_size>: the new pixel size
   void set_pixel_size(int pixel_size) {
      gtk_image_set_pixel_size(&this, pixel_size);
   }
}

struct ImageAnimationData {
   GdkPixbuf2.PixbufAnimation* anim;
   GdkPixbuf2.PixbufAnimationIter* iter;
   uint frame_timeout;
}

struct ImageClass {
   MiscClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ImageGIconData {
   Gio2.Icon* icon;
   GdkPixbuf2.Pixbuf* pixbuf;
   uint theme_change_id;
}

struct ImageIconNameData {
   char* icon_name;
   GdkPixbuf2.Pixbuf* pixbuf;
   uint theme_change_id;
}

struct ImageIconSetData {
   IconSet* icon_set;
}

struct ImageImageData {
   Gdk2.Image* image;
}

struct ImageMenuItem /* : MenuItem */ {
   alias menu_item this;
   alias menu_item super_;
   alias menu_item menuitem;
   MenuItem menu_item;
   private Widget* image;


   // Creates a new #GtkImageMenuItem with an empty label.
   // RETURNS: a new #GtkImageMenuItem.
   static ImageMenuItem* new_() {
      return gtk_image_menu_item_new();
   }

   // Creates a new #GtkImageMenuItem containing the image and text from a 
   // stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK 
   // and #GTK_STOCK_APPLY.
   // If you want this menu item to have changeable accelerators, then pass in
   // %NULL for accel_group. Next call gtk_menu_item_set_accel_path() with an
   // appropriate path for the menu item, use gtk_stock_lookup() to look up the
   // standard accelerator for the stock item, and if one is found, call
   // gtk_accel_map_add_entry() to register it.
   // RETURNS: a new #GtkImageMenuItem.
   // <stock_id>: the name of the stock item.
   // <accel_group>: the #GtkAccelGroup to add the menu items accelerator to, or %NULL.
   static ImageMenuItem* new_from_stock(char* stock_id, AccelGroup* accel_group=null) {
      return gtk_image_menu_item_new_from_stock(stock_id, accel_group);
   }

   // Creates a new #GtkImageMenuItem containing a label.
   // RETURNS: a new #GtkImageMenuItem.
   // <label>: the text of the menu item.
   static ImageMenuItem* new_with_label(char* label) {
      return gtk_image_menu_item_new_with_label(label);
   }

   // Creates a new #GtkImageMenuItem containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the menu item.
   // RETURNS: a new #GtkImageMenuItem
   // <label>: the text of the menu item, with an underscore in front of the mnemonic character
   static ImageMenuItem* new_with_mnemonic(char* label) {
      return gtk_image_menu_item_new_with_mnemonic(label);
   }

   // Returns whether the menu item will ignore the #GtkSettings:gtk-menu-images
   // setting and always show the image, if available.
   // RETURNS: %TRUE if the menu item will always show the image
   int get_always_show_image() {
      return gtk_image_menu_item_get_always_show_image(&this);
   }

   // Gets the widget that is currently set as the image of @image_menu_item.
   // See gtk_image_menu_item_set_image().
   // RETURNS: the widget set as image of @image_menu_item
   Widget* get_image() {
      return gtk_image_menu_item_get_image(&this);
   }

   // Checks whether the label set in the menuitem is used as a
   // stock id to select the stock item for the item.
   // stock id to select the stock item for the item
   // RETURNS: %TRUE if the label set in the menuitem is used as a
   int get_use_stock() {
      return gtk_image_menu_item_get_use_stock(&this);
   }

   // Specifies an @accel_group to add the menu items accelerator to
   // (this only applies to stock items so a stock item must already
   // be set, make sure to call gtk_image_menu_item_set_use_stock()
   // and gtk_menu_item_set_label() with a valid stock item first).
   // If you want this menu item to have changeable accelerators then
   // you shouldnt need this (see gtk_image_menu_item_new_from_stock()).
   // <accel_group>: the #GtkAccelGroup
   void set_accel_group(AccelGroup* accel_group) {
      gtk_image_menu_item_set_accel_group(&this, accel_group);
   }

   // If %TRUE, the menu item will ignore the #GtkSettings:gtk-menu-images 
   // setting and always show the image, if available.
   // Use this property if the menuitem would be useless or hard to use
   // without the image.
   // <always_show>: %TRUE if the menuitem should always show the image
   void set_always_show_image(int always_show) {
      gtk_image_menu_item_set_always_show_image(&this, always_show);
   }

   // Sets the image of @image_menu_item to the given widget.
   // Note that it depends on the show-menu-images setting whether
   // the image will be displayed or not.
   // <image>: a widget to set as the image for the menu item.
   void set_image(Widget* image=null) {
      gtk_image_menu_item_set_image(&this, image);
   }

   // If %TRUE, the label set in the menuitem is used as a
   // stock id to select the stock item for the item.
   // <use_stock>: %TRUE if the menuitem should use a stock item
   void set_use_stock(int use_stock) {
      gtk_image_menu_item_set_use_stock(&this, use_stock);
   }
}

struct ImageMenuItemClass {
   MenuItemClass parent_class;
}

struct ImagePixbufData {
   GdkPixbuf2.Pixbuf* pixbuf;
}

struct ImagePixmapData {
   Gdk2.Pixmap* pixmap;
}

struct ImageStockData {
   char* stock_id;
}


// Describes the image data representation used by a #GtkImage. If you
// want to get the image from the widget, you can only get the
// currently-stored representation. e.g.  if the
// gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
// call gtk_image_get_pixbuf() but not gtk_image_get_stock().  For empty
// images, you can request any storage type (call any of the "get"
// functions), but they will all return %NULL values.
enum ImageType {
   EMPTY = 0,
   PIXMAP = 1,
   IMAGE = 2,
   PIXBUF = 3,
   STOCK = 4,
   ICON_SET = 5,
   ANIMATION = 6,
   ICON_NAME = 7,
   GICON = 8
}

// #GtkInfoBar is a widget that can be used to show messages to
// the user without showing a dialog. It is often temporarily shown
// at the top or bottom of a document. In contrast to #GtkDialog, which
// has a horizontal action area at the bottom, #GtkInfoBar has a
// vertical action area at the side.
// The API of #GtkInfoBar is very similar to #GtkDialog, allowing you
// to add buttons to the action area with gtk_info_bar_add_button() or
// gtk_info_bar_new_with_buttons(). The sensitivity of action widgets
// can be controlled with gtk_info_bar_set_response_sensitive().
// To add widgets to the main content area of a #GtkInfoBar, use
// gtk_info_bar_get_content_area() and add your widgets to the container.
// Similar to #GtkMessageDialog, the contents of a #GtkInfoBar can by
// classified as error message, warning, informational message, etc,
// by using gtk_info_bar_set_message_type(). GTK+ uses the message type
// to determine the background color of the message area.
// <example>
// <title>Simple GtkInfoBar usage.</title>
// <programlisting>
// /&ast; set up info bar &ast;/
// info_bar = gtk_info_bar_new ();
// gtk_widget_set_no_show_all (info_bar, TRUE);
// message_label = gtk_label_new ("");
// gtk_widget_show (message_label);
// content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
// gtk_container_add (GTK_CONTAINER (content_area), message_label);
// gtk_info_bar_add_button (GTK_INFO_BAR (info_bar),
// GTK_STOCK_OK, GTK_RESPONSE_OK);
// g_signal_connect (info_bar, "response",
// G_CALLBACK (gtk_widget_hide), NULL);
// gtk_table_attach (GTK_TABLE (table),
// info_bar,
// 0, 1, 2, 3,
// GTK_EXPAND | GTK_FILL,  0,
// 0,                      0);
// /&ast; ... &ast;/
// /&ast; show an error message &ast;/
// gtk_label_set_text (GTK_LABEL (message_label), error_message);
// gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar),
// GTK_MESSAGE_ERROR);
// gtk_widget_show (info_bar);
// </programlisting>
// </example>
// <refsect2 id="GtkInfoBar-BUILDER-UI">
// <title>GtkInfoBar as GtkBuildable</title>
// <para>
// The GtkInfoBar implementation of the GtkBuildable interface exposes
// the content area and action area as internal children with the names
// "content_area" and "action_area".
// </para>
// <para>
// GtkInfoBar supports a custom &lt;action-widgets&gt; element, which
// can contain multiple &lt;action-widget&gt; elements. The "response"
// attribute specifies a numeric response, and the content of the element
// is the id of widget (which should be a child of the dialogs @action_area).
// </para>
// </refsect2>
struct InfoBar /* : HBox */ {
   alias parent this;
   alias parent super_;
   alias parent hbox;
   HBox parent;
   private InfoBarPrivate* priv;


   // Creates a new #GtkInfoBar object.
   // RETURNS: a new #GtkInfoBar object
   static InfoBar* new_() {
      return gtk_info_bar_new();
   }

   // Unintrospectable constructor: new_with_buttons() / gtk_info_bar_new_with_buttons()
   // Creates a new #GtkInfoBar with buttons. Button text/response ID
   // pairs should be listed, with a %NULL pointer ending the list.
   // Button text can be either a stock ID such as %GTK_STOCK_OK, or
   // some arbitrary text. A response ID can be any positive number,
   // or one of the values in the #GtkResponseType enumeration. If the
   // user clicks one of these dialog buttons, GtkInfoBar will emit
   // the "response" signal with the corresponding response ID.
   // RETURNS: a new #GtkInfoBar
   // <first_button_text>: stock ID or text to go in first button, or %NULL
   alias gtk_info_bar_new_with_buttons new_with_buttons; // Variadic

   // Add an activatable widget to the action area of a #GtkInfoBar,
   // connecting a signal handler that will emit the #GtkInfoBar::response
   // signal on the message area when the widget is activated. The widget
   // is appended to the end of the message areas action area.
   // <child>: an activatable widget
   // <response_id>: response ID for @child
   void add_action_widget(Widget* child, int response_id) {
      gtk_info_bar_add_action_widget(&this, child, response_id);
   }

   // Adds a button with the given text (or a stock button, if button_text
   // is a stock ID) and sets things up so that clicking the button will emit
   // the "response" signal with the given response_id. The button is appended
   // to the end of the info bars's action area. The button widget is
   // returned, but usually you don't need it.
   // RETURNS: the button widget that was added
   // <button_text>: text of button, or stock ID
   // <response_id>: response ID for the button
   Widget* add_button(char* button_text, int response_id) {
      return gtk_info_bar_add_button(&this, button_text, response_id);
   }

   // Unintrospectable method: add_buttons() / gtk_info_bar_add_buttons()
   // Adds more buttons, same as calling gtk_info_bar_add_button()
   // repeatedly. The variable argument list should be %NULL-terminated
   // as with gtk_info_bar_new_with_buttons(). Each button must have both
   // text and response ID.
   // <first_button_text>: button text or stock ID
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_info_bar_add_buttons add_buttons; // Variadic
   +/

   // Returns the action area of @info_bar.
   // RETURNS: the action area
   Widget* get_action_area() {
      return gtk_info_bar_get_action_area(&this);
   }

   // Returns the content area of @info_bar.
   // RETURNS: the content area
   Widget* get_content_area() {
      return gtk_info_bar_get_content_area(&this);
   }

   // Returns the message type of the message area.
   // RETURNS: the message type of the message area.
   MessageType get_message_type() {
      return gtk_info_bar_get_message_type(&this);
   }

   // Emits the 'response' signal with the given @response_id.
   // <response_id>: a response ID
   void response(int response_id) {
      gtk_info_bar_response(&this, response_id);
   }

   // Sets the last widget in the info bar's action area with
   // the given response_id as the default widget for the dialog.
   // Pressing "Enter" normally activates the default widget.
   // Note that this function currently requires @info_bar to
   // be added to a widget hierarchy.
   // <response_id>: a response ID
   void set_default_response(int response_id) {
      gtk_info_bar_set_default_response(&this, response_id);
   }

   // Sets the message type of the message area.
   // GTK+ uses this type to determine what color to use
   // when drawing the message area.
   // <message_type>: a #GtkMessageType
   void set_message_type(MessageType message_type) {
      gtk_info_bar_set_message_type(&this, message_type);
   }

   // Calls gtk_widget_set_sensitive (widget, setting) for each
   // widget in the info bars's action area with the given response_id.
   // A convenient way to sensitize/desensitize dialog buttons.
   // <response_id>: a response ID
   // <setting>: TRUE for sensitive
   void set_response_sensitive(int response_id, int setting) {
      gtk_info_bar_set_response_sensitive(&this, response_id, setting);
   }

   // The ::close signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user uses a keybinding to dismiss
   // the info bar.
   // The default binding for this signal is the Escape key.
   extern (C) alias static void function (InfoBar* this_, void* user_data=null) signal_close;

   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", CB/*:signal_close*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"close",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when an action widget is clicked or the application programmer
   // calls gtk_dialog_response(). The @response_id depends on which action
   // widget was clicked.
   // <response_id>: the response ID
   extern (C) alias static void function (InfoBar* this_, int response_id, void* user_data=null) signal_response;
   ulong signal_connect(string name:"response", CB/*:signal_response*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"response",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct InfoBarClass {
   HBoxClass parent_class;
   // <response_id>: a response ID
   extern (C) void function (InfoBar* info_bar, int response_id) response;
   extern (C) void function (InfoBar* info_bar) close;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
}

struct InfoBarPrivate {
}

struct InputDialog /* : Dialog */ {
   alias dialog this;
   alias dialog super_;
   Dialog dialog;
   Widget* axis_list, axis_listbox, mode_optionmenu, close_button, save_button;
   Widget*[666] axis_items;
   Gdk2.Device* current_device;
   Widget* keys_list, keys_listbox;

   static InputDialog* new_() {
      return gtk_input_dialog_new();
   }
   extern (C) alias static void function (InputDialog* this_, Gdk2.Device* object, void* user_data=null) signal_disable_device;

   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:"disable-device", CB/*:signal_disable_device*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"disable-device",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (InputDialog* this_, Gdk2.Device* object, void* user_data=null) signal_enable_device;
   ulong signal_connect(string name:"enable-device", CB/*:signal_enable_device*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"enable-device",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct InputDialogClass {
   DialogClass parent_class;
   extern (C) void function (InputDialog* inputd, Gdk2.Device* device) enable_device;
   extern (C) void function (InputDialog* inputd, Gdk2.Device* device) disable_device;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Invisible /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   int has_user_ref_count;
   Gdk2.Screen* screen;


   // Creates a new #GtkInvisible.
   // RETURNS: a new #GtkInvisible.
   static Invisible* new_() {
      return gtk_invisible_new();
   }

   // Creates a new #GtkInvisible object for a specified screen
   // RETURNS: a newly created #GtkInvisible object
   // <screen>: a #GdkScreen which identifies on which the new #GtkInvisible will be created.
   static Invisible* new_for_screen(Gdk2.Screen* screen) {
      return gtk_invisible_new_for_screen(screen);
   }

   // Returns the #GdkScreen object associated with @invisible
   // RETURNS: the associated #GdkScreen.
   Gdk2.Screen* get_screen() {
      return gtk_invisible_get_screen(&this);
   }

   // Sets the #GdkScreen where the #GtkInvisible object will be displayed.
   // <screen>: a #GdkScreen.
   void set_screen(Gdk2.Screen* screen) {
      gtk_invisible_set_screen(&this, screen);
   }
}

struct InvisibleClass {
   WidgetClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Item /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;


   // Deletes all widgets constructed from the specified path.
   // <ifactory_path>: a factory path to prepend to @path. May be %NULL if @path starts with a factory path
   // <path>: a path
   static void factories_path_delete(char* ifactory_path, char* path) {
      gtk_item_factories_path_delete(ifactory_path, path);
   }
   void deselect() {
      gtk_item_deselect(&this);
   }
   void select() {
      gtk_item_select(&this);
   }
   void toggle() {
      gtk_item_toggle(&this);
   }
   extern (C) alias static void function (Item* this_, void* user_data=null) signal_deselect;

   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:"deselect", CB/*:signal_deselect*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"deselect",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Item* this_, void* user_data=null) signal_select;
   ulong signal_connect(string name:"select", CB/*:signal_select*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Item* this_, void* user_data=null) signal_toggle;
   ulong signal_connect(string name:"toggle", CB/*:signal_toggle*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ItemClass {
   BinClass parent_class;
   extern (C) void function (Item* item) select;
   extern (C) void function (Item* item) deselect;
   extern (C) void function (Item* item) toggle;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ItemFactory /* : Object */ {
   alias object this;
   alias object super_;
   Object object;
   char* path;
   AccelGroup* accel_group;
   Widget* widget;
   GLib2.SList* items;
   TranslateFunc translate_func;
   void* translate_data;
   GLib2.DestroyNotify translate_notify;


   // Creates a new #GtkItemFactory.
   // Beware that the returned object does not have a floating reference.
   // RETURNS: a new #GtkItemFactory
   // <container_type>: the kind of menu to create; can be #GTK_TYPE_MENU_BAR, #GTK_TYPE_MENU or #GTK_TYPE_OPTION_MENU
   // <path>: the factory path of the new item factory, a string of the form <literal>"&lt;name&gt;"</literal>
   // <accel_group>: a #GtkAccelGroup to which the accelerators for the menu items will be added, or %NULL to create a new one
   static ItemFactory* new_(Type container_type, char* path, AccelGroup* accel_group=null) {
      return gtk_item_factory_new(container_type, path, accel_group);
   }

   // Installs an accelerator for @accel_widget in @accel_group, that causes
   // the ::activate signal to be emitted if the accelerator is activated.
   // This function can be used to make widgets participate in the accel
   // saving/restoring functionality provided by gtk_accel_map_save() and
   // gtk_accel_map_load(), even if they haven't been created by an item
   // factory. 
   // gtk_menu_item_set_accel_path() and gtk_widget_set_accel_path(); don't 
   // use gtk_item_factory_add_foreign() in new code, since it is likely to
   // be removed in the future.
   // <accel_widget>: widget to install an accelerator on
   // <accel_group>: the accelerator group to install the accelerator in
   // <keyval>: key value of the accelerator
   // <modifiers>: modifier combination of the accelerator
   static void add_foreign(Widget* accel_widget, char* full_path, AccelGroup* accel_group, uint keyval, Gdk2.ModifierType modifiers) {
      gtk_item_factory_add_foreign(accel_widget, full_path, accel_group, keyval, modifiers);
   }

   // Creates the menu items from the @entries.
   // <n_entries>: the length of @entries
   // <entries>: an array of #GtkMenuEntry<!-- -->s
   static void create_menu_entries(uint n_entries, MenuEntry* entries) {
      gtk_item_factory_create_menu_entries(n_entries, entries);
   }

   // Unintrospectable function: from_path() / gtk_item_factory_from_path()
   // Finds an item factory which has been constructed using the 
   // <literal>"&lt;name&gt;"</literal> prefix of @path as the @path argument 
   // for gtk_item_factory_new().
   // RETURNS: the #GtkItemFactory created for the given factory path, or %NULL
   // <path>: a string starting with a factory path of the form <literal>"&lt;name&gt;"</literal>
   static ItemFactory* from_path(char* path) {
      return gtk_item_factory_from_path(path);
   }

   // Unintrospectable function: from_widget() / gtk_item_factory_from_widget()
   // Obtains the item factory from which a widget was created.
   // RETURNS: the item factory from which @widget was created, or %NULL
   // <widget>: a widget
   static ItemFactory* from_widget(Widget* widget) {
      return gtk_item_factory_from_widget(widget);
   }

   // If @widget has been created by an item factory, returns the full path
   // to it. (The full path of a widget is the concatenation of the factory 
   // path specified in gtk_item_factory_new() with the path specified in the 
   // #GtkItemFactoryEntry from which the widget was created.)
   // RETURNS: the full path to @widget if it has been created by an item factory, %NULL otherwise. This value is owned by GTK+ and must not be modified or freed.
   // <widget>: a widget
   static char* path_from_widget(Widget* widget) {
      return gtk_item_factory_path_from_widget(widget);
   }

   // Unintrospectable function: popup_data_from_widget() / gtk_item_factory_popup_data_from_widget()
   // Obtains the @popup_data which was passed to 
   // gtk_item_factory_popup_with_data(). This data is available until the menu
   // is popped down again.
   // RETURNS: @popup_data associated with the item factory from which @widget was created, or %NULL if @widget wasn't created by an item factory
   // <widget>: a widget
   static void* popup_data_from_widget(Widget* widget) {
      return gtk_item_factory_popup_data_from_widget(widget);
   }

   // Initializes an item factory.
   // <container_type>: the kind of menu to create; can be #GTK_TYPE_MENU_BAR, #GTK_TYPE_MENU or #GTK_TYPE_OPTION_MENU
   // <path>: the factory path of @ifactory, a string of the form <literal>"&lt;name&gt;"</literal>
   // <accel_group>: a #GtkAccelGroup to which the accelerators for the menu items will be added, or %NULL to create a new one
   void construct(Type container_type, char* path, AccelGroup* accel_group) {
      gtk_item_factory_construct(&this, container_type, path, accel_group);
   }

   // Creates an item for @entry.
   // <entry>: the #GtkItemFactoryEntry to create an item for
   // <callback_data>: data passed to the callback function of @entry
   // <callback_type>: 1 if the callback function of @entry is of type #GtkItemFactoryCallback1, 2 if it is of type #GtkItemFactoryCallback2
   void create_item(ItemFactoryEntry* entry, void* callback_data, uint callback_type) {
      gtk_item_factory_create_item(&this, entry, callback_data, callback_type);
   }

   // Creates the menu items from the @entries.
   // <n_entries>: the length of @entries
   // <entries>: an array of #GtkItemFactoryEntry<!-- -->s whose @callback members must by of type #GtkItemFactoryCallback1
   // <callback_data>: data passed to the callback functions of all entries
   void create_items(uint n_entries, ItemFactoryEntry* entries, void* callback_data) {
      gtk_item_factory_create_items(&this, n_entries, entries, callback_data);
   }

   // Creates the menu items from the @entries.
   // <n_entries>: the length of @entries
   // <entries>: an array of #GtkItemFactoryEntry<!-- -->s
   // <callback_data>: data passed to the callback functions of all entries
   // <callback_type>: 1 if the callback functions in @entries are of type #GtkItemFactoryCallback1, 2 if they are of type #GtkItemFactoryCallback2
   void create_items_ac(uint n_entries, ItemFactoryEntry* entries, void* callback_data, uint callback_type) {
      gtk_item_factory_create_items_ac(&this, n_entries, entries, callback_data, callback_type);
   }

   // Deletes the menu items which were created from the @entries by the given
   // item factory.
   // <n_entries>: the length of @entries
   // <entries>: an array of #GtkItemFactoryEntry<!-- -->s
   void delete_entries(uint n_entries, ItemFactoryEntry* entries) {
      gtk_item_factory_delete_entries(&this, n_entries, entries);
   }

   // Deletes the menu item which was created from @entry by the given
   // item factory.
   // <entry>: a #GtkItemFactoryEntry
   void delete_entry(ItemFactoryEntry* entry) {
      gtk_item_factory_delete_entry(&this, entry);
   }

   // Deletes the menu item which was created for @path by the given
   // item factory.
   // <path>: a path
   void delete_item(char* path) {
      gtk_item_factory_delete_item(&this, path);
   }

   // Unintrospectable method: get_item() / gtk_item_factory_get_item()
   // Obtains the menu item which corresponds to @path. 
   // If the widget corresponding to @path is a menu item which opens a 
   // submenu, then the item is returned. If you are interested in the submenu, 
   // use gtk_item_factory_get_widget() instead.
   // RETURNS: the menu item for the given path, or %NULL if @path doesn't lead to a menu item
   // <path>: the path to the menu item
   Widget* get_item(char* path) {
      return gtk_item_factory_get_item(&this, path);
   }

   // Unintrospectable method: get_item_by_action() / gtk_item_factory_get_item_by_action()
   // Obtains the menu item which was constructed from the first 
   // #GtkItemFactoryEntry with the given @action.
   // RETURNS: the menu item which corresponds to the given action, or %NULL if no menu item was found
   // <action>: an action as specified in the @callback_action field of #GtkItemFactoryEntry
   Widget* get_item_by_action(uint action) {
      return gtk_item_factory_get_item_by_action(&this, action);
   }

   // Unintrospectable method: get_widget() / gtk_item_factory_get_widget()
   // Obtains the widget which corresponds to @path. 
   // If the widget corresponding to @path is a menu item which opens a 
   // submenu, then the submenu is returned. If you are interested in the menu 
   // item, use gtk_item_factory_get_item() instead.
   // RETURNS: the widget for the given path, or %NULL if @path doesn't lead to a widget
   // <path>: the path to the widget
   Widget* get_widget(char* path) {
      return gtk_item_factory_get_widget(&this, path);
   }

   // Unintrospectable method: get_widget_by_action() / gtk_item_factory_get_widget_by_action()
   // Obtains the widget which was constructed from the #GtkItemFactoryEntry
   // with the given @action.
   // If there are multiple items with the same action, the result is 
   // undefined.
   // RETURNS: the widget which corresponds to the given action, or %NULL if no widget was found
   // <action>: an action as specified in the @callback_action field of #GtkItemFactoryEntry
   Widget* get_widget_by_action(uint action) {
      return gtk_item_factory_get_widget_by_action(&this, action);
   }

   // Pops up the menu constructed from the item factory at (@x, @y).
   // The @mouse_button parameter should be the mouse button pressed to initiate
   // the menu popup. If the menu popup was initiated by something other than
   // a mouse button press, such as a mouse button release or a keypress,
   // The @time_ parameter should be the time stamp of the event that
   // initiated the popup. If such an event is not available, use
   // gtk_get_current_event_time() instead.
   // The operation of the @mouse_button and the @time_ parameter is the same
   // as the @button and @activation_time parameters for gtk_menu_popup().
   // <x>: the x position
   // <y>: the y position
   // <mouse_button>: the mouse button which was pressed to initiate the popup
   // <time_>: the time at which the activation event occurred
   void popup(uint x, uint y, uint mouse_button, uint time_) {
      gtk_item_factory_popup(&this, x, y, mouse_button, time_);
   }

   // Unintrospectable method: popup_data() / gtk_item_factory_popup_data()
   // Obtains the @popup_data which was passed to 
   // gtk_item_factory_popup_with_data(). This data is available until the menu
   // is popped down again.
   // RETURNS: @popup_data associated with @ifactory
   void* popup_data() {
      return gtk_item_factory_popup_data(&this);
   }

   // Pops up the menu constructed from the item factory at (@x, @y). Callbacks
   // can access the @popup_data while the menu is posted via 
   // gtk_item_factory_popup_data() and gtk_item_factory_popup_data_from_widget().
   // The @mouse_button parameter should be the mouse button pressed to initiate
   // the menu popup. If the menu popup was initiated by something other than
   // a mouse button press, such as a mouse button release or a keypress,
   // The @time_ parameter should be the time stamp of the event that
   // initiated the popup. If such an event is not available, use
   // gtk_get_current_event_time() instead.
   // The operation of the @mouse_button and the @time_ parameters is the same
   // as the @button and @activation_time parameters for gtk_menu_popup().
   // <popup_data>: data available for callbacks while the menu is posted
   // <destroy>: a #GDestroyNotify function to be called on @popup_data when the menu is unposted
   // <x>: the x position
   // <y>: the y position
   // <mouse_button>: the mouse button which was pressed to initiate the popup
   // <time_>: the time at which the activation event occurred
   void popup_with_data(void* popup_data, GLib2.DestroyNotify destroy, uint x, uint y, uint mouse_button, uint time_) {
      gtk_item_factory_popup_with_data(&this, popup_data, destroy, x, y, mouse_button, time_);
   }

   // Sets a function to be used for translating the path elements before they
   // are displayed.
   // <func>: the #GtkTranslateFunc function to be used to translate path elements
   // <data>: data to pass to @func and @notify
   // <notify>: a #GDestroyNotify function to be called when @ifactory is destroyed and when the translation function is changed again
   void set_translate_func(TranslateFunc func, void* data, GLib2.DestroyNotify notify) {
      gtk_item_factory_set_translate_func(&this, func, data, notify);
   }
}

extern (C) alias void function () ItemFactoryCallback;

extern (C) alias void function (void* callback_data, uint callback_action, Widget* widget) ItemFactoryCallback1;

extern (C) alias void function (Widget* widget, void* callback_data, uint callback_action) ItemFactoryCallback2;

struct ItemFactoryClass {
   ObjectClass object_class;
   GLib2.HashTable* item_ht;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ItemFactoryEntry {
   char* path, accelerator;
   ItemFactoryCallback callback;
   uint callback_action;
   char* item_type;
   const(void)* extra_data;
}

struct ItemFactoryItem {
   char* path;
   GLib2.SList* widgets;
}

enum Justification {
   LEFT = 0,
   RIGHT = 1,
   CENTER = 2,
   FILL = 3
}
extern (C) alias int function (Widget* grab_widget, Gdk2.EventKey* event, void* func_data) KeySnoopFunc;

struct Label /* : Misc */ {
   alias misc this;
   alias misc super_;
   Misc misc;
   private char* label;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "jtype", 2,
   uint, "wrap", 1,
   uint, "use_underline", 1,
   uint, "use_markup", 1,
   uint, "ellipsize", 3,
   uint, "single_line_mode", 1,
   uint, "have_transform", 1,
   uint, "in_click", 1,
   uint, "wrap_mode", 3,
   uint, "pattern_set", 1,
   uint, "track_links", 1,
    uint, "__dummy32A", 16));
   private uint mnemonic_keyval;
   private char* text;
   private Pango.AttrList* attrs, effective_attrs;
   private Pango.Layout* layout;
   private Widget* mnemonic_widget;
   private Window* mnemonic_window;
   private LabelSelectionInfo* select_info;


   // Creates a new label with the given text inside it. You can
   // pass %NULL to get an empty label widget.
   // RETURNS: the new #GtkLabel
   // <str>: The text of the label
   static Label* new_(char* str) {
      return gtk_label_new(str);
   }

   // Creates a new #GtkLabel, containing the text in @str.
   // If characters in @str are preceded by an underscore, they are
   // underlined. If you need a literal underscore character in a label, use
   // '__' (two underscores). The first underlined character represents a 
   // keyboard accelerator called a mnemonic. The mnemonic key can be used 
   // to activate another widget, chosen automatically, or explicitly using
   // gtk_label_set_mnemonic_widget().
   // If gtk_label_set_mnemonic_widget() is not called, then the first 
   // activatable ancestor of the #GtkLabel will be chosen as the mnemonic 
   // widget. For instance, if the label is inside a button or menu item, 
   // the button or menu item will automatically become the mnemonic widget 
   // and be activated by the mnemonic.
   // RETURNS: the new #GtkLabel
   // <str>: The text of the label, with an underscore in front of the mnemonic character
   static Label* new_with_mnemonic(char* str) {
      return gtk_label_new_with_mnemonic(str);
   }
   void get(char** str) {
      gtk_label_get(&this, str);
   }

   // Gets the angle of rotation for the label. See
   // gtk_label_set_angle().
   // RETURNS: the angle of rotation for the label
   double get_angle() {
      return gtk_label_get_angle(&this);
   }

   // Gets the attribute list that was set on the label using
   // gtk_label_set_attributes(), if any. This function does
   // not reflect attributes that come from the labels markup
   // (see gtk_label_set_markup()). If you want to get the
   // effective attributes for the label, use
   // pango_layout_get_attribute (gtk_label_get_layout (label)).
   // if none was set.
   // RETURNS: the attribute list, or %NULL
   Pango.AttrList* get_attributes() {
      return gtk_label_get_attributes(&this);
   }

   // Returns the URI for the currently active link in the label.
   // The active link is the one under the mouse pointer or, in a
   // selectable label, the link in which the text cursor is currently
   // positioned.
   // This function is intended for use in a #GtkLabel::activate-link handler
   // or for use in a #GtkWidget::query-tooltip handler.
   // not be freed or modified.
   // RETURNS: the currently active URI. The string is owned by GTK+ and must
   char* get_current_uri() {
      return gtk_label_get_current_uri(&this);
   }

   // Returns the ellipsizing position of the label. See gtk_label_set_ellipsize().
   // RETURNS: #PangoEllipsizeMode
   Pango.EllipsizeMode get_ellipsize() {
      return gtk_label_get_ellipsize(&this);
   }

   // Returns the justification of the label. See gtk_label_set_justify().
   // RETURNS: #GtkJustification
   Justification get_justify() {
      return gtk_label_get_justify(&this);
   }

   // Fetches the text from a label widget including any embedded
   // underlines indicating mnemonics and Pango markup. (See
   // gtk_label_get_text()).
   // owned by the widget and must not be modified or freed.
   // RETURNS: the text of the label widget. This string is
   char* get_label() {
      return gtk_label_get_label(&this);
   }

   // Gets the #PangoLayout used to display the label.
   // The layout is useful to e.g. convert text positions to
   // pixel positions, in combination with gtk_label_get_layout_offsets().
   // The returned layout is owned by the label so need not be
   // freed by the caller.
   // RETURNS: the #PangoLayout for this label
   Pango.Layout* get_layout() {
      return gtk_label_get_layout(&this);
   }

   // Obtains the coordinates where the label will draw the #PangoLayout
   // representing the text in the label; useful to convert mouse events
   // into coordinates inside the #PangoLayout, e.g. to take some action
   // if some part of the label is clicked. Of course you will need to
   // create a #GtkEventBox to receive the events, and pack the label
   // inside it, since labels are a #GTK_NO_WINDOW widget. Remember
   // when using the #PangoLayout functions you need to convert to
   // and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
   // <x>: location to store X offset of layout, or %NULL
   // <y>: location to store Y offset of layout, or %NULL
   void get_layout_offsets(/*out*/ int* x=null, /*out*/ int* y=null) {
      gtk_label_get_layout_offsets(&this, x, y);
   }

   // Returns whether lines in the label are automatically wrapped. 
   // See gtk_label_set_line_wrap().
   // RETURNS: %TRUE if the lines of the label are automatically wrapped.
   int get_line_wrap() {
      return gtk_label_get_line_wrap(&this);
   }

   // Returns line wrap mode used by the label. See gtk_label_set_line_wrap_mode().
   // RETURNS: %TRUE if the lines of the label are automatically wrapped.
   Pango.WrapMode get_line_wrap_mode() {
      return gtk_label_get_line_wrap_mode(&this);
   }

   // Retrieves the desired maximum width of @label, in characters. See
   // gtk_label_set_width_chars().
   // RETURNS: the maximum width of the label in characters.
   int get_max_width_chars() {
      return gtk_label_get_max_width_chars(&this);
   }

   // If the label has been set so that it has an mnemonic key this function
   // returns the keyval used for the mnemonic accelerator. If there is no
   // mnemonic set up it returns #GDK_VoidSymbol.
   // RETURNS: GDK keyval usable for accelerators, or #GDK_VoidSymbol
   uint get_mnemonic_keyval() {
      return gtk_label_get_mnemonic_keyval(&this);
   }

   // Retrieves the target of the mnemonic (keyboard shortcut) of this
   // label. See gtk_label_set_mnemonic_widget().
   // or %NULL if none has been set and the default algorithm will be used.
   // RETURNS: the target of the label's mnemonic,
   Widget* get_mnemonic_widget() {
      return gtk_label_get_mnemonic_widget(&this);
   }

   // Gets the value set by gtk_label_set_selectable().
   // RETURNS: %TRUE if the user can copy text from the label
   int get_selectable() {
      return gtk_label_get_selectable(&this);
   }

   // Gets the selected range of characters in the label, returning %TRUE
   // if there's a selection.
   // RETURNS: %TRUE if selection is non-empty
   // <start>: return location for start of selection, as a character offset
   // <end>: return location for end of selection, as a character offset
   int get_selection_bounds(/*out*/ int* start, /*out*/ int* end) {
      return gtk_label_get_selection_bounds(&this, start, end);
   }

   // Returns whether the label is in single line mode.
   // RETURNS: %TRUE when the label is in single line mode.
   int get_single_line_mode() {
      return gtk_label_get_single_line_mode(&this);
   }

   // Fetches the text from a label widget, as displayed on the
   // screen. This does not include any embedded underlines
   // indicating mnemonics or Pango markup. (See gtk_label_get_label())
   // string used by the label, and must not be modified.
   // RETURNS: the text in the label widget. This is the internal
   char* get_text() {
      return gtk_label_get_text(&this);
   }

   // Returns whether the label is currently keeping track
   // of clicked links.
   // RETURNS: %TRUE if clicked links are remembered
   int get_track_visited_links() {
      return gtk_label_get_track_visited_links(&this);
   }

   // Returns whether the label's text is interpreted as marked up with
   // the <link linkend="PangoMarkupFormat">Pango text markup
   // language</link>. See gtk_label_set_use_markup ().
   // RETURNS: %TRUE if the label's text will be parsed for markup.
   int get_use_markup() {
      return gtk_label_get_use_markup(&this);
   }

   // Returns whether an embedded underline in the label indicates a
   // mnemonic. See gtk_label_set_use_underline().
   // the mnemonic accelerator keys.
   // RETURNS: %TRUE whether an embedded underline in the label indicates
   int get_use_underline() {
      return gtk_label_get_use_underline(&this);
   }

   // Retrieves the desired width of @label, in characters. See
   // gtk_label_set_width_chars().
   // RETURNS: the width of the label in characters.
   int get_width_chars() {
      return gtk_label_get_width_chars(&this);
   }
   uint parse_uline(char* string_) {
      return gtk_label_parse_uline(&this, string_);
   }

   // Selects a range of characters in the label, if the label is selectable.
   // See gtk_label_set_selectable(). If the label is not selectable,
   // this function has no effect. If @start_offset or
   // <start_offset>: start offset (in characters not bytes)
   // <end_offset>: end offset (in characters not bytes)
   void select_region(int start_offset, int end_offset) {
      gtk_label_select_region(&this, start_offset, end_offset);
   }

   // Sets the angle of rotation for the label. An angle of 90 reads from
   // from bottom to top, an angle of 270, from top to bottom. The angle
   // setting for the label is ignored if the label is selectable,
   // wrapped, or ellipsized.
   // <angle>: the angle that the baseline of the label makes with the horizontal, in degrees, measured counterclockwise
   void set_angle(double angle) {
      gtk_label_set_angle(&this, angle);
   }

   // Sets a #PangoAttrList; the attributes in the list are applied to the
   // label text. 
   // <note><para>The attributes set with this function will be applied
   // and merged with any other attributes previously effected by way
   // of the #GtkLabel:use-underline or #GtkLabel:use-markup properties.
   // While it is not recommended to mix markup strings with manually set
   // attributes, if you must; know that the attributes will be applied
   // to the label after the markup string is parsed.</para></note>
   // <attrs>: a #PangoAttrList
   void set_attributes(Pango.AttrList* attrs) {
      gtk_label_set_attributes(&this, attrs);
   }

   // if there is not enough space to render the entire string.
   // <mode>: a #PangoEllipsizeMode
   void set_ellipsize(Pango.EllipsizeMode mode) {
      gtk_label_set_ellipsize(&this, mode);
   }

   // Sets the alignment of the lines in the text of the label relative to
   // each other. %GTK_JUSTIFY_LEFT is the default value when the
   // widget is first created with gtk_label_new(). If you instead want
   // to set the alignment of the label as a whole, use
   // gtk_misc_set_alignment() instead. gtk_label_set_justify() has no
   // effect on labels containing only a single line.
   // <jtype>: a #GtkJustification
   void set_justify(Justification jtype) {
      gtk_label_set_justify(&this, jtype);
   }

   // Sets the text of the label. The label is interpreted as
   // including embedded underlines and/or Pango markup depending
   // on the values of the #GtkLabel:use-underline" and
   // #GtkLabel:use-markup properties.
   // <str>: the new text to set for the label
   void set_label(char* str) {
      gtk_label_set_label(&this, str);
   }

   // Toggles line wrapping within the #GtkLabel widget. %TRUE makes it break
   // lines if text exceeds the widget's size. %FALSE lets the text get cut off
   // by the edge of the widget if it exceeds the widget size.
   // Note that setting line wrapping to %TRUE does not make the label
   // wrap at its parent container's width, because GTK+ widgets
   // conceptually can't make their requisition depend on the parent
   // container's size. For a label that wraps at a specific position,
   // set the label's width using gtk_widget_set_size_request().
   // <wrap>: the setting
   void set_line_wrap(int wrap) {
      gtk_label_set_line_wrap(&this, wrap);
   }

   // If line wrapping is on (see gtk_label_set_line_wrap()) this controls how
   // the line wrapping is done. The default is %PANGO_WRAP_WORD which means
   // wrap on word boundaries.
   // <wrap_mode>: the line wrapping mode
   void set_line_wrap_mode(Pango.WrapMode wrap_mode) {
      gtk_label_set_line_wrap_mode(&this, wrap_mode);
   }

   // Parses @str which is marked up with the <link
   // linkend="PangoMarkupFormat">Pango text markup language</link>, setting the
   // label's text and attribute list based on the parse results. If the @str is
   // external data, you may need to escape it with g_markup_escape_text() or
   // g_markup_printf_escaped()<!-- -->:
   // |[
   // char *markup;
   // markup = g_markup_printf_escaped ("&lt;span style=\"italic\"&gt;&percnt;s&lt;/span&gt;", str);
   // gtk_label_set_markup (GTK_LABEL (label), markup);
   // g_free (markup);
   // ]|
   // <str>: a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>)
   void set_markup(char* str) {
      gtk_label_set_markup(&this, str);
   }

   // Parses @str which is marked up with the <link linkend="PangoMarkupFormat">Pango text markup language</link>,
   // setting the label's text and attribute list based on the parse results.
   // If characters in @str are preceded by an underscore, they are underlined
   // indicating that they represent a keyboard accelerator called a mnemonic.
   // The mnemonic key can be used to activate another widget, chosen 
   // automatically, or explicitly using gtk_label_set_mnemonic_widget().
   // <str>: a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>)
   void set_markup_with_mnemonic(char* str) {
      gtk_label_set_markup_with_mnemonic(&this, str);
   }

   // Sets the desired maximum width in characters of @label to @n_chars.
   // <n_chars>: the new desired maximum width, in characters.
   void set_max_width_chars(int n_chars) {
      gtk_label_set_max_width_chars(&this, n_chars);
   }

   // If the label has been set so that it has an mnemonic key (using
   // i.e. gtk_label_set_markup_with_mnemonic(),
   // gtk_label_set_text_with_mnemonic(), gtk_label_new_with_mnemonic()
   // or the "use_underline" property) the label can be associated with a
   // widget that is the target of the mnemonic. When the label is inside
   // a widget (like a #GtkButton or a #GtkNotebook tab) it is
   // automatically associated with the correct widget, but sometimes
   // (i.e. when the target is a #GtkEntry next to the label) you need to
   // set it explicitly using this function.
   // The target widget will be accelerated by emitting the 
   // GtkWidget::mnemonic-activate signal on it. The default handler for 
   // this signal will activate the widget if there are no mnemonic collisions 
   // and toggle focus between the colliding widgets otherwise.
   // <widget>: the target #GtkWidget
   void set_mnemonic_widget(Widget* widget=null) {
      gtk_label_set_mnemonic_widget(&this, widget);
   }
   void set_pattern(char* pattern) {
      gtk_label_set_pattern(&this, pattern);
   }

   // Selectable labels allow the user to select text from the label, for
   // copy-and-paste.
   // <setting>: %TRUE to allow selecting text in the label
   void set_selectable(int setting) {
      gtk_label_set_selectable(&this, setting);
   }

   // Sets whether the label is in single line mode.
   // <single_line_mode>: %TRUE if the label should be in single line mode
   void set_single_line_mode(int single_line_mode) {
      gtk_label_set_single_line_mode(&this, single_line_mode);
   }

   // Sets the text within the #GtkLabel widget. It overwrites any text that
   // was there before.  
   // This will also clear any previously set mnemonic accelerators.
   // <str>: The text you want to set
   void set_text(char* str) {
      gtk_label_set_text(&this, str);
   }

   // Sets the label's text from the string @str.
   // If characters in @str are preceded by an underscore, they are underlined
   // indicating that they represent a keyboard accelerator called a mnemonic.
   // The mnemonic key can be used to activate another widget, chosen 
   // automatically, or explicitly using gtk_label_set_mnemonic_widget().
   // <str>: a string
   void set_text_with_mnemonic(char* str) {
      gtk_label_set_text_with_mnemonic(&this, str);
   }

   // Sets whether the label should keep track of clicked
   // links (and use a different color for them).
   // <track_links>: %TRUE to track visited links
   void set_track_visited_links(int track_links) {
      gtk_label_set_track_visited_links(&this, track_links);
   }

   // Sets whether the text of the label contains markup in <link
   // linkend="PangoMarkupFormat">Pango's text markup
   // language</link>. See gtk_label_set_markup().
   // <setting>: %TRUE if the label's text should be parsed for markup.
   void set_use_markup(int setting) {
      gtk_label_set_use_markup(&this, setting);
   }

   // If true, an underline in the text indicates the next character should be
   // used for the mnemonic accelerator key.
   // <setting>: %TRUE if underlines in the text indicate mnemonics
   void set_use_underline(int setting) {
      gtk_label_set_use_underline(&this, setting);
   }

   // Sets the desired width in characters of @label to @n_chars.
   // <n_chars>: the new desired width, in characters.
   void set_width_chars(int n_chars) {
      gtk_label_set_width_chars(&this, n_chars);
   }

   // A <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user activates a link in the label.
   // Applications may also emit the signal with g_signal_emit_by_name()
   // if they need to control activation of URIs programmatically.
   // The default bindings for this signal are all forms of the Enter key.
   extern (C) alias static void function (Label* this_, void* user_data=null) signal_activate_current_link;

   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-current-link", CB/*:signal_activate_current_link*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-current-link",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The signal which gets emitted to activate a URI.
   // Applications may connect to it to override the default behaviour,
   // which is to call gtk_show_uri().
   // RETURNS: %TRUE if the link has been activated
   // <uri>: the URI that is activated
   extern (C) alias static c_int function (Label* this_, char* uri, void* user_data=null) signal_activate_link;
   ulong signal_connect(string name:"activate-link", CB/*:signal_activate_link*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-link",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::copy-clipboard signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to copy the selection to the clipboard.
   // The default binding for this signal is Ctrl-c.
   extern (C) alias static void function (Label* this_, void* user_data=null) signal_copy_clipboard;
   ulong signal_connect(string name:"copy-clipboard", CB/*:signal_copy_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"copy-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates a cursor movement.
   // If the cursor is not visible in @entry, this signal causes
   // the viewport to be moved instead.
   // Applications should not connect to it, but may emit it with
   // g_signal_emit_by_name() if they need to control the cursor
   // programmatically.
   // The default bindings for this signal come in two variants,
   // the variant with the Shift modifier extends the selection,
   // the variant without the Shift modifer does not.
   // There are too many key combinations to list them all here.
   // <itemizedlist>
   // <listitem>Arrow keys move by individual characters/lines</listitem>
   // <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
   // <listitem>Home/End keys move to the ends of the buffer</listitem>
   // </itemizedlist>
   // <step>: the granularity of the move, as a #GtkMovementStep
   // <count>: the number of @step units to move
   // <extend_selection>: %TRUE if the move should extend the selection
   extern (C) alias static void function (Label* this_, MovementStep* step, int count, c_int extend_selection, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::populate-popup signal gets emitted before showing the
   // context menu of the label. Note that only selectable labels
   // have context menus.
   // If you need to add items to the context menu, connect
   // to this signal and append your menuitems to the @menu.
   // <menu>: the menu that is being populated
   extern (C) alias static void function (Label* this_, Menu* menu, void* user_data=null) signal_populate_popup;
   ulong signal_connect(string name:"populate-popup", CB/*:signal_populate_popup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"populate-popup",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct LabelClass {
   MiscClass parent_class;
   extern (C) void function (Label* label, MovementStep step, int count, int extend_selection) move_cursor;
   extern (C) void function (Label* label) copy_clipboard;
   extern (C) void function (Label* label, Menu* menu) populate_popup;
   extern (C) int function (Label* label, char* uri) activate_link;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

struct LabelSelectionInfo {
}

struct Layout /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children;
   uint width, height;
   Adjustment* hadjustment, vadjustment;
   Gdk2.Window* bin_window;
   private Gdk2.VisibilityState visibility;
   private int scroll_x, scroll_y;
   private uint freeze_count;


   // Creates a new #GtkLayout. Unless you have a specific adjustment
   // you'd like the layout to use for scrolling, pass %NULL for
   // RETURNS: a new #GtkLayout
   // <hadjustment>: horizontal scroll adjustment, or %NULL
   // <vadjustment>: vertical scroll adjustment, or %NULL
   static Layout* new_(Adjustment* hadjustment=null, Adjustment* vadjustment=null) {
      return gtk_layout_new(hadjustment, vadjustment);
   }
   // This is a deprecated function, it doesn't do anything useful.
   void freeze() {
      gtk_layout_freeze(&this);
   }

   // Retrieve the bin window of the layout used for drawing operations.
   // RETURNS: a #GdkWindow
   Gdk2.Window* get_bin_window() {
      return gtk_layout_get_bin_window(&this);
   }

   // This function should only be called after the layout has been
   // placed in a #GtkScrolledWindow or otherwise configured for
   // scrolling. It returns the #GtkAdjustment used for communication
   // between the horizontal scrollbar and @layout.
   // See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
   // RETURNS: horizontal scroll adjustment
   Adjustment* get_hadjustment() {
      return gtk_layout_get_hadjustment(&this);
   }

   // Gets the size that has been set on the layout, and that determines
   // the total extents of the layout's scrollbar area. See
   // gtk_layout_set_size ().
   // <width>: location to store the width set on
   // <height>: location to store the height set on
   void get_size(/*out*/ uint* width=null, /*out*/ uint* height=null) {
      gtk_layout_get_size(&this, width, height);
   }

   // This function should only be called after the layout has been
   // placed in a #GtkScrolledWindow or otherwise configured for
   // scrolling. It returns the #GtkAdjustment used for communication
   // between the vertical scrollbar and @layout.
   // See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
   // RETURNS: vertical scroll adjustment
   Adjustment* get_vadjustment() {
      return gtk_layout_get_vadjustment(&this);
   }

   // Moves a current child of @layout to a new position.
   // <child_widget>: a current child of @layout
   // <x>: X position to move to
   // <y>: Y position to move to
   void move(Widget* child_widget, int x, int y) {
      gtk_layout_move(&this, child_widget, x, y);
   }

   // Adds @child_widget to @layout, at position (@x,@y).
   // <child_widget>: child widget
   // <x>: X position of child widget
   // <y>: Y position of child widget
   void put(Widget* child_widget, int x, int y) {
      gtk_layout_put(&this, child_widget, x, y);
   }

   // Sets the horizontal scroll adjustment for the layout.
   // See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
   // <adjustment>: new scroll adjustment
   void set_hadjustment(Adjustment* adjustment=null) {
      gtk_layout_set_hadjustment(&this, adjustment);
   }

   // Sets the size of the scrollable area of the layout.
   // <width>: width of entire scrollable area
   // <height>: height of entire scrollable area
   void set_size(uint width, uint height) {
      gtk_layout_set_size(&this, width, height);
   }

   // Sets the vertical scroll adjustment for the layout.
   // See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
   // <adjustment>: new scroll adjustment
   void set_vadjustment(Adjustment* adjustment=null) {
      gtk_layout_set_vadjustment(&this, adjustment);
   }
   // This is a deprecated function, it doesn't do anything useful.
   void thaw() {
      gtk_layout_thaw(&this);
   }

   // Set the scroll adjustments for the layout. Usually scrolled containers
   // like #GtkScrolledWindow will emit this signal to connect two instances
   // of #GtkScrollbar to the scroll directions of the #GtkLayout.
   extern (C) alias static void function (Layout* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;

   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:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct LayoutClass {
   ContainerClass parent_class;
   extern (C) void function (Layout* layout, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct LinkButton /* : Button */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance button;
   Button parent_instance;
   LinkButtonPrivate* priv;


   // Creates a new #GtkLinkButton with the URI as its text.
   // RETURNS: a new link button widget.
   // <uri>: a valid URI
   static LinkButton* new_(char* uri) {
      return gtk_link_button_new(uri);
   }

   // Creates a new #GtkLinkButton containing a label.
   // RETURNS: a new link button widget.
   // <uri>: a valid URI
   // <label>: the text of the button
   static LinkButton* new_with_label(char* uri, char* label=null) {
      return gtk_link_button_new_with_label(uri, label);
   }

   // Unintrospectable function: set_uri_hook() / gtk_link_button_set_uri_hook()
   // Sets @func as the function that should be invoked every time a user clicks
   // a #GtkLinkButton. This function is called before every callback registered
   // for the "clicked" signal.
   // If no uri hook has been set, GTK+ defaults to calling gtk_show_uri().
   // RETURNS: the previously set hook function.
   // <func>: a function called each time a #GtkLinkButton is clicked, or %NULL
   // <data>: user data to be passed to @func, or %NULL
   // <destroy>: a #GDestroyNotify that gets called when @data is no longer needed, or %NULL
   static LinkButtonUriFunc set_uri_hook(LinkButtonUriFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null) {
      return gtk_link_button_set_uri_hook(func, data, destroy);
   }

   // Retrieves the URI set using gtk_link_button_set_uri().
   // and should not be modified or freed.
   // RETURNS: a valid URI.  The returned string is owned by the link button
   char* get_uri() {
      return gtk_link_button_get_uri(&this);
   }

   // Retrieves the 'visited' state of the URI where the #GtkLinkButton
   // points. The button becomes visited when it is clicked. If the URI
   // is changed on the button, the 'visited' state is unset again.
   // The state may also be changed using gtk_link_button_set_visited().
   // RETURNS: %TRUE if the link has been visited, %FALSE otherwise
   int get_visited() {
      return gtk_link_button_get_visited(&this);
   }

   // Sets @uri as the URI where the #GtkLinkButton points. As a side-effect
   // this unsets the 'visited' state of the button.
   // <uri>: a valid URI
   void set_uri(char* uri) {
      gtk_link_button_set_uri(&this, uri);
   }

   // Sets the 'visited' state of the URI where the #GtkLinkButton
   // points.  See gtk_link_button_get_visited() for more details.
   // <visited>: the new 'visited' state
   void set_visited(int visited) {
      gtk_link_button_set_visited(&this, visited);
   }
}

struct LinkButtonClass {
   ButtonClass parent_class;
   extern (C) void function () _gtk_padding1;
   extern (C) void function () _gtk_padding2;
   extern (C) void function () _gtk_padding3;
   extern (C) void function () _gtk_padding4;
}

struct LinkButtonPrivate {
}

extern (C) alias void function (LinkButton* button, char* link_, void* user_data) LinkButtonUriFunc;

struct List /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children, selection, undo_selection_, undo_unselection;
   Widget* last_focus_child, undo_focus_child;
   uint htimer, vtimer;
   int anchor, drag_pos;
   StateType anchor_state;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "selection_mode", 2,
   uint, "drag_selection", 1,
   uint, "add_mode", 1,
    uint, "__dummy32A", 28));

   static List* new_() {
      return gtk_list_new();
   }
   void append_items(GLib2.List* items) {
      gtk_list_append_items(&this, items);
   }
   int child_position(Widget* child) {
      return gtk_list_child_position(&this, child);
   }
   void clear_items(int start, int end) {
      gtk_list_clear_items(&this, start, end);
   }
   void end_drag_selection() {
      gtk_list_end_drag_selection(&this);
   }
   void end_selection() {
      gtk_list_end_selection(&this);
   }
   void extend_selection(ScrollType scroll_type, float position, int auto_start_selection) {
      gtk_list_extend_selection(&this, scroll_type, position, auto_start_selection);
   }
   void insert_items(GLib2.List* items, int position) {
      gtk_list_insert_items(&this, items, position);
   }
   void prepend_items(GLib2.List* items) {
      gtk_list_prepend_items(&this, items);
   }
   void remove_items(GLib2.List* items) {
      gtk_list_remove_items(&this, items);
   }
   void remove_items_no_unref(GLib2.List* items) {
      gtk_list_remove_items_no_unref(&this, items);
   }
   void scroll_horizontal(ScrollType scroll_type, float position) {
      gtk_list_scroll_horizontal(&this, scroll_type, position);
   }
   void scroll_vertical(ScrollType scroll_type, float position) {
      gtk_list_scroll_vertical(&this, scroll_type, position);
   }
   void select_all() {
      gtk_list_select_all(&this);
   }
   void select_child(Widget* child) {
      gtk_list_select_child(&this, child);
   }
   void select_item(int item) {
      gtk_list_select_item(&this, item);
   }
   void set_selection_mode(SelectionMode mode) {
      gtk_list_set_selection_mode(&this, mode);
   }
   void start_selection() {
      gtk_list_start_selection(&this);
   }
   void toggle_add_mode() {
      gtk_list_toggle_add_mode(&this);
   }
   void toggle_focus_row() {
      gtk_list_toggle_focus_row(&this);
   }
   void toggle_row(Widget* item) {
      gtk_list_toggle_row(&this, item);
   }
   void undo_selection() {
      gtk_list_undo_selection(&this);
   }
   void unselect_all() {
      gtk_list_unselect_all(&this);
   }
   void unselect_child(Widget* child) {
      gtk_list_unselect_child(&this, child);
   }
   void unselect_item(int item) {
      gtk_list_unselect_item(&this, item);
   }
   extern (C) alias static void function (List* this_, Widget* object, void* user_data=null) signal_select_child;

   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:"select-child", CB/*:signal_select_child*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-child",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (List* this_, void* user_data=null) signal_selection_changed;
   ulong signal_connect(string name:"selection-changed", CB/*:signal_selection_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (List* this_, Widget* object, void* user_data=null) signal_unselect_child;
   ulong signal_connect(string name:"unselect-child", CB/*:signal_unselect_child*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-child",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ListClass {
   ContainerClass parent_class;
   extern (C) void function (List* list) selection_changed;
   extern (C) void function (List* list, Widget* child) select_child;
   extern (C) void function (List* list, Widget* child) unselect_child;
}

struct ListItem /* : Item */ {
   alias item this;
   alias item super_;
   Item item;

   static ListItem* new_() {
      return gtk_list_item_new();
   }
   static ListItem* new_with_label(char* label) {
      return gtk_list_item_new_with_label(label);
   }
   void deselect() {
      gtk_list_item_deselect(&this);
   }
   void select() {
      gtk_list_item_select(&this);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_end_selection;

   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:"end-selection", CB/*:signal_end_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"end-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, ScrollType* object, float p0, c_int p1, void* user_data=null) signal_extend_selection;
   ulong signal_connect(string name:"extend-selection", CB/*:signal_extend_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"extend-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, ScrollType* object, float p0, void* user_data=null) signal_scroll_horizontal;
   ulong signal_connect(string name:"scroll-horizontal", CB/*:signal_scroll_horizontal*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-horizontal",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, ScrollType* object, float p0, void* user_data=null) signal_scroll_vertical;
   ulong signal_connect(string name:"scroll-vertical", CB/*:signal_scroll_vertical*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-vertical",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_select_all;
   ulong signal_connect(string name:"select-all", CB/*:signal_select_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_start_selection;
   ulong signal_connect(string name:"start-selection", CB/*:signal_start_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"start-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_toggle_add_mode;
   ulong signal_connect(string name:"toggle-add-mode", CB/*:signal_toggle_add_mode*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-add-mode",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_toggle_focus_row;
   ulong signal_connect(string name:"toggle-focus-row", CB/*:signal_toggle_focus_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-focus-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_undo_selection;
   ulong signal_connect(string name:"undo-selection", CB/*:signal_undo_selection*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"undo-selection",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (ListItem* this_, void* user_data=null) signal_unselect_all;
   ulong signal_connect(string name:"unselect-all", CB/*:signal_unselect_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ListItemClass {
   ItemClass parent_class;
   extern (C) void function (ListItem* list_item) toggle_focus_row;
   extern (C) void function (ListItem* list_item) select_all;
   extern (C) void function (ListItem* list_item) unselect_all;
   extern (C) void function (ListItem* list_item) undo_selection;
   extern (C) void function (ListItem* list_item) start_selection;
   extern (C) void function (ListItem* list_item) end_selection;
   extern (C) void function (ListItem* list_item, ScrollType scroll_type, float position, int auto_start_selection) extend_selection;
   extern (C) void function (ListItem* list_item, ScrollType scroll_type, float position) scroll_horizontal;
   extern (C) void function (ListItem* list_item, ScrollType scroll_type, float position) scroll_vertical;
   extern (C) void function (ListItem* list_item) toggle_add_mode;
}

struct ListStore /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private int stamp;
   private void* seq, _gtk_reserved1;
   private GLib2.List* sort_list;
   private int n_columns, sort_column_id;
   private SortType order;
   private Type* column_headers;
   private int length;
   private TreeIterCompareFunc default_sort_func;
   private void* default_sort_data;
   private GLib2.DestroyNotify default_sort_destroy;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "columns_dirty", 1,
    uint, "__dummy32A", 31));


   // Unintrospectable constructor: new() / gtk_list_store_new()
   // Creates a new list store as with @n_columns columns each of the types passed
   // in.  Note that only types derived from standard GObject fundamental types 
   // are supported. 
   // As an example, <literal>gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
   // GDK_TYPE_PIXBUF);</literal> will create a new #GtkListStore with three columns, of type
   // int, string and #GdkPixbuf respectively.
   // RETURNS: a new #GtkListStore
   // <n_columns>: number of columns in the list store
   alias gtk_list_store_new new_; // Variadic

   // Non-vararg creation function.  Used primarily by language bindings.
   // RETURNS: a new #GtkListStore
   // <n_columns>: number of columns in the list store
   // <types>: an array of #GType types for the columns, from first to last
   static ListStore* newv(int n_columns, Type* types) {
      return gtk_list_store_newv(n_columns, types);
   }

   // Appends a new row to @list_store.  @iter will be changed to point to this new
   // row.  The row will be empty after this function is called.  To fill in
   // values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the appended row
   void append(/*out*/ TreeIter* iter) {
      gtk_list_store_append(&this, iter);
   }
   // Removes all rows from the list store.
   void clear() {
      gtk_list_store_clear(&this);
   }

   // Creates a new row at @position.  @iter will be changed to point to this new
   // row.  If @position is larger than the number of rows on the list, then the
   // new row will be appended to the list. The row will be empty after this
   // function is called.  To fill in values, you need to call 
   // gtk_list_store_set() or gtk_list_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <position>: position to insert the new row
   void insert(/*out*/ TreeIter* iter, int position) {
      gtk_list_store_insert(&this, iter, position);
   }

   // Inserts a new row after @sibling. If @sibling is %NULL, then the row will be
   // prepended to the beginning of the list. @iter will be changed to point to
   // this new row. The row will be empty after this function is called. To fill
   // in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <sibling>: A valid #GtkTreeIter, or %NULL
   void insert_after(/*out*/ TreeIter* iter, TreeIter* sibling=null) {
      gtk_list_store_insert_after(&this, iter, sibling);
   }

   // Inserts a new row before @sibling. If @sibling is %NULL, then the row will 
   // be appended to the end of the list. @iter will be changed to point to this 
   // new row. The row will be empty after this function is called. To fill in 
   // values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <sibling>: A valid #GtkTreeIter, or %NULL
   void insert_before(/*out*/ TreeIter* iter, TreeIter* sibling=null) {
      gtk_list_store_insert_before(&this, iter, sibling);
   }

   // Unintrospectable method: insert_with_values() / gtk_list_store_insert_with_values()
   // Creates a new row at @position.  @iter will be changed to point to this new
   // row.  If @position is larger than the number of rows on the list, then the
   // new row will be appended to the list. The row will be filled with the 
   // values given to this function. 
   // Calling
   // <literal>gtk_list_store_insert_with_values(list_store, iter, position...)</literal> 
   // has the same effect as calling 
   // |[
   // gtk_list_store_insert (list_store, iter, position);
   // gtk_list_store_set (list_store, iter, ...);
   // ]|
   // with the difference that the former will only emit a row_inserted signal,
   // while the latter will emit row_inserted, row_changed and, if the list store
   // is sorted, rows_reordered. Since emitting the rows_reordered signal
   // repeatedly can affect the performance of the program, 
   // gtk_list_store_insert_with_values() should generally be preferred when
   // inserting rows in a sorted list store.
   // <iter>: An unset #GtkTreeIter to set to the new row, or %NULL.
   // <position>: position to insert the new row
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_list_store_insert_with_values insert_with_values; // Variadic
   +/

   // A variant of gtk_list_store_insert_with_values() which
   // takes the columns and values as two arrays, instead of
   // varargs. This function is mainly intended for 
   // language-bindings.
   // <iter>: An unset #GtkTreeIter to set to the new row, or %NULL.
   // <position>: position to insert the new row
   // <columns>: an array of column numbers
   // <values>: an array of GValues
   // <n_values>: the length of the @columns and @values arrays
   void insert_with_valuesv(/*out*/ TreeIter* iter, int position, int* columns, GObject2.Value* values, int n_values) {
      gtk_list_store_insert_with_valuesv(&this, iter, position, columns, values, n_values);
   }

   // <warning>This function is slow. Only use it for debugging and/or testing
   // purposes.</warning>
   // Checks if the given iter is a valid iter for this #GtkListStore.
   // RETURNS: %TRUE if the iter is valid, %FALSE if the iter is invalid.
   // <iter>: A #GtkTreeIter.
   int iter_is_valid(TreeIter* iter) {
      return gtk_list_store_iter_is_valid(&this, iter);
   }

   // Moves @iter in @store to the position after @position. Note that this
   // function only works with unsorted stores. If @position is %NULL, @iter
   // will be moved to the start of the list.
   // <iter>: A #GtkTreeIter.
   // <position>: A #GtkTreeIter or %NULL.
   void move_after(TreeIter* iter, TreeIter* position=null) {
      gtk_list_store_move_after(&this, iter, position);
   }

   // Moves @iter in @store to the position before @position. Note that this
   // function only works with unsorted stores. If @position is %NULL, @iter
   // will be moved to the end of the list.
   // <iter>: A #GtkTreeIter.
   // <position>: A #GtkTreeIter, or %NULL.
   void move_before(TreeIter* iter, TreeIter* position=null) {
      gtk_list_store_move_before(&this, iter, position);
   }

   // Prepends a new row to @list_store. @iter will be changed to point to this new
   // row. The row will be empty after this function is called. To fill in
   // values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the prepend row
   void prepend(/*out*/ TreeIter* iter) {
      gtk_list_store_prepend(&this, iter);
   }

   // Removes the given row from the list store.  After being removed, 
   // to the last row in @list_store.
   // RETURNS: %TRUE if @iter is valid, %FALSE if not.
   // <iter>: A valid #GtkTreeIter
   int remove(TreeIter* iter) {
      return gtk_list_store_remove(&this, iter);
   }

   // Reorders @store to follow the order indicated by @new_order. Note that
   // this function only works with unsorted stores.
   // <new_order>: an array of integers mapping the new position of each child to its old position before the re-ordering, i.e. @new_order<literal>[newpos] = oldpos</literal>.
   void reorder(int* new_order) {
      gtk_list_store_reorder(&this, new_order);
   }

   // Unintrospectable method: set() / gtk_list_store_set()
   // Sets the value of one or more cells in the row referenced by @iter.
   // The variable argument list should contain integer column numbers,
   // each column number followed by the value to be set.
   // The list is terminated by a -1. For example, to set column 0 with type
   // %G_TYPE_STRING to "Foo", you would write <literal>gtk_list_store_set (store, iter,
   // 0, "Foo", -1)</literal>.
   // The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it
   // will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED.
   // <iter>: row iterator
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_list_store_set set; // Variadic
   +/

   // This function is meant primarily for #GObjects that inherit from #GtkListStore,
   // and should only be used when constructing a new #GtkListStore.  It will not
   // function after a row has been added, or a method on the #GtkTreeModel
   // interface is called.
   // <n_columns>: Number of columns for the list store
   // <types>: An array length n of #GTypes
   void set_column_types(int n_columns, Type* types) {
      gtk_list_store_set_column_types(&this, n_columns, types);
   }

   // Unintrospectable method: set_valist() / gtk_list_store_set_valist()
   // See gtk_list_store_set(); this version takes a va_list for use by language
   // bindings.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <var_args>: va_list of column/value pairs
   void set_valist(TreeIter* iter, va_list var_args) {
      gtk_list_store_set_valist(&this, iter, var_args);
   }

   // Sets the data in the cell specified by @iter and @column.
   // The type of @value must be convertible to the type of the
   // column.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <column>: column number to modify
   // <value>: new value for the cell
   void set_value(TreeIter* iter, int column, GObject2.Value* value) {
      gtk_list_store_set_value(&this, iter, column, value);
   }

   // A variant of gtk_list_store_set_valist() which
   // takes the columns and values as two arrays, instead of
   // varargs. This function is mainly intended for 
   // language-bindings and in case the number of columns to
   // change is not known until run-time.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <columns>: an array of column numbers
   // <values>: an array of GValues
   // <n_values>: the length of the @columns and @values arrays
   void set_valuesv(TreeIter* iter, int* columns, GObject2.Value* values, int n_values) {
      gtk_list_store_set_valuesv(&this, iter, columns, values, n_values);
   }

   // Swaps @a and @b in @store. Note that this function only works with
   // unsorted stores.
   // <a>: A #GtkTreeIter.
   // <b>: Another #GtkTreeIter.
   void swap(TreeIter* a, TreeIter* b) {
      gtk_list_store_swap(&this, a, b);
   }
}

struct ListStoreClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum int MAJOR_VERSION = 2;
enum int MAX_COMPOSE_LEN = 7;
enum int MICRO_VERSION = 8;
enum int MINOR_VERSION = 24;
enum MatchType {
   ALL = 0,
   ALL_TAIL = 1,
   HEAD = 2,
   TAIL = 3,
   EXACT = 4,
   LAST = 5
}
struct Menu /* : MenuShell */ {
   alias menu_shell this;
   alias menu_shell super_;
   alias menu_shell menushell;
   MenuShell menu_shell;
   Widget* parent_menu_item, old_active_menu_item;
   AccelGroup* accel_group;
   char* accel_path;
   MenuPositionFunc position_func;
   void* position_func_data;
   uint toggle_size;
   Widget* toplevel, tearoff_window, tearoff_hbox, tearoff_scrollbar;
   Adjustment* tearoff_adjustment;
   Gdk2.Window* view_window, bin_window;
   int scroll_offset, saved_scroll_offset, scroll_step;
   uint timeout_id;
   Gdk2.Region* navigation_region;
   uint navigation_timeout;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "needs_destruction_ref_count", 1,
   uint, "torn_off", 1,
   uint, "tearoff_active", 1,
   uint, "scroll_fast", 1,
   uint, "upper_arrow_visible", 1,
   uint, "lower_arrow_visible", 1,
   uint, "upper_arrow_prelight", 1,
   uint, "lower_arrow_prelight", 1,
    uint, "__dummy32A", 24));

   static Menu* new_() {
      return gtk_menu_new();
   }

   // Returns a list of the menus which are attached to this widget.
   // This list is owned by GTK+ and must not be modified.
   // RETURNS: the list of menus attached to his widget.
   // <widget>: a #GtkWidget
   static GLib2.List* get_for_attach_widget(Widget* widget) {
      return gtk_menu_get_for_attach_widget(widget);
   }

   // Adds a new #GtkMenuItem to a (table) menu. The number of 'cells' that
   // an item will occupy is specified by @left_attach, @right_attach,
   // rightmost, uppermost and lower column and row numbers of the table.
   // (Columns and rows are indexed from zero).
   // Note that this function is not related to gtk_menu_detach().
   // <child>: a #GtkMenuItem.
   // <left_attach>: The column number to attach the left side of the item to.
   // <right_attach>: The column number to attach the right side of the item to.
   // <top_attach>: The row number to attach the top of the item to.
   // <bottom_attach>: The row number to attach the bottom of the item to.
   void attach(Widget* child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach) {
      gtk_menu_attach(&this, child, left_attach, right_attach, top_attach, bottom_attach);
   }
   // Unintrospectable method: attach_to_widget() / gtk_menu_attach_to_widget()
   void attach_to_widget(Widget* attach_widget, MenuDetachFunc detacher) {
      gtk_menu_attach_to_widget(&this, attach_widget, detacher);
   }
   void detach() {
      gtk_menu_detach(&this);
   }

   // Gets the #GtkAccelGroup which holds global accelerators for the
   // menu.  See gtk_menu_set_accel_group().
   // RETURNS: the #GtkAccelGroup associated with the menu.
   AccelGroup* get_accel_group() {
      return gtk_menu_get_accel_group(&this);
   }

   // Retrieves the accelerator path set on the menu.
   // RETURNS: the accelerator path set on the menu.
   char* get_accel_path() {
      return gtk_menu_get_accel_path(&this);
   }

   // Returns the selected menu item from the menu.  This is used by the
   // #GtkOptionMenu.
   // in the menu.  If a selection has not yet been made, the
   // first menu item is selected.
   // RETURNS: the #GtkMenuItem that was last selected
   Widget* get_active() {
      return gtk_menu_get_active(&this);
   }

   // Returns the #GtkWidget that the menu is attached to.
   // RETURNS: the #GtkWidget that the menu is attached to
   Widget* get_attach_widget() {
      return gtk_menu_get_attach_widget(&this);
   }

   // Retrieves the number of the monitor on which to show the menu.
   // be popped up or -1, if no monitor has been set
   // RETURNS: the number of the monitor on which the menu should
   int get_monitor() {
      return gtk_menu_get_monitor(&this);
   }

   // Returns whether the menu reserves space for toggles and
   // icons, regardless of their actual presence.
   // RETURNS: Whether the menu reserves toggle space
   int get_reserve_toggle_size() {
      return gtk_menu_get_reserve_toggle_size(&this);
   }

   // Returns whether the menu is torn off. See
   // gtk_menu_set_tearoff_state ().
   // RETURNS: %TRUE if the menu is currently torn off.
   int get_tearoff_state() {
      return gtk_menu_get_tearoff_state(&this);
   }

   // Returns the title of the menu. See gtk_menu_set_title().
   // title set on it. This string is owned by the widget and should
   // not be modified or freed.
   // RETURNS: the title of the menu, or %NULL if the menu has no
   char* get_title() {
      return gtk_menu_get_title(&this);
   }
   void popdown() {
      gtk_menu_popdown(&this);
   }

   // Unintrospectable method: popup() / gtk_menu_popup()
   // Displays a menu and makes it available for selection.  Applications can use
   // this function to display context-sensitive menus, and will typically supply
   // %NULL for the @parent_menu_shell, @parent_menu_item, @func and @data 
   // parameters. The default menu positioning function will position the menu
   // at the current mouse cursor position.
   // The @button parameter should be the mouse button pressed to initiate
   // the menu popup. If the menu popup was initiated by something other than
   // a mouse button press, such as a mouse button release or a keypress,
   // The @activate_time parameter is used to conflict-resolve initiation of
   // concurrent requests for mouse/keyboard grab requests. To function
   // properly, this needs to be the time stamp of the user event (such as
   // a mouse click or key press) that caused the initiation of the popup.
   // Only if no such event is available, gtk_get_current_event_time() can
   // be used instead.
   // <parent_menu_shell>: the menu shell containing the triggering menu item, or %NULL
   // <parent_menu_item>: the menu item whose activation triggered the popup, or %NULL
   // <func>: a user supplied function used to position the menu, or %NULL
   // <data>: user supplied data to be passed to @func.
   // <button>: the mouse button which was pressed to initiate the event.
   // <activate_time>: the time at which the activation event occurred.
   void popup(Widget* parent_menu_shell, Widget* parent_menu_item, MenuPositionFunc func, void* data, uint button, uint activate_time) {
      gtk_menu_popup(&this, parent_menu_shell, parent_menu_item, func, data, button, activate_time);
   }
   void reorder_child(Widget* child, int position) {
      gtk_menu_reorder_child(&this, child, position);
   }
   void reposition() {
      gtk_menu_reposition(&this);
   }
   void set_accel_group(AccelGroup* accel_group=null) {
      gtk_menu_set_accel_group(&this, accel_group);
   }

   // Sets an accelerator path for this menu from which accelerator paths
   // for its immediate children, its menu items, can be constructed.
   // The main purpose of this function is to spare the programmer the
   // inconvenience of having to call gtk_menu_item_set_accel_path() on
   // each menu item that should support runtime user changable accelerators.
   // Instead, by just calling gtk_menu_set_accel_path() on their parent,
   // each menu item of this menu, that contains a label describing its purpose,
   // automatically gets an accel path assigned. For example, a menu containing
   // menu items "New" and "Exit", will, after 
   // <literal>gtk_menu_set_accel_path (menu, "&lt;Gnumeric-Sheet&gt;/File");</literal>
   // has been called, assign its items the accel paths:
   // <literal>"&lt;Gnumeric-Sheet&gt;/File/New"</literal> and <literal>"&lt;Gnumeric-Sheet&gt;/File/Exit"</literal>.
   // Assigning accel paths to menu items then enables the user to change
   // their accelerators at runtime. More details about accelerator paths
   // and their default setups can be found at gtk_accel_map_add_entry().
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: a valid accelerator path
   void set_accel_path(char* accel_path=null) {
      gtk_menu_set_accel_path(&this, accel_path);
   }
   void set_active(uint index_) {
      gtk_menu_set_active(&this, index_);
   }

   // Informs GTK+ on which monitor a menu should be popped up. 
   // See gdk_screen_get_monitor_geometry().
   // This function should be called from a #GtkMenuPositionFunc if the
   // menu should not appear on the same monitor as the pointer. This 
   // information can't be reliably inferred from the coordinates returned
   // by a #GtkMenuPositionFunc, since, for very long menus, these coordinates 
   // may extend beyond the monitor boundaries or even the screen boundaries.
   // <monitor_num>: the number of the monitor on which the menu should be popped up
   void set_monitor(int monitor_num) {
      gtk_menu_set_monitor(&this, monitor_num);
   }

   // Sets whether the menu should reserve space for drawing toggles 
   // or icons, regardless of their actual presence.
   // <reserve_toggle_size>: whether to reserve size for toggles
   void set_reserve_toggle_size(int reserve_toggle_size) {
      gtk_menu_set_reserve_toggle_size(&this, reserve_toggle_size);
   }

   // Sets the #GdkScreen on which the menu will be displayed.
   // <screen>: a #GdkScreen, or %NULL if the screen should be determined by the widget the menu is attached to.
   void set_screen(Gdk2.Screen* screen=null) {
      gtk_menu_set_screen(&this, screen);
   }
   void set_tearoff_state(int torn_off) {
      gtk_menu_set_tearoff_state(&this, torn_off);
   }

   // Sets the title string for the menu.  The title is displayed when the menu
   // is shown as a tearoff menu.  If @title is %NULL, the menu will see if it is
   // attached to a parent menu item, and if so it will try to use the same text as
   // that menu item's label.
   // <title>: a string containing the title for the menu.
   void set_title(char* title) {
      gtk_menu_set_title(&this, title);
   }
   extern (C) alias static void function (Menu* this_, ScrollType* object, void* user_data=null) signal_move_scroll;

   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:"move-scroll", CB/*:signal_move_scroll*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-scroll",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct MenuBar /* : MenuShell */ {
   alias menu_shell this;
   alias menu_shell super_;
   alias menu_shell menushell;
   MenuShell menu_shell;

   static MenuBar* new_() {
      return gtk_menu_bar_new();
   }

   // Retrieves the current child pack direction of the menubar.
   // See gtk_menu_bar_set_child_pack_direction().
   // RETURNS: the child pack direction
   PackDirection get_child_pack_direction() {
      return gtk_menu_bar_get_child_pack_direction(&this);
   }

   // Retrieves the current pack direction of the menubar. 
   // See gtk_menu_bar_set_pack_direction().
   // RETURNS: the pack direction
   PackDirection get_pack_direction() {
      return gtk_menu_bar_get_pack_direction(&this);
   }

   // Sets how widgets should be packed inside the children of a menubar.
   // <child_pack_dir>: a new #GtkPackDirection
   void set_child_pack_direction(PackDirection child_pack_dir) {
      gtk_menu_bar_set_child_pack_direction(&this, child_pack_dir);
   }

   // Sets how items should be packed inside a menubar.
   // <pack_dir>: a new #GtkPackDirection
   void set_pack_direction(PackDirection pack_dir) {
      gtk_menu_bar_set_pack_direction(&this, pack_dir);
   }
}

struct MenuBarClass {
   MenuShellClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias void function (Widget* widget, void* user_data) MenuCallback;

struct MenuClass {
   MenuShellClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias void function (Widget* attach_widget, Menu* menu) MenuDetachFunc;

enum MenuDirectionType {
   PARENT = 0,
   CHILD = 1,
   NEXT = 2,
   PREV = 3
}
struct MenuEntry {
   char* path, accelerator;
   MenuCallback callback;
   void* callback_data;
   Widget* widget;
}

struct MenuItem /* : Item */ {
   alias item this;
   alias item super_;
   Item item;
   Widget* submenu;
   Gdk2.Window* event_window;
   ushort toggle_size, accelerator_width;
   char* accel_path;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "show_submenu_indicator", 1,
   uint, "submenu_placement", 1,
   uint, "submenu_direction", 1,
   uint, "right_justify", 1,
   uint, "timer_from_keypress", 1,
   uint, "from_menubar", 1,
    uint, "__dummy32A", 26));
   uint timer;

   static MenuItem* new_() {
      return gtk_menu_item_new();
   }
   static MenuItem* new_with_label(char* label) {
      return gtk_menu_item_new_with_label(label);
   }

   // Creates a new #GtkMenuItem containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the menu item.
   // RETURNS: a new #GtkMenuItem
   // <label>: The text of the button, with an underscore in front of the mnemonic character
   static MenuItem* new_with_mnemonic(char* label) {
      return gtk_menu_item_new_with_mnemonic(label);
   }
   void activate() {
      gtk_menu_item_activate(&this);
   }
   void deselect() {
      gtk_menu_item_deselect(&this);
   }

   // Retrieve the accelerator path that was previously set on @menu_item.
   // See gtk_menu_item_set_accel_path() for details.
   // functionality, or %NULL if not set
   // RETURNS: the accelerator path corresponding to this menu item's
   char* get_accel_path() {
      return gtk_menu_item_get_accel_path(&this);
   }

   // Sets @text on the @menu_item label
   // string used by the label, and must not be modified.
   // RETURNS: The text in the @menu_item label. This is the internal
   char* get_label() {
      return gtk_menu_item_get_label(&this);
   }

   // Gets whether the menu item appears justified at the right
   // side of the menu bar.
   // far right if added to a menu bar.
   // RETURNS: %TRUE if the menu item will appear at the
   int get_right_justified() {
      return gtk_menu_item_get_right_justified(&this);
   }

   // Gets the submenu underneath this menu item, if any.
   // See gtk_menu_item_set_submenu().
   // RETURNS: submenu for this menu item, or %NULL if none.
   Widget* get_submenu() {
      return gtk_menu_item_get_submenu(&this);
   }

   // Checks if an underline in the text indicates the next character should be
   // used for the mnemonic accelerator key.
   // the mnemonic accelerator key.
   // RETURNS: %TRUE if an embedded underline in the label indicates
   int get_use_underline() {
      return gtk_menu_item_get_use_underline(&this);
   }

   // Removes the widget's submenu.
   // should not be used in newly written code. Use
   // gtk_menu_item_set_submenu() instead.
   void remove_submenu() {
      gtk_menu_item_remove_submenu(&this);
   }
   void select() {
      gtk_menu_item_select(&this);
   }

   // Set the accelerator path on @menu_item, through which runtime changes of the
   // menu item's accelerator caused by the user can be identified and saved to
   // persistant storage (see gtk_accel_map_save() on this).
   // To setup a default accelerator for this menu item, call
   // gtk_accel_map_add_entry() with the same @accel_path.
   // See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
   // and gtk_menu_set_accel_path() for a more convenient variant of this function.
   // This function is basically a convenience wrapper that handles calling
   // gtk_widget_set_accel_path() with the appropriate accelerator group for
   // the menu item.
   // Note that you do need to set an accelerator on the parent menu with
   // gtk_menu_set_accel_group() for this to work.
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: accelerator path, corresponding to this menu item's functionality, or %NULL to unset the current path.
   void set_accel_path(char* accel_path=null) {
      gtk_menu_item_set_accel_path(&this, accel_path);
   }

   // Sets @text on the @menu_item label
   // <label>: the text you want to set
   void set_label(char* label) {
      gtk_menu_item_set_label(&this, label);
   }

   // Sets whether the menu item appears justified at the right
   // side of a menu bar. This was traditionally done for "Help" menu
   // items, but is now considered a bad idea. (If the widget
   // layout is reversed for a right-to-left language like Hebrew
   // or Arabic, right-justified-menu-items appear at the left.)
   // <right_justified>: if %TRUE the menu item will appear at the far right if added to a menu bar.
   void set_right_justified(int right_justified) {
      gtk_menu_item_set_right_justified(&this, right_justified);
   }

   // Sets or replaces the menu item's submenu, or removes it when a %NULL
   // submenu is passed.
   // <submenu>: the submenu, or %NULL
   void set_submenu(Widget* submenu=null) {
      gtk_menu_item_set_submenu(&this, submenu);
   }

   // If true, an underline in the text indicates the next character should be
   // used for the mnemonic accelerator key.
   // <setting>: %TRUE if underlines in the text indicate mnemonics
   void set_use_underline(int setting) {
      gtk_menu_item_set_use_underline(&this, setting);
   }
   void toggle_size_allocate(int allocation) {
      gtk_menu_item_toggle_size_allocate(&this, allocation);
   }
   void toggle_size_request(int* requisition) {
      gtk_menu_item_toggle_size_request(&this, requisition);
   }
   extern (C) alias static void function (MenuItem* this_, 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);
   }
   extern (C) alias static void function (MenuItem* this_, void* user_data=null) signal_activate_item;
   ulong signal_connect(string name:"activate-item", CB/*:signal_activate_item*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-item",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuItem* this_, int object, void* user_data=null) signal_toggle_size_allocate;
   ulong signal_connect(string name:"toggle-size-allocate", CB/*:signal_toggle_size_allocate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-size-allocate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuItem* this_, void* object, void* user_data=null) signal_toggle_size_request;
   ulong signal_connect(string name:"toggle-size-request", CB/*:signal_toggle_size_request*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-size-request",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct MenuItemClass {
   ItemClass parent_class;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "hide_on_activate", 1,
    uint, "__dummy32A", 31));
   extern (C) void function (MenuItem* menu_item) activate;
   extern (C) void function (MenuItem* menu_item) activate_item;
   extern (C) void function (MenuItem* menu_item, int* requisition) toggle_size_request;
   extern (C) void function (MenuItem* menu_item, int allocation) toggle_size_allocate;
   // <label>: the text you want to set
   extern (C) void function (MenuItem* menu_item, char* label) set_label;
   // RETURNS: The text in the @menu_item label. This is the internal
   extern (C) char* function (MenuItem* menu_item) get_label;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

extern (C) alias void function (Menu* menu, int* x, int* y, int* push_in, void* user_data) MenuPositionFunc;

struct MenuShell /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children;
   Widget* active_menu_item, parent_menu_shell;
   uint button;
   uint activate_time;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "active", 1,
   uint, "have_grab", 1,
   uint, "have_xgrab", 1,
   uint, "ignore_leave", 1,
   uint, "menu_flag", 1,
   uint, "ignore_enter", 1,
   uint, "keyboard_mode", 1,
    uint, "__dummy32A", 25));

   void activate_item(Widget* menu_item, int force_deactivate) {
      gtk_menu_shell_activate_item(&this, menu_item, force_deactivate);
   }
   void append(Widget* child) {
      gtk_menu_shell_append(&this, child);
   }
   // Cancels the selection within the menu shell.
   void cancel() {
      gtk_menu_shell_cancel(&this);
   }
   void deactivate() {
      gtk_menu_shell_deactivate(&this);
   }
   void deselect() {
      gtk_menu_shell_deselect(&this);
   }

   // Returns %TRUE if the menu shell will take the keyboard focus on popup.
   // RETURNS: %TRUE if the menu shell will take the keyboard focus on popup.
   int get_take_focus() {
      return gtk_menu_shell_get_take_focus(&this);
   }
   void insert(Widget* child, int position) {
      gtk_menu_shell_insert(&this, child, position);
   }
   void prepend(Widget* child) {
      gtk_menu_shell_prepend(&this, child);
   }

   // Select the first visible or selectable child of the menu shell;
   // don't select tearoff items unless the only item is a tearoff
   // item.
   // <search_sensitive>: if %TRUE, search for the first selectable menu item, otherwise select nothing if the first item isn't sensitive. This should be %FALSE if the menu is being popped up initially.
   void select_first(int search_sensitive) {
      gtk_menu_shell_select_first(&this, search_sensitive);
   }
   void select_item(Widget* menu_item) {
      gtk_menu_shell_select_item(&this, menu_item);
   }

   // If @take_focus is %TRUE (the default) the menu shell will take the keyboard 
   // focus so that it will receive all keyboard events which is needed to enable
   // keyboard navigation in menus.
   // Setting @take_focus to %FALSE is useful only for special applications
   // like virtual keyboard implementations which should not take keyboard
   // focus.
   // The @take_focus state of a menu or menu bar is automatically propagated
   // to submenus whenever a submenu is popped up, so you don't have to worry
   // about recursively setting it for your entire menu hierarchy. Only when
   // programmatically picking a submenu and popping it up manually, the
   // Note that setting it to %FALSE has side-effects:
   // If the focus is in some other app, it keeps the focus and keynav in
   // the menu doesn't work. Consequently, keynav on the menu will only
   // work if the focus is on some toplevel owned by the onscreen keyboard.
   // To avoid confusing the user, menus with @take_focus set to %FALSE
   // should not display mnemonics or accelerators, since it cannot be
   // guaranteed that they will work.
   // See also gdk_keyboard_grab()
   // <take_focus>: %TRUE if the menu shell should take the keyboard focus on popup.
   void set_take_focus(int take_focus) {
      gtk_menu_shell_set_take_focus(&this, take_focus);
   }
   extern (C) alias static void function (MenuShell* this_, c_int object, void* user_data=null) signal_activate_current;

   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-current", CB/*:signal_activate_current*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-current",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuShell* this_, void* user_data=null) signal_cancel;
   ulong signal_connect(string name:"cancel", CB/*:signal_cancel*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cancel",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuShell* this_, DirectionType* object, void* user_data=null) signal_cycle_focus;
   ulong signal_connect(string name:"cycle-focus", CB/*:signal_cycle_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cycle-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuShell* this_, void* user_data=null) signal_deactivate;
   ulong signal_connect(string name:"deactivate", CB/*:signal_deactivate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"deactivate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuShell* this_, MenuDirectionType* object, void* user_data=null) signal_move_current;
   ulong signal_connect(string name:"move-current", CB/*:signal_move_current*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-current",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-selected signal is emitted to move the selection to
   // another item.
   // RETURNS: %TRUE to stop the signal emission, %FALSE to continue
   // <distance>: +1 to move to the next item, -1 to move to the previous
   extern (C) alias static c_int function (MenuShell* this_, int distance, void* user_data=null) signal_move_selected;
   ulong signal_connect(string name:"move-selected", CB/*:signal_move_selected*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-selected",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (MenuShell* this_, void* user_data=null) signal_selection_done;
   ulong signal_connect(string name:"selection-done", CB/*:signal_selection_done*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-done",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct MenuShellClass {
   ContainerClass parent_class;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "submenu_placement", 1,
    uint, "__dummy32A", 31));
   extern (C) void function (MenuShell* menu_shell) deactivate;
   extern (C) void function (MenuShell* menu_shell) selection_done;
   extern (C) void function (MenuShell* menu_shell, MenuDirectionType direction) move_current;
   extern (C) void function (MenuShell* menu_shell, int force_hide) activate_current;
   extern (C) void function (MenuShell* menu_shell) cancel;
   extern (C) void function (MenuShell* menu_shell, Widget* menu_item) select_item;
   extern (C) void function (MenuShell* menu_shell, Widget* child, int position) insert;
   extern (C) int function (MenuShell* menu_shell) get_popup_delay;
   extern (C) int function (MenuShell* menu_shell, int distance) move_selected;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

struct MenuToolButton /* : ToolButton */ {
   alias parent this;
   alias parent super_;
   alias parent toolbutton;
   ToolButton parent;
   private MenuToolButtonPrivate* priv;


   // Creates a new #GtkMenuToolButton using @icon_widget as icon and
   // RETURNS: the new #GtkMenuToolButton
   // <icon_widget>: a widget that will be used as icon widget, or %NULL
   // <label>: a string that will be used as label, or %NULL
   static MenuToolButton* new_(Widget* icon_widget=null, char* label=null) {
      return gtk_menu_tool_button_new(icon_widget, label);
   }

   // Creates a new #GtkMenuToolButton.
   // The new #GtkMenuToolButton will contain an icon and label from
   // the stock item indicated by @stock_id.
   // RETURNS: the new #GtkMenuToolButton
   // <stock_id>: the name of a stock item
   static MenuToolButton* new_from_stock(char* stock_id) {
      return gtk_menu_tool_button_new_from_stock(stock_id);
   }

   // Gets the #GtkMenu associated with #GtkMenuToolButton.
   // with #GtkMenuToolButton
   // RETURNS: the #GtkMenu associated
   Widget* get_menu() {
      return gtk_menu_tool_button_get_menu(&this);
   }

   // Sets the #GtkTooltips object to be used for arrow button which
   // pops up the menu. See gtk_tool_item_set_tooltip() for setting
   // a tooltip on the whole #GtkMenuToolButton.
   // instead.
   // <tooltips>: the #GtkTooltips object to be used
   // <tip_text>: text to be used as tooltip text for tool_item
   // <tip_private>: text to be used as private tooltip text
   void set_arrow_tooltip(Tooltips* tooltips, char* tip_text=null, char* tip_private=null) {
      gtk_menu_tool_button_set_arrow_tooltip(&this, tooltips, tip_text, tip_private);
   }

   // Sets the tooltip markup text to be used as tooltip for the arrow button
   // which pops up the menu.  See gtk_tool_item_set_tooltip() for setting a
   // tooltip on the whole #GtkMenuToolButton.
   // <markup>: markup text to be used as tooltip text for button's arrow button
   void set_arrow_tooltip_markup(char* markup) {
      gtk_menu_tool_button_set_arrow_tooltip_markup(&this, markup);
   }

   // Sets the tooltip text to be used as tooltip for the arrow button which
   // pops up the menu.  See gtk_tool_item_set_tooltip() for setting a tooltip
   // on the whole #GtkMenuToolButton.
   // <text>: text to be used as tooltip text for button's arrow button
   void set_arrow_tooltip_text(char* text) {
      gtk_menu_tool_button_set_arrow_tooltip_text(&this, text);
   }

   // Sets the #GtkMenu that is popped up when the user clicks on the arrow.
   // If @menu is NULL, the arrow button becomes insensitive.
   // <menu>: the #GtkMenu associated with #GtkMenuToolButton
   void set_menu(Widget* menu) {
      gtk_menu_tool_button_set_menu(&this, menu);
   }

   // The ::show-menu signal is emitted before the menu is shown.
   // It can be used to populate the menu on demand, using 
   // gtk_menu_tool_button_get_menu(). 
   // Note that even if you populate the menu dynamically in this way, 
   // you must set an empty menu on the #GtkMenuToolButton beforehand,
   // since the arrow is made insensitive if the menu is not set.
   extern (C) alias static void function (MenuToolButton* this_, void* user_data=null) signal_show_menu;

   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:"show-menu", CB/*:signal_show_menu*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"show-menu",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct MenuToolButtonClass {
   ToolButtonClass parent_class;
   extern (C) void function (MenuToolButton* button) show_menu;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct MenuToolButtonPrivate {
}


// #GtkMessageDialog presents a dialog with an image representing the type of
// message (Error, Question, etc.) alongside some message text. It's simply a
// convenience widget; you could construct the equivalent of #GtkMessageDialog
// from #GtkDialog without too much effort, but #GtkMessageDialog saves typing.
// The easiest way to do a modal message dialog is to use gtk_dialog_run(), though
// you can also pass in the %GTK_DIALOG_MODAL flag, gtk_dialog_run() automatically
// makes the dialog modal and waits for the user to respond to it. gtk_dialog_run()
// returns when any dialog button is clicked.
// <example>
// <title>A modal dialog.</title>
// <programlisting>
// dialog = gtk_message_dialog_new (main_application_window,
// GTK_DIALOG_DESTROY_WITH_PARENT,
// GTK_MESSAGE_ERROR,
// GTK_BUTTONS_CLOSE,
// "Error loading file '&percnt;s': &percnt;s",
// filename, g_strerror (errno));
// gtk_dialog_run (GTK_DIALOG (dialog));
// gtk_widget_destroy (dialog);
// </programlisting>
// </example>
// You might do a non-modal #GtkMessageDialog as follows:
// <example>
// <title>A non-modal dialog.</title>
// <programlisting>
// dialog = gtk_message_dialog_new (main_application_window,
// GTK_DIALOG_DESTROY_WITH_PARENT,
// GTK_MESSAGE_ERROR,
// GTK_BUTTONS_CLOSE,
// "Error loading file '&percnt;s': &percnt;s",
// filename, g_strerror (errno));
// /&ast; Destroy the dialog when the user responds to it (e.g. clicks a button) &ast;/
// g_signal_connect_swapped (dialog, "response",
// G_CALLBACK (gtk_widget_destroy),
// dialog);
// </programlisting>
// </example>
// <refsect2 id="GtkMessageDialog-BUILDER-UI">
// <title>GtkMessageDialog as GtkBuildable</title>
// <para>
// The GtkMessageDialog implementation of the GtkBuildable interface exposes
// the message area as an internal child with the name "message_area".
// </para>
// </refsect2>
struct MessageDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   private Widget* image, label;


   // Unintrospectable constructor: new() / gtk_message_dialog_new()
   // Creates a new message dialog, which is a simple dialog with an icon
   // indicating the dialog type (error, warning, etc.) and some text the
   // user may want to see. When the user clicks a button a "response"
   // signal is emitted with response IDs from #GtkResponseType. See
   // #GtkDialog for more details.
   // RETURNS: a new #GtkMessageDialog
   // <parent>: transient parent, or %NULL for none
   // <flags>: flags
   // <type>: type of message
   // <buttons>: set of buttons to use
   // <message_format>: printf()-style format string, or %NULL
   alias gtk_message_dialog_new new_; // Variadic

   // Unintrospectable constructor: new_with_markup() / gtk_message_dialog_new_with_markup()
   // Creates a new message dialog, which is a simple dialog with an icon
   // indicating the dialog type (error, warning, etc.) and some text which
   // is marked up with the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
   // When the user clicks a button a "response" signal is emitted with
   // response IDs from #GtkResponseType. See #GtkDialog for more details.
   // Special XML characters in the printf() arguments passed to this
   // function will automatically be escaped as necessary.
   // (See g_markup_printf_escaped() for how this is implemented.)
   // Usually this is what you want, but if you have an existing
   // Pango markup string that you want to use literally as the
   // label, then you need to use gtk_message_dialog_set_markup()
   // instead, since you can't pass the markup string either
   // as the format (it might contain '%' characters) or as a string
   // argument.
   // |[
   // GtkWidget *dialog;
   // dialog = gtk_message_dialog_new (main_application_window,
   // GTK_DIALOG_DESTROY_WITH_PARENT,
   // GTK_MESSAGE_ERROR,
   // GTK_BUTTONS_CLOSE,
   // NULL);
   // gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog),
   // markup);
   // ]|
   // RETURNS: a new #GtkMessageDialog
   // <parent>: transient parent, or %NULL for none
   // <flags>: flags
   // <type>: type of message
   // <buttons>: set of buttons to use
   // <message_format>: printf()-style format string, or %NULL
   alias gtk_message_dialog_new_with_markup new_with_markup; // Variadic

   // Unintrospectable method: format_secondary_markup() / gtk_message_dialog_format_secondary_markup()
   // Sets the secondary text of the message dialog to be @message_format (with 
   // printf()-style), which is marked up with the 
   // <link linkend="PangoMarkupFormat">Pango text markup language</link>.
   // Note that setting a secondary text makes the primary text become
   // bold, unless you have provided explicit markup.
   // Due to an oversight, this function does not escape special XML characters
   // like gtk_message_dialog_new_with_markup() does. Thus, if the arguments 
   // may contain special XML characters, you should use g_markup_printf_escaped()
   // to escape it.
   // <informalexample><programlisting>
   // gchar *msg;
   // msg = g_markup_printf_escaped (message_format, ...);
   // gtk_message_dialog_format_secondary_markup (message_dialog, "&percnt;s", msg);
   // g_free (msg);
   // </programlisting></informalexample>
   // <message_format>: printf()-style markup string (see
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_message_dialog_format_secondary_markup format_secondary_markup; // Variadic
   +/

   // Unintrospectable method: format_secondary_text() / gtk_message_dialog_format_secondary_text()
   // Sets the secondary text of the message dialog to be @message_format 
   // (with printf()-style).
   // Note that setting a secondary text makes the primary text become
   // bold, unless you have provided explicit markup.
   // <message_format>: printf()-style format string, or %NULL
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_message_dialog_format_secondary_text format_secondary_text; // Variadic
   +/

   // Gets the dialog's image.
   // RETURNS: the dialog's image
   Widget* get_image() {
      return gtk_message_dialog_get_image(&this);
   }

   // Returns the message area of the dialog. This is the box where the
   // dialog's primary and secondary labels are packed. You can add your
   // own extra content to that box and it will appear below those labels,
   // on the right side of the dialog's image (or on the left for right-to-left
   // languages).  See gtk_dialog_get_content_area() for the corresponding
   // function in the parent #GtkDialog.
   // "message area" in the @message_dialog.
   // RETURNS: A #GtkVBox corresponding to the
   Widget* get_message_area() {
      return gtk_message_dialog_get_message_area(&this);
   }

   // Sets the dialog's image to @image.
   // <image>: the image
   void set_image(Widget* image) {
      gtk_message_dialog_set_image(&this, image);
   }

   // Sets the text of the message dialog to be @str, which is marked
   // up with the <link linkend="PangoMarkupFormat">Pango text markup
   // language</link>.
   // <str>: markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>)
   void set_markup(char* str) {
      gtk_message_dialog_set_markup(&this, str);
   }
}

struct MessageDialogClass {
   DialogClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

// The type of message being displayed in the dialog.
enum MessageType {
   INFO = 0,
   WARNING = 1,
   QUESTION = 2,
   ERROR = 3,
   OTHER = 4
}
enum MetricType {
   PIXELS = 0,
   INCHES = 1,
   CENTIMETERS = 2
}
struct Misc /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   float xalign, yalign;
   ushort xpad, ypad;


   // Gets the X and Y alignment of the widget within its allocation. 
   // See gtk_misc_set_alignment().
   // <xalign>: location to store X alignment of @misc, or %NULL
   // <yalign>: location to store Y alignment of @misc, or %NULL
   void get_alignment(/*out*/ float* xalign=null, /*out*/ float* yalign=null) {
      gtk_misc_get_alignment(&this, xalign, yalign);
   }

   // Gets the padding in the X and Y directions of the widget. 
   // See gtk_misc_set_padding().
   // <xpad>: location to store padding in the X direction, or %NULL
   // <ypad>: location to store padding in the Y direction, or %NULL
   void get_padding(/*out*/ int* xpad=null, /*out*/ int* ypad=null) {
      gtk_misc_get_padding(&this, xpad, ypad);
   }
   void set_alignment(float xalign, float yalign) {
      gtk_misc_set_alignment(&this, xalign, yalign);
   }
   void set_padding(int xpad, int ypad) {
      gtk_misc_set_padding(&this, xpad, ypad);
   }
}

struct MiscClass {
   WidgetClass parent_class;
}

extern (C) alias void function (Gdk2.Display* display) ModuleDisplayInitFunc;

extern (C) alias void function (int* argc, char*** argv) ModuleInitFunc;

// This should not be accessed directly. Use the accessor functions below.
struct MountOperation /* : Gio.MountOperation */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance mountoperation;
   Gio2.MountOperation parent_instance;
   MountOperationPrivate* priv;


   // Creates a new #GtkMountOperation
   // RETURNS: a new #GtkMountOperation
   // <parent>: transient parent of the window, or %NULL
   static MountOperation* /*new*/ new_(Window* parent=null) {
      return gtk_mount_operation_new(parent);
   }

   // Gets the transient parent used by the #GtkMountOperation
   // RETURNS: the transient parent for windows shown by @op
   Window* get_parent() {
      return gtk_mount_operation_get_parent(&this);
   }

   // Gets the screen on which windows of the #GtkMountOperation
   // will be shown.
   // RETURNS: the screen on which windows of @op are shown
   Gdk2.Screen* get_screen() {
      return gtk_mount_operation_get_screen(&this);
   }

   // Returns whether the #GtkMountOperation is currently displaying
   // a window.
   // RETURNS: %TRUE if @op is currently displaying a window
   int is_showing() {
      return gtk_mount_operation_is_showing(&this);
   }

   // Sets the transient parent for windows shown by the
   // #GtkMountOperation.
   // <parent>: transient parent of the window, or %NULL
   void set_parent(Window* parent=null) {
      gtk_mount_operation_set_parent(&this, parent);
   }

   // Sets the screen to show windows of the #GtkMountOperation on.
   // <screen>: a #GdkScreen
   void set_screen(Gdk2.Screen* screen) {
      gtk_mount_operation_set_screen(&this, screen);
   }
}

struct MountOperationClass {
   Gio2.MountOperationClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct MountOperationPrivate {
}

enum MovementStep {
   LOGICAL_POSITIONS = 0,
   VISUAL_POSITIONS = 1,
   WORDS = 2,
   DISPLAY_LINES = 3,
   DISPLAY_LINE_ENDS = 4,
   PARAGRAPHS = 5,
   PARAGRAPH_ENDS = 6,
   PAGES = 7,
   BUFFER_ENDS = 8,
   HORIZONTAL_PAGES = 9
}
enum int NO_TEXT_INPUT_MOD_MASK = 0;
struct Notebook /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   NotebookPage* cur_page;
   GLib2.List* children, first_tab, focus_tab;
   Widget* menu;
   Gdk2.Window* event_window;
   uint timer;
   ushort tab_hborder, tab_vborder;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "show_tabs", 1,
   uint, "homogeneous", 1,
   uint, "show_border", 1,
   uint, "tab_pos", 2,
   uint, "scrollable", 1,
   uint, "in_child", 3,
   uint, "click_child", 3,
   uint, "button", 2,
   uint, "need_timer", 1,
   uint, "child_has_focus", 1,
   uint, "have_visible_child", 1,
   uint, "focus_out", 1,
   uint, "has_before_previous", 1,
   uint, "has_before_next", 1,
   uint, "has_after_previous", 1,
   uint, "has_after_next", 1,
    uint, "__dummy32A", 10));


   // Creates a new #GtkNotebook widget with no pages.
   // RETURNS: the newly created #GtkNotebook
   static Notebook* new_() {
      return gtk_notebook_new();
   }

   // Unintrospectable function: set_window_creation_hook() / gtk_notebook_set_window_creation_hook()
   // Installs a global function used to create a window
   // when a detached tab is dropped in an empty area.
   // <func>: the #GtkNotebookWindowCreationFunc, or %NULL
   // <data>: user data for @func
   // <destroy>: Destroy notifier for @data, or %NULL
   static void set_window_creation_hook(NotebookWindowCreationFunc func, void* data, GLib2.DestroyNotify destroy=null) {
      gtk_notebook_set_window_creation_hook(func, data, destroy);
   }

   // Appends a page to @notebook.
   // page in the notebook, or -1 if function fails
   // RETURNS: the index (starting from 0) of the appended
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   int append_page(Widget* child, Widget* tab_label=null) {
      return gtk_notebook_append_page(&this, child, tab_label);
   }

   // Appends a page to @notebook, specifying the widget to use as the
   // label in the popup menu.
   // page in the notebook, or -1 if function fails
   // RETURNS: the index (starting from 0) of the appended
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   // <menu_label>: the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; If @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used.
   int append_page_menu(Widget* child, Widget* tab_label=null, Widget* menu_label=null) {
      return gtk_notebook_append_page_menu(&this, child, tab_label, menu_label);
   }

   // Gets one of the action widgets. See gtk_notebook_set_action_widget().
   // or %NULL when this action widget has not been set
   // RETURNS: The action widget with the given @pack_type
   // <pack_type>: pack type of the action widget to receive
   Widget* get_action_widget(PackType pack_type) {
      return gtk_notebook_get_action_widget(&this, pack_type);
   }

   // Returns the page number of the current page.
   // page in the notebook. If the notebook has no pages, then
   // -1 will be returned.
   // RETURNS: the index (starting from 0) of the current
   int get_current_page() {
      return gtk_notebook_get_current_page(&this);
   }

   // Gets the current group identificator pointer for @notebook.
   // or %NULL if none is set.
   // RETURNS: the group identificator,
   void* get_group() {
      return gtk_notebook_get_group(&this);
   }

   // Gets the current group identificator for @notebook.
   // RETURNS: the group identificator, or -1 if none is set.
   int get_group_id() {
      return gtk_notebook_get_group_id(&this);
   }

   // Gets the current group name for @notebook.
   // Note that this funtion can emphasis not be used
   // together with gtk_notebook_set_group() or
   // gtk_notebook_set_group_id().
   // or %NULL if none is set.
   char* get_group_name() {
      return gtk_notebook_get_group_name(&this);
   }

   // Retrieves the menu label widget of the page containing @child.
   // notebook page does not have a menu label other than the
   // default (the tab label).
   // RETURNS: the menu label, or %NULL if the
   // <child>: a widget contained in a page of @notebook
   Widget* get_menu_label(Widget* child) {
      return gtk_notebook_get_menu_label(&this, child);
   }

   // Retrieves the text of the menu label for the page containing
   // widget does not have a menu label other than
   // the default menu label, or the menu label widget
   // is not a #GtkLabel. The string is owned by
   // the widget and must not be freed.
   // RETURNS: the text of the tab label, or %NULL if the
   // <child>: the child widget of a page of the notebook.
   char* get_menu_label_text(Widget* child) {
      return gtk_notebook_get_menu_label_text(&this, child);
   }

   // Gets the number of pages in a notebook.
   // RETURNS: the number of pages in the notebook.
   int get_n_pages() {
      return gtk_notebook_get_n_pages(&this);
   }

   // Returns the child widget contained in page number @page_num.
   // out of bounds.
   // RETURNS: the child widget, or %NULL if @page_num is
   // <page_num>: the index of a page in the notebook, or -1 to get the last page.
   Widget* get_nth_page(int page_num) {
      return gtk_notebook_get_nth_page(&this, page_num);
   }

   // Returns whether the tab label area has arrows for scrolling. See
   // gtk_notebook_set_scrollable().
   // RETURNS: %TRUE if arrows for scrolling are present
   int get_scrollable() {
      return gtk_notebook_get_scrollable(&this);
   }

   // Returns whether a bevel will be drawn around the notebook pages. See
   // gtk_notebook_set_show_border().
   // RETURNS: %TRUE if the bevel is drawn
   int get_show_border() {
      return gtk_notebook_get_show_border(&this);
   }

   // Returns whether the tabs of the notebook are shown. See
   // gtk_notebook_set_show_tabs().
   // RETURNS: %TRUE if the tabs are shown
   int get_show_tabs() {
      return gtk_notebook_get_show_tabs(&this);
   }

   // Returns whether the tab contents can be detached from @notebook.
   // RETURNS: TRUE if the tab is detachable.
   // <child>: a child #GtkWidget
   int get_tab_detachable(Widget* child) {
      return gtk_notebook_get_tab_detachable(&this, child);
   }

   // Returns the horizontal width of a tab border.
   // RETURNS: horizontal width of a tab border
   ushort get_tab_hborder() {
      return gtk_notebook_get_tab_hborder(&this);
   }

   // Returns the tab label widget for the page @child. %NULL is returned
   // if @child is not in @notebook or if no tab label has specifically
   // been set for @child.
   // RETURNS: the tab label
   // <child>: the page
   Widget* get_tab_label(Widget* child) {
      return gtk_notebook_get_tab_label(&this, child);
   }

   // Retrieves the text of the tab label for the page containing
   // tab label widget is not a #GtkLabel. The
   // string is owned by the widget and must not
   // be freed.
   // RETURNS: the text of the tab label, or %NULL if the
   // <child>: a widget contained in a page of @notebook
   char* get_tab_label_text(Widget* child) {
      return gtk_notebook_get_tab_label_text(&this, child);
   }

   // Gets the edge at which the tabs for switching pages in the
   // notebook are drawn.
   // RETURNS: the edge at which the tabs are drawn
   PositionType get_tab_pos() {
      return gtk_notebook_get_tab_pos(&this);
   }

   // Gets whether the tab can be reordered via drag and drop or not.
   // RETURNS: %TRUE if the tab is reorderable.
   // <child>: a child #GtkWidget
   int get_tab_reorderable(Widget* child) {
      return gtk_notebook_get_tab_reorderable(&this, child);
   }

   // Returns the vertical width of a tab border.
   // RETURNS: vertical width of a tab border
   ushort get_tab_vborder() {
      return gtk_notebook_get_tab_vborder(&this);
   }

   // Insert a page into @notebook at the given position.
   // page in the notebook, or -1 if function fails
   // RETURNS: the index (starting from 0) of the inserted
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   // <position>: the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages.
   int insert_page(Widget* child, Widget* tab_label, int position) {
      return gtk_notebook_insert_page(&this, child, tab_label, position);
   }

   // Insert a page into @notebook at the given position, specifying
   // the widget to use as the label in the popup menu.
   // page in the notebook
   // RETURNS: the index (starting from 0) of the inserted
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   // <menu_label>: the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; If @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used.
   // <position>: the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages.
   int insert_page_menu(Widget* child, Widget* tab_label, Widget* menu_label, int position) {
      return gtk_notebook_insert_page_menu(&this, child, tab_label, menu_label, position);
   }

   // Switches to the next page. Nothing happens if the current page is
   // the last page.
   void next_page() {
      gtk_notebook_next_page(&this);
   }

   // Finds the index of the page which contains the given child
   // widget.
   // -1 if @child is not in the notebook.
   // RETURNS: the index of the page containing @child, or
   // <child>: a #GtkWidget
   int page_num(Widget* child) {
      return gtk_notebook_page_num(&this, child);
   }
   // Disables the popup menu.
   void popup_disable() {
      gtk_notebook_popup_disable(&this);
   }
   // the tab labels, a menu with all the pages will be popped up.
   void popup_enable() {
      gtk_notebook_popup_enable(&this);
   }

   // Prepends a page to @notebook.
   // page in the notebook, or -1 if function fails
   // RETURNS: the index (starting from 0) of the prepended
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   int prepend_page(Widget* child, Widget* tab_label=null) {
      return gtk_notebook_prepend_page(&this, child, tab_label);
   }

   // Prepends a page to @notebook, specifying the widget to use as the
   // label in the popup menu.
   // page in the notebook, or -1 if function fails
   // RETURNS: the index (starting from 0) of the prepended
   // <child>: the #GtkWidget to use as the contents of the page.
   // <tab_label>: the #GtkWidget to be used as the label for the page, or %NULL to use the default label, 'page N'.
   // <menu_label>: the widget to use as a label for the page-switch menu, if that is enabled. If %NULL, and @tab_label is a #GtkLabel or %NULL, then the menu label will be a newly created label with the same text as @tab_label; If @tab_label is not a #GtkLabel, @menu_label must be specified if the page-switch menu is to be used.
   int prepend_page_menu(Widget* child, Widget* tab_label=null, Widget* menu_label=null) {
      return gtk_notebook_prepend_page_menu(&this, child, tab_label, menu_label);
   }

   // Switches to the previous page. Nothing happens if the current page
   // is the first page.
   void prev_page() {
      gtk_notebook_prev_page(&this);
   }

   // Query the packing attributes for the tab label of the page
   // containing @child.
   // #GtkNotebook:tab-fill child properties instead.
   // <child>: the page
   // <expand>: location to store the expand value (or NULL)
   // <fill>: location to store the fill value (or NULL)
   // <pack_type>: location to store the pack_type (or NULL)
   void query_tab_label_packing(Widget* child, int* expand, int* fill, PackType* pack_type) {
      gtk_notebook_query_tab_label_packing(&this, child, expand, fill, pack_type);
   }

   // Removes a page from the notebook given its index
   // in the notebook.
   // <page_num>: the index of a notebook page, starting from 0. If -1, the last page will be removed.
   void remove_page(int page_num) {
      gtk_notebook_remove_page(&this, page_num);
   }

   // Reorders the page containing @child, so that it appears in position
   // children in the list or negative, @child will be moved to the end
   // of the list.
   // <child>: the child to move
   // <position>: the new position, or -1 to move to the end
   void reorder_child(Widget* child, int position) {
      gtk_notebook_reorder_child(&this, child, position);
   }

   // Sets @widget as one of the action widgets. Depending on the pack type
   // the widget will be placed before or after the tabs. You can use
   // a #GtkBox if you need to pack more than one widget on the same side.
   // Note that action widgets are "internal" children of the notebook and thus
   // not included in the list returned from gtk_container_foreach().
   // <widget>: a #GtkWidget
   // <pack_type>: pack type of the action widget
   void set_action_widget(Widget* widget, PackType pack_type) {
      gtk_notebook_set_action_widget(&this, widget, pack_type);
   }

   // Switches to the page number @page_num. 
   // Note that due to historical reasons, GtkNotebook refuses
   // to switch to a page unless the child widget is visible. 
   // Therefore, it is recommended to show child widgets before
   // adding them to a notebook.
   // <page_num>: index of the page to switch to, starting from 0. If negative, the last page will be used. If greater than the number of pages in the notebook, nothing will be done.
   void set_current_page(int page_num) {
      gtk_notebook_set_current_page(&this, page_num);
   }

   // Sets a group identificator pointer for @notebook, notebooks sharing
   // the same group identificator pointer will be able to exchange tabs
   // via drag and drop. A notebook with a %NULL group identificator will
   // not be able to exchange tabs with any other notebook.
   // <group>: a pointer to identify the notebook group, or %NULL to unset it
   void set_group(void* group=null) {
      gtk_notebook_set_group(&this, group);
   }

   // Sets an group identificator for @notebook, notebooks sharing
   // the same group identificator will be able to exchange tabs
   // via drag and drop. A notebook with group identificator -1 will
   // not be able to exchange tabs with any other notebook.
   // <group_id>: a group identificator, or -1 to unset it
   void set_group_id(int group_id) {
      gtk_notebook_set_group_id(&this, group_id);
   }

   // Sets a group name for @notebook.
   // Notebooks with the same name will be able to exchange tabs
   // via drag and drop. A notebook with a %NULL group name will
   // not be able to exchange tabs with any other notebook.
   void set_group_name(char* group_name) {
      gtk_notebook_set_group_name(&this, group_name);
   }

   // Sets whether the tabs must have all the same size or not.
   // <homogeneous>: %TRUE if all tabs should be the same size.
   void set_homogeneous_tabs(int homogeneous) {
      gtk_notebook_set_homogeneous_tabs(&this, homogeneous);
   }

   // Changes the menu label for the page containing @child.
   // <child>: the child widget
   // <menu_label>: the menu label, or NULL for default
   void set_menu_label(Widget* child, Widget* menu_label=null) {
      gtk_notebook_set_menu_label(&this, child, menu_label);
   }

   // Creates a new label and sets it as the menu label of @child.
   // <child>: the child widget
   // <menu_text>: the label text
   void set_menu_label_text(Widget* child, char* menu_text) {
      gtk_notebook_set_menu_label_text(&this, child, menu_text);
   }

   // Sets whether the tab label area will have arrows for scrolling if
   // there are too many tabs to fit in the area.
   // <scrollable>: %TRUE if scroll arrows should be added
   void set_scrollable(int scrollable) {
      gtk_notebook_set_scrollable(&this, scrollable);
   }

   // Sets whether a bevel will be drawn around the notebook pages.
   // This only has a visual effect when the tabs are not shown.
   // See gtk_notebook_set_show_tabs().
   // <show_border>: %TRUE if a bevel should be drawn around the notebook.
   void set_show_border(int show_border) {
      gtk_notebook_set_show_border(&this, show_border);
   }

   // Sets whether to show the tabs for the notebook or not.
   // <show_tabs>: %TRUE if the tabs should be shown.
   void set_show_tabs(int show_tabs) {
      gtk_notebook_set_show_tabs(&this, show_tabs);
   }

   // Sets the width the border around the tab labels
   // in a notebook. This is equivalent to calling
   // gtk_notebook_set_tab_hborder (@notebook, @border_width) followed
   // by gtk_notebook_set_tab_vborder (@notebook, @border_width).
   // <border_width>: width of the border around the tab labels.
   void set_tab_border(uint border_width) {
      gtk_notebook_set_tab_border(&this, border_width);
   }

   // Sets whether the tab can be detached from @notebook to another
   // notebook or widget.
   // Note that 2 notebooks must share a common group identificator
   // (see gtk_notebook_set_group_id ()) to allow automatic tabs
   // interchange between them.
   // If you want a widget to interact with a notebook through DnD
   // (i.e.: accept dragged tabs from it) it must be set as a drop
   // destination and accept the target "GTK_NOTEBOOK_TAB". The notebook
   // will fill the selection with a GtkWidget** pointing to the child
   // widget that corresponds to the dropped tab.
   // |[
   // static void
   // on_drop_zone_drag_data_received (GtkWidget        *widget,
   // GdkDragContext   *context,
   // gint              x,
   // gint              y,
   // GtkSelectionData *selection_data,
   // guint             info,
   // guint             time,
   // gpointer          user_data)
   // {
   // GtkWidget *notebook;
   // GtkWidget **child;
   // notebook = gtk_drag_get_source_widget (context);
   // child = (void*) selection_data->data;
   // process_widget (*child);
   // gtk_container_remove (GTK_CONTAINER (notebook), *child);
   // }
   // ]|
   // If you want a notebook to accept drags from other widgets,
   // you will have to set your own DnD code to do it.
   // <child>: a child #GtkWidget
   // <detachable>: whether the tab is detachable or not
   void set_tab_detachable(Widget* child, int detachable) {
      gtk_notebook_set_tab_detachable(&this, child, detachable);
   }

   // Sets the width of the horizontal border of tab labels.
   // <tab_hborder>: width of the horizontal border of tab labels.
   void set_tab_hborder(uint tab_hborder) {
      gtk_notebook_set_tab_hborder(&this, tab_hborder);
   }

   // Changes the tab label for @child. If %NULL is specified
   // for @tab_label, then the page will have the label 'page N'.
   // <child>: the page
   // <tab_label>: the tab label widget to use, or %NULL for default tab label.
   void set_tab_label(Widget* child, Widget* tab_label=null) {
      gtk_notebook_set_tab_label(&this, child, tab_label);
   }

   // Sets the packing parameters for the tab label of the page
   // containing @child. See gtk_box_pack_start() for the exact meaning
   // of the parameters.
   // #GtkNotebook:tab-fill child properties instead.
   // Modifying the packing of the tab label is a deprecated feature and
   // shouldn't be done anymore.
   // <child>: the child widget
   // <expand>: whether to expand the tab label or not
   // <fill>: whether the tab label should fill the allocated area or not
   // <pack_type>: the position of the tab label
   void set_tab_label_packing(Widget* child, int expand, int fill, PackType pack_type) {
      gtk_notebook_set_tab_label_packing(&this, child, expand, fill, pack_type);
   }

   // Creates a new label and sets it as the tab label for the page
   // containing @child.
   // <child>: the page
   // <tab_text>: the label text
   void set_tab_label_text(Widget* child, char* tab_text) {
      gtk_notebook_set_tab_label_text(&this, child, tab_text);
   }

   // Sets the edge at which the tabs for switching pages in the
   // notebook are drawn.
   // <pos>: the edge to draw the tabs at.
   void set_tab_pos(PositionType pos) {
      gtk_notebook_set_tab_pos(&this, pos);
   }

   // Sets whether the notebook tab can be reordered
   // via drag and drop or not.
   // <child>: a child #GtkWidget
   // <reorderable>: whether the tab is reorderable or not.
   void set_tab_reorderable(Widget* child, int reorderable) {
      gtk_notebook_set_tab_reorderable(&this, child, reorderable);
   }

   // Sets the width of the vertical border of tab labels.
   // <tab_vborder>: width of the vertical border of tab labels.
   void set_tab_vborder(uint tab_vborder) {
      gtk_notebook_set_tab_vborder(&this, tab_vborder);
   }
   extern (C) alias static c_int function (Notebook* this_, int object, void* user_data=null) signal_change_current_page;

   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:"change-current-page", CB/*:signal_change_current_page*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-current-page",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::create-window signal is emitted when a detachable
   // tab is dropped on the root window. 
   // A handler for this signal can create a window containing 
   // a notebook where the tab will be attached. It is also 
   // responsible for moving/resizing the window and adding the 
   // necessary properties to the notebook (e.g. the 
   // #GtkNotebook:group ).
   // The default handler uses the global window creation hook,
   // if one has been set with gtk_notebook_set_window_creation_hook().
   // added to, or %NULL.
   // RETURNS: a #GtkNotebook that @page should be
   // <page>: the tab of @notebook that is being detached
   // <x>: the X coordinate where the drop happens
   // <y>: the Y coordinate where the drop happens
   extern (C) alias static Notebook* function (Notebook* this_, Widget* page, int x, int y, void* user_data=null) signal_create_window;
   ulong signal_connect(string name:"create-window", CB/*:signal_create_window*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"create-window",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Notebook* this_, NotebookTab* object, void* user_data=null) signal_focus_tab;
   ulong signal_connect(string name:"focus-tab", CB/*:signal_focus_tab*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"focus-tab",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Notebook* this_, DirectionType* object, void* user_data=null) signal_move_focus_out;
   ulong signal_connect(string name:"move-focus-out", CB/*:signal_move_focus_out*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-focus-out",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // the ::page-added signal is emitted in the notebook
   // right after a page is added to the notebook.
   // <child>: the child #GtkWidget affected
   // <page_num>: the new page number for @child
   extern (C) alias static void function (Notebook* this_, Widget* child, c_uint page_num, void* user_data=null) signal_page_added;
   ulong signal_connect(string name:"page-added", CB/*:signal_page_added*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"page-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // the ::page-removed signal is emitted in the notebook
   // right after a page is removed from the notebook.
   // <child>: the child #GtkWidget affected
   // <page_num>: the @child page number
   extern (C) alias static void function (Notebook* this_, Widget* child, c_uint page_num, void* user_data=null) signal_page_removed;
   ulong signal_connect(string name:"page-removed", CB/*:signal_page_removed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"page-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // the ::page-reordered signal is emitted in the notebook
   // right after a page has been reordered.
   // <child>: the child #GtkWidget affected
   // <page_num>: the new page number for @child
   extern (C) alias static void function (Notebook* this_, Widget* child, c_uint page_num, void* user_data=null) signal_page_reordered;
   ulong signal_connect(string name:"page-reordered", CB/*:signal_page_reordered*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"page-reordered",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Notebook* this_, DirectionType* object, c_int p0, void* user_data=null) signal_reorder_tab;
   ulong signal_connect(string name:"reorder-tab", CB/*:signal_reorder_tab*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"reorder-tab",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Notebook* this_, c_int object, void* user_data=null) signal_select_page;
   ulong signal_connect(string name:"select-page", CB/*:signal_select_page*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-page",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Notebook* this_, void* object, c_uint p0, void* user_data=null) signal_switch_page;
   ulong signal_connect(string name:"switch-page", CB/*:signal_switch_page*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"switch-page",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct NotebookClass {
   ContainerClass parent_class;
   extern (C) void function (Notebook* notebook, NotebookPage* page, uint page_num) switch_page;
   extern (C) int function (Notebook* notebook, int move_focus) select_page;
   extern (C) int function (Notebook* notebook, NotebookTab type) focus_tab;
   extern (C) int function (Notebook* notebook, int offset) change_current_page;
   extern (C) void function (Notebook* notebook, DirectionType direction) move_focus_out;
   extern (C) int function (Notebook* notebook, DirectionType direction, int move_to_last) reorder_tab;
   extern (C) int function (Notebook* notebook, Widget* child, Widget* tab_label, Widget* menu_label, int position) insert_page;
   // Unintrospectable functionp: create_window() / ()
   extern (C) Notebook* function (Notebook* notebook, Widget* page, int x, int y) create_window;
   extern (C) void function () _gtk_reserved1;
}

struct NotebookPage {
}

enum NotebookTab {
   FIRST = 0,
   LAST = 1
}
// Unintrospectable callback: NotebookWindowCreationFunc() / ()
extern (C) alias Notebook* function (Notebook* source, Widget* page, int x, int y, void* data) NotebookWindowCreationFunc;

enum NumberUpLayout {
   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM = 0,
   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP = 1,
   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM = 2,
   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP = 3,
   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT = 4,
   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT = 5,
   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT = 6,
   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT = 7
}
struct Object /* : GObject.InitiallyUnowned */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance initiallyunowned;
   GObject2.InitiallyUnowned parent_instance;
   uint flags;

   // Unintrospectable constructor: new() / gtk_object_new()
   alias gtk_object_new new_; // Variadic
   static void add_arg_type(char* arg_name, Type arg_type, uint arg_flags, uint arg_id) {
      gtk_object_add_arg_type(arg_name, arg_type, arg_flags, arg_id);
   }
   void destroy() {
      gtk_object_destroy(&this);
   }
   // Unintrospectable method: get() / gtk_object_get()
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_object_get get; // Variadic
   +/
   // Unintrospectable method: get_data() / gtk_object_get_data()
   void* get_data(char* key) {
      return gtk_object_get_data(&this, key);
   }
   // Unintrospectable method: get_data_by_id() / gtk_object_get_data_by_id()
   void* get_data_by_id(GLib2.Quark data_id) {
      return gtk_object_get_data_by_id(&this, data_id);
   }
   // Unintrospectable method: get_user_data() / gtk_object_get_user_data()
   void* get_user_data() {
      return gtk_object_get_user_data(&this);
   }
   // Unintrospectable method: ref() / gtk_object_ref()
   Object* ref_() {
      return gtk_object_ref(&this);
   }
   void remove_data(char* key) {
      gtk_object_remove_data(&this, key);
   }
   void remove_data_by_id(GLib2.Quark data_id) {
      gtk_object_remove_data_by_id(&this, data_id);
   }
   void remove_no_notify(char* key) {
      gtk_object_remove_no_notify(&this, key);
   }
   void remove_no_notify_by_id(GLib2.Quark key_id) {
      gtk_object_remove_no_notify_by_id(&this, key_id);
   }
   // Unintrospectable method: set() / gtk_object_set()
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_object_set set; // Variadic
   +/
   void set_data(char* key, void* data) {
      gtk_object_set_data(&this, key, data);
   }
   void set_data_by_id(GLib2.Quark data_id, void* data) {
      gtk_object_set_data_by_id(&this, data_id, data);
   }
   void set_data_by_id_full(GLib2.Quark data_id, void* data, GLib2.DestroyNotify destroy) {
      gtk_object_set_data_by_id_full(&this, data_id, data, destroy);
   }
   void set_data_full(char* key, void* data, GLib2.DestroyNotify destroy) {
      gtk_object_set_data_full(&this, key, data, destroy);
   }
   void set_user_data(void* data) {
      gtk_object_set_user_data(&this, data);
   }
   void sink() {
      gtk_object_sink(&this);
   }
   void unref() {
      gtk_object_unref(&this);
   }
   void weakref(GLib2.DestroyNotify notify, void* data) {
      gtk_object_weakref(&this, notify, data);
   }
   void weakunref(GLib2.DestroyNotify notify, void* data) {
      gtk_object_weakunref(&this, notify, data);
   }
   extern (C) alias static void function (Object* 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 ObjectClass {
   GObject2.InitiallyUnownedClass parent_class;
   extern (C) void function (Object* object, Arg* arg, uint arg_id) set_arg;
   extern (C) void function (Object* object, Arg* arg, uint arg_id) get_arg;
   extern (C) void function (Object* object) destroy;
}

enum ObjectFlags {
   IN_DESTRUCTION = 1,
   FLOATING = 2,
   RESERVED_1 = 4,
   RESERVED_2 = 8
}

// #GtkOffscreenWindow is strictly intended to be used for obtaining
// snapshots of widgets that are not part of a normal widget hierarchy.
// It differs from gtk_widget_get_snapshot() in that the widget you
// want to get a snapshot of need not be displayed on the user's screen
// as a part of a widget hierarchy.  However, since #GtkOffscreenWindow
// is a toplevel widget you cannot obtain snapshots of a full window
// with it since you cannot pack a toplevel widget in another toplevel.
// The idea is to take a widget and manually set the state of it,
// add it to a #GtkOffscreenWindow and then retrieve the snapshot
// as a #GdkPixmap or #GdkPixbuf.
// #GtkOffscreenWindow derives from #GtkWindow only as an implementation
// detail.  Applications should not use any API specific to #GtkWindow
// to operate on this object.  It should be treated as a #GtkBin that
// has no parent widget.
// When contained offscreen widgets are redrawn, #GtkOffscreenWindow
// will emit a #GtkWidget::damage-event signal.
struct OffscreenWindow /* : Window */ {
   alias parent_object this;
   alias parent_object super_;
   alias parent_object window;
   Window parent_object;


   // Creates a toplevel container widget that is used to retrieve
   // snapshots of widgets without showing them on the screen.  For
   // widgets that are on the screen and part of a normal widget
   // hierarchy, gtk_widget_get_snapshot() can be used instead.
   // RETURNS: A pointer to a #GtkWidget
   static OffscreenWindow* new_() {
      return gtk_offscreen_window_new();
   }

   // Retrieves a snapshot of the contained widget in the form of
   // a #GdkPixbuf.  This is a new pixbuf with a reference count of 1,
   // and the application should unreference it once it is no longer
   // needed.
   // RETURNS: A #GdkPixbuf pointer, or %NULL.
   GdkPixbuf2.Pixbuf* /*new*/ get_pixbuf() {
      return gtk_offscreen_window_get_pixbuf(&this);
   }

   // Retrieves a snapshot of the contained widget in the form of
   // a #GdkPixmap.  If you need to keep this around over window
   // resizes then you should add a reference to it.
   // or %NULL.
   // RETURNS: A #GdkPixmap pointer to the offscreen pixmap,
   Gdk2.Pixmap* get_pixmap() {
      return gtk_offscreen_window_get_pixmap(&this);
   }
}

struct OffscreenWindowClass {
   WindowClass parent_class;
}

struct OldEditable /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   uint current_pos, selection_start_pos, selection_end_pos;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "has_selection", 1,
   uint, "editable", 1,
   uint, "visible", 1,
    uint, "__dummy32A", 29));
   private char* clipboard_text;

   // Emits the ::changed signal on @old_editable.
   void changed() {
      gtk_old_editable_changed(&this);
   }

   // Claims or gives up ownership of the selection.
   // <claim>: if %TRUE, claim ownership of the selection, if %FALSE, give up ownership
   // <time_>: timestamp for this operation
   void claim_selection(int claim, uint time_) {
      gtk_old_editable_claim_selection(&this, claim, time_);
   }
   extern (C) alias static void function (OldEditable* this_, 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);
   }
   extern (C) alias static void function (OldEditable* this_, void* user_data=null) signal_copy_clipboard;
   ulong signal_connect(string name:"copy-clipboard", CB/*:signal_copy_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"copy-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, void* user_data=null) signal_cut_clipboard;
   ulong signal_connect(string name:"cut-clipboard", CB/*:signal_cut_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cut-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_kill_char;
   ulong signal_connect(string name:"kill-char", CB/*:signal_kill_char*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"kill-char",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_kill_line;
   ulong signal_connect(string name:"kill-line", CB/*:signal_kill_line*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"kill-line",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_kill_word;
   ulong signal_connect(string name:"kill-word", CB/*:signal_kill_word*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"kill-word",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, int p0, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, int p0, void* user_data=null) signal_move_page;
   ulong signal_connect(string name:"move-page", CB/*:signal_move_page*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-page",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_move_to_column;
   ulong signal_connect(string name:"move-to-column", CB/*:signal_move_to_column*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-to-column",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_move_to_row;
   ulong signal_connect(string name:"move-to-row", CB/*:signal_move_to_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-to-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, int object, void* user_data=null) signal_move_word;
   ulong signal_connect(string name:"move-word", CB/*:signal_move_word*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-word",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, void* user_data=null) signal_paste_clipboard;
   ulong signal_connect(string name:"paste-clipboard", CB/*:signal_paste_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"paste-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (OldEditable* this_, c_int object, void* user_data=null) signal_set_editable;
   ulong signal_connect(string name:"set-editable", CB/*:signal_set_editable*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-editable",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct OldEditableClass {
   WidgetClass parent_class;
   extern (C) void function (OldEditable* editable) activate;
   extern (C) void function (OldEditable* editable, int is_editable) set_editable;
   extern (C) void function (OldEditable* editable, int x, int y) move_cursor;
   extern (C) void function (OldEditable* editable, int n) move_word;
   extern (C) void function (OldEditable* editable, int x, int y) move_page;
   extern (C) void function (OldEditable* editable, int row) move_to_row;
   extern (C) void function (OldEditable* editable, int row) move_to_column;
   extern (C) void function (OldEditable* editable, int direction) kill_char;
   extern (C) void function (OldEditable* editable, int direction) kill_word;
   extern (C) void function (OldEditable* editable, int direction) kill_line;
   extern (C) void function (OldEditable* editable) cut_clipboard;
   extern (C) void function (OldEditable* editable) copy_clipboard;
   extern (C) void function (OldEditable* editable) paste_clipboard;
   extern (C) void function (OldEditable* editable, int start_pos, int end_pos) update_text;
   extern (C) char* /*new*/ function (OldEditable* editable, int start_pos, int end_pos) get_chars;
   extern (C) void function (OldEditable* editable, int start_pos, int end_pos) set_selection;
   extern (C) void function (OldEditable* editable, int position) set_position;
}

struct OptionMenu /* : Button */ {
   alias button this;
   alias button super_;
   Button button;
   Widget* menu, menu_item;
   ushort width, height;

   static OptionMenu* new_() {
      return gtk_option_menu_new();
   }

   // Retrieves the index of the currently selected menu item. The menu
   // items are numbered from top to bottom, starting with 0.
   // RETURNS: index of the selected menu item, or -1 if there are no menu items
   int get_history() {
      return gtk_option_menu_get_history(&this);
   }
   // Unintrospectable method: get_menu() / gtk_option_menu_get_menu()
   Widget* get_menu() {
      return gtk_option_menu_get_menu(&this);
   }
   void remove_menu() {
      gtk_option_menu_remove_menu(&this);
   }
   void set_history(uint index_) {
      gtk_option_menu_set_history(&this, index_);
   }
   void set_menu(Widget* menu) {
      gtk_option_menu_set_menu(&this, menu);
   }
   extern (C) alias static void function (OptionMenu* 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);
   }
}

struct OptionMenuClass {
   ButtonClass parent_class;
   extern (C) void function (OptionMenu* option_menu) changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Orientable {

   // Retrieves the orientation of the @orientable.
   // RETURNS: the orientation of the @orientable.
   Orientation get_orientation() {
      return gtk_orientable_get_orientation(&this);
   }

   // Sets the orientation of the @orientable.
   // <orientation>: the orientable's new orientation.
   void set_orientation(Orientation orientation) {
      gtk_orientable_set_orientation(&this, orientation);
   }
}

struct OrientableIface {
   GObject2.TypeInterface base_iface;
}

enum Orientation {
   HORIZONTAL = 0,
   VERTICAL = 1
}
enum PAPER_NAME_A3 = "iso_a3";
enum PAPER_NAME_A4 = "iso_a4";
enum PAPER_NAME_A5 = "iso_a5";
enum PAPER_NAME_B5 = "iso_b5";
enum PAPER_NAME_EXECUTIVE = "na_executive";
enum PAPER_NAME_LEGAL = "na_legal";
enum PAPER_NAME_LETTER = "na_letter";
enum int PARAM_READABLE = 0;
enum int PARAM_READWRITE = 0;
enum int PARAM_WRITABLE = 0;
enum int PATH_PRIO_MASK = 15;
enum PRINT_SETTINGS_COLLATE = "collate";
enum PRINT_SETTINGS_DEFAULT_SOURCE = "default-source";
enum PRINT_SETTINGS_DITHER = "dither";
enum PRINT_SETTINGS_DUPLEX = "duplex";
enum PRINT_SETTINGS_FINISHINGS = "finishings";
enum PRINT_SETTINGS_MEDIA_TYPE = "media-type";
enum PRINT_SETTINGS_NUMBER_UP = "number-up";
enum PRINT_SETTINGS_NUMBER_UP_LAYOUT = "number-up-layout";
enum PRINT_SETTINGS_N_COPIES = "n-copies";
enum PRINT_SETTINGS_ORIENTATION = "orientation";
enum PRINT_SETTINGS_OUTPUT_BIN = "output-bin";
enum PRINT_SETTINGS_OUTPUT_FILE_FORMAT = "output-file-format";
enum PRINT_SETTINGS_OUTPUT_URI = "output-uri";
enum PRINT_SETTINGS_PAGE_RANGES = "page-ranges";
enum PRINT_SETTINGS_PAGE_SET = "page-set";
enum PRINT_SETTINGS_PAPER_FORMAT = "paper-format";
enum PRINT_SETTINGS_PAPER_HEIGHT = "paper-height";
enum PRINT_SETTINGS_PAPER_WIDTH = "paper-width";
enum PRINT_SETTINGS_PRINTER = "printer";
enum PRINT_SETTINGS_PRINTER_LPI = "printer-lpi";
enum PRINT_SETTINGS_PRINT_PAGES = "print-pages";
enum PRINT_SETTINGS_QUALITY = "quality";
enum PRINT_SETTINGS_RESOLUTION = "resolution";
enum PRINT_SETTINGS_RESOLUTION_X = "resolution-x";
enum PRINT_SETTINGS_RESOLUTION_Y = "resolution-y";
enum PRINT_SETTINGS_REVERSE = "reverse";
enum PRINT_SETTINGS_SCALE = "scale";
enum PRINT_SETTINGS_USE_COLOR = "use-color";
enum PRINT_SETTINGS_WIN32_DRIVER_EXTRA = "win32-driver-extra";
enum PRINT_SETTINGS_WIN32_DRIVER_VERSION = "win32-driver-version";
enum int PRIORITY_REDRAW = 20;
enum int PRIORITY_RESIZE = 10;
enum PackDirection {
   LTR = 0,
   RTL = 1,
   TTB = 2,
   BTT = 3
}
enum PackType {
   START = 0,
   END = 1
}
enum PageOrientation {
   PORTRAIT = 0,
   LANDSCAPE = 1,
   REVERSE_PORTRAIT = 2,
   REVERSE_LANDSCAPE = 3
}
struct PageRange {
   int start, end;
}

enum PageSet {
   ALL = 0,
   EVEN = 1,
   ODD = 2
}
struct PageSetup /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GtkPageSetup.
   // RETURNS: a new #GtkPageSetup.
   static PageSetup* /*new*/ new_() {
      return gtk_page_setup_new();
   }

   // Reads the page setup from the file @file_name. Returns a 
   // new #GtkPageSetup object with the restored page setup, 
   // or %NULL if an error occurred. See gtk_page_setup_to_file().
   // RETURNS: the restored #GtkPageSetup
   // <file_name>: the filename to read the page setup from
   static PageSetup* /*new*/ new_from_file(char* file_name, GLib2.Error** error=null) {
      return gtk_page_setup_new_from_file(file_name, error);
   }

   // Reads the page setup from the group @group_name in the key file
   // page setup, or %NULL if an error occurred.
   // RETURNS: the restored #GtkPageSetup
   // <key_file>: the #GKeyFile to retrieve the page_setup from
   // <group_name>: the name of the group in the key_file to read, or %NULL to use the default name "Page Setup"
   static PageSetup* /*new*/ new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error=null) {
      return gtk_page_setup_new_from_key_file(key_file, group_name, error);
   }

   // Copies a #GtkPageSetup.
   // RETURNS: a copy of @other
   PageSetup* /*new*/ copy() {
      return gtk_page_setup_copy(&this);
   }

   // Gets the bottom margin in units of @unit.
   // RETURNS: the bottom margin
   // <unit>: the unit for the return value
   double get_bottom_margin(Unit unit) {
      return gtk_page_setup_get_bottom_margin(&this, unit);
   }

   // Gets the left margin in units of @unit.
   // RETURNS: the left margin
   // <unit>: the unit for the return value
   double get_left_margin(Unit unit) {
      return gtk_page_setup_get_left_margin(&this, unit);
   }

   // Gets the page orientation of the #GtkPageSetup.
   // RETURNS: the page orientation
   PageOrientation get_orientation() {
      return gtk_page_setup_get_orientation(&this);
   }

   // Returns the page height in units of @unit.
   // Note that this function takes orientation and
   // margins into consideration. 
   // See gtk_page_setup_get_paper_height().
   // RETURNS: the page height.
   // <unit>: the unit for the return value
   double get_page_height(Unit unit) {
      return gtk_page_setup_get_page_height(&this, unit);
   }

   // Returns the page width in units of @unit.
   // Note that this function takes orientation and
   // margins into consideration. 
   // See gtk_page_setup_get_paper_width().
   // RETURNS: the page width.
   // <unit>: the unit for the return value
   double get_page_width(Unit unit) {
      return gtk_page_setup_get_page_width(&this, unit);
   }

   // Returns the paper height in units of @unit.
   // Note that this function takes orientation, but 
   // not margins into consideration.
   // See gtk_page_setup_get_page_height().
   // RETURNS: the paper height.
   // <unit>: the unit for the return value
   double get_paper_height(Unit unit) {
      return gtk_page_setup_get_paper_height(&this, unit);
   }

   // Gets the paper size of the #GtkPageSetup.
   // RETURNS: the paper size
   PaperSize* /*new*/ get_paper_size() {
      return gtk_page_setup_get_paper_size(&this);
   }

   // Returns the paper width in units of @unit.
   // Note that this function takes orientation, but 
   // not margins into consideration. 
   // See gtk_page_setup_get_page_width().
   // RETURNS: the paper width.
   // <unit>: the unit for the return value
   double get_paper_width(Unit unit) {
      return gtk_page_setup_get_paper_width(&this, unit);
   }

   // Gets the right margin in units of @unit.
   // RETURNS: the right margin
   // <unit>: the unit for the return value
   double get_right_margin(Unit unit) {
      return gtk_page_setup_get_right_margin(&this, unit);
   }

   // Gets the top margin in units of @unit.
   // RETURNS: the top margin
   // <unit>: the unit for the return value
   double get_top_margin(Unit unit) {
      return gtk_page_setup_get_top_margin(&this, unit);
   }

   // Reads the page setup from the file @file_name.
   // See gtk_page_setup_to_file().
   // RETURNS: %TRUE on success
   // <file_name>: the filename to read the page setup from
   int load_file(char* file_name, GLib2.Error** error=null) {
      return gtk_page_setup_load_file(&this, file_name, error);
   }

   // Reads the page setup from the group @group_name in the key file
   // RETURNS: %TRUE on success
   // <key_file>: the #GKeyFile to retrieve the page_setup from
   // <group_name>: the name of the group in the key_file to read, or %NULL to use the default name "Page Setup"
   int load_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error=null) {
      return gtk_page_setup_load_key_file(&this, key_file, group_name, error);
   }

   // Sets the bottom margin of the #GtkPageSetup.
   // <margin>: the new bottom margin in units of @unit
   // <unit>: the units for @margin
   void set_bottom_margin(double margin, Unit unit) {
      gtk_page_setup_set_bottom_margin(&this, margin, unit);
   }

   // Sets the left margin of the #GtkPageSetup.
   // <margin>: the new left margin in units of @unit
   // <unit>: the units for @margin
   void set_left_margin(double margin, Unit unit) {
      gtk_page_setup_set_left_margin(&this, margin, unit);
   }

   // Sets the page orientation of the #GtkPageSetup.
   // <orientation>: a #GtkPageOrientation value
   void set_orientation(PageOrientation orientation) {
      gtk_page_setup_set_orientation(&this, orientation);
   }

   // Sets the paper size of the #GtkPageSetup without
   // changing the margins. See 
   // gtk_page_setup_set_paper_size_and_default_margins().
   // <size>: a #GtkPaperSize
   void set_paper_size(PaperSize* size) {
      gtk_page_setup_set_paper_size(&this, size);
   }

   // Sets the paper size of the #GtkPageSetup and modifies
   // the margins according to the new paper size.
   // <size>: a #GtkPaperSize
   void set_paper_size_and_default_margins(PaperSize* size) {
      gtk_page_setup_set_paper_size_and_default_margins(&this, size);
   }

   // Sets the right margin of the #GtkPageSetup.
   // <margin>: the new right margin in units of @unit
   // <unit>: the units for @margin
   void set_right_margin(double margin, Unit unit) {
      gtk_page_setup_set_right_margin(&this, margin, unit);
   }

   // Sets the top margin of the #GtkPageSetup.
   // <margin>: the new top margin in units of @unit
   // <unit>: the units for @margin
   void set_top_margin(double margin, Unit unit) {
      gtk_page_setup_set_top_margin(&this, margin, unit);
   }

   // This function saves the information from @setup to @file_name.
   // RETURNS: %TRUE on success
   // <file_name>: the file to save to
   int to_file(char* file_name, GLib2.Error** error=null) {
      return gtk_page_setup_to_file(&this, file_name, error);
   }

   // This function adds the page setup from @setup to @key_file.
   // <key_file>: the #GKeyFile to save the page setup to
   // <group_name>: the group to add the settings to in @key_file, or %NULL to use the default name "Page Setup"
   void to_key_file(GLib2.KeyFile* key_file, char* group_name) {
      gtk_page_setup_to_key_file(&this, key_file, group_name);
   }
}

extern (C) alias void function (PageSetup* page_setup, void* data) PageSetupDoneFunc;

struct Paned /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   Widget* child1, child2;
   Gdk2.Window* handle;
   Gdk2.GC* xor_gc;
   Gdk2.CursorType cursor_type;
   private Gdk2.Rectangle handle_pos;
   private int child1_size, last_allocation, min_position, max_position;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "position_set", 1,
   uint, "in_drag", 1,
   uint, "child1_shrink", 1,
   uint, "child1_resize", 1,
   uint, "child2_shrink", 1,
   uint, "child2_resize", 1,
   uint, "orientation", 1,
   uint, "in_recursion", 1,
   uint, "handle_prelit", 1,
    uint, "__dummy32A", 23));
   private Widget* last_child1_focus, last_child2_focus;
   private PanedPrivate* priv;
   private int drag_pos, original_position;

   void add1(Widget* child) {
      gtk_paned_add1(&this, child);
   }
   void add2(Widget* child) {
      gtk_paned_add2(&this, child);
   }
   void compute_position(int allocation, int child1_req, int child2_req) {
      gtk_paned_compute_position(&this, allocation, child1_req, child2_req);
   }

   // Obtains the first child of the paned widget.
   // RETURNS: first child, or %NULL if it is not set.
   Widget* get_child1() {
      return gtk_paned_get_child1(&this);
   }

   // Obtains the second child of the paned widget.
   // RETURNS: second child, or %NULL if it is not set.
   Widget* get_child2() {
      return gtk_paned_get_child2(&this);
   }

   // Returns the #GdkWindow of the handle. This function is
   // useful when handling button or motion events because it
   // enables the callback to distinguish between the window
   // of the paned, a child and the handle.
   // RETURNS: the paned's handle window.
   Gdk2.Window* get_handle_window() {
      return gtk_paned_get_handle_window(&this);
   }

   // Obtains the position of the divider between the two panes.
   // RETURNS: position of the divider
   int get_position() {
      return gtk_paned_get_position(&this);
   }
   void pack1(Widget* child, int resize, int shrink) {
      gtk_paned_pack1(&this, child, resize, shrink);
   }
   void pack2(Widget* child, int resize, int shrink) {
      gtk_paned_pack2(&this, child, resize, shrink);
   }

   // Sets the position of the divider between the two panes.
   // <position>: pixel position of divider, a negative value means that the position is unset.
   void set_position(int position) {
      gtk_paned_set_position(&this, position);
   }

   // The ::accept-position signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to accept the current position of the handle when 
   // moving it using key bindings.
   // The default binding for this signal is Return or Space.
   extern (C) alias static c_int function (Paned* this_, void* user_data=null) signal_accept_position;

   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:"accept-position", CB/*:signal_accept_position*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accept-position",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::cancel-position signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to cancel moving the position of the handle using key 
   // bindings. The position of the handle will be reset to the value prior to 
   // moving it.
   // The default binding for this signal is Escape.
   extern (C) alias static c_int function (Paned* this_, void* user_data=null) signal_cancel_position;
   ulong signal_connect(string name:"cancel-position", CB/*:signal_cancel_position*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cancel-position",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::cycle-child-focus signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to cycle the focus between the children of the paned.
   // The default binding is f6.
   // <reversed>: whether cycling backward or forward
   extern (C) alias static c_int function (Paned* this_, c_int reversed, void* user_data=null) signal_cycle_child_focus;
   ulong signal_connect(string name:"cycle-child-focus", CB/*:signal_cycle_child_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cycle-child-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::cycle-handle-focus signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to cycle whether the paned should grab focus to allow
   // the user to change position of the handle by using key bindings.
   // The default binding for this signal is f8.
   // <reversed>: whether cycling backward or forward
   extern (C) alias static c_int function (Paned* this_, c_int reversed, void* user_data=null) signal_cycle_handle_focus;
   ulong signal_connect(string name:"cycle-handle-focus", CB/*:signal_cycle_handle_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cycle-handle-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-handle signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to move the handle when the user is using key bindings 
   // to move it.
   // <scroll_type>: a #GtkScrollType
   extern (C) alias static c_int function (Paned* this_, ScrollType* scroll_type, void* user_data=null) signal_move_handle;
   ulong signal_connect(string name:"move-handle", CB/*:signal_move_handle*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-handle",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::toggle-handle-focus is a 
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to accept the current position of the handle and then 
   // move focus to the next widget in the focus chain.
   // The default binding is Tab.
   extern (C) alias static c_int function (Paned* this_, void* user_data=null) signal_toggle_handle_focus;
   ulong signal_connect(string name:"toggle-handle-focus", CB/*:signal_toggle_handle_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-handle-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct PanedClass {
   ContainerClass parent_class;
   extern (C) int function (Paned* paned, int reverse) cycle_child_focus;
   extern (C) int function (Paned* paned) toggle_handle_focus;
   extern (C) int function (Paned* paned, ScrollType scroll) move_handle;
   extern (C) int function (Paned* paned, int reverse) cycle_handle_focus;
   extern (C) int function (Paned* paned) accept_position;
   extern (C) int function (Paned* paned) cancel_position;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct PanedPrivate {
}

struct PaperSize {

   // Creates a new #GtkPaperSize object by parsing a
   // <ulink url="ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf">PWG 5101.1-2002</ulink>
   // paper name.
   // If @name is %NULL, the default paper size is returned,
   // see gtk_paper_size_get_default().
   // to free it
   // RETURNS: a new #GtkPaperSize, use gtk_paper_size_free()
   // <name>: a paper size name, or %NULL
   static PaperSize* /*new*/ new_(char* name=null) {
      return gtk_paper_size_new(name);
   }

   // Creates a new #GtkPaperSize object with the
   // given parameters.
   // to free it
   // RETURNS: a new #GtkPaperSize object, use gtk_paper_size_free()
   // <name>: the paper name
   // <display_name>: the human-readable name
   // <width>: the paper width, in units of @unit
   // <height>: the paper height, in units of @unit
   // <unit>: the unit for @width and @height
   static PaperSize* /*new*/ new_custom(char* name, char* display_name, double width, double height, Unit unit) {
      return gtk_paper_size_new_custom(name, display_name, width, height, unit);
   }

   // Reads a paper size from the group @group_name in the key file
   // paper size, or %NULL if an error occurred.
   // RETURNS: a new #GtkPaperSize object with the restored
   // <key_file>: the #GKeyFile to retrieve the papersize from
   // <group_name>: the name ofthe group in the key file to read, or %NULL to read the first group
   static PaperSize* /*new*/ new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error=null) {
      return gtk_paper_size_new_from_key_file(key_file, group_name, error);
   }

   // Creates a new #GtkPaperSize object by using 
   // PPD information. 
   // If @ppd_name is not a recognized PPD paper name, 
   // construct a custom #GtkPaperSize object.
   // to free it
   // RETURNS: a new #GtkPaperSize, use gtk_paper_size_free()
   // <ppd_name>: a PPD paper name
   // <ppd_display_name>: the corresponding human-readable name
   // <width>: the paper width, in points
   // <height>: the paper height in points
   static PaperSize* /*new*/ new_from_ppd(char* ppd_name, char* ppd_display_name, double width, double height) {
      return gtk_paper_size_new_from_ppd(ppd_name, ppd_display_name, width, height);
   }

   // Copies an existing #GtkPaperSize.
   // RETURNS: a copy of @other
   PaperSize* /*new*/ copy() {
      return gtk_paper_size_copy(&this);
   }
   // Free the given #GtkPaperSize object.
   void free() {
      gtk_paper_size_free(&this);
   }

   // Gets the default bottom margin for the #GtkPaperSize.
   // RETURNS: the default bottom margin
   // <unit>: the unit for the return value
   double get_default_bottom_margin(Unit unit) {
      return gtk_paper_size_get_default_bottom_margin(&this, unit);
   }

   // Gets the default left margin for the #GtkPaperSize.
   // RETURNS: the default left margin
   // <unit>: the unit for the return value
   double get_default_left_margin(Unit unit) {
      return gtk_paper_size_get_default_left_margin(&this, unit);
   }

   // Gets the default right margin for the #GtkPaperSize.
   // RETURNS: the default right margin
   // <unit>: the unit for the return value
   double get_default_right_margin(Unit unit) {
      return gtk_paper_size_get_default_right_margin(&this, unit);
   }

   // Gets the default top margin for the #GtkPaperSize.
   // RETURNS: the default top margin
   // <unit>: the unit for the return value
   double get_default_top_margin(Unit unit) {
      return gtk_paper_size_get_default_top_margin(&this, unit);
   }

   // Gets the human-readable name of the #GtkPaperSize.
   // RETURNS: the human-readable name of @size
   char* get_display_name() {
      return gtk_paper_size_get_display_name(&this);
   }

   // Gets the paper height of the #GtkPaperSize, in 
   // units of @unit.
   // RETURNS: the paper height
   // <unit>: the unit for the return value
   double get_height(Unit unit) {
      return gtk_paper_size_get_height(&this, unit);
   }

   // Gets the name of the #GtkPaperSize.
   // RETURNS: the name of @size
   char* get_name() {
      return gtk_paper_size_get_name(&this);
   }

   // Gets the PPD name of the #GtkPaperSize, which
   // may be %NULL.
   // RETURNS: the PPD name of @size
   char* get_ppd_name() {
      return gtk_paper_size_get_ppd_name(&this);
   }

   // Gets the paper width of the #GtkPaperSize, in 
   // units of @unit.
   // RETURNS: the paper width
   // <unit>: the unit for the return value
   double get_width(Unit unit) {
      return gtk_paper_size_get_width(&this, unit);
   }

   // Returns %TRUE if @size is not a standard paper size.
   // RETURNS: whether @size is a custom paper size.
   int is_custom() {
      return gtk_paper_size_is_custom(&this);
   }

   // Compares two #GtkPaperSize objects.
   // represent the same paper size
   // RETURNS: %TRUE, if @size1 and @size2
   // <size2>: another #GtkPaperSize object
   int is_equal(PaperSize* size2) {
      return gtk_paper_size_is_equal(&this, size2);
   }

   // Changes the dimensions of a @size to @width x @height.
   // <width>: the new width in units of @unit
   // <height>: the new height in units of @unit
   // <unit>: the unit for @width and @height
   void set_size(double width, double height, Unit unit) {
      gtk_paper_size_set_size(&this, width, height, unit);
   }

   // This function adds the paper size from @size to @key_file.
   // <key_file>: the #GKeyFile to save the paper size to
   // <group_name>: the group to add the settings to in @key_file
   void to_key_file(GLib2.KeyFile* key_file, char* group_name) {
      gtk_paper_size_to_key_file(&this, key_file, group_name);
   }
}

enum PathPriorityType {
   LOWEST = 0,
   GTK = 4,
   APPLICATION = 8,
   THEME = 10,
   RC = 12,
   HIGHEST = 15
}
enum PathType {
   WIDGET = 0,
   WIDGET_CLASS = 1,
   CLASS = 2
}
struct Pixmap /* : Misc */ {
   alias misc this;
   alias misc super_;
   Misc misc;
   Gdk2.Pixmap* pixmap;
   Gdk2.Bitmap* mask;
   Gdk2.Pixmap* pixmap_insensitive;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "build_insensitive", 1,
    uint, "__dummy32A", 31));

   static Pixmap* new_(Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null) {
      return gtk_pixmap_new(pixmap, mask);
   }
   void get(Gdk2.Pixmap** val, Gdk2.Bitmap** mask) {
      gtk_pixmap_get(&this, val, mask);
   }
   void set(Gdk2.Pixmap* val, Gdk2.Bitmap* mask) {
      gtk_pixmap_set(&this, val, mask);
   }
   void set_build_insensitive(int build) {
      gtk_pixmap_set_build_insensitive(&this, build);
   }
}

struct PixmapClass {
   MiscClass parent_class;
}


// Together with #GtkSocket, #GtkPlug provides the ability
// to embed widgets from one process into another process
// in a fashion that is transparent to the user. One
// process creates a #GtkSocket widget and passes the
// ID of that widget's window to the other process,
// which then creates a #GtkPlug with that window ID.
// Any widgets contained in the #GtkPlug then will appear
// inside the first application's window.
// <note>
// The #GtkPlug and #GtkSocket widgets are currently not available
// on all platforms supported by GTK+.
// </note>
struct Plug /* : Window */ {
   alias window this;
   alias window super_;
   Window window;
   Gdk2.Window* socket_window;
   Widget* modality_window;
   WindowGroup* modality_group;
   GLib2.HashTable* grabbed_keys;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "same_app", 1,
    uint, "__dummy32A", 31));


   // Creates a new plug widget inside the #GtkSocket identified
   // by @socket_id. If @socket_id is 0, the plug is left "unplugged" and
   // can later be plugged into a #GtkSocket by  gtk_socket_add_id().
   // RETURNS: the new #GtkPlug widget.
   // <socket_id>: the window ID of the socket, or 0.
   static Plug* new_(Gdk2.NativeWindow socket_id) {
      return gtk_plug_new(socket_id);
   }

   // Create a new plug widget inside the #GtkSocket identified by socket_id.
   // RETURNS: the new #GtkPlug widget.
   // <display>: the #GdkDisplay on which @socket_id is displayed
   // <socket_id>: the XID of the socket's window.
   static Plug* new_for_display(Gdk2.Display* display, Gdk2.NativeWindow socket_id) {
      return gtk_plug_new_for_display(display, socket_id);
   }

   // Finish the initialization of @plug for a given #GtkSocket identified by
   // <socket_id>: the XID of the socket's window.
   void construct(Gdk2.NativeWindow socket_id) {
      gtk_plug_construct(&this, socket_id);
   }

   // Finish the initialization of @plug for a given #GtkSocket identified by
   // This function will generally only be used by classes deriving from #GtkPlug.
   // <display>: the #GdkDisplay associated with @socket_id's #GtkSocket.
   // <socket_id>: the XID of the socket's window.
   void construct_for_display(Gdk2.Display* display, Gdk2.NativeWindow socket_id) {
      gtk_plug_construct_for_display(&this, display, socket_id);
   }

   // Determines whether the plug is embedded in a socket.
   // RETURNS: %TRUE if the plug is embedded in a socket
   int get_embedded() {
      return gtk_plug_get_embedded(&this);
   }

   // Gets the window ID of a #GtkPlug widget, which can then
   // be used to embed this window inside another window, for
   // instance with gtk_socket_add_id().
   // RETURNS: the window ID for the plug
   Gdk2.NativeWindow get_id() {
      return gtk_plug_get_id(&this);
   }

   // Retrieves the socket the plug is embedded in.
   // RETURNS: the window of the socket, or %NULL
   Gdk2.Window* get_socket_window() {
      return gtk_plug_get_socket_window(&this);
   }
   // Gets emitted when the plug becomes embedded in a socket.
   extern (C) alias static void function (Plug* this_, void* user_data=null) signal_embedded;

   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:"embedded", CB/*:signal_embedded*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"embedded",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct PlugClass {
   WindowClass parent_class;
   extern (C) void function (Plug* plug) embedded;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum PolicyType {
   ALWAYS = 0,
   AUTOMATIC = 1,
   NEVER = 2
}
enum PositionType {
   LEFT = 0,
   RIGHT = 1,
   TOP = 2,
   BOTTOM = 3
}
struct Preview /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   ubyte* buffer;
   ushort buffer_width, buffer_height, bpp, rowstride;
   Gdk2.RgbDither dither;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "type", 1,
   uint, "expand", 1,
    uint, "__dummy32A", 30));

   static Preview* new_(PreviewType type) {
      return gtk_preview_new(type);
   }
   // Unintrospectable function: get_cmap() / gtk_preview_get_cmap()
   static Gdk2.Colormap* get_cmap() {
      return gtk_preview_get_cmap();
   }
   // Unintrospectable function: get_info() / gtk_preview_get_info()
   static PreviewInfo* get_info() {
      return gtk_preview_get_info();
   }
   // Unintrospectable function: get_visual() / gtk_preview_get_visual()
   static Gdk2.Visual* get_visual() {
      return gtk_preview_get_visual();
   }
   static void reset() {
      gtk_preview_reset();
   }
   static void set_color_cube(uint nred_shades, uint ngreen_shades, uint nblue_shades, uint ngray_shades) {
      gtk_preview_set_color_cube(nred_shades, ngreen_shades, nblue_shades, ngray_shades);
   }
   static void set_gamma(double gamma_) {
      gtk_preview_set_gamma(gamma_);
   }
   static void set_install_cmap(int install_cmap) {
      gtk_preview_set_install_cmap(install_cmap);
   }
   static void set_reserved(int nreserved) {
      gtk_preview_set_reserved(nreserved);
   }
   static void uninit() {
      gtk_preview_uninit();
   }
   void draw_row(ubyte* data, int x, int y, int w) {
      gtk_preview_draw_row(&this, data, x, y, w);
   }
   void put(Gdk2.Window* window, Gdk2.GC* gc, int srcx, int srcy, int destx, int desty, int width, int height) {
      gtk_preview_put(&this, window, gc, srcx, srcy, destx, desty, width, height);
   }
   void set_dither(Gdk2.RgbDither dither) {
      gtk_preview_set_dither(&this, dither);
   }
   void set_expand(int expand) {
      gtk_preview_set_expand(&this, expand);
   }
   void size(int width, int height) {
      gtk_preview_size(&this, width, height);
   }
}

struct PreviewClass {
   WidgetClass parent_class;
   PreviewInfo info;
}

struct PreviewInfo {
   ubyte* lookup;
   double gamma;
}

enum PreviewType {
   COLOR = 0,
   GRAYSCALE = 1
}
struct PrintContext /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #PangoContext that can be used with the
   // #GtkPrintContext.
   // RETURNS: a new Pango context for @context
   Pango.Context* /*new*/ create_pango_context() {
      return gtk_print_context_create_pango_context(&this);
   }

   // Creates a new #PangoLayout that is suitable for use
   // with the #GtkPrintContext.
   // RETURNS: a new Pango layout for @context
   Pango.Layout* /*new*/ create_pango_layout() {
      return gtk_print_context_create_pango_layout(&this);
   }

   // Obtains the cairo context that is associated with the
   // #GtkPrintContext.
   // RETURNS: the cairo context of @context
   cairo.Context* get_cairo_context() {
      return gtk_print_context_get_cairo_context(&this);
   }

   // Obtains the horizontal resolution of the #GtkPrintContext,
   // in dots per inch.
   // RETURNS: the horizontal resolution of @context
   double get_dpi_x() {
      return gtk_print_context_get_dpi_x(&this);
   }

   // Obtains the vertical resolution of the #GtkPrintContext,
   // in dots per inch.
   // RETURNS: the vertical resolution of @context
   double get_dpi_y() {
      return gtk_print_context_get_dpi_y(&this);
   }

   // Obtains the hardware printer margins of the #GtkPrintContext, in units.
   // RETURNS: %TRUE if the hard margins were retrieved
   // <top>: top hardware printer margin
   // <bottom>: bottom hardware printer margin
   // <left>: left hardware printer margin
   // <right>: right hardware printer margin
   int get_hard_margins(/*out*/ double* top, /*out*/ double* bottom, /*out*/ double* left, /*out*/ double* right) {
      return gtk_print_context_get_hard_margins(&this, top, bottom, left, right);
   }

   // Obtains the height of the #GtkPrintContext, in pixels.
   // RETURNS: the height of @context
   double get_height() {
      return gtk_print_context_get_height(&this);
   }

   // Obtains the #GtkPageSetup that determines the page
   // dimensions of the #GtkPrintContext.
   // RETURNS: the page setup of @context
   PageSetup* get_page_setup() {
      return gtk_print_context_get_page_setup(&this);
   }

   // Returns a #PangoFontMap that is suitable for use
   // with the #GtkPrintContext.
   // RETURNS: the font map of @context
   Pango.FontMap* get_pango_fontmap() {
      return gtk_print_context_get_pango_fontmap(&this);
   }

   // Obtains the width of the #GtkPrintContext, in pixels.
   // RETURNS: the width of @context
   double get_width() {
      return gtk_print_context_get_width(&this);
   }

   // Sets a new cairo context on a print context. 
   // This function is intended to be used when implementing
   // an internal print preview, it is not needed for printing,
   // since GTK+ itself creates a suitable cairo context in that
   // case.
   // <cr>: the cairo context
   // <dpi_x>: the horizontal resolution to use with @cr
   // <dpi_y>: the vertical resolution to use with @cr
   void set_cairo_context(cairo.Context* cr, double dpi_x, double dpi_y) {
      gtk_print_context_set_cairo_context(&this, cr, dpi_x, dpi_y);
   }
}

enum PrintDuplex {
   SIMPLEX = 0,
   HORIZONTAL = 1,
   VERTICAL = 2
}
enum PrintError {
   GENERAL = 0,
   INTERNAL_ERROR = 1,
   NOMEM = 2,
   INVALID_FILE = 3
}
extern (C) alias void function (void* func_data, char* str) PrintFunc;

struct PrintOperation /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   PrintOperationPrivate* priv;


   // Creates a new #GtkPrintOperation.
   // RETURNS: a new #GtkPrintOperation
   static PrintOperation* /*new*/ new_() {
      return gtk_print_operation_new();
   }

   // Cancels a running print operation. This function may
   // be called from a #GtkPrintOperation::begin-print, 
   // #GtkPrintOperation::paginate or #GtkPrintOperation::draw-page
   // signal handler to stop the currently running print 
   // operation.
   void cancel() {
      gtk_print_operation_cancel(&this);
   }

   // Signalize that drawing of particular page is complete.
   // It is called after completion of page drawing (e.g. drawing in another
   // thread).
   // If gtk_print_operation_set_defer_drawing() was called before, then this function
   // has to be called by application. In another case it is called by the library
   // itself.
   void draw_page_finish() {
      gtk_print_operation_draw_page_finish(&this);
   }

   // Returns the default page setup, see
   // gtk_print_operation_set_default_page_setup().
   // RETURNS: the default page setup
   PageSetup* get_default_page_setup() {
      return gtk_print_operation_get_default_page_setup(&this);
   }

   // Gets the value of #GtkPrintOperation::embed-page-setup property.
   // RETURNS: whether page setup selection combos are embedded
   int get_embed_page_setup() {
      return gtk_print_operation_get_embed_page_setup(&this);
   }

   // Call this when the result of a print operation is
   // %GTK_PRINT_OPERATION_RESULT_ERROR, either as returned by 
   // gtk_print_operation_run(), or in the #GtkPrintOperation::done signal 
   // handler. The returned #GError will contain more details on what went wrong.
   void get_error(GLib2.Error** error=null) {
      gtk_print_operation_get_error(&this, error);
   }

   // Gets the value of #GtkPrintOperation::has-selection property.
   // RETURNS: whether there is a selection
   int get_has_selection() {
      return gtk_print_operation_get_has_selection(&this);
   }

   // Returns the number of pages that will be printed.
   // Note that this value is set during print preparation phase
   // (%GTK_PRINT_STATUS_PREPARING), so this function should never be
   // called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
   // You can connect to the #GtkPrintOperation::status-changed signal
   // and call gtk_print_operation_get_n_pages_to_print() when
   // print status is %GTK_PRINT_STATUS_GENERATING_DATA.
   // This is typically used to track the progress of print operation.
   // RETURNS: the number of pages that will be printed
   int get_n_pages_to_print() {
      return gtk_print_operation_get_n_pages_to_print(&this);
   }

   // Returns the current print settings.
   // Note that the return value is %NULL until either
   // gtk_print_operation_set_print_settings() or
   // gtk_print_operation_run() have been called.
   // RETURNS: the current print settings of @op.
   PrintSettings* get_print_settings() {
      return gtk_print_operation_get_print_settings(&this);
   }

   // Returns the status of the print operation. 
   // Also see gtk_print_operation_get_status_string().
   // RETURNS: the status of the print operation
   PrintStatus get_status() {
      return gtk_print_operation_get_status(&this);
   }

   // Returns a string representation of the status of the 
   // print operation. The string is translated and suitable
   // for displaying the print status e.g. in a #GtkStatusbar.
   // Use gtk_print_operation_get_status() to obtain a status
   // value that is suitable for programmatic use. 
   // of the print operation
   // RETURNS: a string representation of the status
   char* get_status_string() {
      return gtk_print_operation_get_status_string(&this);
   }

   // Gets the value of #GtkPrintOperation::support-selection property.
   // RETURNS: whether the application supports print of selection
   int get_support_selection() {
      return gtk_print_operation_get_support_selection(&this);
   }

   // A convenience function to find out if the print operation
   // is finished, either successfully (%GTK_PRINT_STATUS_FINISHED)
   // or unsuccessfully (%GTK_PRINT_STATUS_FINISHED_ABORTED).
   // can be in a non-finished state even after done has been called, as
   // the operation status then tracks the print job status on the printer.
   // RETURNS: %TRUE, if the print operation is finished.
   int is_finished() {
      return gtk_print_operation_is_finished(&this);
   }

   // Runs the print operation, by first letting the user modify
   // print settings in the print dialog, and then print the document.
   // Normally that this function does not return until the rendering of all 
   // pages is complete. You can connect to the 
   // #GtkPrintOperation::status-changed signal on @op to obtain some 
   // information about the progress of the print operation. 
   // Furthermore, it may use a recursive mainloop to show the print dialog.
   // If you call gtk_print_operation_set_allow_async() or set the 
   // #GtkPrintOperation:allow-async property the operation will run 
   // asynchronously if this is supported on the platform. The 
   // #GtkPrintOperation::done signal will be emitted with the result of the 
   // operation when the it is done (i.e. when the dialog is canceled, or when 
   // the print succeeds or fails).
   // |[
   // if (settings != NULL)
   // gtk_print_operation_set_print_settings (print, settings);
   // if (page_setup != NULL)
   // gtk_print_operation_set_default_page_setup (print, page_setup);
   // g_signal_connect (print, "begin-print", 
   // G_CALLBACK (begin_print), &data);
   // g_signal_connect (print, "draw-page", 
   // G_CALLBACK (draw_page), &data);
   // res = gtk_print_operation_run (print, 
   // GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, 
   // parent, 
   // &error);
   // if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
   // {
   // error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
   // GTK_DIALOG_DESTROY_WITH_PARENT,
   // GTK_MESSAGE_ERROR,
   // GTK_BUTTONS_CLOSE,
   // "Error printing file:\n%s",
   // error->message);
   // g_signal_connect (error_dialog, "response", 
   // G_CALLBACK (gtk_widget_destroy), NULL);
   // gtk_widget_show (error_dialog);
   // g_error_free (error);
   // }
   // else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
   // {
   // if (settings != NULL)
   // g_object_unref (settings);
   // settings = g_object_ref (gtk_print_operation_get_print_settings (print));
   // }
   // ]|
   // Note that gtk_print_operation_run() can only be called once on a
   // given #GtkPrintOperation.
   // %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was
   // completed successfully. In this case, it is a good idea to obtain 
   // the used print settings with gtk_print_operation_get_print_settings() 
   // and store them for reuse with the next print operation. A value of
   // %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running
   // asynchronously, and will emit the #GtkPrintOperation::done signal when 
   // done.
   // RETURNS: the result of the print operation. A return value of
   // <action>: the action to start
   // <parent>: Transient parent of the dialog
   PrintOperationResult run(PrintOperationAction action, Window* parent, GLib2.Error** error=null) {
      return gtk_print_operation_run(&this, action, parent, error);
   }

   // Sets whether the gtk_print_operation_run() may return
   // before the print operation is completed. Note that
   // some platforms may not allow asynchronous operation.
   // <allow_async>: %TRUE to allow asynchronous operation
   void set_allow_async(int allow_async) {
      gtk_print_operation_set_allow_async(&this, allow_async);
   }

   // Sets the current page.
   // If this is called before gtk_print_operation_run(), 
   // the user will be able to select to print only the current page.
   // Note that this only makes sense for pre-paginated documents.
   // <current_page>: the current page, 0-based
   void set_current_page(int current_page) {
      gtk_print_operation_set_current_page(&this, current_page);
   }

   // Sets the label for the tab holding custom widgets.
   // <label>: the label to use, or %NULL to use the default label
   void set_custom_tab_label(char* label=null) {
      gtk_print_operation_set_custom_tab_label(&this, label);
   }

   // Makes @default_page_setup the default page setup for @op.
   // This page setup will be used by gtk_print_operation_run(),
   // but it can be overridden on a per-page basis by connecting
   // to the #GtkPrintOperation::request-page-setup signal.
   // <default_page_setup>: a #GtkPageSetup, or %NULL
   void set_default_page_setup(PageSetup* default_page_setup=null) {
      gtk_print_operation_set_default_page_setup(&this, default_page_setup);
   }

   // Sets up the #GtkPrintOperation to wait for calling of
   // gtk_print_operation_draw_page_finish() from application. It can
   // be used for drawing page in another thread.
   // This function must be called in the callback of "draw-page" signal.
   void set_defer_drawing() {
      gtk_print_operation_set_defer_drawing(&this);
   }

   // Embed page size combo box and orientation combo box into page setup page.
   // Selected page setup is stored as default page setup in #GtkPrintOperation.
   // <embed>: %TRUE to embed page setup selection in the #GtkPrintDialog
   void set_embed_page_setup(int embed) {
      gtk_print_operation_set_embed_page_setup(&this, embed);
   }

   // Sets up the #GtkPrintOperation to generate a file instead
   // of showing the print dialog. The indended use of this function
   // is for implementing "Export to PDF" actions. Currently, PDF
   // is the only supported format.
   // "Print to PDF" support is independent of this and is done
   // by letting the user pick the "Print to PDF" item from the list
   // of printers in the print dialog.
   // <filename>: the filename for the exported file
   void set_export_filename(char* filename) {
      gtk_print_operation_set_export_filename(&this, filename);
   }

   // Sets whether there is a selection to print.
   // Application has to set number of pages to which the selection
   // will draw by gtk_print_operation_set_n_pages() in a callback of
   // #GtkPrintOperation::begin-print.
   // <has_selection>: %TRUE indicates that a selection exists
   void set_has_selection(int has_selection) {
      gtk_print_operation_set_has_selection(&this, has_selection);
   }

   // Sets the name of the print job. The name is used to identify 
   // the job (e.g. in monitoring applications like eggcups). 
   // If you don't set a job name, GTK+ picks a default one by 
   // numbering successive print jobs.
   // <job_name>: a string that identifies the print job
   void set_job_name(char* job_name) {
      gtk_print_operation_set_job_name(&this, job_name);
   }

   // Sets the number of pages in the document. 
   // This <emphasis>must</emphasis> be set to a positive number
   // before the rendering starts. It may be set in a 
   // #GtkPrintOperation::begin-print signal hander.
   // Note that the page numbers passed to the 
   // #GtkPrintOperation::request-page-setup 
   // and #GtkPrintOperation::draw-page signals are 0-based, i.e. if 
   // the user chooses to print all pages, the last ::draw-page signal 
   // will be for page @n_pages - 1.
   // <n_pages>: the number of pages
   void set_n_pages(int n_pages) {
      gtk_print_operation_set_n_pages(&this, n_pages);
   }

   // Sets the print settings for @op. This is typically used to
   // re-establish print settings from a previous print operation,
   // see gtk_print_operation_run().
   // <print_settings>: #GtkPrintSettings
   void set_print_settings(PrintSettings* print_settings=null) {
      gtk_print_operation_set_print_settings(&this, print_settings);
   }

   // If @show_progress is %TRUE, the print operation will show a 
   // progress dialog during the print operation.
   // <show_progress>: %TRUE to show a progress dialog
   void set_show_progress(int show_progress) {
      gtk_print_operation_set_show_progress(&this, show_progress);
   }

   // Sets whether selection is supported by #GtkPrintOperation.
   // <support_selection>: %TRUE to support selection
   void set_support_selection(int support_selection) {
      gtk_print_operation_set_support_selection(&this, support_selection);
   }

   // If track_status is %TRUE, the print operation will try to continue report
   // on the status of the print job in the printer queues and printer. This
   // can allow your application to show things like "out of paper" issues,
   // and when the print job actually reaches the printer.
   // This function is often implemented using some form of polling, so it should
   // not be enabled unless needed.
   // <track_status>: %TRUE to track status after printing
   void set_track_print_status(int track_status) {
      gtk_print_operation_set_track_print_status(&this, track_status);
   }

   // Sets up the transformation for the cairo context obtained from
   // #GtkPrintContext in such a way that distances are measured in 
   // units of @unit.
   // <unit>: the unit to use
   void set_unit(Unit unit) {
      gtk_print_operation_set_unit(&this, unit);
   }

   // If @full_page is %TRUE, the transformation for the cairo context 
   // obtained from #GtkPrintContext puts the origin at the top left 
   // corner of the page (which may not be the top left corner of the 
   // sheet, depending on page orientation and the number of pages per 
   // sheet). Otherwise, the origin is at the top left corner of the
   // imageable area (i.e. inside the margins).
   // <full_page>: %TRUE to set up the #GtkPrintContext for the full page
   void set_use_full_page(int full_page) {
      gtk_print_operation_set_use_full_page(&this, full_page);
   }

   // Emitted after the user has finished changing print settings
   // in the dialog, before the actual rendering starts. 
   // A typical use for ::begin-print is to use the parameters from the
   // #GtkPrintContext and paginate the document accordingly, and then
   // set the number of pages with gtk_print_operation_set_n_pages().
   // <context>: the #GtkPrintContext for the current operation
   extern (C) alias static void function (PrintOperation* this_, PrintContext* context, void* user_data=null) signal_begin_print;

   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:"begin-print", CB/*:signal_begin_print*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"begin-print",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when displaying the print dialog. If you return a
   // widget in a handler for this signal it will be added to a custom
   // tab in the print dialog. You typically return a container widget
   // with multiple widgets in it.
   // The print dialog owns the returned widget, and its lifetime is not 
   // controlled by the application. However, the widget is guaranteed 
   // to stay around until the #GtkPrintOperation::custom-widget-apply 
   // signal is emitted on the operation. Then you can read out any 
   // information you need from the widgets.
   // the print dialog, or %NULL
   // RETURNS: A custom widget that gets embedded in
   extern (C) alias static GObject2.Object* function (PrintOperation* this_, void* user_data=null) signal_create_custom_widget;
   ulong signal_connect(string name:"create-custom-widget", CB/*:signal_create_custom_widget*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"create-custom-widget",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted right before #GtkPrintOperation::begin-print if you added
   // a custom widget in the #GtkPrintOperation::create-custom-widget handler. 
   // When you get this signal you should read the information from the 
   // custom widgets, as the widgets are not guaraneed to be around at a 
   // later time.
   // <widget>: the custom widget added in create-custom-widget
   extern (C) alias static void function (PrintOperation* this_, Widget* widget, void* user_data=null) signal_custom_widget_apply;
   ulong signal_connect(string name:"custom-widget-apply", CB/*:signal_custom_widget_apply*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"custom-widget-apply",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the print operation run has finished doing
   // everything required for printing. 
   // If @result is %GTK_PRINT_OPERATION_RESULT_ERROR then you can call
   // gtk_print_operation_get_error() for more information.
   // If you enabled print status tracking then 
   // gtk_print_operation_is_finished() may still return %FALSE 
   // after #GtkPrintOperation::done was emitted.
   // <result>: the result of the print operation
   extern (C) alias static void function (PrintOperation* this_, PrintOperationResult* result, void* user_data=null) signal_done;
   ulong signal_connect(string name:"done", CB/*:signal_done*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"done",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted for every page that is printed. The signal handler
   // must render the @page_nr's page onto the cairo context obtained
   // from @context using gtk_print_context_get_cairo_context().
   // |[
   // static void
   // draw_page (GtkPrintOperation *operation,
   // GtkPrintContext   *context,
   // gint               page_nr,
   // gpointer           user_data)
   // {
   // cairo_t *cr;
   // PangoLayout *layout;
   // gdouble width, text_height;
   // gint layout_height;
   // PangoFontDescription *desc;
   // cr = gtk_print_context_get_cairo_context (context);
   // width = gtk_print_context_get_width (context);
   // cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
   // cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
   // cairo_fill (cr);
   // layout = gtk_print_context_create_pango_layout (context);
   // desc = pango_font_description_from_string ("sans 14");
   // pango_layout_set_font_description (layout, desc);
   // pango_font_description_free (desc);
   // pango_layout_set_text (layout, "some text", -1);
   // pango_layout_set_width (layout, width * PANGO_SCALE);
   // pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
   // pango_layout_get_size (layout, NULL, &layout_height);
   // text_height = (gdouble)layout_height / PANGO_SCALE;
   // cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);
   // pango_cairo_show_layout (cr, layout);
   // g_object_unref (layout);
   // }
   // ]|
   // Use gtk_print_operation_set_use_full_page() and 
   // gtk_print_operation_set_unit() before starting the print operation
   // to set up the transformation of the cairo context according to your
   // needs.
   // <context>: the #GtkPrintContext for the current operation
   // <page_nr>: the number of the currently printed page (0-based)
   extern (C) alias static void function (PrintOperation* this_, PrintContext* context, int page_nr, void* user_data=null) signal_draw_page;
   ulong signal_connect(string name:"draw-page", CB/*:signal_draw_page*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"draw-page",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted after all pages have been rendered. 
   // A handler for this signal can clean up any resources that have
   // been allocated in the #GtkPrintOperation::begin-print handler.
   // <context>: the #GtkPrintContext for the current operation
   extern (C) alias static void function (PrintOperation* this_, PrintContext* context, void* user_data=null) signal_end_print;
   ulong signal_connect(string name:"end-print", CB/*:signal_end_print*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"end-print",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted after the #GtkPrintOperation::begin-print signal, but before 
   // the actual rendering starts. It keeps getting emitted until a connected 
   // signal handler returns %TRUE.
   // The ::paginate signal is intended to be used for paginating a document
   // in small chunks, to avoid blocking the user interface for a long
   // time. The signal handler should update the number of pages using
   // gtk_print_operation_set_n_pages(), and return %TRUE if the document
   // has been completely paginated.
   // If you don't need to do pagination in chunks, you can simply do
   // it all in the ::begin-print handler, and set the number of pages
   // from there.
   // RETURNS: %TRUE if pagination is complete
   // <context>: the #GtkPrintContext for the current operation
   extern (C) alias static c_int function (PrintOperation* this_, PrintContext* context, void* user_data=null) signal_paginate;
   ulong signal_connect(string name:"paginate", CB/*:signal_paginate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"paginate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when a preview is requested from the native dialog.
   // The default handler for this signal uses an external viewer 
   // application to preview.
   // To implement a custom print preview, an application must return
   // %TRUE from its handler for this signal. In order to use the
   // provided @context for the preview implementation, it must be
   // given a suitable cairo context with gtk_print_context_set_cairo_context().
   // The custom preview implementation can use 
   // gtk_print_operation_preview_is_selected() and 
   // gtk_print_operation_preview_render_page() to find pages which
   // are selected for print and render them. The preview must be
   // finished by calling gtk_print_operation_preview_end_preview()
   // (typically in response to the user clicking a close button).
   // RETURNS: %TRUE if the listener wants to take over control of the preview
   // <preview>: the #GtkPrintPreviewOperation for the current operation
   // <context>: the #GtkPrintContext that will be used
   // <parent>: the #GtkWindow to use as window parent, or %NULL
   extern (C) alias static c_int function (PrintOperation* this_, PrintOperationPreview* preview, PrintContext* context, Window* parent=null, void* user_data=null) signal_preview;
   ulong signal_connect(string name:"preview", CB/*:signal_preview*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preview",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted once for every page that is printed, to give
   // the application a chance to modify the page setup. Any changes 
   // done to @setup will be in force only for printing this page.
   // <context>: the #GtkPrintContext for the current operation
   // <page_nr>: the number of the currently printed page (0-based)
   // <setup>: the #GtkPageSetup
   extern (C) alias static void function (PrintOperation* this_, PrintContext* context, int page_nr, PageSetup* setup, void* user_data=null) signal_request_page_setup;
   ulong signal_connect(string name:"request-page-setup", CB/*:signal_request_page_setup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"request-page-setup",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted at between the various phases of the print operation.
   // See #GtkPrintStatus for the phases that are being discriminated.
   // Use gtk_print_operation_get_status() to find out the current
   // status.
   extern (C) alias static void function (PrintOperation* this_, void* user_data=null) signal_status_changed;
   ulong signal_connect(string name:"status-changed", CB/*:signal_status_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"status-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted after change of selected printer. The actual page setup and
   // print settings are passed to the custom widget, which can actualize
   // itself according to this change.
   // <widget>: the custom widget added in create-custom-widget
   // <setup>: actual page setup
   // <settings>: actual print settings
   extern (C) alias static void function (PrintOperation* this_, Widget* widget, PageSetup* setup, PrintSettings* settings, void* user_data=null) signal_update_custom_widget;
   ulong signal_connect(string name:"update-custom-widget", CB/*:signal_update_custom_widget*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"update-custom-widget",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

enum PrintOperationAction {
   PRINT_DIALOG = 0,
   PRINT = 1,
   PREVIEW = 2,
   EXPORT = 3
}
struct PrintOperationClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (PrintOperation* operation, PrintOperationResult result) done;
   extern (C) void function (PrintOperation* operation, PrintContext* context) begin_print;
   extern (C) int function (PrintOperation* operation, PrintContext* context) paginate;
   extern (C) void function (PrintOperation* operation, PrintContext* context, int page_nr, PageSetup* setup) request_page_setup;
   extern (C) void function (PrintOperation* operation, PrintContext* context, int page_nr) draw_page;
   extern (C) void function (PrintOperation* operation, PrintContext* context) end_print;
   extern (C) void function (PrintOperation* operation) status_changed;
   // Unintrospectable functionp: create_custom_widget() / ()
   extern (C) Widget* function (PrintOperation* operation) create_custom_widget;
   extern (C) void function (PrintOperation* operation, Widget* widget) custom_widget_apply;
   extern (C) int function (PrintOperation* operation, PrintOperationPreview* preview, PrintContext* context, Window* parent) preview;
   extern (C) void function (PrintOperation* operation, Widget* widget, PageSetup* setup, PrintSettings* settings) update_custom_widget;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
}

struct PrintOperationPreview {

   // Ends a preview. 
   // This function must be called to finish a custom print preview.
   void end_preview() {
      gtk_print_operation_preview_end_preview(&this);
   }

   // Returns whether the given page is included in the set of pages that
   // have been selected for printing.
   // RETURNS: %TRUE if the page has been selected for printing
   // <page_nr>: a page number
   int is_selected(int page_nr) {
      return gtk_print_operation_preview_is_selected(&this, page_nr);
   }

   // Renders a page to the preview, using the print context that
   // was passed to the #GtkPrintOperation::preview handler together
   // with @preview.
   // A custom iprint preview should use this function in its ::expose
   // handler to render the currently selected page.
   // Note that this function requires a suitable cairo context to 
   // be associated with the print context.
   // <page_nr>: the page to render
   void render_page(int page_nr) {
      gtk_print_operation_preview_render_page(&this, page_nr);
   }

   // The ::got-page-size signal is emitted once for each page
   // that gets rendered to the preview. 
   // A handler for this signal should update the @context
   // according to @page_setup and set up a suitable cairo
   // context, using gtk_print_context_set_cairo_context().
   // <context>: the current #GtkPrintContext
   // <page_setup>: the #GtkPageSetup for the current page
   extern (C) alias static void function (PrintOperationPreview* this_, PrintContext* context, PageSetup* page_setup, void* user_data=null) signal_got_page_size;

   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:"got-page-size", CB/*:signal_got_page_size*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"got-page-size",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::ready signal gets emitted once per preview operation,
   // before the first page is rendered.
   // A handler for this signal can be used for setup tasks.
   // <context>: the current #GtkPrintContext
   extern (C) alias static void function (PrintOperationPreview* this_, PrintContext* context, void* user_data=null) signal_ready;
   ulong signal_connect(string name:"ready", CB/*:signal_ready*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"ready",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct PrintOperationPreviewIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (PrintOperationPreview* preview, PrintContext* context) ready;
   extern (C) void function (PrintOperationPreview* preview, PrintContext* context, PageSetup* page_setup) got_page_size;
   // <page_nr>: the page to render
   extern (C) void function (PrintOperationPreview* preview, int page_nr) render_page;

   // RETURNS: %TRUE if the page has been selected for printing
   // <page_nr>: a page number
   extern (C) int function (PrintOperationPreview* preview, int page_nr) is_selected;
   extern (C) void function (PrintOperationPreview* preview) end_preview;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
   extern (C) void function () _gtk_reserved7;
}

struct PrintOperationPrivate {
}

enum PrintOperationResult {
   ERROR = 0,
   APPLY = 1,
   CANCEL = 2,
   IN_PROGRESS = 3
}
enum PrintPages {
   ALL = 0,
   CURRENT = 1,
   RANGES = 2,
   SELECTION = 3
}
enum PrintQuality {
   LOW = 0,
   NORMAL = 1,
   HIGH = 2,
   DRAFT = 3
}
struct PrintSettings /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Creates a new #GtkPrintSettings object.
   // RETURNS: a new #GtkPrintSettings object
   static PrintSettings* /*new*/ new_() {
      return gtk_print_settings_new();
   }

   // Reads the print settings from @file_name. Returns a new #GtkPrintSettings
   // object with the restored settings, or %NULL if an error occurred. If the
   // file could not be loaded then error is set to either a #GFileError or
   // #GKeyFileError.  See gtk_print_settings_to_file().
   // RETURNS: the restored #GtkPrintSettings
   // <file_name>: the filename to read the settings from
   static PrintSettings* /*new*/ new_from_file(char* file_name, GLib2.Error** error=null) {
      return gtk_print_settings_new_from_file(file_name, error);
   }

   // Reads the print settings from the group @group_name in @key_file.  Returns a
   // new #GtkPrintSettings object with the restored settings, or %NULL if an
   // error occurred. If the file could not be loaded then error is set to either
   // a #GFileError or #GKeyFileError.
   // RETURNS: the restored #GtkPrintSettings
   // <key_file>: the #GKeyFile to retrieve the settings from
   // <group_name>: the name of the group to use, or %NULL to use the default "Print Settings"
   static PrintSettings* /*new*/ new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error=null) {
      return gtk_print_settings_new_from_key_file(key_file, group_name, error);
   }

   // Copies a #GtkPrintSettings object.
   // RETURNS: a newly allocated copy of @other
   PrintSettings* /*new*/ copy() {
      return gtk_print_settings_copy(&this);
   }

   // Calls @func for each key-value pair of @settings.
   // <func>: the function to call
   // <user_data>: user data for @func
   void foreach_(PrintSettingsFunc func, void* user_data) {
      gtk_print_settings_foreach(&this, func, user_data);
   }

   // Looks up the string value associated with @key.
   // RETURNS: the string value for @key
   // <key>: a key
   char* get(char* key) {
      return gtk_print_settings_get(&this, key);
   }

   // Returns the boolean represented by the value
   // that is associated with @key. 
   // The string "true" represents %TRUE, any other 
   // string %FALSE.
   // RETURNS: %TRUE, if @key maps to a true value.
   // <key>: a key
   int get_bool(char* key) {
      return gtk_print_settings_get_bool(&this, key);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
   // RETURNS: whether to collate the printed pages
   int get_collate() {
      return gtk_print_settings_get_collate(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
   // RETURNS: the default source
   char* get_default_source() {
      return gtk_print_settings_get_default_source(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_DITHER.
   // RETURNS: the dithering that is used
   char* get_dither() {
      return gtk_print_settings_get_dither(&this);
   }

   // Returns the double value associated with @key, or 0.
   // RETURNS: the double value of @key
   // <key>: a key
   double get_double(char* key) {
      return gtk_print_settings_get_double(&this, key);
   }

   // Returns the floating point number represented by 
   // the value that is associated with @key, or @default_val
   // if the value does not represent a floating point number.
   // Floating point numbers are parsed with g_ascii_strtod().
   // RETURNS: the floating point number associated with @key
   // <key>: a key
   // <def>: the default value
   double get_double_with_default(char* key, double def) {
      return gtk_print_settings_get_double_with_default(&this, key, def);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
   // RETURNS: whether to print the output in duplex.
   PrintDuplex get_duplex() {
      return gtk_print_settings_get_duplex(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
   // RETURNS: the finishings
   char* get_finishings() {
      return gtk_print_settings_get_finishings(&this);
   }

   // Returns the integer value of @key, or 0.
   // RETURNS: the integer value of @key
   // <key>: a key
   int get_int(char* key) {
      return gtk_print_settings_get_int(&this, key);
   }

   // Returns the value of @key, interpreted as
   // an integer, or the default value.
   // RETURNS: the integer value of @key
   // <key>: a key
   // <def>: the default value
   int get_int_with_default(char* key, int def) {
      return gtk_print_settings_get_int_with_default(&this, key, def);
   }

   // Returns the value associated with @key, interpreted
   // as a length. The returned value is converted to @units.
   // RETURNS: the length value of @key, converted to @unit
   // <key>: a key
   // <unit>: the unit of the return value
   double get_length(char* key, Unit unit) {
      return gtk_print_settings_get_length(&this, key, unit);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
   // The set of media types is defined in PWG 5101.1-2002 PWG.
   // <!-- FIXME link here -->
   // RETURNS: the media type
   char* get_media_type() {
      return gtk_print_settings_get_media_type(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
   // RETURNS: the number of copies to print
   int get_n_copies() {
      return gtk_print_settings_get_n_copies(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
   // RETURNS: the number of pages per sheet
   int get_number_up() {
      return gtk_print_settings_get_number_up(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
   // RETURNS: layout of page in number-up mode
   NumberUpLayout get_number_up_layout() {
      return gtk_print_settings_get_number_up_layout(&this);
   }

   // Get the value of %GTK_PRINT_SETTINGS_ORIENTATION, 
   // converted to a #GtkPageOrientation.
   // RETURNS: the orientation
   PageOrientation get_orientation() {
      return gtk_print_settings_get_orientation(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
   // RETURNS: the output bin
   char* get_output_bin() {
      return gtk_print_settings_get_output_bin(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
   // of #GtkPageRange<!-- -->s.  Use g_free() to free the array when
   // it is no longer needed.
   // RETURNS: an array
   // <num_ranges>: return location for the length of the returned array
   PageRange* /*new*/ get_page_ranges(/*out*/ int* num_ranges) {
      return gtk_print_settings_get_page_ranges(&this, num_ranges);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
   // RETURNS: the set of pages to print
   PageSet get_page_set() {
      return gtk_print_settings_get_page_set(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
   // converted to @unit.
   // RETURNS: the paper height, in units of @unit
   // <unit>: the unit for the return value
   double get_paper_height(Unit unit) {
      return gtk_print_settings_get_paper_height(&this, unit);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT, 
   // converted to a #GtkPaperSize.
   // RETURNS: the paper size
   PaperSize* /*new*/ get_paper_size() {
      return gtk_print_settings_get_paper_size(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
   // converted to @unit.
   // RETURNS: the paper width, in units of @unit
   // <unit>: the unit for the return value
   double get_paper_width(Unit unit) {
      return gtk_print_settings_get_paper_width(&this, unit);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
   // RETURNS: which pages to print
   PrintPages get_print_pages() {
      return gtk_print_settings_get_print_pages(&this);
   }

   // Convenience function to obtain the value of 
   // %GTK_PRINT_SETTINGS_PRINTER.
   // RETURNS: the printer name
   char* get_printer() {
      return gtk_print_settings_get_printer(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
   // RETURNS: the resolution in lpi (lines per inch)
   double get_printer_lpi() {
      return gtk_print_settings_get_printer_lpi(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
   // RETURNS: the print quality
   PrintQuality get_quality() {
      return gtk_print_settings_get_quality(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
   // RETURNS: the resolution in dpi
   int get_resolution() {
      return gtk_print_settings_get_resolution(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
   // RETURNS: the horizontal resolution in dpi
   int get_resolution_x() {
      return gtk_print_settings_get_resolution_x(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
   // RETURNS: the vertical resolution in dpi
   int get_resolution_y() {
      return gtk_print_settings_get_resolution_y(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
   // RETURNS: whether to reverse the order of the printed pages
   int get_reverse() {
      return gtk_print_settings_get_reverse(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_SCALE.
   // RETURNS: the scale in percent
   double get_scale() {
      return gtk_print_settings_get_scale(&this);
   }

   // Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
   // RETURNS: whether to use color
   int get_use_color() {
      return gtk_print_settings_get_use_color(&this);
   }

   // Returns %TRUE, if a value is associated with @key.
   // RETURNS: %TRUE, if @key has a value
   // <key>: a key
   int has_key(char* key) {
      return gtk_print_settings_has_key(&this, key);
   }

   // Reads the print settings from @file_name. If the file could not be loaded
   // then error is set to either a #GFileError or #GKeyFileError.
   // See gtk_print_settings_to_file().
   // RETURNS: %TRUE on success
   // <file_name>: the filename to read the settings from
   int load_file(char* file_name, GLib2.Error** error=null) {
      return gtk_print_settings_load_file(&this, file_name, error);
   }

   // Reads the print settings from the group @group_name in @key_file. If the
   // file could not be loaded then error is set to either a #GFileError or
   // #GKeyFileError.
   // RETURNS: %TRUE on success
   // <key_file>: the #GKeyFile to retrieve the settings from
   // <group_name>: the name of the group to use, or %NULL to use the default "Print Settings"
   int load_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error=null) {
      return gtk_print_settings_load_key_file(&this, key_file, group_name, error);
   }

   // Associates @value with @key.
   // <key>: a key
   // <value>: a string value, or %NULL
   void set(char* key, char* value=null) {
      gtk_print_settings_set(&this, key, value);
   }

   // Sets @key to a boolean value.
   // <key>: a key
   // <value>: a boolean
   void set_bool(char* key, int value) {
      gtk_print_settings_set_bool(&this, key, value);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
   // <collate>: whether to collate the output
   void set_collate(int collate) {
      gtk_print_settings_set_collate(&this, collate);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
   // <default_source>: the default source
   void set_default_source(char* default_source) {
      gtk_print_settings_set_default_source(&this, default_source);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_DITHER.
   // <dither>: the dithering that is used
   void set_dither(char* dither) {
      gtk_print_settings_set_dither(&this, dither);
   }

   // Sets @key to a double value.
   // <key>: a key
   // <value>: a double value
   void set_double(char* key, double value) {
      gtk_print_settings_set_double(&this, key, value);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
   // <duplex>: a #GtkPrintDuplex value
   void set_duplex(PrintDuplex duplex) {
      gtk_print_settings_set_duplex(&this, duplex);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
   // <finishings>: the finishings
   void set_finishings(char* finishings) {
      gtk_print_settings_set_finishings(&this, finishings);
   }

   // Sets @key to an integer value.
   // <key>: a key
   // <value>: an integer
   void set_int(char* key, int value) {
      gtk_print_settings_set_int(&this, key, value);
   }

   // Associates a length in units of @unit with @key.
   // <key>: a key
   // <value>: a length
   // <unit>: the unit of @length
   void set_length(char* key, double value, Unit unit) {
      gtk_print_settings_set_length(&this, key, value, unit);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
   // The set of media types is defined in PWG 5101.1-2002 PWG.
   // <!-- FIXME link here -->
   // <media_type>: the media type
   void set_media_type(char* media_type) {
      gtk_print_settings_set_media_type(&this, media_type);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
   // <num_copies>: the number of copies
   void set_n_copies(int num_copies) {
      gtk_print_settings_set_n_copies(&this, num_copies);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
   // <number_up>: the number of pages per sheet
   void set_number_up(int number_up) {
      gtk_print_settings_set_number_up(&this, number_up);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
   // <number_up_layout>: a #GtkNumberUpLayout value
   void set_number_up_layout(NumberUpLayout number_up_layout) {
      gtk_print_settings_set_number_up_layout(&this, number_up_layout);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
   // <orientation>: a page orientation
   void set_orientation(PageOrientation orientation) {
      gtk_print_settings_set_orientation(&this, orientation);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
   // <output_bin>: the output bin
   void set_output_bin(char* output_bin) {
      gtk_print_settings_set_output_bin(&this, output_bin);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
   // <page_ranges>: an array of #GtkPageRange<!-- -->s
   // <num_ranges>: the length of @page_ranges
   void set_page_ranges(PageRange* page_ranges, int num_ranges) {
      gtk_print_settings_set_page_ranges(&this, page_ranges, num_ranges);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
   // <page_set>: a #GtkPageSet value
   void set_page_set(PageSet page_set) {
      gtk_print_settings_set_page_set(&this, page_set);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
   // <height>: the paper height
   // <unit>: the units of @height
   void set_paper_height(double height, Unit unit) {
      gtk_print_settings_set_paper_height(&this, height, unit);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
   // %GTK_PRINT_SETTINGS_PAPER_WIDTH and
   // %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
   // <paper_size>: a paper size
   void set_paper_size(PaperSize* paper_size) {
      gtk_print_settings_set_paper_size(&this, paper_size);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
   // <width>: the paper width
   // <unit>: the units of @width
   void set_paper_width(double width, Unit unit) {
      gtk_print_settings_set_paper_width(&this, width, unit);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
   // <pages>: a #GtkPrintPages value
   void set_print_pages(PrintPages pages) {
      gtk_print_settings_set_print_pages(&this, pages);
   }

   // Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
   // to @printer.
   // <printer>: the printer name
   void set_printer(char* printer) {
      gtk_print_settings_set_printer(&this, printer);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
   // <lpi>: the resolution in lpi (lines per inch)
   void set_printer_lpi(double lpi) {
      gtk_print_settings_set_printer_lpi(&this, lpi);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
   // <quality>: a #GtkPrintQuality value
   void set_quality(PrintQuality quality) {
      gtk_print_settings_set_quality(&this, quality);
   }

   // Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
   // %GTK_PRINT_SETTINGS_RESOLUTION_X and 
   // %GTK_PRINT_SETTINGS_RESOLUTION_Y.
   // <resolution>: the resolution in dpi
   void set_resolution(int resolution) {
      gtk_print_settings_set_resolution(&this, resolution);
   }

   // Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
   // %GTK_PRINT_SETTINGS_RESOLUTION_X and
   // %GTK_PRINT_SETTINGS_RESOLUTION_Y.
   // <resolution_x>: the horizontal resolution in dpi
   // <resolution_y>: the vertical resolution in dpi
   void set_resolution_xy(int resolution_x, int resolution_y) {
      gtk_print_settings_set_resolution_xy(&this, resolution_x, resolution_y);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
   // <reverse>: whether to reverse the output
   void set_reverse(int reverse) {
      gtk_print_settings_set_reverse(&this, reverse);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_SCALE.
   // <scale>: the scale in percent
   void set_scale(double scale) {
      gtk_print_settings_set_scale(&this, scale);
   }

   // Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
   // <use_color>: whether to use color
   void set_use_color(int use_color) {
      gtk_print_settings_set_use_color(&this, use_color);
   }

   // This function saves the print settings from @settings to @file_name. If the
   // file could not be loaded then error is set to either a #GFileError or
   // #GKeyFileError.
   // RETURNS: %TRUE on success
   // <file_name>: the file to save to
   int to_file(char* file_name, GLib2.Error** error=null) {
      return gtk_print_settings_to_file(&this, file_name, error);
   }

   // This function adds the print settings from @settings to @key_file.
   // <key_file>: the #GKeyFile to save the print settings to
   // <group_name>: the group to add the settings to in @key_file, or %NULL to use the default "Print Settings"
   void to_key_file(GLib2.KeyFile* key_file, char* group_name) {
      gtk_print_settings_to_key_file(&this, key_file, group_name);
   }

   // Removes any value associated with @key. 
   // This has the same effect as setting the value to %NULL.
   // <key>: a key
   void unset(char* key) {
      gtk_print_settings_unset(&this, key);
   }
}

extern (C) alias void function (char* key, char* value, void* user_data) PrintSettingsFunc;

enum PrintStatus {
   INITIAL = 0,
   PREPARING = 1,
   GENERATING_DATA = 2,
   SENDING_DATA = 3,
   PENDING = 4,
   PENDING_ISSUE = 5,
   PRINTING = 6,
   FINISHED = 7,
   FINISHED_ABORTED = 8
}
enum PrivateFlags {
   USER_STYLE = 1,
   RESIZE_PENDING = 4,
   HAS_POINTER = 8,
   SHADOWED = 16,
   HAS_SHAPE_MASK = 32,
   IN_REPARENT = 64,
   DIRECTION_SET = 128,
   DIRECTION_LTR = 256,
   ANCHORED = 512,
   CHILD_VISIBLE = 1024,
   REDRAW_ON_ALLOC = 2048,
   ALLOC_NEEDED = 4096,
   REQUEST_NEEDED = 8192
}
struct Progress /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   Adjustment* adjustment;
   Gdk2.Pixmap* offscreen_pixmap;
   char* format;
   float x_align, y_align;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "show_text", 1,
   uint, "activity_mode", 1,
   uint, "use_text_format", 1,
    uint, "__dummy32A", 29));

   void configure(double value, double min, double max) {
      gtk_progress_configure(&this, value, min, max);
   }
   double get_current_percentage() {
      return gtk_progress_get_current_percentage(&this);
   }
   char* /*new*/ get_current_text() {
      return gtk_progress_get_current_text(&this);
   }
   double get_percentage_from_value(double value) {
      return gtk_progress_get_percentage_from_value(&this, value);
   }
   char* /*new*/ get_text_from_value(double value) {
      return gtk_progress_get_text_from_value(&this, value);
   }
   double get_value() {
      return gtk_progress_get_value(&this);
   }
   void set_activity_mode(int activity_mode) {
      gtk_progress_set_activity_mode(&this, activity_mode);
   }
   void set_adjustment(Adjustment* adjustment) {
      gtk_progress_set_adjustment(&this, adjustment);
   }
   void set_format_string(char* format) {
      gtk_progress_set_format_string(&this, format);
   }
   void set_percentage(double percentage) {
      gtk_progress_set_percentage(&this, percentage);
   }
   void set_show_text(int show_text) {
      gtk_progress_set_show_text(&this, show_text);
   }
   void set_text_alignment(float x_align, float y_align) {
      gtk_progress_set_text_alignment(&this, x_align, y_align);
   }
   void set_value(double value) {
      gtk_progress_set_value(&this, value);
   }
}

struct ProgressBar /* : Progress */ {
   alias progress this;
   alias progress super_;
   Progress progress;
   ProgressBarStyle bar_style;
   ProgressBarOrientation orientation;
   uint blocks;
   int in_block, activity_pos;
   uint activity_step, activity_blocks;
   double pulse_fraction;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "activity_dir", 1,
   uint, "ellipsize", 3,
   uint, "dirty", 1,
    uint, "__dummy32A", 27));


   // Creates a new #GtkProgressBar.
   // RETURNS: a #GtkProgressBar.
   static ProgressBar* new_() {
      return gtk_progress_bar_new();
   }

   // Creates a new #GtkProgressBar with an associated #GtkAdjustment.
   // RETURNS: a #GtkProgressBar.
   static ProgressBar* new_with_adjustment(Adjustment* adjustment=null) {
      return gtk_progress_bar_new_with_adjustment(adjustment);
   }

   // Returns the ellipsizing position of the progressbar. 
   // See gtk_progress_bar_set_ellipsize().
   // RETURNS: #PangoEllipsizeMode
   Pango.EllipsizeMode get_ellipsize() {
      return gtk_progress_bar_get_ellipsize(&this);
   }

   // Returns the current fraction of the task that's been completed.
   // RETURNS: a fraction from 0.0 to 1.0
   double get_fraction() {
      return gtk_progress_bar_get_fraction(&this);
   }

   // Retrieves the current progress bar orientation.
   // RETURNS: orientation of the progress bar
   ProgressBarOrientation get_orientation() {
      return gtk_progress_bar_get_orientation(&this);
   }

   // Retrieves the pulse step set with gtk_progress_bar_set_pulse_step()
   // RETURNS: a fraction from 0.0 to 1.0
   double get_pulse_step() {
      return gtk_progress_bar_get_pulse_step(&this);
   }

   // Retrieves the text displayed superimposed on the progress bar,
   // if any, otherwise %NULL. The return value is a reference
   // to the text, not a copy of it, so will become invalid
   // if you change the text in the progress bar.
   // and should not be modified or freed.
   // RETURNS: text, or %NULL; this string is owned by the widget
   char* get_text() {
      return gtk_progress_bar_get_text(&this);
   }

   // Indicates that some progress is made, but you don't know how much.
   // Causes the progress bar to enter "activity mode," where a block
   // bounces back and forth. Each call to gtk_progress_bar_pulse()
   // causes the block to move by a little bit (the amount of movement
   // per pulse is determined by gtk_progress_bar_set_pulse_step()).
   void pulse() {
      gtk_progress_bar_pulse(&this);
   }
   void set_activity_blocks(uint blocks) {
      gtk_progress_bar_set_activity_blocks(&this, blocks);
   }
   void set_activity_step(uint step) {
      gtk_progress_bar_set_activity_step(&this, step);
   }
   void set_bar_style(ProgressBarStyle style) {
      gtk_progress_bar_set_bar_style(&this, style);
   }
   void set_discrete_blocks(uint blocks) {
      gtk_progress_bar_set_discrete_blocks(&this, blocks);
   }

   // if there is not enough space to render the entire string.
   // <mode>: a #PangoEllipsizeMode
   void set_ellipsize(Pango.EllipsizeMode mode) {
      gtk_progress_bar_set_ellipsize(&this, mode);
   }

   // Causes the progress bar to "fill in" the given fraction
   // of the bar. The fraction should be between 0.0 and 1.0,
   // inclusive.
   // <fraction>: fraction of the task that's been completed
   void set_fraction(double fraction) {
      gtk_progress_bar_set_fraction(&this, fraction);
   }

   // Causes the progress bar to switch to a different orientation
   // (left-to-right, right-to-left, top-to-bottom, or bottom-to-top).
   // <orientation>: orientation of the progress bar
   void set_orientation(ProgressBarOrientation orientation) {
      gtk_progress_bar_set_orientation(&this, orientation);
   }

   // Sets the fraction of total progress bar length to move the
   // bouncing block for each call to gtk_progress_bar_pulse().
   // <fraction>: fraction between 0.0 and 1.0
   void set_pulse_step(double fraction) {
      gtk_progress_bar_set_pulse_step(&this, fraction);
   }

   // Causes the given @text to appear superimposed on the progress bar.
   // <text>: a UTF-8 string, or %NULL
   void set_text(char* text=null) {
      gtk_progress_bar_set_text(&this, text);
   }
   void update(double percentage) {
      gtk_progress_bar_update(&this, percentage);
   }
}

struct ProgressBarClass {
   ProgressClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum ProgressBarOrientation {
   LEFT_TO_RIGHT = 0,
   RIGHT_TO_LEFT = 1,
   BOTTOM_TO_TOP = 2,
   TOP_TO_BOTTOM = 3
}
enum ProgressBarStyle {
   CONTINUOUS = 0,
   DISCRETE = 1
}
struct ProgressClass {
   WidgetClass parent_class;
   extern (C) void function (Progress* progress) paint;
   extern (C) void function (Progress* progress) update;
   extern (C) void function (Progress* progress) act_mode_enter;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct RadioAction /* : ToggleAction */ {
   alias parent this;
   alias parent super_;
   alias parent toggleaction;
   ToggleAction parent;
   private RadioActionPrivate* private_data;


   // Creates a new #GtkRadioAction object. To add the action to
   // a #GtkActionGroup and set the accelerator for the action,
   // call gtk_action_group_add_action_with_accel().
   // RETURNS: a new #GtkRadioAction
   // <name>: A unique name for the action
   // <label>: The label displayed in menu items and on buttons, or %NULL
   // <tooltip>: A tooltip for this action, or %NULL
   // <stock_id>: The stock icon to display in widgets representing this action, or %NULL
   // <value>: The value which gtk_radio_action_get_current_value() should return if this action is selected.
   static RadioAction* /*new*/ new_(char* name, char* label, char* tooltip, char* stock_id, int value) {
      return gtk_radio_action_new(name, label, tooltip, stock_id, value);
   }

   // Obtains the value property of the currently active member of 
   // the group to which @action belongs.
   // RETURNS: The value of the currently active group member
   int get_current_value() {
      return gtk_radio_action_get_current_value(&this);
   }

   // Returns the list representing the radio group for this object.
   // Note that the returned list is only valid until the next change
   // to the group. 
   // A common way to set up a group of radio group is the following:
   // |[
   // GSList *group = NULL;
   // GtkRadioAction *action;
   // while (/&ast; more actions to add &ast;/)
   // {
   // action = gtk_radio_action_new (...);
   // gtk_radio_action_set_group (action, group);
   // group = gtk_radio_action_get_group (action);
   // }
   // ]|
   // RETURNS: the list representing the radio group for this object
   GLib2.SList* get_group() {
      return gtk_radio_action_get_group(&this);
   }

   // Sets the currently active group member to the member with value
   // property @current_value.
   // <current_value>: the new value
   void set_current_value(int current_value) {
      gtk_radio_action_set_current_value(&this, current_value);
   }

   // Sets the radio group for the radio action object.
   // <group>: a list representing a radio group
   void set_group(GLib2.SList* group) {
      gtk_radio_action_set_group(&this, group);
   }

   // The ::changed signal is emitted on every member of a radio group when the
   // active member is changed. The signal gets emitted after the ::activate signals
   // for the previous and current active members.
   // <current>: the member of @action<!-- -->s group which has just been activated
   extern (C) alias static void function (RadioAction* this_, RadioAction* current, 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);
   }
}

struct RadioActionClass {
   ToggleActionClass parent_class;
   extern (C) void function (RadioAction* action, RadioAction* current) changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct RadioActionEntry {
   char* name, stock_id, label, accelerator, tooltip;
   int value;
}

struct RadioActionPrivate {
}

struct RadioButton /* : CheckButton */ {
   alias check_button this;
   alias check_button super_;
   alias check_button checkbutton;
   CheckButton check_button;
   GLib2.SList* group;


   // Creates a new #GtkRadioButton. To be of any practical value, a widget should
   // then be packed into the radio button.
   // RETURNS: a new radio button
   // <group>: an existing radio button group, or %NULL if you are creating a new group.
   static RadioButton* new_(GLib2.SList* group=null) {
      return gtk_radio_button_new(group);
   }

   // Creates a new #GtkRadioButton with a text label.
   // RETURNS: a new radio button.
   // <group>: an existing radio button group, or %NULL if you are creating a new group.
   // <label>: the text label to display next to the radio button.
   static RadioButton* new_with_label(GLib2.SList* group, char* label) {
      return gtk_radio_button_new_with_label(group, label);
   }

   // Creates a new #GtkRadioButton with a text label, adding it to
   // the same group as @radio_group_member.
   // RETURNS: a new radio button.
   // <radio_group_member>: widget to get radio group from or %NULL
   // <label>: a text string to display next to the radio button.
   static RadioButton* new_with_label_from_widget(RadioButton* radio_group_member, char* label) {
      return gtk_radio_button_new_with_label_from_widget(radio_group_member, label);
   }

   // Creates a new #GtkRadioButton containing a label, adding it to the same 
   // group as @group. The label will be created using 
   // gtk_label_new_with_mnemonic(), so underscores in @label indicate the 
   // mnemonic for the button.
   // RETURNS: a new #GtkRadioButton
   // <group>: the radio button group
   // <label>: the text of the button, with an underscore in front of the mnemonic character
   static RadioButton* new_with_mnemonic(GLib2.SList* group, char* label) {
      return gtk_radio_button_new_with_mnemonic(group, label);
   }

   // Creates a new #GtkRadioButton containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the button.
   // RETURNS: a new #GtkRadioButton
   // <radio_group_member>: widget to get radio group from or %NULL
   // <label>: the text of the button, with an underscore in front of the mnemonic character
   static RadioButton* new_with_mnemonic_from_widget(RadioButton* radio_group_member, char* label) {
      return gtk_radio_button_new_with_mnemonic_from_widget(radio_group_member, label);
   }

   // Retrieves the group assigned to a radio button.
   // containing all the radio buttons in the same group
   // as @radio_button. The returned list is owned by the radio button
   // and must not be modified or freed.
   // RETURNS: a linked list
   GLib2.SList* get_group() {
      return gtk_radio_button_get_group(&this);
   }

   // Creates a new #GtkRadioButton, adding it to the same group as
   // should be packed into the radio button.
   // RETURNS: a new radio button.
   Widget* new_from_widget() {
      return gtk_radio_button_new_from_widget(&this);
   }

   // Sets a #GtkRadioButton's group. It should be noted that this does not change
   // the layout of your interface in any way, so if you are changing the group,
   // it is likely you will need to re-arrange the user interface to reflect these
   // changes.
   // <group>: an existing radio button group, such as one returned from gtk_radio_button_get_group().
   void set_group(GLib2.SList* group) {
      gtk_radio_button_set_group(&this, group);
   }

   // Emitted when the group of radio buttons that a radio button belongs
   // to changes. This is emitted when a radio button switches from
   // being alone to being part of a group of 2 or more buttons, or
   // vice-versa, and when a button is moved from one group of 2 or
   // more buttons to a different one, but not when the composition
   // of the group that a button belongs to changes.
   extern (C) alias static void function (RadioButton* this_, void* user_data=null) signal_group_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:"group-changed", CB/*:signal_group_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"group-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct RadioButtonClass {
   CheckButtonClass parent_class;
   extern (C) void function (RadioButton* radio_button) group_changed;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct RadioMenuItem /* : CheckMenuItem */ {
   alias check_menu_item this;
   alias check_menu_item super_;
   alias check_menu_item checkmenuitem;
   CheckMenuItem check_menu_item;
   GLib2.SList* group;

   static RadioMenuItem* new_(GLib2.SList* group) {
      return gtk_radio_menu_item_new(group);
   }

   // Creates a new #GtkRadioMenuItem whose child is a simple #GtkLabel.
   // RETURNS: A new #GtkRadioMenuItem
   // <label>: the text for the label
   static RadioMenuItem* new_with_label(GLib2.SList* group, char* label) {
      return gtk_radio_menu_item_new_with_label(group, label);
   }

   // Creates a new #GtkRadioMenuItem containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the menu item.
   // RETURNS: a new #GtkRadioMenuItem
   // <group>: group the radio menu item is inside
   // <label>: the text of the button, with an underscore in front of the mnemonic character
   static RadioMenuItem* new_with_mnemonic(GLib2.SList* group, char* label) {
      return gtk_radio_menu_item_new_with_mnemonic(group, label);
   }

   // Returns the group to which the radio menu item belongs, as a #GList of
   // #GtkRadioMenuItem. The list belongs to GTK+ and should not be freed.
   // RETURNS: the group of @radio_menu_item
   GLib2.SList* get_group() {
      return gtk_radio_menu_item_get_group(&this);
   }

   // Creates a new #GtkRadioMenuItem adding it to the same group as @group.
   // RETURNS: The new #GtkRadioMenuItem
   Widget* new_from_widget() {
      return gtk_radio_menu_item_new_from_widget(&this);
   }

   // Creates a new GtkRadioMenuItem whose child is a simple GtkLabel.
   // The new #GtkRadioMenuItem is added to the same group as @group.
   // RETURNS: The new #GtkRadioMenuItem
   // <label>: the text for the label
   Widget* new_with_label_from_widget(char* label) {
      return gtk_radio_menu_item_new_with_label_from_widget(&this, label);
   }

   // Creates a new GtkRadioMenuItem containing a label. The label will be
   // created using gtk_label_new_with_mnemonic(), so underscores in label
   // indicate the mnemonic for the menu item.
   // The new #GtkRadioMenuItem is added to the same group as @group.
   // RETURNS: The new #GtkRadioMenuItem
   // <label>: the text of the button, with an underscore in front of the mnemonic character
   Widget* new_with_mnemonic_from_widget(char* label) {
      return gtk_radio_menu_item_new_with_mnemonic_from_widget(&this, label);
   }
   void set_group(GLib2.SList* group) {
      gtk_radio_menu_item_set_group(&this, group);
   }
   extern (C) alias static void function (RadioMenuItem* this_, void* user_data=null) signal_group_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:"group-changed", CB/*:signal_group_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"group-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct RadioMenuItemClass {
   CheckMenuItemClass parent_class;
   extern (C) void function (RadioMenuItem* radio_menu_item) group_changed;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct RadioToolButton /* : ToggleToolButton */ {
   alias parent this;
   alias parent super_;
   alias parent toggletoolbutton;
   ToggleToolButton parent;


   // Creates a new #GtkRadioToolButton, adding it to @group.
   // RETURNS: The new #GtkRadioToolButton
   // <group>: An existing radio button group, or %NULL if you are creating a new group
   static RadioToolButton* new_(GLib2.SList* group=null) {
      return gtk_radio_tool_button_new(group);
   }

   // Creates a new #GtkRadioToolButton, adding it to @group. 
   // The new #GtkRadioToolButton will contain an icon and label from the
   // stock item indicated by @stock_id.
   // RETURNS: The new #GtkRadioToolItem
   // <group>: an existing radio button group, or %NULL if you are creating a new group
   // <stock_id>: the name of a stock item
   static RadioToolButton* new_from_stock(GLib2.SList* group, char* stock_id) {
      return gtk_radio_tool_button_new_from_stock(group, stock_id);
   }

   // Returns the radio button group @button belongs to.
   // RETURNS: The group @button belongs to.
   GLib2.SList* get_group() {
      return gtk_radio_tool_button_get_group(&this);
   }

   // Creates a new #GtkRadioToolButton adding it to the same group as @gruup
   // RETURNS: The new #GtkRadioToolButton
   ToolItem* new_from_widget() {
      return gtk_radio_tool_button_new_from_widget(&this);
   }

   // Creates a new #GtkRadioToolButton adding it to the same group as @group.
   // The new #GtkRadioToolButton will contain an icon and label from the
   // stock item indicated by @stock_id.
   // RETURNS: A new #GtkRadioToolButton
   // <stock_id>: the name of a stock item
   ToolItem* new_with_stock_from_widget(char* stock_id) {
      return gtk_radio_tool_button_new_with_stock_from_widget(&this, stock_id);
   }

   // Adds @button to @group, removing it from the group it belonged to before.
   // <group>: an existing radio button group
   void set_group(GLib2.SList* group) {
      gtk_radio_tool_button_set_group(&this, group);
   }
}

struct RadioToolButtonClass {
   ToggleToolButtonClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct Range /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   Adjustment* adjustment;
   UpdateType update_policy;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "inverted", 1,
   uint, "flippable", 1,
   uint, "has_stepper_a", 1,
   uint, "has_stepper_b", 1,
   uint, "has_stepper_c", 1,
   uint, "has_stepper_d", 1,
   uint, "need_recalc", 1,
   uint, "slider_size_fixed", 1,
    uint, "__dummy32A", 24));
   int min_slider_size;
   Orientation orientation;
   Gdk2.Rectangle range_rect;
   int slider_start, slider_end, round_digits;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "trough_click_forward", 1,
   uint, "update_pending", 1,
    uint, "__dummy32B", 30));
   private RangeLayout* layout;
   private RangeStepTimer* timer;
   private int slide_initial_slider_position, slide_initial_coordinate;
   private uint update_timeout_id;
   private Gdk2.Window* event_window;


   // Get the #GtkAdjustment which is the "model" object for #GtkRange.
   // See gtk_range_set_adjustment() for details.
   // The return value does not have a reference added, so should not
   // be unreferenced.
   // RETURNS: a #GtkAdjustment
   Adjustment* get_adjustment() {
      return gtk_range_get_adjustment(&this);
   }

   // Gets the current position of the fill level indicator.
   // RETURNS: The current fill level
   double get_fill_level() {
      return gtk_range_get_fill_level(&this);
   }

   // Gets the value set by gtk_range_set_flippable().
   // RETURNS: %TRUE if the range is flippable
   int get_flippable() {
      return gtk_range_get_flippable(&this);
   }

   // Gets the value set by gtk_range_set_inverted().
   // RETURNS: %TRUE if the range is inverted
   int get_inverted() {
      return gtk_range_get_inverted(&this);
   }

   // Gets the sensitivity policy for the stepper that points to the
   // 'lower' end of the GtkRange's adjustment.
   // RETURNS: The lower stepper's sensitivity policy.
   SensitivityType get_lower_stepper_sensitivity() {
      return gtk_range_get_lower_stepper_sensitivity(&this);
   }

   // This function is useful mainly for #GtkRange subclasses.
   // See gtk_range_set_min_slider_size().
   // RETURNS: The minimum size of the range's slider.
   int get_min_slider_size() {
      return gtk_range_get_min_slider_size(&this);
   }

   // This function returns the area that contains the range's trough
   // and its steppers, in widget->window coordinates.
   // This function is useful mainly for #GtkRange subclasses.
   // <range_rect>: return location for the range rectangle
   void get_range_rect(/*out*/ Gdk2.Rectangle* range_rect) {
      gtk_range_get_range_rect(&this, range_rect);
   }

   // Gets whether the range is restricted to the fill level.
   // RETURNS: %TRUE if @range is restricted to the fill level.
   int get_restrict_to_fill_level() {
      return gtk_range_get_restrict_to_fill_level(&this);
   }

   // Gets the number of digits to round the value to when
   // it changes. See #GtkRange::change-value.
   // RETURNS: the number of digits to round to
   int get_round_digits() {
      return gtk_range_get_round_digits(&this);
   }

   // Gets whether the range displays the fill level graphically.
   // RETURNS: %TRUE if @range shows the fill level.
   int get_show_fill_level() {
      return gtk_range_get_show_fill_level(&this);
   }

   // This function returns sliders range along the long dimension,
   // in widget->window coordinates.
   // This function is useful mainly for #GtkRange subclasses.
   // <slider_start>: return location for the slider's start, or %NULL
   // <slider_end>: return location for the slider's end, or %NULL
   void get_slider_range(/*out*/ int* slider_start=null, /*out*/ int* slider_end=null) {
      gtk_range_get_slider_range(&this, slider_start, slider_end);
   }

   // This function is useful mainly for #GtkRange subclasses.
   // See gtk_range_set_slider_size_fixed().
   // RETURNS: whether the range's slider has a fixed size.
   int get_slider_size_fixed() {
      return gtk_range_get_slider_size_fixed(&this);
   }

   // Gets the update policy of @range. See gtk_range_set_update_policy().
   // updates, you need to code it yourself.
   // RETURNS: the current update policy
   UpdateType get_update_policy() {
      return gtk_range_get_update_policy(&this);
   }

   // Gets the sensitivity policy for the stepper that points to the
   // 'upper' end of the GtkRange's adjustment.
   // RETURNS: The upper stepper's sensitivity policy.
   SensitivityType get_upper_stepper_sensitivity() {
      return gtk_range_get_upper_stepper_sensitivity(&this);
   }

   // Gets the current value of the range.
   // RETURNS: current value of the range.
   double get_value() {
      return gtk_range_get_value(&this);
   }

   // Sets the adjustment to be used as the "model" object for this range
   // widget. The adjustment indicates the current range value, the
   // minimum and maximum range values, the step/page increments used
   // for keybindings and scrolling, and the page size. The page size
   // is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and
   // indicates the size of the visible area of the widget being scrolled.
   // The page size affects the size of the scrollbar slider.
   // <adjustment>: a #GtkAdjustment
   void set_adjustment(Adjustment* adjustment) {
      gtk_range_set_adjustment(&this, adjustment);
   }

   // Set the new position of the fill level indicator.
   // The "fill level" is probably best described by its most prominent
   // use case, which is an indicator for the amount of pre-buffering in
   // a streaming media player. In that use case, the value of the range
   // would indicate the current play position, and the fill level would
   // be the position up to which the file/stream has been downloaded.
   // This amount of prebuffering can be displayed on the range's trough
   // and is themeable separately from the trough. To enable fill level
   // display, use gtk_range_set_show_fill_level(). The range defaults
   // to not showing the fill level.
   // Additionally, it's possible to restrict the range's slider position
   // to values which are smaller than the fill level. This is controller
   // by gtk_range_set_restrict_to_fill_level() and is by default
   // enabled.
   // <fill_level>: the new position of the fill level indicator
   void set_fill_level(double fill_level) {
      gtk_range_set_fill_level(&this, fill_level);
   }

   // If a range is flippable, it will switch its direction if it is
   // horizontal and its direction is %GTK_TEXT_DIR_RTL.
   // See gtk_widget_get_direction().
   // <flippable>: %TRUE to make the range flippable
   void set_flippable(int flippable) {
      gtk_range_set_flippable(&this, flippable);
   }

   // Sets the step and page sizes for the range.
   // The step size is used when the user clicks the #GtkScrollbar
   // arrows or moves #GtkScale via arrow keys. The page size
   // is used for example when moving via Page Up or Page Down keys.
   // <step>: step size
   // <page>: page size
   void set_increments(double step, double page) {
      gtk_range_set_increments(&this, step, page);
   }

   // Ranges normally move from lower to higher values as the
   // slider moves from top to bottom or left to right. Inverted
   // ranges have higher values at the top or on the right rather than
   // on the bottom or left.
   // <setting>: %TRUE to invert the range
   void set_inverted(int setting) {
      gtk_range_set_inverted(&this, setting);
   }

   // Sets the sensitivity policy for the stepper that points to the
   // 'lower' end of the GtkRange's adjustment.
   // <sensitivity>: the lower stepper's sensitivity policy.
   void set_lower_stepper_sensitivity(SensitivityType sensitivity) {
      gtk_range_set_lower_stepper_sensitivity(&this, sensitivity);
   }

   // Sets the minimum size of the range's slider.
   // This function is useful mainly for #GtkRange subclasses.
   // <min_size>: The slider's minimum size
   void set_min_slider_size(int min_size) {
      gtk_range_set_min_slider_size(&this, min_size);
   }

   // Sets the allowable values in the #GtkRange, and clamps the range
   // value to be between @min and @max. (If the range has a non-zero
   // page size, it is clamped between @min and @max - page-size.)
   // <min>: minimum range value
   // <max>: maximum range value
   void set_range(double min, double max) {
      gtk_range_set_range(&this, min, max);
   }

   // Sets whether the slider is restricted to the fill level. See
   // gtk_range_set_fill_level() for a general description of the fill
   // level concept.
   // <restrict_to_fill_level>: Whether the fill level restricts slider movement.
   void set_restrict_to_fill_level(int restrict_to_fill_level) {
      gtk_range_set_restrict_to_fill_level(&this, restrict_to_fill_level);
   }

   // Sets the number of digits to round the value to when
   // it changes. See #GtkRange::change-value.
   // <round_digits>: the precision in digits, or -1
   void set_round_digits(int round_digits) {
      gtk_range_set_round_digits(&this, round_digits);
   }

   // Sets whether a graphical fill level is show on the trough. See
   // gtk_range_set_fill_level() for a general description of the fill
   // level concept.
   // <show_fill_level>: Whether a fill level indicator graphics is shown.
   void set_show_fill_level(int show_fill_level) {
      gtk_range_set_show_fill_level(&this, show_fill_level);
   }

   // Sets whether the range's slider has a fixed size, or a size that
   // depends on it's adjustment's page size.
   // This function is useful mainly for #GtkRange subclasses.
   // <size_fixed>: %TRUE to make the slider size constant
   void set_slider_size_fixed(int size_fixed) {
      gtk_range_set_slider_size_fixed(&this, size_fixed);
   }

   // Sets the update policy for the range. #GTK_UPDATE_CONTINUOUS means that
   // anytime the range slider is moved, the range value will change and the
   // value_changed signal will be emitted. #GTK_UPDATE_DELAYED means that
   // the value will be updated after a brief timeout where no slider motion
   // occurs, so updates are spaced by a short time rather than
   // continuous. #GTK_UPDATE_DISCONTINUOUS means that the value will only
   // be updated when the user releases the button and ends the slider
   // drag operation.
   // updates, you need to code it yourself.
   // <policy>: update policy
   void set_update_policy(UpdateType policy) {
      gtk_range_set_update_policy(&this, policy);
   }

   // Sets the sensitivity policy for the stepper that points to the
   // 'upper' end of the GtkRange's adjustment.
   // <sensitivity>: the upper stepper's sensitivity policy.
   void set_upper_stepper_sensitivity(SensitivityType sensitivity) {
      gtk_range_set_upper_stepper_sensitivity(&this, sensitivity);
   }

   // Sets the current value of the range; if the value is outside the
   // minimum or maximum range values, it will be clamped to fit inside
   // them. The range emits the #GtkRange::value-changed signal if the 
   // value changes.
   // <value>: new value of the range
   void set_value(double value) {
      gtk_range_set_value(&this, value);
   }
   extern (C) alias static void function (Range* this_, double object, void* user_data=null) signal_adjust_bounds;

   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:"adjust-bounds", CB/*:signal_adjust_bounds*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"adjust-bounds",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::change-value signal is emitted when a scroll action is
   // performed on a range.  It allows an application to determine the
   // type of scroll event that occurred and the resultant new value.
   // The application can handle the event itself and return %TRUE to
   // prevent further processing.  Or, by returning %FALSE, it can pass
   // the event to other handlers until the default GTK+ handler is
   // reached.
   // The value parameter is unrounded.  An application that overrides
   // the ::change-value signal is responsible for clamping the value to
   // the desired number of decimal digits; the default GTK+ handler
   // clamps the value based on #GtkRange:round_digits.
   // It is not possible to use delayed update policies in an overridden
   // ::change-value handler.
   // RETURNS: %TRUE to prevent other handlers from being invoked for the signal, %FALSE to propagate the signal further
   // <scroll>: the type of scroll action that was performed
   // <value>: the new value resulting from the scroll action
   extern (C) alias static c_int function (Range* this_, ScrollType* scroll, double value, void* user_data=null) signal_change_value;
   ulong signal_connect(string name:"change-value", CB/*:signal_change_value*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-value",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Virtual function that moves the slider. Used for keybindings.
   // <step>: how to move the slider
   extern (C) alias static void function (Range* this_, ScrollType* step, void* user_data=null) signal_move_slider;
   ulong signal_connect(string name:"move-slider", CB/*:signal_move_slider*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-slider",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // Emitted when the range value changes.
   extern (C) alias static void function (Range* this_, void* user_data=null) signal_value_changed;
   ulong signal_connect(string name:"value-changed", CB/*:signal_value_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"value-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct RangeClass {
   WidgetClass parent_class;
   char* slider_detail, stepper_detail;
   extern (C) void function (Range* range) value_changed;
   extern (C) void function (Range* range, double new_value) adjust_bounds;
   extern (C) void function (Range* range, ScrollType scroll) move_slider;
   extern (C) void function (Range* range, Border* border_) get_range_border;
   extern (C) int function (Range* range, ScrollType scroll, double new_value) change_value;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

struct RangeLayout {
}

struct RangeStepTimer {
}

struct RcContext {
}

enum RcFlags {
   FG = 1,
   BG = 2,
   TEXT = 4,
   BASE = 8
}
struct RcProperty {
   GLib2.Quark type_name, property_name;
   char* origin;
   GObject2.Value value;
}

extern (C) alias int function (GObject2.ParamSpec* pspec, GLib2.String* rc_string, GObject2.Value* property_value) RcPropertyParser;

struct RcStyle /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   char* name;
   char*[5] bg_pixmap_name;
   Pango.FontDescription* font_desc;
   RcFlags[5] color_flags;
   Gdk2.Color[5] fg, bg, text, base;
   int xthickness, ythickness;
   private void*[0] rc_properties;
   private GLib2.SList* rc_style_lists, icon_factories;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "engine_specified", 1,
    uint, "__dummy32A", 31));

   static RcStyle* /*new*/ new_() {
      return gtk_rc_style_new();
   }

   // Makes a copy of the specified #GtkRcStyle. This function
   // will correctly copy an RC style that is a member of a class
   // derived from #GtkRcStyle.
   // RETURNS: the resulting #GtkRcStyle
   RcStyle* /*new*/ copy() {
      return gtk_rc_style_copy(&this);
   }
   void ref_() {
      gtk_rc_style_ref(&this);
   }
   void unref() {
      gtk_rc_style_unref(&this);
   }
}

struct RcStyleClass {
   GObject2.ObjectClass parent_class;
   // Unintrospectable functionp: create_rc_style() / ()
   extern (C) RcStyle* function (RcStyle* rc_style) create_rc_style;
   extern (C) uint function (RcStyle* rc_style, Settings* settings, GLib2.Scanner* scanner) parse;
   extern (C) void function (RcStyle* dest, RcStyle* src) merge;
   // Unintrospectable functionp: create_style() / ()
   extern (C) Style* function (RcStyle* rc_style) create_style;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum RcTokenType {
   INVALID = 270,
   INCLUDE = 271,
   NORMAL = 272,
   ACTIVE = 273,
   PRELIGHT = 274,
   SELECTED = 275,
   INSENSITIVE = 276,
   FG = 277,
   BG = 278,
   TEXT = 279,
   BASE = 280,
   XTHICKNESS = 281,
   YTHICKNESS = 282,
   FONT = 283,
   FONTSET = 284,
   FONT_NAME = 285,
   BG_PIXMAP = 286,
   PIXMAP_PATH = 287,
   STYLE = 288,
   BINDING = 289,
   BIND = 290,
   WIDGET = 291,
   WIDGET_CLASS = 292,
   CLASS = 293,
   LOWEST = 294,
   GTK = 295,
   APPLICATION = 296,
   THEME = 297,
   RC = 298,
   HIGHEST = 299,
   ENGINE = 300,
   MODULE_PATH = 301,
   IM_MODULE_PATH = 302,
   IM_MODULE_FILE = 303,
   STOCK = 304,
   LTR = 305,
   RTL = 306,
   COLOR = 307,
   UNBIND = 308,
   LAST = 309
}
struct RecentAction /* : Action */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance action;
   Action parent_instance;
   private RecentActionPrivate* priv;


   // Creates a new #GtkRecentAction object. To add the action to
   // a #GtkActionGroup and set the accelerator for the action,
   // call gtk_action_group_add_action_with_accel().
   // RETURNS: the newly created #GtkRecentAction.
   // <name>: a unique name for the action
   // <label>: the label displayed in menu items and on buttons, or %NULL
   // <tooltip>: a tooltip for the action, or %NULL
   // <stock_id>: the stock icon to display in widgets representing the action, or %NULL
   static RecentAction* /*new*/ new_(char* name, char* label, char* tooltip, char* stock_id) {
      return gtk_recent_action_new(name, label, tooltip, stock_id);
   }

   // Creates a new #GtkRecentAction object. To add the action to
   // a #GtkActionGroup and set the accelerator for the action,
   // call gtk_action_group_add_action_with_accel().
   // RETURNS: the newly created #GtkRecentAction
   // <name>: a unique name for the action
   // <label>: the label displayed in menu items and on buttons, or %NULL
   // <tooltip>: a tooltip for the action, or %NULL
   // <stock_id>: the stock icon to display in widgets representing the action, or %NULL
   // <manager>: a #GtkRecentManager, or %NULL for using the default #GtkRecentManager
   static RecentAction* /*new*/ new_for_manager(char* name, char* label, char* tooltip, char* stock_id, RecentManager* manager=null) {
      return gtk_recent_action_new_for_manager(name, label, tooltip, stock_id, manager);
   }

   // Returns the value set by gtk_recent_chooser_menu_set_show_numbers().
   // RETURNS: %TRUE if numbers should be shown.
   int get_show_numbers() {
      return gtk_recent_action_get_show_numbers(&this);
   }

   // Sets whether a number should be added to the items shown by the
   // widgets representing @action. The numbers are shown to provide
   // a unique character for a mnemonic to be used inside the menu item's
   // label. Only the first ten items get a number to avoid clashes.
   // <show_numbers>: %TRUE if the shown items should be numbered
   void set_show_numbers(int show_numbers) {
      gtk_recent_action_set_show_numbers(&this, show_numbers);
   }
}

struct RecentActionClass {
   ActionClass parent_class;
}

struct RecentActionPrivate {
}

struct RecentChooser {

   // Adds @filter to the list of #GtkRecentFilter objects held by @chooser.
   // If no previous filter objects were defined, this function will call
   // gtk_recent_chooser_set_filter().
   // <filter>: a #GtkRecentFilter
   void add_filter(RecentFilter* filter) {
      gtk_recent_chooser_add_filter(&this, filter);
   }

   // Gets the #GtkRecentInfo currently selected by @chooser.
   // when you have finished using it.
   // RETURNS: a #GtkRecentInfo.  Use gtk_recent_info_unref() when
   RecentInfo* /*new*/ get_current_item() {
      return gtk_recent_chooser_get_current_item(&this);
   }

   // Gets the URI currently selected by @chooser.
   // RETURNS: a newly allocated string holding a URI.
   char* /*new*/ get_current_uri() {
      return gtk_recent_chooser_get_current_uri(&this);
   }

   // Gets the #GtkRecentFilter object currently used by @chooser to affect
   // the display of the recently used resources.
   // RETURNS: a #GtkRecentFilter object.
   RecentFilter* get_filter() {
      return gtk_recent_chooser_get_filter(&this);
   }

   // Gets the list of recently used resources in form of #GtkRecentInfo objects.
   // The return value of this function is affected by the "sort-type" and
   // "limit" properties of @chooser.
   // list of #GtkRecentInfo objects.  You should
   // use gtk_recent_info_unref() on every item of the list, and then free
   // the list itself using g_list_free().
   // RETURNS: A newly allocated
   GLib2.List* /*new*/ get_items() {
      return gtk_recent_chooser_get_items(&this);
   }

   // Gets the number of items returned by gtk_recent_chooser_get_items()
   // and gtk_recent_chooser_get_uris().
   // returned.
   // RETURNS: A positive integer, or -1 meaning that all items are
   int get_limit() {
      return gtk_recent_chooser_get_limit(&this);
   }

   // Gets whether only local resources should be shown in the recently used
   // resources selector.  See gtk_recent_chooser_set_local_only()
   // RETURNS: %TRUE if only local resources should be shown.
   int get_local_only() {
      return gtk_recent_chooser_get_local_only(&this);
   }

   // Gets whether @chooser can select multiple items.
   // RETURNS: %TRUE if @chooser can select more than one item.
   int get_select_multiple() {
      return gtk_recent_chooser_get_select_multiple(&this);
   }

   // Retrieves whether @chooser should show an icon near the resource.
   // RETURNS: %TRUE if the icons should be displayed, %FALSE otherwise.
   int get_show_icons() {
      return gtk_recent_chooser_get_show_icons(&this);
   }

   // Retrieves whether @chooser should show the recently used resources that
   // were not found.
   // %FALSE otheriwse.
   // RETURNS: %TRUE if the resources not found should be displayed, and
   int get_show_not_found() {
      return gtk_recent_chooser_get_show_not_found(&this);
   }

   // Returns whether @chooser should display recently used resources
   // prepended by a unique number.
   // %FALSE otherwise.
   // RETURNS: %TRUE if the recent chooser should show display numbers,
   int get_show_numbers() {
      return gtk_recent_chooser_get_show_numbers(&this);
   }

   // Returns whether @chooser should display recently used resources
   // registered as private.
   // %FALSE otherwise.
   // RETURNS: %TRUE if the recent chooser should show private items,
   int get_show_private() {
      return gtk_recent_chooser_get_show_private(&this);
   }

   // Gets whether @chooser should display tooltips containing the full path
   // of a recently user resource.
   // %FALSE otherwise.
   // RETURNS: %TRUE if the recent chooser should show tooltips,
   int get_show_tips() {
      return gtk_recent_chooser_get_show_tips(&this);
   }

   // Gets the value set by gtk_recent_chooser_set_sort_type().
   // RETURNS: the sorting order of the @chooser.
   RecentSortType get_sort_type() {
      return gtk_recent_chooser_get_sort_type(&this);
   }

   // Gets the URI of the recently used resources.
   // The return value of this function is affected by the "sort-type" and "limit"
   // properties of @chooser.
   // Since the returned array is %NULL terminated, @length may be %NULL.
   // A newly allocated, %NULL-terminated array of strings. Use
   // g_strfreev() to free it.
   // <length>: return location for a the length of the URI list, or %NULL
   char** /*new*/ get_uris(/*out*/ size_t* length=null) {
      return gtk_recent_chooser_get_uris(&this, length);
   }

   // Gets the #GtkRecentFilter objects held by @chooser.
   // of #GtkRecentFilter objects.  You
   // should just free the returned list using g_slist_free().
   // RETURNS: A singly linked list
   GLib2.SList* /*new container*/ list_filters() {
      return gtk_recent_chooser_list_filters(&this);
   }

   // Removes @filter from the list of #GtkRecentFilter objects held by @chooser.
   // <filter>: a #GtkRecentFilter
   void remove_filter(RecentFilter* filter) {
      gtk_recent_chooser_remove_filter(&this, filter);
   }

   // Selects all the items inside @chooser, if the @chooser supports
   // multiple selection.
   void select_all() {
      gtk_recent_chooser_select_all(&this);
   }

   // Selects @uri inside @chooser.
   // RETURNS: %TRUE if @uri was found.
   // <uri>: a URI
   int select_uri(char* uri, GLib2.Error** error=null) {
      return gtk_recent_chooser_select_uri(&this, uri, error);
   }

   // Sets @uri as the current URI for @chooser.
   // RETURNS: %TRUE if the URI was found.
   // <uri>: a URI
   int set_current_uri(char* uri, GLib2.Error** error=null) {
      return gtk_recent_chooser_set_current_uri(&this, uri, error);
   }

   // Sets @filter as the current #GtkRecentFilter object used by @chooser
   // to affect the displayed recently used resources.
   // <filter>: a #GtkRecentFilter
   void set_filter(RecentFilter* filter) {
      gtk_recent_chooser_set_filter(&this, filter);
   }

   // Sets the number of items that should be returned by
   // gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
   // <limit>: a positive integer, or -1 for all items
   void set_limit(int limit) {
      gtk_recent_chooser_set_limit(&this, limit);
   }

   // Sets whether only local resources, that is resources using the file:// URI
   // scheme, should be shown in the recently used resources selector.  If
   // to be accessible through the operating system native file system.
   // <local_only>: %TRUE if only local files can be shown
   void set_local_only(int local_only) {
      gtk_recent_chooser_set_local_only(&this, local_only);
   }

   // Sets whether @chooser can select multiple items.
   // <select_multiple>: %TRUE if @chooser can select more than one item
   void set_select_multiple(int select_multiple) {
      gtk_recent_chooser_set_select_multiple(&this, select_multiple);
   }

   // Sets whether @chooser should show an icon near the resource when
   // displaying it.
   // <show_icons>: whether to show an icon near the resource
   void set_show_icons(int show_icons) {
      gtk_recent_chooser_set_show_icons(&this, show_icons);
   }

   // Sets whether @chooser should display the recently used resources that
   // it didn't find.  This only applies to local resources.
   // <show_not_found>: whether to show the local items we didn't find
   void set_show_not_found(int show_not_found) {
      gtk_recent_chooser_set_show_not_found(&this, show_not_found);
   }

   // Whether to show recently used resources prepended by a unique number.
   // <show_numbers>: %TRUE to show numbers, %FALSE otherwise
   void set_show_numbers(int show_numbers) {
      gtk_recent_chooser_set_show_numbers(&this, show_numbers);
   }

   // Whether to show recently used resources marked registered as private.
   // <show_private>: %TRUE to show private items, %FALSE otherwise
   void set_show_private(int show_private) {
      gtk_recent_chooser_set_show_private(&this, show_private);
   }

   // Sets whether to show a tooltips containing the full path of each
   // recently used resource in a #GtkRecentChooser widget.
   // <show_tips>: %TRUE if tooltips should be shown
   void set_show_tips(int show_tips) {
      gtk_recent_chooser_set_show_tips(&this, show_tips);
   }

   // Sets the comparison function used when sorting to be @sort_func.  If
   // the @chooser has the sort type set to #GTK_RECENT_SORT_CUSTOM then
   // the chooser will sort using this function.
   // To the comparison function will be passed two #GtkRecentInfo structs and
   // item comes before the second, zero if the two items are equal and
   // a negative integer if the first item comes after the second.
   // <sort_func>: the comparison function
   // <sort_data>: user data to pass to @sort_func, or %NULL
   // <data_destroy>: destroy notifier for @sort_data, or %NULL
   void set_sort_func(RecentSortFunc sort_func, void* sort_data=null, GLib2.DestroyNotify data_destroy=null) {
      gtk_recent_chooser_set_sort_func(&this, sort_func, sort_data, data_destroy);
   }

   // Changes the sorting order of the recently used resources list displayed by
   // <sort_type>: sort order that the chooser should use
   void set_sort_type(RecentSortType sort_type) {
      gtk_recent_chooser_set_sort_type(&this, sort_type);
   }
   // Unselects all the items inside @chooser.
   void unselect_all() {
      gtk_recent_chooser_unselect_all(&this);
   }

   // Unselects @uri inside @chooser.
   // <uri>: a URI
   void unselect_uri(char* uri) {
      gtk_recent_chooser_unselect_uri(&this, uri);
   }

   // This signal is emitted when the user "activates" a recent item
   // in the recent chooser.  This can happen by double-clicking on an item
   // in the recently used resources list, or by pressing
   // <keycap>Enter</keycap>.
   extern (C) alias static void function (RecentChooser* this_, void* user_data=null) signal_item_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:"item-activated", CB/*:signal_item_activated*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"item-activated",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when there is a change in the set of
   // selected recently used resources.  This can happen when a user
   // modifies the selection with the mouse or the keyboard, or when
   // explicitely calling functions to change the selection.
   extern (C) alias static void function (RecentChooser* this_, void* user_data=null) signal_selection_changed;
   ulong signal_connect(string name:"selection-changed", CB/*:signal_selection_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct RecentChooserDialog /* : Dialog */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance dialog;
   Dialog parent_instance;
   private RecentChooserDialogPrivate* priv;


   // Unintrospectable constructor: new() / gtk_recent_chooser_dialog_new()
   // Creates a new #GtkRecentChooserDialog.  This function is analogous to
   // gtk_dialog_new_with_buttons().
   // RETURNS: a new #GtkRecentChooserDialog
   // <title>: Title of the dialog, or %NULL
   // <parent>: Transient parent of the dialog, or %NULL,
   // <first_button_text>: stock ID or text to go in the first button, or %NULL
   alias gtk_recent_chooser_dialog_new new_; // Variadic

   // Unintrospectable constructor: new_for_manager() / gtk_recent_chooser_dialog_new_for_manager()
   // Creates a new #GtkRecentChooserDialog with a specified recent manager.
   // This is useful if you have implemented your own recent manager, or if you
   // have a customized instance of a #GtkRecentManager object.
   // RETURNS: a new #GtkRecentChooserDialog
   // <title>: Title of the dialog, or %NULL
   // <parent>: Transient parent of the dialog, or %NULL,
   // <manager>: a #GtkRecentManager
   // <first_button_text>: stock ID or text to go in the first button, or %NULL
   alias gtk_recent_chooser_dialog_new_for_manager new_for_manager; // Variadic
}

struct RecentChooserDialogClass {
   DialogClass parent_class;
}

struct RecentChooserDialogPrivate {
}

enum RecentChooserError {
   NOT_FOUND = 0,
   INVALID_URI = 1
}
struct RecentChooserIface {
   GObject2.TypeInterface base_iface;

   // RETURNS: %TRUE if the URI was found.
   // <uri>: a URI
   extern (C) int function (RecentChooser* chooser, char* uri, GLib2.Error** error=null) set_current_uri;
   // RETURNS: a newly allocated string holding a URI.
   extern (C) char* /*new*/ function (RecentChooser* chooser) get_current_uri;

   // RETURNS: %TRUE if @uri was found.
   // <uri>: a URI
   extern (C) int function (RecentChooser* chooser, char* uri, GLib2.Error** error=null) select_uri;
   // <uri>: a URI
   extern (C) void function (RecentChooser* chooser, char* uri) unselect_uri;
   extern (C) void function (RecentChooser* chooser) select_all;
   extern (C) void function (RecentChooser* chooser) unselect_all;
   // RETURNS: A newly allocated
   extern (C) GLib2.List* /*new*/ function (RecentChooser* chooser) get_items;
   // Unintrospectable functionp: get_recent_manager() / ()
   extern (C) RecentManager* function (RecentChooser* chooser) get_recent_manager;
   // <filter>: a #GtkRecentFilter
   extern (C) void function (RecentChooser* chooser, RecentFilter* filter) add_filter;
   // <filter>: a #GtkRecentFilter
   extern (C) void function (RecentChooser* chooser, RecentFilter* filter) remove_filter;
   // RETURNS: A singly linked list
   extern (C) GLib2.SList* /*new container*/ function (RecentChooser* chooser) list_filters;
   // <sort_func>: the comparison function
   extern (C) void function (RecentChooser* chooser, RecentSortFunc sort_func, void* data, GLib2.DestroyNotify destroy) set_sort_func;
   extern (C) void function (RecentChooser* chooser) item_activated;
   extern (C) void function (RecentChooser* chooser) selection_changed;
}

struct RecentChooserMenu /* : Menu */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance menu;
   Menu parent_instance;
   private RecentChooserMenuPrivate* priv;


   // Creates a new #GtkRecentChooserMenu widget.
   // This kind of widget shows the list of recently used resources as
   // a menu, each item as a menu item.  Each item inside the menu might
   // have an icon, representing its MIME type, and a number, for mnemonic
   // access.
   // This widget implements the #GtkRecentChooser interface.
   // This widget creates its own #GtkRecentManager object.  See the
   // gtk_recent_chooser_menu_new_for_manager() function to know how to create
   // a #GtkRecentChooserMenu widget bound to another #GtkRecentManager object.
   // RETURNS: a new #GtkRecentChooserMenu
   static RecentChooserMenu* new_() {
      return gtk_recent_chooser_menu_new();
   }

   // Creates a new #GtkRecentChooserMenu widget using @manager as
   // the underlying recently used resources manager.
   // This is useful if you have implemented your own recent manager,
   // or if you have a customized instance of a #GtkRecentManager
   // object or if you wish to share a common #GtkRecentManager object
   // among multiple #GtkRecentChooser widgets.
   // RETURNS: a new #GtkRecentChooserMenu, bound to @manager.
   // <manager>: a #GtkRecentManager
   static RecentChooserMenu* new_for_manager(RecentManager* manager) {
      return gtk_recent_chooser_menu_new_for_manager(manager);
   }

   // Returns the value set by gtk_recent_chooser_menu_set_show_numbers().
   // RETURNS: %TRUE if numbers should be shown.
   int get_show_numbers() {
      return gtk_recent_chooser_menu_get_show_numbers(&this);
   }

   // Sets whether a number should be added to the items of @menu.  The
   // numbers are shown to provide a unique character for a mnemonic to
   // be used inside ten menu item's label.  Only the first the items
   // get a number to avoid clashes.
   // <show_numbers>: whether to show numbers
   void set_show_numbers(int show_numbers) {
      gtk_recent_chooser_menu_set_show_numbers(&this, show_numbers);
   }
}

struct RecentChooserMenuClass {
   MenuClass parent_class;
   extern (C) void function () gtk_recent1;
   extern (C) void function () gtk_recent2;
   extern (C) void function () gtk_recent3;
   extern (C) void function () gtk_recent4;
}

struct RecentChooserMenuPrivate {
}

struct RecentChooserWidget /* : VBox */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance vbox;
   VBox parent_instance;
   private RecentChooserWidgetPrivate* priv;


   // Creates a new #GtkRecentChooserWidget object.  This is an embeddable widget
   // used to access the recently used resources list.
   // RETURNS: a new #GtkRecentChooserWidget
   static RecentChooserWidget* new_() {
      return gtk_recent_chooser_widget_new();
   }

   // Creates a new #GtkRecentChooserWidget with a specified recent manager.
   // This is useful if you have implemented your own recent manager, or if you
   // have a customized instance of a #GtkRecentManager object.
   // RETURNS: a new #GtkRecentChooserWidget
   // <manager>: a #GtkRecentManager
   static RecentChooserWidget* new_for_manager(RecentManager* manager) {
      return gtk_recent_chooser_widget_new_for_manager(manager);
   }
}

struct RecentChooserWidgetClass {
   VBoxClass parent_class;
}

struct RecentChooserWidgetPrivate {
}


// Meta-data to be passed to gtk_recent_manager_add_full() when
// registering a recently used resource.
struct RecentData {
   char* display_name, description, mime_type, app_name, app_exec;
   char** groups;
   int is_private;
}

struct RecentFilter /* : Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   Object method_parent;


   // Creates a new #GtkRecentFilter with no rules added to it.
   // Such filter does not accept any recently used resources, so is not
   // particularly useful until you add rules with
   // gtk_recent_filter_add_pattern(), gtk_recent_filter_add_mime_type(),
   // gtk_recent_filter_add_application(), gtk_recent_filter_add_age().
   // To create a filter that accepts any recently used resource, use:
   // |[
   // GtkRecentFilter *filter = gtk_recent_filter_new ();
   // gtk_recent_filter_add_pattern (filter, "*");
   // ]|
   // RETURNS: a new #GtkRecentFilter
   static RecentFilter* new_() {
      return gtk_recent_filter_new();
   }

   // Adds a rule that allows resources based on their age - that is, the number
   // of days elapsed since they were last modified.
   // <days>: number of days
   void add_age(int days) {
      gtk_recent_filter_add_age(&this, days);
   }

   // Adds a rule that allows resources based on the name of the application
   // that has registered them.
   // <application>: an application name
   void add_application(char* application) {
      gtk_recent_filter_add_application(&this, application);
   }

   // Adds a rule to a filter that allows resources based on a custom callback
   // function. The bitfield @needed which is passed in provides information
   // about what sorts of information that the filter function needs;
   // this allows GTK+ to avoid retrieving expensive information when
   // it isn't needed by the filter.
   // <needed>: bitfield of flags indicating the information that the custom filter function needs.
   // <func>: callback function; if the function returns %TRUE, then the file will be displayed.
   // <data>: data to pass to @func
   // <data_destroy>: function to call to free @data when it is no longer needed.
   void add_custom(RecentFilterFlags needed, RecentFilterFunc func, void* data, GLib2.DestroyNotify data_destroy) {
      gtk_recent_filter_add_custom(&this, needed, func, data, data_destroy);
   }

   // Adds a rule that allows resources based on the name of the group
   // to which they belong
   // <group>: a group name
   void add_group(char* group) {
      gtk_recent_filter_add_group(&this, group);
   }

   // Adds a rule that allows resources based on their registered MIME type.
   // <mime_type>: a MIME type
   void add_mime_type(char* mime_type) {
      gtk_recent_filter_add_mime_type(&this, mime_type);
   }

   // Adds a rule that allows resources based on a pattern matching their
   // display name.
   // <pattern>: a file pattern
   void add_pattern(char* pattern) {
      gtk_recent_filter_add_pattern(&this, pattern);
   }

   // Adds a rule allowing image files in the formats supported
   // by GdkPixbuf.
   void add_pixbuf_formats() {
      gtk_recent_filter_add_pixbuf_formats(&this);
   }

   // Tests whether a file should be displayed according to @filter.
   // The #GtkRecentFilterInfo structure @filter_info should include
   // the fields returned from gtk_recent_filter_get_needed().
   // This function will not typically be used by applications; it
   // is intended principally for use in the implementation of
   // #GtkRecentChooser.
   // RETURNS: %TRUE if the file should be displayed
   // <filter_info>: a #GtkRecentFilterInfo structure containing information about a recently used resource
   int filter(RecentFilterInfo* filter_info) {
      return gtk_recent_filter_filter(&this, filter_info);
   }

   // Gets the human-readable name for the filter.
   // See gtk_recent_filter_set_name().
   // is owned by the filter object and should not be freed.
   // RETURNS: the name of the filter, or %NULL.  The returned string
   char* get_name() {
      return gtk_recent_filter_get_name(&this);
   }

   // Gets the fields that need to be filled in for the structure
   // passed to gtk_recent_filter_filter()
   // This function will not typically be used by applications; it
   // is intended principally for use in the implementation of
   // #GtkRecentChooser.
   // calling gtk_recent_filter_filter()
   // RETURNS: bitfield of flags indicating needed fields when
   RecentFilterFlags get_needed() {
      return gtk_recent_filter_get_needed(&this);
   }

   // Sets the human-readable name of the filter; this is the string
   // that will be displayed in the recently used resources selector
   // user interface if there is a selectable list of filters.
   // <name>: then human readable name of @filter
   void set_name(char* name) {
      gtk_recent_filter_set_name(&this, name);
   }
}

enum RecentFilterFlags {
   URI = 1,
   DISPLAY_NAME = 2,
   MIME_TYPE = 4,
   APPLICATION = 8,
   GROUP = 16,
   AGE = 32
}
extern (C) alias int function (RecentFilterInfo* filter_info, void* user_data) RecentFilterFunc;

struct RecentFilterInfo {
   RecentFilterFlags contains;
   char* uri, display_name, mime_type;
   char** applications, groups;
   int age;
}

struct RecentInfo {

   // Checks whether the resource pointed by @info still exists.  At
   // the moment this check is done only on resources pointing to local files.
   // RETURNS: %TRUE if the resource exists
   int exists() {
      return gtk_recent_info_exists(&this);
   }

   // Gets the timestamp (seconds from system's Epoch) when the resource
   // was added to the recently used resources list.
   // the resource was added to the list, or -1 on failure.
   // RETURNS: the number of seconds elapsed from system's Epoch when
   time_t get_added() {
      return gtk_recent_info_get_added(&this);
   }

   // Gets the number of days elapsed since the last update of the resource
   // pointed by @info.
   // since the time this resource was last modified.
   // RETURNS: a positive integer containing the number of days elapsed
   int get_age() {
      return gtk_recent_info_get_age(&this);
   }

   // Gets the data regarding the application that has registered the resource
   // pointed by @info.
   // If the command line contains any escape characters defined inside the
   // storage specification, they will be expanded.
   // resource inside the recently used list, or %FALSE otherwise. The
   // modified or freed
   // RETURNS: %TRUE if an application with @app_name has registered this
   // <app_name>: the name of the application that has registered this item
   // <app_exec>: return location for the string containing the command line
   // <count>: return location for the number of times this item was registered
   // <time_>: return location for the timestamp this item was last registered for this application
   int get_application_info(char* app_name, /*out*/ char** app_exec, /*out*/ uint* count, /*out*/ time_t* time_) {
      return gtk_recent_info_get_application_info(&this, app_name, app_exec, count, time_);
   }

   // Retrieves the list of applications that have registered this resource.
   // a newly allocated %NULL-terminated array of strings.
   // Use g_strfreev() to free it.
   // <length>: return location for the length of the returned list
   char** /*new*/ get_applications(/*out*/ size_t* length=null) {
      return gtk_recent_info_get_applications(&this, length);
   }

   // Gets the (short) description of the resource.
   // is owned by the recent manager, and should not be freed.
   // RETURNS: the description of the resource.  The returned string
   char* get_description() {
      return gtk_recent_info_get_description(&this);
   }

   // Gets the name of the resource.  If none has been defined, the basename
   // of the resource is obtained.
   // is owned by the recent manager, and should not be freed.
   // RETURNS: the display name of the resource.  The returned string
   char* get_display_name() {
      return gtk_recent_info_get_display_name(&this);
   }

   // Returns all groups registered for the recently used item @info.  The
   // array of returned group names will be %NULL terminated, so length might
   // optionally be %NULL.
   // a newly allocated %NULL terminated array of strings.
   // Use g_strfreev() to free it.
   // <length>: return location for the number of groups returned
   char** /*new*/ get_groups(/*out*/ size_t* length=null) {
      return gtk_recent_info_get_groups(&this, length);
   }

   // Retrieves the icon of size @size associated to the resource MIME type.
   // or %NULL. Use g_object_unref() when finished using the icon.
   // RETURNS: a #GdkPixbuf containing the icon,
   // <size>: the size of the icon in pixels
   GdkPixbuf2.Pixbuf* /*new*/ get_icon(int size) {
      return gtk_recent_info_get_icon(&this, size);
   }

   // Gets the MIME type of the resource.
   // is owned by the recent manager, and should not be freed.
   // RETURNS: the MIME type of the resource.  The returned string
   char* get_mime_type() {
      return gtk_recent_info_get_mime_type(&this);
   }

   // Gets the timestamp (seconds from system's Epoch) when the resource
   // was last modified.
   // the resource was last modified, or -1 on failure.
   // RETURNS: the number of seconds elapsed from system's Epoch when
   time_t get_modified() {
      return gtk_recent_info_get_modified(&this);
   }

   // Gets the value of the "private" flag.  Resources in the recently used
   // list that have this flag set to %TRUE should only be displayed by the
   // applications that have registered them.
   // RETURNS: %TRUE if the private flag was found, %FALSE otherwise.
   int get_private_hint() {
      return gtk_recent_info_get_private_hint(&this);
   }

   // Computes a valid UTF-8 string that can be used as the name of the item in a
   // menu or list.  For example, calling this function on an item that refers to
   // "file:///foo/bar.txt" will yield "bar.txt".
   // g_free().
   // RETURNS: A newly-allocated string in UTF-8 encoding; free it with
   char* /*new*/ get_short_name() {
      return gtk_recent_info_get_short_name(&this);
   }

   // Gets the URI of the resource.
   // owned by the recent manager, and should not be freed.
   // RETURNS: the URI of the resource.  The returned string is
   char* get_uri() {
      return gtk_recent_info_get_uri(&this);
   }

   // Gets a displayable version of the resource's URI.  If the resource
   // is local, it returns a local path; if the resource is not local,
   // it returns the UTF-8 encoded content of gtk_recent_info_get_uri().
   // resource's URI or %NULL. Use g_free() when done using it.
   // RETURNS: a newly allocated UTF-8 string containing the
   char* /*new*/ get_uri_display() {
      return gtk_recent_info_get_uri_display(&this);
   }

   // Gets the timestamp (seconds from system's Epoch) when the resource
   // was last visited.
   // the resource was last visited, or -1 on failure.
   // RETURNS: the number of seconds elapsed from system's Epoch when
   time_t get_visited() {
      return gtk_recent_info_get_visited(&this);
   }

   // Checks whether an application registered this resource using @app_name.
   // %FALSE otherwise.
   // RETURNS: %TRUE if an application with name @app_name was found,
   // <app_name>: a string containing an application name
   int has_application(char* app_name) {
      return gtk_recent_info_has_application(&this, app_name);
   }

   // Checks whether @group_name appears inside the groups registered for the
   // recently used item @info.
   // RETURNS: %TRUE if the group was found.
   // <group_name>: name of a group
   int has_group(char* group_name) {
      return gtk_recent_info_has_group(&this, group_name);
   }

   // Checks whether the resource is local or not by looking at the
   // scheme of its URI.
   // RETURNS: %TRUE if the resource is local.
   int is_local() {
      return gtk_recent_info_is_local(&this);
   }

   // Gets the name of the last application that have registered the
   // recently used resource represented by @info.
   // RETURNS: an application name.  Use g_free() to free it.
   char* /*new*/ last_application() {
      return gtk_recent_info_last_application(&this);
   }

   // Checks whether two #GtkRecentInfo structures point to the same
   // resource.
   // resource, %FALSE otherwise.
   // RETURNS: %TRUE if both #GtkRecentInfo structures point to se same
   // <info_b>: a #GtkRecentInfo
   int match(RecentInfo* info_b) {
      return gtk_recent_info_match(&this, info_b);
   }

   // Increases the reference count of @recent_info by one.
   // by one.
   // RETURNS: the recent info object with its reference count increased
   RecentInfo* /*new*/ ref_() {
      return gtk_recent_info_ref(&this);
   }

   // Decreases the reference count of @info by one.  If the reference
   // count reaches zero, @info is deallocated, and the memory freed.
   void unref() {
      gtk_recent_info_unref(&this);
   }
}

struct RecentManager /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private RecentManagerPrivate* priv;


   // Creates a new recent manager object.  Recent manager objects are used to
   // handle the list of recently used resources.  A #GtkRecentManager object
   // monitors the recently used resources list, and emits the "changed" signal
   // each time something inside the list changes.
   // #GtkRecentManager objects are expensive: be sure to create them only when
   // needed. You should use gtk_recent_manager_get_default() instead.
   // RETURNS: A newly created #GtkRecentManager object.
   static RecentManager* /*new*/ new_() {
      return gtk_recent_manager_new();
   }

   // Gets a unique instance of #GtkRecentManager, that you can share
   // in your application without caring about memory management. The
   // returned instance will be freed when you application terminates.
   // RETURNS: A unique #GtkRecentManager. Do not ref or unref it.
   static RecentManager* get_default() {
      return gtk_recent_manager_get_default();
   }

   // Unintrospectable function: get_for_screen() / gtk_recent_manager_get_for_screen()
   // Gets the recent manager object associated with @screen; if this
   // function has not previously been called for the given screen,
   // a new recent manager object will be created and associated with
   // the screen. Recent manager objects are fairly expensive to create,
   // so using this function is usually a better choice than calling 
   // gtk_recent_manager_new() and setting the screen yourself; by using
   // this function a single recent manager object will be shared between
   // users.
   // screen. This recent manager is associated to the with the screen
   // and can be used as long as the screen is open. Do not ref or
   // unref it.
   // not be used in newly written code. Calling this function is
   // equivalent to calling gtk_recent_manager_get_default().
   // RETURNS: A unique #GtkRecentManager associated with the given
   // <screen>: a #GdkScreen
   static RecentManager* get_for_screen(Gdk2.Screen* screen) {
      return gtk_recent_manager_get_for_screen(screen);
   }

   // Adds a new resource, pointed by @uri, into the recently used
   // resources list, using the metadata specified inside the #GtkRecentData
   // structure passed in @recent_data.
   // The passed URI will be used to identify this resource inside the
   // list.
   // In order to register the new recently used resource, metadata about
   // the resource must be passed as well as the URI; the metadata is
   // stored in a #GtkRecentData structure, which must contain the MIME
   // type of the resource pointed by the URI; the name of the application
   // that is registering the item, and a command line to be used when
   // launching the item.
   // Optionally, a #GtkRecentData structure might contain a UTF-8 string
   // to be used when viewing the item instead of the last component of the
   // URI; a short description of the item; whether the item should be
   // considered private - that is, should be displayed only by the
   // applications that have registered it.
   // recently used resources list, %FALSE otherwise.
   // RETURNS: %TRUE if the new item was successfully added to the
   // <uri>: a valid URI
   // <recent_data>: metadata of the resource
   int add_full(char* uri, RecentData* recent_data) {
      return gtk_recent_manager_add_full(&this, uri, recent_data);
   }

   // Adds a new resource, pointed by @uri, into the recently used
   // resources list.
   // This function automatically retrieves some of the needed
   // metadata and setting other metadata to common default values; it
   // then feeds the data to gtk_recent_manager_add_full().
   // See gtk_recent_manager_add_full() if you want to explicitly
   // define the metadata for the resource pointed by @uri.
   // to the recently used resources list
   // RETURNS: %TRUE if the new item was successfully added
   // <uri>: a valid URI
   int add_item(char* uri) {
      return gtk_recent_manager_add_item(&this, uri);
   }

   // Gets the list of recently used resources.
   // newly allocated #GtkRecentInfo objects. Use
   // gtk_recent_info_unref() on each item inside the list, and then
   // free the list itself using g_list_free().
   // RETURNS: a list of
   GLib2.List* /*new*/ get_items() {
      return gtk_recent_manager_get_items(&this);
   }

   // Gets the maximum number of items that the gtk_recent_manager_get_items()
   // function should return.
   // view (implementing #GtkRecentChooser), and not by the model (the
   // #GtkRecentManager). See #GtkRecentChooser:limit.
   // RETURNS: the number of items to return, or -1 for every item.
   int get_limit() {
      return gtk_recent_manager_get_limit(&this);
   }

   // Checks whether there is a recently used resource registered
   // with @uri inside the recent manager.
   // RETURNS: %TRUE if the resource was found, %FALSE otherwise.
   // <uri>: a URI
   int has_item(char* uri) {
      return gtk_recent_manager_has_item(&this, uri);
   }

   // Searches for a URI inside the recently used resources list, and
   // returns a structure containing informations about the resource
   // like its MIME type, or its display name.
   // about the resource pointed by @uri, or %NULL if the URI was
   // not registered in the recently used resources list.  Free with
   // gtk_recent_info_unref().
   // RETURNS: a #GtkRecentInfo structure containing information
   // <uri>: a URI
   RecentInfo* /*new*/ lookup_item(char* uri, GLib2.Error** error=null) {
      return gtk_recent_manager_lookup_item(&this, uri, error);
   }

   // Changes the location of a recently used resource from @uri to @new_uri.
   // Please note that this function will not affect the resource pointed
   // by the URIs, but only the URI used in the recently used resources list.
   // RETURNS: %TRUE on success.
   // <uri>: the URI of a recently used resource
   // <new_uri>: the new URI of the recently used resource, or %NULL to remove the item pointed by @uri in the list
   int move_item(char* uri, char* new_uri, GLib2.Error** error=null) {
      return gtk_recent_manager_move_item(&this, uri, new_uri, error);
   }

   // Purges every item from the recently used resources list.
   // recently used resources list.
   // RETURNS: the number of items that have been removed from the
   int purge_items(GLib2.Error** error=null) {
      return gtk_recent_manager_purge_items(&this, error);
   }

   // Removes a resource pointed by @uri from the recently used resources
   // list handled by a recent manager.
   // removed by the recently used resources list, and %FALSE otherwise.
   // RETURNS: %TRUE if the item pointed by @uri has been successfully
   // <uri>: the URI of the item you wish to remove
   int remove_item(char* uri, GLib2.Error** error=null) {
      return gtk_recent_manager_remove_item(&this, uri, error);
   }

   // Sets the maximum number of item that the gtk_recent_manager_get_items()
   // function should return.  If @limit is set to -1, then return all the
   // items.
   // view (implementing #GtkRecentChooser), and not by the model (the
   // #GtkRecentManager). See #GtkRecentChooser:limit.
   // <limit>: the maximum number of items to return, or -1.
   void set_limit(int limit) {
      gtk_recent_manager_set_limit(&this, limit);
   }

   // Sets the screen for a recent manager; the screen is used to
   // track the user's currently configured recently used documents
   // storage.
   // not be used in newly written code. Calling this function has
   // no effect.
   // <screen>: a #GdkScreen
   void set_screen(Gdk2.Screen* screen) {
      gtk_recent_manager_set_screen(&this, screen);
   }

   // Emitted when the current recently used resources manager changes its
   // contents.
   extern (C) alias static void function (RecentManager* 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);
   }
}

struct RecentManagerClass {
   private GObject2.ObjectClass parent_class;
   extern (C) void function (RecentManager* manager) changed;
   extern (C) void function () _gtk_recent1;
   extern (C) void function () _gtk_recent2;
   extern (C) void function () _gtk_recent3;
   extern (C) void function () _gtk_recent4;
}

// Error codes for GtkRecentManager operations
enum RecentManagerError {
   NOT_FOUND = 0,
   INVALID_URI = 1,
   INVALID_ENCODING = 2,
   NOT_REGISTERED = 3,
   READ = 4,
   WRITE = 5,
   UNKNOWN = 6
}
struct RecentManagerPrivate {
}

extern (C) alias int function (RecentInfo* a, RecentInfo* b, void* user_data) RecentSortFunc;


// Used to specify the sorting method to be applyed to the recently
// used resource list.
enum RecentSortType {
   NONE = 0,
   MRU = 1,
   LRU = 2,
   CUSTOM = 3
}
enum ReliefStyle {
   NORMAL = 0,
   HALF = 1,
   NONE = 2
}

// A <structname>GtkRequisition</structname> represents the desired size of a widget. See
// <xref linkend="size-requisition"/> for more information.
struct Requisition {
   int width, height;


   // Copies a #GtkRequisition.
   // RETURNS: a copy of @requisition
   Requisition* /*new*/ copy() {
      return gtk_requisition_copy(&this);
   }
   // Frees a #GtkRequisition.
   void free() {
      gtk_requisition_free(&this);
   }
}

enum ResizeMode {
   PARENT = 0,
   QUEUE = 1,
   IMMEDIATE = 2
}
enum ResponseType {
   NONE = -1,
   REJECT = -2,
   ACCEPT = -3,
   DELETE_EVENT = -4,
   OK = -5,
   CANCEL = -6,
   CLOSE = -7,
   YES = -8,
   NO = -9,
   APPLY = -10,
   HELP = -11
}
struct Ruler /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
   Gdk2.Pixmap* backing_store;
   Gdk2.GC* non_gr_exp_gc;
   RulerMetric* metric;
   int xsrc, ysrc, slider_size;
   double lower, upper, position, max_size;

   void draw_pos() {
      gtk_ruler_draw_pos(&this);
   }
   void draw_ticks() {
      gtk_ruler_draw_ticks(&this);
   }

   // Gets the units used for a #GtkRuler. See gtk_ruler_set_metric().
   // unmaintained and too specialized. There is no replacement.
   // RETURNS: the units currently used for @ruler
   MetricType get_metric() {
      return gtk_ruler_get_metric(&this);
   }

   // Retrieves values indicating the range and current position of a #GtkRuler.
   // See gtk_ruler_set_range().
   // unmaintained and too specialized. There is no replacement.
   // <lower>: location to store lower limit of the ruler, or %NULL
   // <upper>: location to store upper limit of the ruler, or %NULL
   // <position>: location to store the current position of the mark on the ruler, or %NULL
   // <max_size>: location to store the maximum size of the ruler used when calculating the space to leave for the text, or %NULL.
   void get_range(double* lower, double* upper, double* position, double* max_size) {
      gtk_ruler_get_range(&this, lower, upper, position, max_size);
   }
   void set_metric(MetricType metric) {
      gtk_ruler_set_metric(&this, metric);
   }

   // This sets the range of the ruler. 
   // unmaintained and too specialized. There is no replacement.
   // <lower>: the lower limit of the ruler
   // <upper>: the upper limit of the ruler
   // <position>: the mark on the ruler
   // <max_size>: the maximum size of the ruler used when calculating the space to leave for the text
   void set_range(double lower, double upper, double position, double max_size) {
      gtk_ruler_set_range(&this, lower, upper, position, max_size);
   }
}

struct RulerClass {
   WidgetClass parent_class;
   extern (C) void function (Ruler* ruler) draw_ticks;
   extern (C) void function (Ruler* ruler) draw_pos;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct RulerMetric {
   char* metric_name, abbrev;
   double pixels_per_unit;
   double[10] ruler_scale;
   int[5] subdivide;
}

enum STOCK_ABOUT = "gtk-about";
enum STOCK_ADD = "gtk-add";
enum STOCK_APPLY = "gtk-apply";
enum STOCK_BOLD = "gtk-bold";
enum STOCK_CANCEL = "gtk-cancel";
enum STOCK_CAPS_LOCK_WARNING = "gtk-caps-lock-warning";
enum STOCK_CDROM = "gtk-cdrom";
enum STOCK_CLEAR = "gtk-clear";
enum STOCK_CLOSE = "gtk-close";
enum STOCK_COLOR_PICKER = "gtk-color-picker";
enum STOCK_CONNECT = "gtk-connect";
enum STOCK_CONVERT = "gtk-convert";
enum STOCK_COPY = "gtk-copy";
enum STOCK_CUT = "gtk-cut";
enum STOCK_DELETE = "gtk-delete";
enum STOCK_DIALOG_AUTHENTICATION = "gtk-dialog-authentication";
enum STOCK_DIALOG_ERROR = "gtk-dialog-error";
enum STOCK_DIALOG_INFO = "gtk-dialog-info";
enum STOCK_DIALOG_QUESTION = "gtk-dialog-question";
enum STOCK_DIALOG_WARNING = "gtk-dialog-warning";
enum STOCK_DIRECTORY = "gtk-directory";
enum STOCK_DISCARD = "gtk-discard";
enum STOCK_DISCONNECT = "gtk-disconnect";
enum STOCK_DND = "gtk-dnd";
enum STOCK_DND_MULTIPLE = "gtk-dnd-multiple";
enum STOCK_EDIT = "gtk-edit";
enum STOCK_EXECUTE = "gtk-execute";
enum STOCK_FILE = "gtk-file";
enum STOCK_FIND = "gtk-find";
enum STOCK_FIND_AND_REPLACE = "gtk-find-and-replace";
enum STOCK_FLOPPY = "gtk-floppy";
enum STOCK_FULLSCREEN = "gtk-fullscreen";
enum STOCK_GOTO_BOTTOM = "gtk-goto-bottom";
enum STOCK_GOTO_FIRST = "gtk-goto-first";
enum STOCK_GOTO_LAST = "gtk-goto-last";
enum STOCK_GOTO_TOP = "gtk-goto-top";
enum STOCK_GO_BACK = "gtk-go-back";
enum STOCK_GO_DOWN = "gtk-go-down";
enum STOCK_GO_FORWARD = "gtk-go-forward";
enum STOCK_GO_UP = "gtk-go-up";
enum STOCK_HARDDISK = "gtk-harddisk";
enum STOCK_HELP = "gtk-help";
enum STOCK_HOME = "gtk-home";
enum STOCK_INDENT = "gtk-indent";
enum STOCK_INDEX = "gtk-index";
enum STOCK_INFO = "gtk-info";
enum STOCK_ITALIC = "gtk-italic";
enum STOCK_JUMP_TO = "gtk-jump-to";
enum STOCK_JUSTIFY_CENTER = "gtk-justify-center";
enum STOCK_JUSTIFY_FILL = "gtk-justify-fill";
enum STOCK_JUSTIFY_LEFT = "gtk-justify-left";
enum STOCK_JUSTIFY_RIGHT = "gtk-justify-right";
enum STOCK_LEAVE_FULLSCREEN = "gtk-leave-fullscreen";
enum STOCK_MEDIA_FORWARD = "gtk-media-forward";
enum STOCK_MEDIA_NEXT = "gtk-media-next";
enum STOCK_MEDIA_PAUSE = "gtk-media-pause";
enum STOCK_MEDIA_PLAY = "gtk-media-play";
enum STOCK_MEDIA_PREVIOUS = "gtk-media-previous";
enum STOCK_MEDIA_RECORD = "gtk-media-record";
enum STOCK_MEDIA_REWIND = "gtk-media-rewind";
enum STOCK_MEDIA_STOP = "gtk-media-stop";
enum STOCK_MISSING_IMAGE = "gtk-missing-image";
enum STOCK_NETWORK = "gtk-network";
enum STOCK_NEW = "gtk-new";
enum STOCK_NO = "gtk-no";
enum STOCK_OK = "gtk-ok";
enum STOCK_OPEN = "gtk-open";
enum STOCK_ORIENTATION_LANDSCAPE = "gtk-orientation-landscape";
enum STOCK_ORIENTATION_PORTRAIT = "gtk-orientation-portrait";
enum STOCK_ORIENTATION_REVERSE_LANDSCAPE = "gtk-orientation-reverse-landscape";
enum STOCK_ORIENTATION_REVERSE_PORTRAIT = "gtk-orientation-reverse-portrait";
enum STOCK_PAGE_SETUP = "gtk-page-setup";
enum STOCK_PASTE = "gtk-paste";
enum STOCK_PREFERENCES = "gtk-preferences";
enum STOCK_PRINT = "gtk-print";
enum STOCK_PRINT_ERROR = "gtk-print-error";
enum STOCK_PRINT_PAUSED = "gtk-print-paused";
enum STOCK_PRINT_PREVIEW = "gtk-print-preview";
enum STOCK_PRINT_REPORT = "gtk-print-report";
enum STOCK_PRINT_WARNING = "gtk-print-warning";
enum STOCK_PROPERTIES = "gtk-properties";
enum STOCK_QUIT = "gtk-quit";
enum STOCK_REDO = "gtk-redo";
enum STOCK_REFRESH = "gtk-refresh";
enum STOCK_REMOVE = "gtk-remove";
enum STOCK_REVERT_TO_SAVED = "gtk-revert-to-saved";
enum STOCK_SAVE = "gtk-save";
enum STOCK_SAVE_AS = "gtk-save-as";
enum STOCK_SELECT_ALL = "gtk-select-all";
enum STOCK_SELECT_COLOR = "gtk-select-color";
enum STOCK_SELECT_FONT = "gtk-select-font";
enum STOCK_SORT_ASCENDING = "gtk-sort-ascending";
enum STOCK_SORT_DESCENDING = "gtk-sort-descending";
enum STOCK_SPELL_CHECK = "gtk-spell-check";
enum STOCK_STOP = "gtk-stop";
enum STOCK_STRIKETHROUGH = "gtk-strikethrough";
enum STOCK_UNDELETE = "gtk-undelete";
enum STOCK_UNDERLINE = "gtk-underline";
enum STOCK_UNDO = "gtk-undo";
enum STOCK_UNINDENT = "gtk-unindent";
enum STOCK_YES = "gtk-yes";
enum STOCK_ZOOM_100 = "gtk-zoom-100";
enum STOCK_ZOOM_FIT = "gtk-zoom-fit";
enum STOCK_ZOOM_IN = "gtk-zoom-in";
enum STOCK_ZOOM_OUT = "gtk-zoom-out";
struct Scale /* : Range */ {
   alias range this;
   alias range super_;
   Range range;
   int digits;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "draw_value", 1,
   uint, "value_pos", 2,
    uint, "__dummy32A", 29));


   // Adds a mark at @value. 
   // A mark is indicated visually by drawing a tick mark next to the scale, 
   // and GTK+ makes it easy for the user to position the scale exactly at the 
   // marks value.
   // If @markup is not %NULL, text is shown next to the tick mark. 
   // To remove marks from a scale, use gtk_scale_clear_marks().
   // <value>: the value at which the mark is placed, must be between the lower and upper limits of the scales' adjustment
   // <position>: where to draw the mark. For a horizontal scale, #GTK_POS_TOP is drawn above the scale, anything else below. For a vertical scale, #GTK_POS_LEFT is drawn to the left of the scale, anything else to the right.
   // <markup>: Text to be shown at the mark, using <link linkend="PangoMarkupFormat">Pango markup</link>, or %NULL
   void add_mark(double value, PositionType position, char* markup=null) {
      gtk_scale_add_mark(&this, value, position, markup);
   }
   // Removes any marks that have been added with gtk_scale_add_mark().
   void clear_marks() {
      gtk_scale_clear_marks(&this);
   }

   // Gets the number of decimal places that are displayed in the value.
   // RETURNS: the number of decimal places that are displayed
   int get_digits() {
      return gtk_scale_get_digits(&this);
   }

   // Returns whether the current value is displayed as a string 
   // next to the slider.
   // RETURNS: whether the current value is displayed as a string
   int get_draw_value() {
      return gtk_scale_get_draw_value(&this);
   }

   // Gets the #PangoLayout used to display the scale. The returned
   // object is owned by the scale so does not need to be freed by
   // the caller.
   // or %NULL if the #GtkScale:draw-value property is %FALSE.
   // RETURNS: the #PangoLayout for this scale,
   Pango.Layout* get_layout() {
      return gtk_scale_get_layout(&this);
   }

   // Obtains the coordinates where the scale will draw the 
   // #PangoLayout representing the text in the scale. Remember
   // when using the #PangoLayout function you need to convert to
   // and from pixels using PANGO_PIXELS() or #PANGO_SCALE. 
   // If the #GtkScale:draw-value property is %FALSE, the return 
   // values are undefined.
   // <x>: location to store X offset of layout, or %NULL
   // <y>: location to store Y offset of layout, or %NULL
   void get_layout_offsets(/*out*/ int* x=null, /*out*/ int* y=null) {
      gtk_scale_get_layout_offsets(&this, x, y);
   }

   // Gets the position in which the current value is displayed.
   // RETURNS: the position in which the current value is displayed
   PositionType get_value_pos() {
      return gtk_scale_get_value_pos(&this);
   }

   // Sets the number of decimal places that are displayed in the value.
   // Also causes the value of the adjustment to be rounded off to this
   // number of digits, so the retrieved value matches the value the user saw.
   // <digits>: the number of decimal places to display, e.g. use 1 to display 1.0, 2 to display 1.00, etc
   void set_digits(int digits) {
      gtk_scale_set_digits(&this, digits);
   }

   // Specifies whether the current value is displayed as a string next 
   // to the slider.
   // <draw_value>: %TRUE to draw the value
   void set_draw_value(int draw_value) {
      gtk_scale_set_draw_value(&this, draw_value);
   }

   // Sets the position in which the current value is displayed.
   // <pos>: the position in which the current value is displayed
   void set_value_pos(PositionType pos) {
      gtk_scale_set_value_pos(&this, pos);
   }

   // Signal which allows you to change how the scale value is displayed.
   // Connect a signal handler which returns an allocated string representing 
   // Here's an example signal handler which displays a value 1.0 as
   // with "--&gt;1.0&lt;--".
   // |[
   // static gchar*
   // format_value_callback (GtkScale *scale,
   // gdouble   value)
   // {
   // return g_strdup_printf ("--&gt;&percnt;0.*g&lt;--",
   // gtk_scale_get_digits (scale), value);
   // }
   // ]|
   // RETURNS: allocated string representing @value
   // <value>: the value to format
   extern (C) alias static char* /*new*/ function (Scale* this_, double value, void* user_data=null) signal_format_value;

   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:"format-value", CB/*:signal_format_value*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"format-value",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ScaleButton /* : Button */ {
   alias parent this;
   alias parent super_;
   alias parent button;
   Button parent;
   Widget* plus_button, minus_button;
   private ScaleButtonPrivate* priv;


   // Creates a #GtkScaleButton, with a range between @min and @max, with
   // a stepping of @step.
   // RETURNS: a new #GtkScaleButton
   // <size>: a stock icon size
   // <min>: the minimum value of the scale (usually 0)
   // <max>: the maximum value of the scale (usually 100)
   // <step>: the stepping of value when a scroll-wheel event, or up/down arrow event occurs (usually 2)
   // <icons>: a %NULL-terminated array of icon names, or %NULL if you want to set the list later with gtk_scale_button_set_icons()
   static ScaleButton* new_(IconSize size, double min, double max, double step, char** icons=null) {
      return gtk_scale_button_new(size, min, max, step, icons);
   }

   // Gets the #GtkAdjustment associated with the #GtkScaleButton's scale.
   // See gtk_range_get_adjustment() for details.
   // RETURNS: the adjustment associated with the scale
   Adjustment* get_adjustment() {
      return gtk_scale_button_get_adjustment(&this);
   }

   // Retrieves the minus button of the #GtkScaleButton.
   // RETURNS: the minus button of the #GtkScaleButton
   Widget* get_minus_button() {
      return gtk_scale_button_get_minus_button(&this);
   }

   // Gets the orientation of the #GtkScaleButton's popup window.
   // RETURNS: the #GtkScaleButton's orientation.
   Orientation get_orientation() {
      return gtk_scale_button_get_orientation(&this);
   }

   // Retrieves the plus button of the #GtkScaleButton.
   // RETURNS: the plus button of the #GtkScaleButton
   Widget* get_plus_button() {
      return gtk_scale_button_get_plus_button(&this);
   }

   // Retrieves the popup of the #GtkScaleButton.
   // RETURNS: the popup of the #GtkScaleButton
   Widget* get_popup() {
      return gtk_scale_button_get_popup(&this);
   }

   // Gets the current value of the scale button.
   // RETURNS: current value of the scale button
   double get_value() {
      return gtk_scale_button_get_value(&this);
   }

   // Sets the #GtkAdjustment to be used as a model
   // for the #GtkScaleButton's scale.
   // See gtk_range_set_adjustment() for details.
   // <adjustment>: a #GtkAdjustment
   void set_adjustment(Adjustment* adjustment) {
      gtk_scale_button_set_adjustment(&this, adjustment);
   }

   // Sets the icons to be used by the scale button.
   // For details, see the #GtkScaleButton:icons property.
   // <icons>: a %NULL-terminated array of icon names
   void set_icons(char** icons) {
      gtk_scale_button_set_icons(&this, icons);
   }

   // Sets the orientation of the #GtkScaleButton's popup window.
   // <orientation>: the new orientation
   void set_orientation(Orientation orientation) {
      gtk_scale_button_set_orientation(&this, orientation);
   }

   // Sets the current value of the scale; if the value is outside
   // the minimum or maximum range values, it will be clamped to fit
   // inside them. The scale button emits the #GtkScaleButton::value-changed
   // signal if the value changes.
   // <value>: new value of the scale button
   void set_value(double value) {
      gtk_scale_button_set_value(&this, value);
   }

   // The ::popdown signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to popdown the scale widget.
   // The default binding for this signal is Escape.
   extern (C) alias static void function (ScaleButton* this_, void* user_data=null) signal_popdown;

   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:"popdown", CB/*:signal_popdown*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popdown",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::popup signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted to popup the scale widget.
   // The default bindings for this signal are Space, Enter and Return.
   extern (C) alias static void function (ScaleButton* this_, void* user_data=null) signal_popup;
   ulong signal_connect(string name:"popup", CB/*:signal_popup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popup",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::value-changed signal is emitted when the value field has
   // changed.
   // <value>: the new value
   extern (C) alias static void function (ScaleButton* this_, double value, void* user_data=null) signal_value_changed;
   ulong signal_connect(string name:"value-changed", CB/*:signal_value_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"value-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ScaleButtonClass {
   ButtonClass parent_class;
   extern (C) void function (ScaleButton* button, double value) value_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ScaleButtonPrivate {
}

struct ScaleClass {
   RangeClass parent_class;
   extern (C) char* /*new*/ function (Scale* scale, double value) format_value;
   extern (C) void function (Scale* scale) draw_value;

   // <x>: location to store X offset of layout, or %NULL
   // <y>: location to store Y offset of layout, or %NULL
   extern (C) void function (Scale* scale, /*out*/ int* x=null, /*out*/ int* y=null) get_layout_offsets;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

enum ScrollStep {
   STEPS = 0,
   PAGES = 1,
   ENDS = 2,
   HORIZONTAL_STEPS = 3,
   HORIZONTAL_PAGES = 4,
   HORIZONTAL_ENDS = 5
}
enum ScrollType {
   NONE = 0,
   JUMP = 1,
   STEP_BACKWARD = 2,
   STEP_FORWARD = 3,
   PAGE_BACKWARD = 4,
   PAGE_FORWARD = 5,
   STEP_UP = 6,
   STEP_DOWN = 7,
   PAGE_UP = 8,
   PAGE_DOWN = 9,
   STEP_LEFT = 10,
   STEP_RIGHT = 11,
   PAGE_LEFT = 12,
   PAGE_RIGHT = 13,
   START = 14,
   END = 15
}
struct Scrollbar /* : Range */ {
   alias range this;
   alias range super_;
   Range range;
}

struct ScrollbarClass {
   RangeClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ScrolledWindow /* : Bin */ {
   alias container this;
   alias container super_;
   alias container bin;
   Bin container;
   Widget* hscrollbar, vscrollbar;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "hscrollbar_policy", 2,
   uint, "vscrollbar_policy", 2,
   uint, "hscrollbar_visible", 1,
   uint, "vscrollbar_visible", 1,
   uint, "window_placement", 2,
   uint, "focus_out", 1,
    uint, "__dummy32A", 23));
   private ushort shadow_type;


   // Creates a new scrolled window.
   // The two arguments are the scrolled window's adjustments; these will be
   // shared with the scrollbars and the child widget to keep the bars in sync 
   // with the child. Usually you want to pass %NULL for the adjustments, which 
   // will cause the scrolled window to create them for you.
   // RETURNS: a new scrolled window
   // <hadjustment>: horizontal adjustment
   // <vadjustment>: vertical adjustment
   static ScrolledWindow* new_(Adjustment* hadjustment=null, Adjustment* vadjustment=null) {
      return gtk_scrolled_window_new(hadjustment, vadjustment);
   }

   // Used to add children without native scrolling capabilities. This
   // is simply a convenience function; it is equivalent to adding the
   // unscrollable child to a viewport, then adding the viewport to the
   // scrolled window. If a child has native scrolling, use
   // gtk_container_add() instead of this function.
   // The viewport scrolls the child by moving its #GdkWindow, and takes
   // the size of the child to be the size of its toplevel #GdkWindow. 
   // This will be very wrong for most widgets that support native scrolling;
   // for example, if you add a widget such as #GtkTreeView with a viewport,
   // the whole widget will scroll, including the column headings. Thus, 
   // widgets with native scrolling support should not be used with the 
   // #GtkViewport proxy.
   // A widget supports scrolling natively if the 
   // set_scroll_adjustments_signal field in #GtkWidgetClass is non-zero,
   // i.e. has been filled in with a valid signal identifier.
   // <child>: the widget you want to scroll
   void add_with_viewport(Widget* child) {
      gtk_scrolled_window_add_with_viewport(&this, child);
   }

   // Returns the horizontal scrollbar's adjustment, used to connect the
   // horizontal scrollbar to the child widget's horizontal scroll
   // functionality.
   // RETURNS: the horizontal #GtkAdjustment
   Adjustment* get_hadjustment() {
      return gtk_scrolled_window_get_hadjustment(&this);
   }

   // Returns the horizontal scrollbar of @scrolled_window.
   // or %NULL if it does not have one.
   // RETURNS: the horizontal scrollbar of the scrolled window,
   Widget* get_hscrollbar() {
      return gtk_scrolled_window_get_hscrollbar(&this);
   }

   // Gets the placement of the contents with respect to the scrollbars
   // for the scrolled window. See gtk_scrolled_window_set_placement().
   // See also gtk_scrolled_window_set_placement() and
   // gtk_scrolled_window_unset_placement().
   // RETURNS: the current placement value.
   CornerType get_placement() {
      return gtk_scrolled_window_get_placement(&this);
   }

   // Retrieves the current policy values for the horizontal and vertical
   // scrollbars. See gtk_scrolled_window_set_policy().
   // <hscrollbar_policy>: location to store the policy for the horizontal scrollbar, or %NULL.
   // <vscrollbar_policy>: location to store the policy for the vertical scrollbar, or %NULL.
   void get_policy(/*out*/ PolicyType* hscrollbar_policy=null, /*out*/ PolicyType* vscrollbar_policy=null) {
      gtk_scrolled_window_get_policy(&this, hscrollbar_policy, vscrollbar_policy);
   }

   // Gets the shadow type of the scrolled window. See 
   // gtk_scrolled_window_set_shadow_type().
   // RETURNS: the current shadow type
   ShadowType get_shadow_type() {
      return gtk_scrolled_window_get_shadow_type(&this);
   }

   // Returns the vertical scrollbar's adjustment, used to connect the
   // vertical scrollbar to the child widget's vertical scroll functionality.
   // RETURNS: the vertical #GtkAdjustment
   Adjustment* get_vadjustment() {
      return gtk_scrolled_window_get_vadjustment(&this);
   }

   // Returns the vertical scrollbar of @scrolled_window.
   // or %NULL if it does not have one.
   // RETURNS: the vertical scrollbar of the scrolled window,
   Widget* get_vscrollbar() {
      return gtk_scrolled_window_get_vscrollbar(&this);
   }

   // Sets the #GtkAdjustment for the horizontal scrollbar.
   // <hadjustment>: horizontal scroll adjustment
   void set_hadjustment(Adjustment* hadjustment) {
      gtk_scrolled_window_set_hadjustment(&this, hadjustment);
   }

   // Sets the placement of the contents with respect to the scrollbars
   // for the scrolled window.
   // The default is %GTK_CORNER_TOP_LEFT, meaning the child is
   // in the top left, with the scrollbars underneath and to the right.
   // Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,
   // %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
   // See also gtk_scrolled_window_get_placement() and
   // gtk_scrolled_window_unset_placement().
   // <window_placement>: position of the child window
   void set_placement(CornerType window_placement) {
      gtk_scrolled_window_set_placement(&this, window_placement);
   }

   // Sets the scrollbar policy for the horizontal and vertical scrollbars.
   // The policy determines when the scrollbar should appear; it is a value
   // from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the
   // scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
   // never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
   // if needed (that is, if the slider part of the bar would be smaller
   // than the trough - the display is larger than the page size).
   // <hscrollbar_policy>: policy for horizontal bar
   // <vscrollbar_policy>: policy for vertical bar
   void set_policy(PolicyType hscrollbar_policy, PolicyType vscrollbar_policy) {
      gtk_scrolled_window_set_policy(&this, hscrollbar_policy, vscrollbar_policy);
   }

   // Changes the type of shadow drawn around the contents of
   // <type>: kind of shadow to draw around scrolled window contents
   void set_shadow_type(ShadowType type) {
      gtk_scrolled_window_set_shadow_type(&this, type);
   }

   // Sets the #GtkAdjustment for the vertical scrollbar.
   // <vadjustment>: vertical scroll adjustment
   void set_vadjustment(Adjustment* vadjustment) {
      gtk_scrolled_window_set_vadjustment(&this, vadjustment);
   }

   // Unsets the placement of the contents with respect to the scrollbars
   // for the scrolled window. If no window placement is set for a scrolled
   // window, it obeys the "gtk-scrolled-window-placement" XSETTING.
   // See also gtk_scrolled_window_set_placement() and
   // gtk_scrolled_window_get_placement().
   void unset_placement() {
      gtk_scrolled_window_unset_placement(&this);
   }
   extern (C) alias static void function (ScrolledWindow* this_, DirectionType* object, void* user_data=null) signal_move_focus_out;

   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:"move-focus-out", CB/*:signal_move_focus_out*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-focus-out",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (ScrolledWindow* this_, ScrollType* object, c_int p0, void* user_data=null) signal_scroll_child;
   ulong signal_connect(string name:"scroll-child", CB/*:signal_scroll_child*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-child",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ScrolledWindowClass {
   BinClass parent_class;
   int scrollbar_spacing;
   extern (C) int function (ScrolledWindow* scrolled_window, ScrollType scroll, int horizontal) scroll_child;
   extern (C) void function (ScrolledWindow* scrolled_window, DirectionType direction) move_focus_out;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct SelectionData {
   Gdk2.Atom selection, target, type;
   int format;
   ubyte* data;
   int length;
   Gdk2.Display* display;


   // Makes a copy of a #GtkSelectionData structure and its data.
   // RETURNS: a pointer to a copy of @data.
   SelectionData* /*new*/ copy() {
      return gtk_selection_data_copy(&this);
   }

   // Frees a #GtkSelectionData structure returned from
   // gtk_selection_data_copy().
   void free() {
      gtk_selection_data_free(&this);
   }

   // Retrieves the raw data of the selection.
   // RETURNS: the raw data of the selection.
   ubyte* get_data() {
      return gtk_selection_data_get_data(&this);
   }

   // Retrieves the data type of the selection.
   // RETURNS: the data type of the selection.
   Gdk2.Atom get_data_type() {
      return gtk_selection_data_get_data_type(&this);
   }

   // Retrieves the display of the selection.
   // RETURNS: the display of the selection.
   Gdk2.Display* get_display() {
      return gtk_selection_data_get_display(&this);
   }

   // Retrieves the format of the selection.
   // RETURNS: the format of the selection.
   int get_format() {
      return gtk_selection_data_get_format(&this);
   }

   // Retrieves the length of the raw data of the selection.
   // RETURNS: the length of the data of the selection.
   int get_length() {
      return gtk_selection_data_get_length(&this);
   }

   // Gets the contents of the selection data as a #GdkPixbuf.
   // image type and it could be converted to a #GdkPixbuf, a 
   // newly allocated pixbuf is returned, otherwise %NULL.
   // If the result is non-%NULL it must be freed with g_object_unref().
   // RETURNS: if the selection data contained a recognized
   GdkPixbuf2.Pixbuf* /*new*/ get_pixbuf() {
      return gtk_selection_data_get_pixbuf(&this);
   }

   // Retrieves the selection #GdkAtom of the selection data.
   // RETURNS: the selection #GdkAtom of the selection data.
   Gdk2.Atom get_selection() {
      return gtk_selection_data_get_selection(&this);
   }

   // Retrieves the target of the selection.
   // RETURNS: the target of the selection.
   Gdk2.Atom get_target() {
      return gtk_selection_data_get_target(&this);
   }

   // Gets the contents of @selection_data as an array of targets.
   // This can be used to interpret the results of getting
   // the standard TARGETS target that is always supplied for
   // any selection.
   // array of targets, otherwise %FALSE.
   // RETURNS: %TRUE if @selection_data contains a valid
   // <targets>: location to store an array of targets. The result stored here must be freed with g_free().
   // <n_atoms>: location to store number of items in @targets.
   int get_targets(/*out*/ Gdk2.Atom** targets, /*out*/ int* n_atoms) {
      return gtk_selection_data_get_targets(&this, targets, n_atoms);
   }

   // Gets the contents of the selection data as a UTF-8 string.
   // text type and it could be converted to UTF-8, a newly allocated
   // string containing the converted text, otherwise %NULL.
   // If the result is non-%NULL it must be freed with g_free().
   // RETURNS: if the selection data contained a recognized
   ubyte* get_text() {
      return gtk_selection_data_get_text(&this);
   }

   // Gets the contents of the selection data as array of URIs.
   // the selection data contains a list of
   // URIs, a newly allocated %NULL-terminated string array
   // containing the URIs, otherwise %NULL. If the result is
   // non-%NULL it must be freed with g_strfreev().
   // RETURNS: if
   char** /*new*/ get_uris() {
      return gtk_selection_data_get_uris(&this);
   }

   // Stores new data into a #GtkSelectionData object. Should
   // <emphasis>only</emphasis> be called from a selection handler callback.
   // Zero-terminates the stored data.
   // <type>: the type of selection data
   // <format>: format (number of bits in a unit)
   // <data>: pointer to the data (will be copied)
   // <length>: length of the data
   void set(Gdk2.Atom type, int format, ubyte* data, int length) {
      gtk_selection_data_set(&this, type, format, data, length);
   }

   // Sets the contents of the selection from a #GdkPixbuf
   // The pixbuf is converted to the form determined by
   // otherwise %FALSE.
   // RETURNS: %TRUE if the selection was successfully set,
   // <pixbuf>: a #GdkPixbuf
   int set_pixbuf(GdkPixbuf2.Pixbuf* pixbuf) {
      return gtk_selection_data_set_pixbuf(&this, pixbuf);
   }

   // Sets the contents of the selection from a UTF-8 encoded string.
   // The string is converted to the form determined by
   // otherwise %FALSE.
   // RETURNS: %TRUE if the selection was successfully set,
   // <str>: a UTF-8 string
   // <len>: the length of @str, or -1 if @str is nul-terminated.
   int set_text(char* str, int len) {
      return gtk_selection_data_set_text(&this, str, len);
   }

   // Sets the contents of the selection from a list of URIs.
   // The string is converted to the form determined by
   // otherwise %FALSE.
   // RETURNS: %TRUE if the selection was successfully set,
   // <uris>: a %NULL-terminated array of strings holding URIs
   int set_uris(char** uris) {
      return gtk_selection_data_set_uris(&this, uris);
   }

   // Given a #GtkSelectionData object holding a list of targets,
   // determines if any of the targets in @targets can be used to
   // provide a #GdkPixbuf.
   // and a suitable target for images is included, otherwise %FALSE.
   // RETURNS: %TRUE if @selection_data holds a list of targets,
   // <writable>: whether to accept only targets for which GTK+ knows how to convert a pixbuf into the format
   int targets_include_image(int writable) {
      return gtk_selection_data_targets_include_image(&this, writable);
   }

   // Given a #GtkSelectionData object holding a list of targets,
   // determines if any of the targets in @targets can be used to
   // provide rich text.
   // and a suitable target for rich text is included,
   // otherwise %FALSE.
   // RETURNS: %TRUE if @selection_data holds a list of targets,
   // <buffer>: a #GtkTextBuffer
   int targets_include_rich_text(TextBuffer* buffer) {
      return gtk_selection_data_targets_include_rich_text(&this, buffer);
   }

   // Given a #GtkSelectionData object holding a list of targets,
   // determines if any of the targets in @targets can be used to
   // provide text.
   // and a suitable target for text is included, otherwise %FALSE.
   // RETURNS: %TRUE if @selection_data holds a list of targets,
   int targets_include_text() {
      return gtk_selection_data_targets_include_text(&this);
   }

   // Given a #GtkSelectionData object holding a list of targets,
   // determines if any of the targets in @targets can be used to
   // provide a list or URIs.
   // and a suitable target for URI lists is included, otherwise %FALSE.
   // RETURNS: %TRUE if @selection_data holds a list of targets,
   int targets_include_uri() {
      return gtk_selection_data_targets_include_uri(&this);
   }
}

enum SelectionMode {
   NONE = 0,
   SINGLE = 1,
   BROWSE = 2,
   MULTIPLE = 3,
   EXTENDED = 3
}
enum SensitivityType {
   AUTO = 0,
   ON = 1,
   OFF = 2
}
struct Separator /* : Widget */ {
   alias widget this;
   alias widget super_;
   Widget widget;
}

struct SeparatorClass {
   WidgetClass parent_class;
}

struct SeparatorMenuItem /* : MenuItem */ {
   alias menu_item this;
   alias menu_item super_;
   alias menu_item menuitem;
   MenuItem menu_item;

   static SeparatorMenuItem* new_() {
      return gtk_separator_menu_item_new();
   }
}

struct SeparatorMenuItemClass {
   MenuItemClass parent_class;
}

struct SeparatorToolItem /* : ToolItem */ {
   alias parent this;
   alias parent super_;
   alias parent toolitem;
   ToolItem parent;
   private SeparatorToolItemPrivate* priv;


   // Create a new #GtkSeparatorToolItem
   // RETURNS: the new #GtkSeparatorToolItem
   static SeparatorToolItem* new_() {
      return gtk_separator_tool_item_new();
   }

   // Returns whether @item is drawn as a line, or just blank. 
   // See gtk_separator_tool_item_set_draw().
   // RETURNS: %TRUE if @item is drawn as a line, or just blank.
   int get_draw() {
      return gtk_separator_tool_item_get_draw(&this);
   }

   // Whether @item is drawn as a vertical line, or just blank.
   // Setting this to %FALSE along with gtk_tool_item_set_expand() is useful
   // to create an item that forces following items to the end of the toolbar.
   // <draw>: whether @item is drawn as a vertical line
   void set_draw(int draw) {
      gtk_separator_tool_item_set_draw(&this, draw);
   }
}

struct SeparatorToolItemClass {
   ToolItemClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct SeparatorToolItemPrivate {
}

struct Settings /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   GLib2.Data* queued_settings;
   SettingsPropertyValue* property_values;
   RcContext* rc_context;
   Gdk2.Screen* screen;


   // Gets the #GtkSettings object for the default GDK screen, creating
   // it if necessary. See gtk_settings_get_for_screen().
   // screen, then returns %NULL.
   // RETURNS: a #GtkSettings object. If there is no default
   static Settings* get_default() {
      return gtk_settings_get_default();
   }

   // Gets the #GtkSettings object for @screen, creating it if necessary.
   // RETURNS: a #GtkSettings object.
   // <screen>: a #GdkScreen.
   static Settings* get_for_screen(Gdk2.Screen* screen) {
      return gtk_settings_get_for_screen(screen);
   }
   static void install_property(GObject2.ParamSpec* pspec) {
      gtk_settings_install_property(pspec);
   }
   // Unintrospectable function: install_property_parser() / gtk_settings_install_property_parser()
   static void install_property_parser(GObject2.ParamSpec* pspec, RcPropertyParser parser) {
      gtk_settings_install_property_parser(pspec, parser);
   }
   void set_double_property(char* name, double v_double, char* origin) {
      gtk_settings_set_double_property(&this, name, v_double, origin);
   }
   void set_long_property(char* name, c_long v_long, char* origin) {
      gtk_settings_set_long_property(&this, name, v_long, origin);
   }
   void set_property_value(char* name, SettingsValue* svalue) {
      gtk_settings_set_property_value(&this, name, svalue);
   }
   void set_string_property(char* name, char* v_string, char* origin) {
      gtk_settings_set_string_property(&this, name, v_string, origin);
   }
}

struct SettingsClass {
   GObject2.ObjectClass parent_class;
}

struct SettingsPropertyValue {
}

struct SettingsValue {
   char* origin;
   GObject2.Value value;
}

enum ShadowType {
   NONE = 0,
   IN = 1,
   OUT = 2,
   ETCHED_IN = 3,
   ETCHED_OUT = 4
}
enum SideType {
   TOP = 0,
   BOTTOM = 1,
   LEFT = 2,
   RIGHT = 3
}
extern (C) alias void function () SignalFunc;

enum SignalRunType {
   FIRST = 1,
   LAST = 2,
   BOTH = 3,
   NO_RECURSE = 8,
   ACTION = 32,
   NO_HOOKS = 64
}
struct SizeGroup /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   private GLib2.SList* widgets;
   private ubyte mode;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "have_width", 1,
   uint, "have_height", 1,
   uint, "ignore_hidden", 1,
    uint, "__dummy32A", 29));
   private Requisition requisition;


   // Create a new #GtkSizeGroup.
   // RETURNS: a newly created #GtkSizeGroup
   // <mode>: the mode for the new size group.
   static SizeGroup* /*new*/ new_(SizeGroupMode mode) {
      return gtk_size_group_new(mode);
   }

   // Adds a widget to a #GtkSizeGroup. In the future, the requisition
   // of the widget will be determined as the maximum of its requisition
   // and the requisition of the other widgets in the size group.
   // Whether this applies horizontally, vertically, or in both directions
   // depends on the mode of the size group. See gtk_size_group_set_mode().
   // When the widget is destroyed or no longer referenced elsewhere, it will 
   // be removed from the size group.
   // <widget>: the #GtkWidget to add
   void add_widget(Widget* widget) {
      gtk_size_group_add_widget(&this, widget);
   }

   // Returns if invisible widgets are ignored when calculating the size.
   // RETURNS: %TRUE if invisible widgets are ignored.
   int get_ignore_hidden() {
      return gtk_size_group_get_ignore_hidden(&this);
   }

   // Gets the current mode of the size group. See gtk_size_group_set_mode().
   // RETURNS: the current mode of the size group.
   SizeGroupMode get_mode() {
      return gtk_size_group_get_mode(&this);
   }

   // Returns the list of widgets associated with @size_group.
   // widgets. The list is owned by GTK+ and should not be modified.
   // RETURNS: a #GSList of
   GLib2.SList* get_widgets() {
      return gtk_size_group_get_widgets(&this);
   }

   // Removes a widget from a #GtkSizeGroup.
   // <widget>: the #GtkWidget to remove
   void remove_widget(Widget* widget) {
      gtk_size_group_remove_widget(&this, widget);
   }

   // Sets whether unmapped widgets should be ignored when
   // calculating the size.
   // <ignore_hidden>: whether unmapped widgets should be ignored when calculating the size
   void set_ignore_hidden(int ignore_hidden) {
      gtk_size_group_set_ignore_hidden(&this, ignore_hidden);
   }

   // Sets the #GtkSizeGroupMode of the size group. The mode of the size
   // group determines whether the widgets in the size group should
   // all have the same horizontal requisition (%GTK_SIZE_GROUP_MODE_HORIZONTAL)
   // all have the same vertical requisition (%GTK_SIZE_GROUP_MODE_VERTICAL),
   // or should all have the same requisition in both directions
   // (%GTK_SIZE_GROUP_MODE_BOTH).
   // <mode>: the mode to set for the size group.
   void set_mode(SizeGroupMode mode) {
      gtk_size_group_set_mode(&this, mode);
   }
}

struct SizeGroupClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// The mode of the size group determines the directions in which the size
// group affects the requested sizes of its component widgets.
enum SizeGroupMode {
   NONE = 0,
   HORIZONTAL = 1,
   VERTICAL = 2,
   BOTH = 3
}

// Together with #GtkPlug, #GtkSocket provides the ability
// to embed widgets from one process into another process
// in a fashion that is transparent to the user. One
// process creates a #GtkSocket widget and passes
// that widget's window ID to the other process,
// which then creates a #GtkPlug with that window ID.
// Any widgets contained in the #GtkPlug then will appear
// inside the first application's window.
// The socket's window ID is obtained by using
// gtk_socket_get_id(). Before using this function,
// the socket must have been realized, and for hence,
// have been added to its parent.
// <example>
// <title>Obtaining the window ID of a socket.</title>
// <programlisting>
// GtkWidget *socket = gtk_socket_new (<!-- -->);
// gtk_widget_show (socket);
// gtk_container_add (GTK_CONTAINER (parent), socket);
// /<!---->* The following call is only necessary if one of
// * the ancestors of the socket is not yet visible.
// *<!---->/
// gtk_widget_realize (socket);
// g_print ("The ID of the sockets window is %#x\n",
// gtk_socket_get_id (socket));
// </programlisting>
// </example>
// Note that if you pass the window ID of the socket to another
// process that will create a plug in the socket, you
// must make sure that the socket widget is not destroyed
// until that plug is created. Violating this rule will
// cause unpredictable consequences, the most likely
// consequence being that the plug will appear as a
// separate toplevel window. You can check if the plug
// has been created by using gtk_socket_get_plug_window(). If
// it returns a non-%NULL value, then the plug has been
// successfully created inside of the socket.
// When GTK+ is notified that the embedded window has been
// destroyed, then it will destroy the socket as well. You
// should always, therefore, be prepared for your sockets
// to be destroyed at any time when the main event loop
// is running. To prevent this from happening, you can
// connect to the #GtkSocket::plug-removed signal.
// The communication between a #GtkSocket and a #GtkPlug follows the
// <ulink url="http://www.freedesktop.org/Standards/xembed-spec">XEmbed</ulink>
// protocol. This protocol has also been implemented in other toolkits, e.g.
// <application>Qt</application>, allowing the same level of integration
// when embedding a <application>Qt</application> widget in GTK or vice versa.
// A socket can also be used to swallow arbitrary
// pre-existing top-level windows using gtk_socket_steal(),
// though the integration when this is done will not be as close
// as between a #GtkPlug and a #GtkSocket.
// <note>
// The #GtkPlug and #GtkSocket widgets are currently not available
// on all platforms supported by GTK+.
// </note>
struct Socket /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   ushort request_width, request_height, current_width, current_height;
   Gdk2.Window* plug_window;
   Widget* plug_widget;
   short xembed_version;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "same_app", 1,
   uint, "focus_in", 1,
   uint, "have_size", 1,
   uint, "need_map", 1,
   uint, "is_mapped", 1,
   uint, "active", 1,
    uint, "__dummy32A", 26));
   AccelGroup* accel_group;
   Widget* toplevel;


   // Create a new empty #GtkSocket.
   // RETURNS: the new #GtkSocket.
   static Socket* new_() {
      return gtk_socket_new();
   }

   // Adds an XEMBED client, such as a #GtkPlug, to the #GtkSocket.  The
   // client may be in the same process or in a different process. 
   // To embed a #GtkPlug in a #GtkSocket, you can either create the
   // #GtkPlug with <literal>gtk_plug_new (0)</literal>, call 
   // gtk_plug_get_id() to get the window ID of the plug, and then pass that to the
   // gtk_socket_add_id(), or you can call gtk_socket_get_id() to get the
   // window ID for the socket, and call gtk_plug_new() passing in that
   // ID.
   // The #GtkSocket must have already be added into a toplevel window
   // before you can make this call.
   // <window_id>: the window ID of a client participating in the XEMBED protocol.
   void add_id(Gdk2.NativeWindow window_id) {
      gtk_socket_add_id(&this, window_id);
   }

   // Gets the window ID of a #GtkSocket widget, which can then
   // be used to create a client embedded inside the socket, for
   // instance with gtk_plug_new(). 
   // The #GtkSocket must have already be added into a toplevel window 
   // before you can make this call.
   // RETURNS: the window ID for the socket
   Gdk2.NativeWindow get_id() {
      return gtk_socket_get_id(&this);
   }

   // Retrieves the window of the plug. Use this to check if the plug has
   // been created inside of the socket.
   // RETURNS: the window of the plug if available, or %NULL
   Gdk2.Window* get_plug_window() {
      return gtk_socket_get_plug_window(&this);
   }

   // Reparents a pre-existing toplevel window into a #GtkSocket. This is
   // meant to embed clients that do not know about embedding into a
   // #GtkSocket, however doing so is inherently unreliable, and using
   // this function is not recommended.
   // The #GtkSocket must have already be added into a toplevel window
   // before you can make this call.
   // <wid>: the window ID of an existing toplevel window.
   void steal(Gdk2.NativeWindow wid) {
      gtk_socket_steal(&this, wid);
   }

   // This signal is emitted when a client is successfully
   // added to the socket.
   extern (C) alias static void function (Socket* this_, void* user_data=null) signal_plug_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:"plug-added", CB/*:signal_plug_added*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"plug-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when a client is removed from the socket. 
   // The default action is to destroy the #GtkSocket widget, so if you 
   // want to reuse it you must add a signal handler that returns %TRUE.
   // RETURNS: %TRUE to stop other handlers from being invoked.
   extern (C) alias static c_int function (Socket* this_, void* user_data=null) signal_plug_removed;
   ulong signal_connect(string name:"plug-removed", CB/*:signal_plug_removed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"plug-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct SocketClass {
   ContainerClass parent_class;
   extern (C) void function (Socket* socket_) plug_added;
   extern (C) int function (Socket* socket_) plug_removed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

enum SortType {
   ASCENDING = 0,
   DESCENDING = 1
}
struct SpinButton /* : Entry */ {
   alias entry this;
   alias entry super_;
   Entry entry;
   Adjustment* adjustment;
   Gdk2.Window* panel;
   uint timer;
   double climb_rate, timer_step;
   SpinButtonUpdatePolicy update_policy;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "in_child", 2,
   uint, "click_child", 2,
   uint, "button", 2,
   uint, "need_timer", 1,
   uint, "timer_calls", 3,
   uint, "digits", 10,
   uint, "numeric", 1,
   uint, "wrap", 1,
   uint, "snap_to_ticks", 1,
    uint, "__dummy32A", 9));

   static SpinButton* new_(Adjustment* adjustment, double climb_rate, uint digits) {
      return gtk_spin_button_new(adjustment, climb_rate, digits);
   }

   // This is a convenience constructor that allows creation of a numeric 
   // #GtkSpinButton without manually creating an adjustment. The value is 
   // initially set to the minimum value and a page increment of 10 * @step
   // is the default. The precision of the spin button is equivalent to the 
   // precision of @step. 
   // Note that the way in which the precision is derived works best if @step 
   // is a power of ten. If the resulting precision is not suitable for your 
   // needs, use gtk_spin_button_set_digits() to correct it.
   // RETURNS: The new spin button as a #GtkWidget.
   // <min>: Minimum allowable value
   // <max>: Maximum allowable value
   // <step>: Increment added or subtracted by spinning the widget
   static SpinButton* new_with_range(double min, double max, double step) {
      return gtk_spin_button_new_with_range(min, max, step);
   }

   // Changes the properties of an existing spin button. The adjustment, climb rate,
   // and number of decimal places are all changed accordingly, after this function call.
   // <adjustment>: a #GtkAdjustment.
   // <climb_rate>: the new climb rate.
   // <digits>: the number of decimal places to display in the spin button.
   void configure(Adjustment* adjustment, double climb_rate, uint digits) {
      gtk_spin_button_configure(&this, adjustment, climb_rate, digits);
   }

   // Get the adjustment associated with a #GtkSpinButton
   // RETURNS: the #GtkAdjustment of @spin_button
   Adjustment* get_adjustment() {
      return gtk_spin_button_get_adjustment(&this);
   }

   // Fetches the precision of @spin_button. See gtk_spin_button_set_digits().
   // RETURNS: the current precision
   uint get_digits() {
      return gtk_spin_button_get_digits(&this);
   }

   // Gets the current step and page the increments used by @spin_button. See
   // gtk_spin_button_set_increments().
   // <step>: location to store step increment, or %NULL
   // <page>: location to store page increment, or %NULL
   void get_increments(/*out*/ double* step=null, /*out*/ double* page=null) {
      gtk_spin_button_get_increments(&this, step, page);
   }

   // Returns whether non-numeric text can be typed into the spin button.
   // See gtk_spin_button_set_numeric().
   // RETURNS: %TRUE if only numeric text can be entered
   int get_numeric() {
      return gtk_spin_button_get_numeric(&this);
   }

   // Gets the range allowed for @spin_button. See
   // gtk_spin_button_set_range().
   // <min>: location to store minimum allowed value, or %NULL
   // <max>: location to store maximum allowed value, or %NULL
   void get_range(/*out*/ double* min=null, /*out*/ double* max=null) {
      gtk_spin_button_get_range(&this, min, max);
   }

   // Returns whether the values are corrected to the nearest step. See
   // gtk_spin_button_set_snap_to_ticks().
   // RETURNS: %TRUE if values are snapped to the nearest step.
   int get_snap_to_ticks() {
      return gtk_spin_button_get_snap_to_ticks(&this);
   }

   // Gets the update behavior of a spin button. See
   // gtk_spin_button_set_update_policy().
   // RETURNS: the current update policy
   SpinButtonUpdatePolicy get_update_policy() {
      return gtk_spin_button_get_update_policy(&this);
   }

   // Get the value in the @spin_button.
   // RETURNS: the value of @spin_button
   double get_value() {
      return gtk_spin_button_get_value(&this);
   }

   // Get the value @spin_button represented as an integer.
   // RETURNS: the value of @spin_button
   int get_value_as_int() {
      return gtk_spin_button_get_value_as_int(&this);
   }

   // Returns whether the spin button's value wraps around to the
   // opposite limit when the upper or lower limit of the range is
   // exceeded. See gtk_spin_button_set_wrap().
   // RETURNS: %TRUE if the spin button wraps around
   int get_wrap() {
      return gtk_spin_button_get_wrap(&this);
   }

   // Replaces the #GtkAdjustment associated with @spin_button.
   // <adjustment>: a #GtkAdjustment to replace the existing adjustment
   void set_adjustment(Adjustment* adjustment) {
      gtk_spin_button_set_adjustment(&this, adjustment);
   }

   // Set the precision to be displayed by @spin_button. Up to 20 digit precision
   // is allowed.
   // <digits>: the number of digits after the decimal point to be displayed for the spin button's value
   void set_digits(uint digits) {
      gtk_spin_button_set_digits(&this, digits);
   }

   // Sets the step and page increments for spin_button.  This affects how 
   // quickly the value changes when the spin button's arrows are activated.
   // <step>: increment applied for a button 1 press.
   // <page>: increment applied for a button 2 press.
   void set_increments(double step, double page) {
      gtk_spin_button_set_increments(&this, step, page);
   }

   // Sets the flag that determines if non-numeric text can be typed into
   // the spin button.
   // <numeric>: flag indicating if only numeric entry is allowed.
   void set_numeric(int numeric) {
      gtk_spin_button_set_numeric(&this, numeric);
   }

   // Sets the minimum and maximum allowable values for @spin_button
   // <min>: minimum allowable value
   // <max>: maximum allowable value
   void set_range(double min, double max) {
      gtk_spin_button_set_range(&this, min, max);
   }

   // Sets the policy as to whether values are corrected to the nearest step 
   // increment when a spin button is activated after providing an invalid value.
   // <snap_to_ticks>: a flag indicating if invalid values should be corrected.
   void set_snap_to_ticks(int snap_to_ticks) {
      gtk_spin_button_set_snap_to_ticks(&this, snap_to_ticks);
   }

   // Sets the update behavior of a spin button. This determines whether the
   // spin button is always updated or only when a valid value is set.
   // <policy>: a #GtkSpinButtonUpdatePolicy value
   void set_update_policy(SpinButtonUpdatePolicy policy) {
      gtk_spin_button_set_update_policy(&this, policy);
   }

   // Set the value of @spin_button.
   // <value>: the new value
   void set_value(double value) {
      gtk_spin_button_set_value(&this, value);
   }

   // Sets the flag that determines if a spin button value wraps around to the
   // opposite limit when the upper or lower limit of the range is exceeded.
   // <wrap>: a flag indicating if wrapping behavior is performed.
   void set_wrap(int wrap) {
      gtk_spin_button_set_wrap(&this, wrap);
   }

   // Increment or decrement a spin button's value in a specified direction
   // by a specified amount.
   // <direction>: a #GtkSpinType indicating the direction to spin.
   // <increment>: step increment to apply in the specified direction.
   void spin(SpinType direction, double increment) {
      gtk_spin_button_spin(&this, direction, increment);
   }
   // Manually force an update of the spin button.
   void update() {
      gtk_spin_button_update(&this);
   }
   extern (C) alias static void function (SpinButton* this_, ScrollType* object, void* user_data=null) signal_change_value;

   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:"change-value", CB/*:signal_change_value*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"change-value",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static int function (SpinButton* this_, void* object, void* user_data=null) signal_input;
   ulong signal_connect(string name:"input", CB/*:signal_input*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"input",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::output signal can be used to change to formatting
   // of the value that is displayed in the spin buttons entry.
   // |[
   // /&ast; show leading zeros &ast;/
   // static gboolean
   // on_output (GtkSpinButton *spin,
   // gpointer       data)
   // {
   // GtkAdjustment *adj;
   // gchar *text;
   // int value;
   // adj = gtk_spin_button_get_adjustment (spin);
   // value = (int)gtk_adjustment_get_value (adj);
   // text = g_strdup_printf ("%02d", value);
   // gtk_entry_set_text (GTK_ENTRY (spin), text);
   // g_free (text);
   // return TRUE;
   // }
   // ]|
   // RETURNS: %TRUE if the value has been displayed.
   extern (C) alias static c_int function (SpinButton* this_, void* user_data=null) signal_output;
   ulong signal_connect(string name:"output", CB/*:signal_output*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"output",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (SpinButton* this_, void* user_data=null) signal_value_changed;
   ulong signal_connect(string name:"value-changed", CB/*:signal_value_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"value-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The wrapped signal is emitted right after the spinbutton wraps
   // from its maximum to minimum value or vice-versa.
   extern (C) alias static void function (SpinButton* this_, void* user_data=null) signal_wrapped;
   ulong signal_connect(string name:"wrapped", CB/*:signal_wrapped*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"wrapped",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct SpinButtonClass {
   EntryClass parent_class;
   extern (C) int function (SpinButton* spin_button, double* new_value) input;
   extern (C) int function (SpinButton* spin_button) output;
   extern (C) void function (SpinButton* spin_button) value_changed;
   extern (C) void function (SpinButton* spin_button, ScrollType scroll) change_value;
   extern (C) void function (SpinButton* spin_button) wrapped;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

enum SpinButtonUpdatePolicy {
   ALWAYS = 0,
   IF_VALID = 1
}
enum SpinType {
   STEP_FORWARD = 0,
   STEP_BACKWARD = 1,
   PAGE_FORWARD = 2,
   PAGE_BACKWARD = 3,
   HOME = 4,
   END = 5,
   USER_DEFINED = 6
}

// A GtkSpinner widget displays an icon-size spinning animation.
// It is often used as an alternative to a #GtkProgressBar for
// displaying indefinite activity, instead of actual progress.
// To start the animation, use gtk_spinner_start(), to stop it
// use gtk_spinner_stop().
struct Spinner /* : DrawingArea */ {
   alias parent this;
   alias parent super_;
   alias parent drawingarea;
   DrawingArea parent;
   SpinnerPrivate* priv;


   // Returns a new spinner widget. Not yet started.
   // RETURNS: a new #GtkSpinner
   static Spinner* new_() {
      return gtk_spinner_new();
   }
   // Starts the animation of the spinner.
   void start() {
      gtk_spinner_start(&this);
   }
   // Stops the animation of the spinner.
   void stop() {
      gtk_spinner_stop(&this);
   }
}

struct SpinnerClass {
   DrawingAreaClass parent_class;
}

struct SpinnerPrivate {
}

enum StateType {
   NORMAL = 0,
   ACTIVE = 1,
   PRELIGHT = 2,
   SELECTED = 3,
   INSENSITIVE = 4
}
struct StatusIcon /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   StatusIconPrivate* priv;


   // Creates an empty status icon object.
   // RETURNS: a new #GtkStatusIcon
   static StatusIcon* /*new*/ new_() {
      return gtk_status_icon_new();
   }

   // Creates a status icon displaying the file @filename. 
   // The image will be scaled down to fit in the available 
   // space in the notification area, if necessary.
   // RETURNS: a new #GtkStatusIcon
   // <filename>: a filename
   static StatusIcon* /*new*/ new_from_file(char* filename) {
      return gtk_status_icon_new_from_file(filename);
   }

   // Creates a status icon displaying a #GIcon. If the icon is a
   // themed icon, it will be updated when the theme changes.
   // RETURNS: a new #GtkStatusIcon
   // <icon>: a #GIcon
   static StatusIcon* /*new*/ new_from_gicon(Gio2.Icon* icon) {
      return gtk_status_icon_new_from_gicon(icon);
   }

   // Creates a status icon displaying an icon from the current icon theme.
   // If the current icon theme is changed, the icon will be updated 
   // appropriately.
   // RETURNS: a new #GtkStatusIcon
   // <icon_name>: an icon name
   static StatusIcon* /*new*/ new_from_icon_name(char* icon_name) {
      return gtk_status_icon_new_from_icon_name(icon_name);
   }

   // Creates a status icon displaying @pixbuf. 
   // The image will be scaled down to fit in the available 
   // space in the notification area, if necessary.
   // RETURNS: a new #GtkStatusIcon
   // <pixbuf>: a #GdkPixbuf
   static StatusIcon* /*new*/ new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf) {
      return gtk_status_icon_new_from_pixbuf(pixbuf);
   }

   // Creates a status icon displaying a stock icon. Sample stock icon
   // names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. You can register your 
   // own stock icon names, see gtk_icon_factory_add_default() and 
   // gtk_icon_factory_add().
   // RETURNS: a new #GtkStatusIcon
   // <stock_id>: a stock icon id
   static StatusIcon* /*new*/ new_from_stock(char* stock_id) {
      return gtk_status_icon_new_from_stock(stock_id);
   }

   // Menu positioning function to use with gtk_menu_popup()
   // to position @menu aligned to the status icon @user_data.
   // <menu>: the #GtkMenu
   // <x>: return location for the x position
   // <y>: return location for the y position
   // <push_in>: whether the first menu item should be offset (pushed in) to be aligned with the menu popup position (only useful for GtkOptionMenu).
   // <user_data>: the status icon to position the menu on
   static void position_menu(Menu* menu, int* x, int* y, int* push_in, void* user_data) {
      gtk_status_icon_position_menu(menu, x, y, push_in, user_data);
   }

   // Returns whether the icon is blinking, see 
   // gtk_status_icon_set_blinking().
   // RETURNS: %TRUE if the icon is blinking
   int get_blinking() {
      return gtk_status_icon_get_blinking(&this);
   }

   // Obtains information about the location of the status icon
   // on screen. This information can be used to e.g. position 
   // popups like notification bubbles. 
   // See gtk_status_icon_position_menu() for a more convenient 
   // alternative for positioning menus.
   // Note that some platforms do not allow GTK+ to provide 
   // this information, and even on platforms that do allow it,
   // the information is not reliable unless the status icon
   // is embedded in a notification area, see
   // gtk_status_icon_is_embedded().
   // been filled in
   // RETURNS: %TRUE if the location information has
   // <screen>: return location for the screen, or %NULL if the information is not needed
   // <area>: return location for the area occupied by the status icon, or %NULL
   // <orientation>: return location for the orientation of the panel in which the status icon is embedded, or %NULL. A panel at the top or bottom of the screen is horizontal, a panel at the left or right is vertical.
   int get_geometry(/*out*/ Gdk2.Screen** screen=null, /*out*/ Gdk2.Rectangle* area=null, /*out*/ Orientation* orientation=null) {
      return gtk_status_icon_get_geometry(&this, screen, area, orientation);
   }

   // Retrieves the #GIcon being displayed by the #GtkStatusIcon.
   // The storage type of the status icon must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_GICON (see gtk_status_icon_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned #GIcon.
   // If this function fails, @icon is left unchanged;
   // RETURNS: the displayed icon, or %NULL if the image is empty
   Gio2.Icon* get_gicon() {
      return gtk_status_icon_get_gicon(&this);
   }

   // Returns the current value of the has-tooltip property.
   // See #GtkStatusIcon:has-tooltip for more information.
   // RETURNS: current value of has-tooltip on @status_icon.
   int get_has_tooltip() {
      return gtk_status_icon_get_has_tooltip(&this);
   }

   // Gets the name of the icon being displayed by the #GtkStatusIcon.
   // The storage type of the status icon must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_ICON_NAME (see gtk_status_icon_get_storage_type()).
   // The returned string is owned by the #GtkStatusIcon and should not
   // be freed or modified.
   // RETURNS: name of the displayed icon, or %NULL if the image is empty.
   char* get_icon_name() {
      return gtk_status_icon_get_icon_name(&this);
   }

   // Gets the #GdkPixbuf being displayed by the #GtkStatusIcon.
   // The storage type of the status icon must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_PIXBUF (see gtk_status_icon_get_storage_type()).
   // The caller of this function does not own a reference to the
   // returned pixbuf.
   // or %NULL if the image is empty.
   // RETURNS: the displayed pixbuf,
   GdkPixbuf2.Pixbuf* get_pixbuf() {
      return gtk_status_icon_get_pixbuf(&this);
   }

   // Returns the #GdkScreen associated with @status_icon.
   // RETURNS: a #GdkScreen.
   Gdk2.Screen* get_screen() {
      return gtk_status_icon_get_screen(&this);
   }

   // Gets the size in pixels that is available for the image. 
   // Stock icons and named icons adapt their size automatically
   // if the size of the notification area changes. For other
   // storage types, the size-changed signal can be used to
   // react to size changes.
   // Note that the returned size is only meaningful while the 
   // status icon is embedded (see gtk_status_icon_is_embedded()).
   // RETURNS: the size that is available for the image
   int get_size() {
      return gtk_status_icon_get_size(&this);
   }

   // Gets the id of the stock icon being displayed by the #GtkStatusIcon.
   // The storage type of the status icon must be %GTK_IMAGE_EMPTY or
   // %GTK_IMAGE_STOCK (see gtk_status_icon_get_storage_type()).
   // The returned string is owned by the #GtkStatusIcon and should not
   // be freed or modified.
   // or %NULL if the image is empty.
   // RETURNS: stock id of the displayed stock icon,
   char* get_stock() {
      return gtk_status_icon_get_stock(&this);
   }

   // Gets the type of representation being used by the #GtkStatusIcon
   // to store image data. If the #GtkStatusIcon has no image data,
   // the return value will be %GTK_IMAGE_EMPTY.
   // RETURNS: the image representation being used
   ImageType get_storage_type() {
      return gtk_status_icon_get_storage_type(&this);
   }

   // Gets the title of this tray icon. See gtk_status_icon_set_title().
   // RETURNS: the title of the status icon
   char* get_title() {
      return gtk_status_icon_get_title(&this);
   }

   // Gets the contents of the tooltip for @status_icon.
   // returned string with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. You should free the
   char* /*new*/ get_tooltip_markup() {
      return gtk_status_icon_get_tooltip_markup(&this);
   }

   // Gets the contents of the tooltip for @status_icon.
   // returned string with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. You should free the
   char* /*new*/ get_tooltip_text() {
      return gtk_status_icon_get_tooltip_text(&this);
   }

   // Returns whether the status icon is visible or not. 
   // Note that being visible does not guarantee that 
   // the user can actually see the icon, see also 
   // gtk_status_icon_is_embedded().
   // RETURNS: %TRUE if the status icon is visible
   int get_visible() {
      return gtk_status_icon_get_visible(&this);
   }

   // This function is only useful on the X11/freedesktop.org platform.
   // It returns a window ID for the widget in the underlying
   // status icon implementation.  This is useful for the Galago 
   // notification service, which can send a window ID in the protocol 
   // in order for the server to position notification windows 
   // pointing to a status icon reliably.
   // This function is not intended for other use cases which are
   // more likely to be met by one of the non-X11 specific methods, such
   // as gtk_status_icon_position_menu().
   // underlying X11 Window
   // RETURNS: An 32 bit unsigned integer identifier for the
   uint get_x11_window_id() {
      return gtk_status_icon_get_x11_window_id(&this);
   }

   // Returns whether the status icon is embedded in a notification
   // area. 
   // a notification area.
   // RETURNS: %TRUE if the status icon is embedded in
   int is_embedded() {
      return gtk_status_icon_is_embedded(&this);
   }

   // Makes the status icon start or stop blinking. 
   // Note that blinking user interface elements may be problematic
   // for some users, and thus may be turned off, in which case
   // this setting has no effect.
   // <blinking>: %TRUE to turn blinking on, %FALSE to turn it off
   void set_blinking(int blinking) {
      gtk_status_icon_set_blinking(&this, blinking);
   }

   // Makes @status_icon display the file @filename.
   // See gtk_status_icon_new_from_file() for details.
   // <filename>: a filename
   void set_from_file(char* filename) {
      gtk_status_icon_set_from_file(&this, filename);
   }

   // Makes @status_icon display the #GIcon.
   // See gtk_status_icon_new_from_gicon() for details.
   // <icon>: a GIcon
   void set_from_gicon(Gio2.Icon* icon) {
      gtk_status_icon_set_from_gicon(&this, icon);
   }

   // Makes @status_icon display the icon named @icon_name from the 
   // current icon theme.
   // See gtk_status_icon_new_from_icon_name() for details.
   // <icon_name>: an icon name
   void set_from_icon_name(char* icon_name) {
      gtk_status_icon_set_from_icon_name(&this, icon_name);
   }

   // Makes @status_icon display @pixbuf.
   // See gtk_status_icon_new_from_pixbuf() for details.
   // <pixbuf>: a #GdkPixbuf or %NULL
   void set_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_status_icon_set_from_pixbuf(&this, pixbuf);
   }

   // Makes @status_icon display the stock icon with the id @stock_id.
   // See gtk_status_icon_new_from_stock() for details.
   // <stock_id>: a stock icon id
   void set_from_stock(char* stock_id) {
      gtk_status_icon_set_from_stock(&this, stock_id);
   }

   // Sets the has-tooltip property on @status_icon to @has_tooltip.
   // See #GtkStatusIcon:has-tooltip for more information.
   // <has_tooltip>: whether or not @status_icon has a tooltip
   void set_has_tooltip(int has_tooltip) {
      gtk_status_icon_set_has_tooltip(&this, has_tooltip);
   }

   // Sets the name of this tray icon.
   // This should be a string identifying this icon. It is may be
   // used for sorting the icons in the tray and will not be shown to
   // the user.
   // <name>: the name
   void set_name(char* name) {
      gtk_status_icon_set_name(&this, name);
   }

   // Sets the #GdkScreen where @status_icon is displayed; if
   // the icon is already mapped, it will be unmapped, and
   // then remapped on the new screen.
   // <screen>: a #GdkScreen
   void set_screen(Gdk2.Screen* screen) {
      gtk_status_icon_set_screen(&this, screen);
   }

   // Sets the title of this tray icon.
   // This should be a short, human-readable, localized string 
   // describing the tray icon. It may be used by tools like screen
   // readers to render the tray icon.
   // <title>: the title
   void set_title(char* title) {
      gtk_status_icon_set_title(&this, title);
   }

   // Sets the tooltip of the status icon.
   // <tooltip_text>: the tooltip text, or %NULL
   void set_tooltip(char* tooltip_text=null) {
      gtk_status_icon_set_tooltip(&this, tooltip_text);
   }

   // Sets @markup as the contents of the tooltip, which is marked up with
   // the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
   // This function will take care of setting #GtkStatusIcon:has-tooltip to %TRUE
   // and of the default handler for the #GtkStatusIcon::query-tooltip signal.
   // See also the #GtkStatusIcon:tooltip-markup property and
   // gtk_tooltip_set_markup().
   // <markup>: the contents of the tooltip for @status_icon, or %NULL
   void set_tooltip_markup(char* markup=null) {
      gtk_status_icon_set_tooltip_markup(&this, markup);
   }

   // Sets @text as the contents of the tooltip.
   // This function will take care of setting #GtkStatusIcon:has-tooltip to
   // %TRUE and of the default handler for the #GtkStatusIcon::query-tooltip
   // signal.
   // See also the #GtkStatusIcon:tooltip-text property and
   // gtk_tooltip_set_text().
   // <text>: the contents of the tooltip for @status_icon
   void set_tooltip_text(char* text) {
      gtk_status_icon_set_tooltip_text(&this, text);
   }

   // Shows or hides a status icon.
   // <visible>: %TRUE to show the status icon, %FALSE to hide it
   void set_visible(int visible) {
      gtk_status_icon_set_visible(&this, visible);
   }

   // Gets emitted when the user activates the status icon. 
   // If and how status icons can activated is platform-dependent.
   // Unlike most G_SIGNAL_ACTION signals, this signal is meant to 
   // be used by applications and should be wrapped by language bindings.
   extern (C) alias static void function (StatusIcon* this_, 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);
   }

   // The ::button-press-event signal will be emitted when a button
   // (typically from a mouse) is pressed.
   // Whether this event is emitted is platform-dependent.  Use the ::activate
   // and ::popup-menu signals in preference.
   // for the event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked
   // <event>: the #GdkEventButton which triggered this signal
   extern (C) alias static c_int function (StatusIcon* this_, Gdk2.Event* event, void* user_data=null) signal_button_press_event;
   ulong signal_connect(string name:"button-press-event", CB/*:signal_button_press_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"button-press-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::button-release-event signal will be emitted when a button
   // (typically from a mouse) is released.
   // Whether this event is emitted is platform-dependent.  Use the ::activate
   // and ::popup-menu signals in preference.
   // for the event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked
   // <event>: the #GdkEventButton which triggered this signal
   extern (C) alias static c_int function (StatusIcon* this_, Gdk2.Event* event, void* user_data=null) signal_button_release_event;
   ulong signal_connect(string name:"button-release-event", CB/*:signal_button_release_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"button-release-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when the user brings up the context menu
   // of the status icon. Whether status icons can have context 
   // menus and how these are activated is platform-dependent.
   // The @button and @activate_time parameters should be 
   // passed as the last to arguments to gtk_menu_popup().
   // Unlike most G_SIGNAL_ACTION signals, this signal is meant to 
   // be used by applications and should be wrapped by language bindings.
   // <button>: the button that was pressed, or 0 if the signal is not emitted in response to a button press event
   // <activate_time>: the timestamp of the event that triggered the signal emission
   extern (C) alias static void function (StatusIcon* this_, c_uint button, c_uint activate_time, void* user_data=null) signal_popup_menu;
   ulong signal_connect(string name:"popup-menu", CB/*:signal_popup_menu*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popup-menu",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the #GtkSettings:gtk-tooltip-timeout has expired with the
   // cursor hovering above @status_icon; or emitted when @status_icon got
   // focus in keyboard mode.
   // Using the given coordinates, the signal handler should determine
   // whether a tooltip should be shown for @status_icon. If this is
   // the case %TRUE should be returned, %FALSE otherwise. Note that if
   // should not be used.
   // The signal handler is free to manipulate @tooltip with the therefore
   // destined function calls.
   // Whether this signal is emitted is platform-dependent.
   // For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference.
   // RETURNS: %TRUE if @tooltip should be shown right now, %FALSE otherwise.
   // <x>: the x coordinate of the cursor position where the request has been emitted, relative to @status_icon
   // <y>: the y coordinate of the cursor position where the request has been emitted, relative to @status_icon
   // <keyboard_mode>: %TRUE if the tooltip was trigged using the keyboard
   // <tooltip>: a #GtkTooltip
   extern (C) alias static c_int function (StatusIcon* this_, int x, int y, c_int keyboard_mode, Tooltip* tooltip, void* user_data=null) signal_query_tooltip;
   ulong signal_connect(string name:"query-tooltip", CB/*:signal_query_tooltip*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"query-tooltip",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::scroll-event signal is emitted when a button in the 4 to 7
   // range is pressed. Wheel mice are usually configured to generate 
   // button press events for buttons 4 and 5 when the wheel is turned.
   // Whether this event is emitted is platform-dependent.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventScroll which triggered this signal
   extern (C) alias static c_int function (StatusIcon* this_, Gdk2.Event* event, void* user_data=null) signal_scroll_event;
   ulong signal_connect(string name:"scroll-event", CB/*:signal_scroll_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted when the size available for the image
   // changes, e.g. because the notification area got resized.
   // size. Otherwise, GTK+ will scale the icon as necessary.
   // RETURNS: %TRUE if the icon was updated for the new
   // <size>: the new size
   extern (C) alias static c_int function (StatusIcon* this_, int size, void* user_data=null) signal_size_changed;
   ulong signal_connect(string name:"size-changed", CB/*:signal_size_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"size-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct StatusIconClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (StatusIcon* status_icon) activate;
   extern (C) void function (StatusIcon* status_icon, uint button, uint activate_time) popup_menu;
   extern (C) int function (StatusIcon* status_icon, int size) size_changed;
   extern (C) int function (StatusIcon* status_icon, Gdk2.EventButton* event) button_press_event;
   extern (C) int function (StatusIcon* status_icon, Gdk2.EventButton* event) button_release_event;
   extern (C) int function (StatusIcon* status_icon, Gdk2.EventScroll* event) scroll_event;
   extern (C) int function (StatusIcon* status_icon, int x, int y, int keyboard_mode, Tooltip* tooltip) query_tooltip;
   void* __gtk_reserved1, __gtk_reserved2;
}

struct StatusIconPrivate {
}

struct Statusbar /* : HBox */ {
   alias parent_widget this;
   alias parent_widget super_;
   alias parent_widget hbox;
   HBox parent_widget;
   Widget* frame, label;
   GLib2.SList* messages, keys;
   uint seq_context_id, seq_message_id;
   Gdk2.Window* grip_window;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "has_resize_grip", 1,
    uint, "__dummy32A", 31));


   // Creates a new #GtkStatusbar ready for messages.
   // RETURNS: the new #GtkStatusbar
   static Statusbar* new_() {
      return gtk_statusbar_new();
   }

   // Returns a new context identifier, given a description 
   // of the actual context. Note that the description is 
   // <emphasis>not</emphasis> shown in the UI.
   // RETURNS: an integer id
   // <context_description>: textual description of what context the new message is being used in
   uint get_context_id(char* context_description) {
      return gtk_statusbar_get_context_id(&this, context_description);
   }

   // Returns whether the statusbar has a resize grip.
   // RETURNS: %TRUE if the statusbar has a resize grip.
   int get_has_resize_grip() {
      return gtk_statusbar_get_has_resize_grip(&this);
   }

   // Retrieves the box containing the label widget.
   // RETURNS: a #GtkBox
   Widget* get_message_area() {
      return gtk_statusbar_get_message_area(&this);
   }

   // Removes the first message in the #GtkStatusBar's stack
   // with the given context id. 
   // Note that this may not change the displayed message, if 
   // the message at the top of the stack has a different 
   // context id.
   // <context_id>: a context identifier
   void pop(uint context_id) {
      gtk_statusbar_pop(&this, context_id);
   }

   // Pushes a new message onto a statusbar's stack.
   // gtk_statusbar_remove().
   // RETURNS: a message id that can be used with
   // <context_id>: the message's context id, as returned by gtk_statusbar_get_context_id()
   // <text>: the message to add to the statusbar
   uint push(uint context_id, char* text) {
      return gtk_statusbar_push(&this, context_id, text);
   }

   // Forces the removal of a message from a statusbar's stack. 
   // The exact @context_id and @message_id must be specified.
   // <context_id>: a context identifier
   // <message_id>: a message identifier, as returned by gtk_statusbar_push()
   void remove(uint context_id, uint message_id) {
      gtk_statusbar_remove(&this, context_id, message_id);
   }

   // Forces the removal of all messages from a statusbar's
   // stack with the exact @context_id.
   // <context_id>: a context identifier
   void remove_all(uint context_id) {
      gtk_statusbar_remove_all(&this, context_id);
   }

   // Sets whether the statusbar has a resize grip. 
   // %TRUE by default.
   // <setting>: %TRUE to have a resize grip
   void set_has_resize_grip(int setting) {
      gtk_statusbar_set_has_resize_grip(&this, setting);
   }

   // Is emitted whenever a new message is popped off a statusbar's stack.
   // <context_id>: the context id of the relevant message/statusbar.
   // <text>: the message that was just popped.
   extern (C) alias static void function (Statusbar* this_, c_uint context_id, char* text, void* user_data=null) signal_text_popped;

   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:"text-popped", CB/*:signal_text_popped*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"text-popped",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Is emitted whenever a new message gets pushed onto a statusbar's stack.
   // <context_id>: the context id of the relevant message/statusbar.
   // <text>: the message that was pushed.
   extern (C) alias static void function (Statusbar* this_, c_uint context_id, char* text, void* user_data=null) signal_text_pushed;
   ulong signal_connect(string name:"text-pushed", CB/*:signal_text_pushed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"text-pushed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct StatusbarClass {
   HBoxClass parent_class;
   void* reserved;
   extern (C) void function (Statusbar* statusbar, uint context_id, char* text) text_pushed;
   extern (C) void function (Statusbar* statusbar, uint context_id, char* text) text_popped;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct StockItem {
   char* stock_id, label;
   Gdk2.ModifierType modifier;
   uint keyval;
   char* translation_domain;


   // Unintrospectable method: copy() / gtk_stock_item_copy()
   // Copies a stock item, mostly useful for language bindings and not in applications.
   // RETURNS: a new #GtkStockItem
   StockItem* copy() {
      return gtk_stock_item_copy(&this);
   }

   // Frees a stock item allocated on the heap, such as one returned by
   // gtk_stock_item_copy(). Also frees the fields inside the stock item,
   // if they are not %NULL.
   void free() {
      gtk_stock_item_free(&this);
   }
}

struct Style /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   Gdk2.Color[5] fg, bg, light, dark, mid, text, base, text_aa;
   Gdk2.Color black, white;
   Pango.FontDescription* font_desc;
   int xthickness, ythickness;
   Gdk2.GC*[5] fg_gc, bg_gc, light_gc, dark_gc, mid_gc, text_gc, base_gc, text_aa_gc;
   Gdk2.GC* black_gc, white_gc;
   Gdk2.Pixmap*[5] bg_pixmap;
   private int attach_count, depth;
   private Gdk2.Colormap* colormap;
   private Gdk2.Font* private_font;
   private Pango.FontDescription* private_font_desc;
   private RcStyle* rc_style;
   private GLib2.SList* styles;
   private void*[0] property_cache;
   private GLib2.SList* icon_factories;


   // Creates a new #GtkStyle.
   // RETURNS: a new #GtkStyle.
   static Style* /*new*/ new_() {
      return gtk_style_new();
   }
   void apply_default_background(Gdk2.Window* window, int set_bg, StateType state_type, Gdk2.Rectangle* area, int x, int y, int width, int height) {
      gtk_style_apply_default_background(&this, window, set_bg, state_type, area, x, y, width, height);
   }

   // Unintrospectable method: attach() / gtk_style_attach()
   // Attaches a style to a window; this process allocates the
   // colors and creates the GC's for the style - it specializes
   // it to a particular visual and colormap. The process may
   // involve the creation of a new style if the style has already
   // been attached to a window with a different style and colormap.
   // Since this function may return a new object, you have to use it
   // in the following way:
   // <literal>style = gtk_style_attach (style, window)</literal>
   // If the style is newly created, the style parameter
   // will be unref'ed, and the new style will have
   // a reference count belonging to the caller.
   // RETURNS: Either @style, or a newly-created #GtkStyle.
   // <window>: a #GdkWindow.
   Style* attach(Gdk2.Window* window) {
      return gtk_style_attach(&this, window);
   }

   // Creates a copy of the passed in #GtkStyle object.
   // RETURNS: a copy of @style
   Style* /*new*/ copy() {
      return gtk_style_copy(&this);
   }

   // Detaches a style from a window. If the style is not attached
   // to any windows anymore, it is unrealized. See gtk_style_attach().
   void detach() {
      gtk_style_detach(&this);
   }

   // Unintrospectable method: get() / gtk_style_get()
   // Gets the values of a multiple style properties for @widget_type
   // from @style.
   // <widget_type>: the #GType of a descendant of #GtkWidget
   // <first_property_name>: the name of the first style property to get
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_style_get get; // Variadic
   +/

   // Gets the #GdkFont to use for the given style. This is
   // meant only as a replacement for direct access to @style->font
   // and should not be used in new code. New code should
   // use @style->font_desc instead.
   // by the style; if you want to keep around a copy, you must
   // call gdk_font_ref().
   // RETURNS: the #GdkFont for the style. This font is owned
   Gdk2.Font* /*new*/ get_font() {
      return gtk_style_get_font(&this);
   }

   // Queries the value of a style property corresponding to a
   // widget class is in the given style.
   // <widget_type>: the #GType of a descendant of #GtkWidget
   // <property_name>: the name of the style property to get
   // <value>: a #GValue where the value of the property being queried will be stored
   void get_style_property(Type widget_type, char* property_name, GObject2.Value* value) {
      gtk_style_get_style_property(&this, widget_type, property_name, value);
   }

   // Unintrospectable method: get_valist() / gtk_style_get_valist()
   // Non-vararg variant of gtk_style_get().
   // Used primarily by language bindings.
   // <widget_type>: the #GType of a descendant of #GtkWidget
   // <first_property_name>: the name of the first style property to get
   // <var_args>: a <type>va_list</type> of pairs of property names and locations to return the property values, starting with the location for @first_property_name.
   void get_valist(Type widget_type, char* first_property_name, va_list var_args) {
      gtk_style_get_valist(&this, widget_type, first_property_name, var_args);
   }

   // Looks up @color_name in the style's logical color mappings,
   // filling in @color and returning %TRUE if found, otherwise
   // returning %FALSE. Do not cache the found mapping, because
   // it depends on the #GtkStyle and might change when a theme
   // switch occurs.
   // RETURNS: %TRUE if the mapping was found.
   // <color_name>: the name of the logical color to look up
   // <color>: the #GdkColor to fill in
   int lookup_color(char* color_name, /*out*/ Gdk2.Color* color) {
      return gtk_style_lookup_color(&this, color_name, color);
   }

   // Looks up @stock_id in the icon factories associated with @style
   // and the default icon factory, returning an icon set if found,
   // otherwise %NULL.
   // RETURNS: icon set of @stock_id
   // <stock_id>: an icon name
   IconSet* lookup_icon_set(char* stock_id) {
      return gtk_style_lookup_icon_set(&this, stock_id);
   }

   // Unintrospectable method: ref() / gtk_style_ref()
   // Increase the reference count of @style.
   // RETURNS: @style.
   Style* ref_() {
      return gtk_style_ref(&this);
   }

   // Renders the icon specified by @source at the given @size
   // according to the given parameters and returns the result in a
   // pixbuf.
   // containing the rendered icon
   // RETURNS: a newly-created #GdkPixbuf
   // <source>: the #GtkIconSource specifying the icon to render
   // <direction>: a text direction
   // <state>: a state
   // <size>: (type int) the size to render the icon at. A size of (GtkIconSize)-1 means render at the size of the source and don't scale.
   // <widget>: the widget
   // <detail>: a style detail
   GdkPixbuf2.Pixbuf* /*new*/ render_icon(IconSource* source, TextDirection direction, StateType state, IconSize size, Widget* widget=null, char* detail=null) {
      return gtk_style_render_icon(&this, source, direction, state, size, widget, detail);
   }

   // Sets the background of @window to the background color or pixmap
   // specified by @style for the given state.
   // <window>: a #GdkWindow
   // <state_type>: a state
   void set_background(Gdk2.Window* window, StateType state_type) {
      gtk_style_set_background(&this, window, state_type);
   }

   // Sets the #GdkFont to use for a given style. This is
   // meant only as a replacement for direct access to style->font
   // and should not be used in new code. New code should
   // use style->font_desc instead.
   // <font>: a #GdkFont, or %NULL to use the #GdkFont corresponding to style->font_desc.
   void set_font(Gdk2.Font* font=null) {
      gtk_style_set_font(&this, font);
   }
   // Decrease the reference count of @style.
   void unref() {
      gtk_style_unref(&this);
   }

   // Emitted when the style has been initialized for a particular
   // colormap and depth. Connecting to this signal is probably seldom
   // useful since most of the time applications and widgets only
   // deal with styles that have been already realized.
   extern (C) alias static void function (Style* this_, void* user_data=null) signal_realize;

   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:"realize", CB/*:signal_realize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"realize",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the aspects of the style specific to a particular colormap
   // and depth are being cleaned up. A connection to this signal can be useful
   // if a widget wants to cache objects like a #GdkGC as object data on #GtkStyle.
   // This signal provides a convenient place to free such cached objects.
   extern (C) alias static void function (Style* this_, void* user_data=null) signal_unrealize;
   ulong signal_connect(string name:"unrealize", CB/*:signal_unrealize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unrealize",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct StyleClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (Style* style) realize;
   extern (C) void function (Style* style) unrealize;
   extern (C) void function (Style* style, Style* src) copy;
   // Unintrospectable functionp: clone() / ()
   extern (C) Style* function (Style* style) clone;
   extern (C) void function (Style* style, RcStyle* rc_style) init_from_rc;

   // <window>: a #GdkWindow
   // <state_type>: a state
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type) set_background;

   // RETURNS: a newly-created #GdkPixbuf
   // <source>: the #GtkIconSource specifying the icon to render
   // <direction>: a text direction
   // <state>: a state
   // <size>: (type int) the size to render the icon at. A size of (GtkIconSize)-1 means render at the size of the source and don't scale.
   // <widget>: the widget
   // <detail>: a style detail
   extern (C) GdkPixbuf2.Pixbuf* /*new*/ function (Style* style, IconSource* source, TextDirection direction, StateType state, IconSize size, Widget* widget=null, char* detail=null) render_icon;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x1, int x2, int y) draw_hline;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int y1_, int y2_, int x) draw_vline;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_shadow;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.Point* point, int npoints, int fill) draw_polygon;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, ArrowType arrow_type, int fill, int x, int y, int width, int height) draw_arrow;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_diamond;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, char* string_) draw_string;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_box;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_flat_box;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_check;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_option;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_tab;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) draw_shadow_gap;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) draw_box_gap;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side) draw_extension;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) draw_focus;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation) draw_slider;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation) draw_handle;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, ExpanderStyle expander_style) draw_expander;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, int use_text, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, Pango.Layout* layout) draw_layout;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.WindowEdge edge, int x, int y, int width, int height) draw_resize_grip;
   extern (C) void function (Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, uint step, int x, int y, int width, int height) draw_spinner;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
   extern (C) void function () _gtk_reserved7;
   extern (C) void function () _gtk_reserved8;
   extern (C) void function () _gtk_reserved9;
   extern (C) void function () _gtk_reserved10;
   extern (C) void function () _gtk_reserved11;
}

enum SubmenuDirection {
   LEFT = 0,
   RIGHT = 1
}
enum SubmenuPlacement {
   TOP_BOTTOM = 0,
   LEFT_RIGHT = 1
}
enum int TEXT_VIEW_PRIORITY_VALIDATE = 5;
enum int TYPE_FUNDAMENTAL_LAST = -1;
struct Table /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   GLib2.List* children;
   TableRowCol* rows, cols;
   ushort nrows, ncols, column_spacing, row_spacing;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "homogeneous", 1,
    uint, "__dummy32A", 31));

   static Table* new_(uint rows, uint columns, int homogeneous) {
      return gtk_table_new(rows, columns, homogeneous);
   }
   void attach(Widget* child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach, AttachOptions xoptions, AttachOptions yoptions, uint xpadding, uint ypadding) {
      gtk_table_attach(&this, child, left_attach, right_attach, top_attach, bottom_attach, xoptions, yoptions, xpadding, ypadding);
   }
   void attach_defaults(Widget* widget, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach) {
      gtk_table_attach_defaults(&this, widget, left_attach, right_attach, top_attach, bottom_attach);
   }

   // Gets the amount of space between column @col, and
   // column @col + 1. See gtk_table_set_col_spacing().
   // RETURNS: the column spacing
   // <column>: a column in the table, 0 indicates the first column
   uint get_col_spacing(uint column) {
      return gtk_table_get_col_spacing(&this, column);
   }

   // Gets the default column spacing for the table. This is
   // the spacing that will be used for newly added columns.
   // (See gtk_table_set_col_spacings())
   // RETURNS: the default column spacing
   uint get_default_col_spacing() {
      return gtk_table_get_default_col_spacing(&this);
   }

   // Gets the default row spacing for the table. This is
   // the spacing that will be used for newly added rows.
   // (See gtk_table_set_row_spacings())
   // RETURNS: the default row spacing
   uint get_default_row_spacing() {
      return gtk_table_get_default_row_spacing(&this);
   }

   // Returns whether the table cells are all constrained to the same
   // width and height. (See gtk_table_set_homogenous ())
   // RETURNS: %TRUE if the cells are all constrained to the same size
   int get_homogeneous() {
      return gtk_table_get_homogeneous(&this);
   }

   // Gets the amount of space between row @row, and
   // row @row + 1. See gtk_table_set_row_spacing().
   // RETURNS: the row spacing
   // <row>: a row in the table, 0 indicates the first row
   uint get_row_spacing(uint row) {
      return gtk_table_get_row_spacing(&this, row);
   }

   // Returns the number of rows and columns in the table.
   // <rows>: return location for the number of rows, or %NULL
   // <columns>: return location for the number of columns, or %NULL
   void get_size(/*out*/ uint* rows=null, /*out*/ uint* columns=null) {
      gtk_table_get_size(&this, rows, columns);
   }
   void resize(uint rows, uint columns) {
      gtk_table_resize(&this, rows, columns);
   }
   void set_col_spacing(uint column, uint spacing) {
      gtk_table_set_col_spacing(&this, column, spacing);
   }
   void set_col_spacings(uint spacing) {
      gtk_table_set_col_spacings(&this, spacing);
   }
   void set_homogeneous(int homogeneous) {
      gtk_table_set_homogeneous(&this, homogeneous);
   }
   void set_row_spacing(uint row, uint spacing) {
      gtk_table_set_row_spacing(&this, row, spacing);
   }
   void set_row_spacings(uint spacing) {
      gtk_table_set_row_spacings(&this, spacing);
   }
}

struct TableChild {
   Widget* widget;
   ushort left_attach, right_attach, top_attach, bottom_attach, xpadding, ypadding;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "xexpand", 1,
   uint, "yexpand", 1,
   uint, "xshrink", 1,
   uint, "yshrink", 1,
   uint, "xfill", 1,
   uint, "yfill", 1,
    uint, "__dummy32A", 26));
}

struct TableClass {
   ContainerClass parent_class;
}

struct TableRowCol {
   ushort requisition, allocation, spacing;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "need_expand", 1,
   uint, "need_shrink", 1,
   uint, "expand", 1,
   uint, "shrink", 1,
   uint, "empty", 1,
    uint, "__dummy32A", 27));
}

struct TargetEntry {
   char* target;
   uint flags, info;
}

enum TargetFlags {
   SAME_APP = 1,
   SAME_WIDGET = 2,
   OTHER_APP = 4,
   OTHER_WIDGET = 8
}
struct TargetList {
   GLib2.List* list;
   uint ref_count;


   // Creates a new #GtkTargetList from an array of #GtkTargetEntry.
   // RETURNS: the new #GtkTargetList.
   // <targets>: Pointer to an array of #GtkTargetEntry
   // <ntargets>: number of entries in @targets.
   static TargetList* /*new*/ new_(TargetEntry* targets, uint ntargets) {
      return gtk_target_list_new(targets, ntargets);
   }

   // Appends another target to a #GtkTargetList.
   // <target>: the interned atom representing the target
   // <flags>: the flags for this target
   // <info>: an ID that will be passed back to the application
   void add(Gdk2.Atom target, uint flags, uint info) {
      gtk_target_list_add(&this, target, flags, info);
   }

   // Appends the image targets supported by #GtkSelection to
   // the target list. All targets are added with the same @info.
   // <info>: an ID that will be passed back to the application
   // <writable>: whether to add only targets for which GTK+ knows how to convert a pixbuf into the format
   void add_image_targets(uint info, int writable) {
      gtk_target_list_add_image_targets(&this, info, writable);
   }

   // Appends the rich text targets registered with
   // gtk_text_buffer_register_serialize_format() or
   // gtk_text_buffer_register_deserialize_format() to the target list. All
   // targets are added with the same @info.
   // <info>: an ID that will be passed back to the application
   // <deserializable>: if %TRUE, then deserializable rich text formats will be added, serializable formats otherwise.
   // <buffer>: a #GtkTextBuffer.
   void add_rich_text_targets(uint info, int deserializable, TextBuffer* buffer) {
      gtk_target_list_add_rich_text_targets(&this, info, deserializable, buffer);
   }

   // Prepends a table of #GtkTargetEntry to a target list.
   // <targets>: the table of #GtkTargetEntry
   // <ntargets>: number of targets in the table
   void add_table(TargetEntry* targets, uint ntargets) {
      gtk_target_list_add_table(&this, targets, ntargets);
   }

   // Appends the text targets supported by #GtkSelection to
   // the target list. All targets are added with the same @info.
   // <info>: an ID that will be passed back to the application
   void add_text_targets(uint info) {
      gtk_target_list_add_text_targets(&this, info);
   }

   // Appends the URI targets supported by #GtkSelection to
   // the target list. All targets are added with the same @info.
   // <info>: an ID that will be passed back to the application
   void add_uri_targets(uint info) {
      gtk_target_list_add_uri_targets(&this, info);
   }

   // Looks up a given target in a #GtkTargetList.
   // RETURNS: %TRUE if the target was found, otherwise %FALSE
   // <target>: an interned atom representing the target to search for
   // <info>: a pointer to the location to store application info for target, or %NULL
   int find(Gdk2.Atom target, uint* info) {
      return gtk_target_list_find(&this, target, info);
   }

   // Increases the reference count of a #GtkTargetList by one.
   // RETURNS: the passed in #GtkTargetList.
   TargetList* /*new*/ ref_() {
      return gtk_target_list_ref(&this);
   }

   // Removes a target from a target list.
   // <target>: the interned atom representing the target
   void remove(Gdk2.Atom target) {
      gtk_target_list_remove(&this, target);
   }

   // Decreases the reference count of a #GtkTargetList by one.
   // If the resulting reference count is zero, frees the list.
   void unref() {
      gtk_target_list_unref(&this);
   }
}

struct TargetPair {
   Gdk2.Atom target;
   uint flags, info;
}

struct TearoffMenuItem /* : MenuItem */ {
   alias menu_item this;
   alias menu_item super_;
   alias menu_item menuitem;
   MenuItem menu_item;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "torn_off", 1,
    uint, "__dummy32A", 31));

   static TearoffMenuItem* new_() {
      return gtk_tearoff_menu_item_new();
   }
}

struct TearoffMenuItemClass {
   MenuItemClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TextAppearance {
   Gdk2.Color bg_color, fg_color;
   Gdk2.Bitmap* bg_stipple, fg_stipple;
   int rise;
   private void* padding1;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "underline", 4,
   uint, "strikethrough", 1,
   uint, "draw_bg", 1,
   uint, "inside_selection", 1,
   uint, "is_text", 1,
   uint, "pad1", 1,
   uint, "pad2", 1,
   uint, "pad3", 1,
   uint, "pad4", 1,
    uint, "__dummy32A", 20));
}

struct TextAttrAppearance {
   Pango.Attribute attr;
   TextAppearance appearance;
}

struct TextAttributes {
   private uint refcount;
   TextAppearance appearance;
   Justification justification;
   TextDirection direction;
   Pango.FontDescription* font;
   double font_scale;
   int left_margin, indent, right_margin, pixels_above_lines, pixels_below_lines, pixels_inside_wrap;
   Pango.TabArray* tabs;
   WrapMode wrap_mode;
   Pango.Language* language;
   private Gdk2.Color* pg_bg_color;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "invisible", 1,
   uint, "bg_full_height", 1,
   uint, "editable", 1,
   uint, "realized", 1,
   uint, "pad1", 1,
   uint, "pad2", 1,
   uint, "pad3", 1,
   uint, "pad4", 1,
    uint, "__dummy32A", 24));


   // Creates a #GtkTextAttributes, which describes
   // a set of properties on some text.
   // RETURNS: a new #GtkTextAttributes
   static TextAttributes* /*new*/ new_() {
      return gtk_text_attributes_new();
   }

   // Copies @src and returns a new #GtkTextAttributes.
   // RETURNS: a copy of @src
   TextAttributes* /*new*/ copy() {
      return gtk_text_attributes_copy(&this);
   }

   // Copies the values from @src to @dest so that @dest has the same values
   // as @src. Frees existing values in @dest.
   // <dest>: another #GtkTextAttributes
   void copy_values(TextAttributes* dest) {
      gtk_text_attributes_copy_values(&this, dest);
   }

   // Increments the reference count on @values.
   // RETURNS: the #GtkTextAttributes that were passed in
   TextAttributes* /*new*/ ref_() {
      return gtk_text_attributes_ref(&this);
   }

   // Decrements the reference count on @values, freeing the structure
   // if the reference count reaches 0.
   void unref() {
      gtk_text_attributes_unref(&this);
   }
}

struct TextBTree {
}

struct TextBuffer /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   TextTagTable* tag_table;
   TextBTree* btree;
   GLib2.SList* clipboard_contents_buffers, selection_clipboards;
   TextLogAttrCache* log_attr_cache;
   uint user_action_count;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "modified", 1,
   uint, "has_selection", 1,
    uint, "__dummy32A", 30));


   // Creates a new text buffer.
   // RETURNS: a new text buffer
   // <table>: a tag table, or %NULL to create a new one
   static TextBuffer* /*new*/ new_(TextTagTable* table=null) {
      return gtk_text_buffer_new(table);
   }

   // Adds the mark at position @where. The mark must not be added to
   // another buffer, and if its name is not %NULL then there must not
   // be another mark in the buffer with the same name.
   // Emits the "mark-set" signal as notification of the mark's initial
   // placement.
   // <mark>: the mark to add
   // <where>: location to place mark
   void add_mark(TextMark* mark, TextIter* where) {
      gtk_text_buffer_add_mark(&this, mark, where);
   }

   // Adds @clipboard to the list of clipboards in which the selection 
   // contents of @buffer are available. In most cases, @clipboard will be 
   // the #GtkClipboard of type %GDK_SELECTION_PRIMARY for a view of @buffer.
   // <clipboard>: a #GtkClipboard
   void add_selection_clipboard(Clipboard* clipboard) {
      gtk_text_buffer_add_selection_clipboard(&this, clipboard);
   }

   // Emits the "apply-tag" signal on @buffer. The default
   // handler for the signal applies @tag to the given range.
   // <tag>: a #GtkTextTag
   // <start>: one bound of range to be tagged
   // <end>: other bound of range to be tagged
   void apply_tag(TextTag* tag, TextIter* start, TextIter* end) {
      gtk_text_buffer_apply_tag(&this, tag, start, end);
   }

   // Calls gtk_text_tag_table_lookup() on the buffer's tag table to
   // get a #GtkTextTag, then calls gtk_text_buffer_apply_tag().
   // <name>: name of a named #GtkTextTag
   // <start>: one bound of range to be tagged
   // <end>: other bound of range to be tagged
   void apply_tag_by_name(char* name, TextIter* start, TextIter* end) {
      gtk_text_buffer_apply_tag_by_name(&this, name, start, end);
   }

   // Performs the appropriate action as if the user hit the delete
   // key with the cursor at the position specified by @iter. In the
   // normal case a single character will be deleted, but when
   // combining accents are involved, more than one character can
   // be deleted, and when precomposed character and accent combinations
   // are involved, less than one character will be deleted.
   // Because the buffer is modified, all outstanding iterators become 
   // invalid after calling this function; however, the @iter will be
   // re-initialized to point to the location where text was deleted.
   // RETURNS: %TRUE if the buffer was modified
   // <iter>: a position in @buffer
   // <interactive>: whether the deletion is caused by user interaction
   // <default_editable>: whether the buffer is editable by default
   int backspace(TextIter* iter, int interactive, int default_editable) {
      return gtk_text_buffer_backspace(&this, iter, interactive, default_editable);
   }

   // Called to indicate that the buffer operations between here and a
   // call to gtk_text_buffer_end_user_action() are part of a single
   // user-visible operation. The operations between
   // gtk_text_buffer_begin_user_action() and
   // gtk_text_buffer_end_user_action() can then be grouped when creating
   // an undo stack. #GtkTextBuffer maintains a count of calls to
   // gtk_text_buffer_begin_user_action() that have not been closed with
   // a call to gtk_text_buffer_end_user_action(), and emits the 
   // "begin-user-action" and "end-user-action" signals only for the 
   // outermost pair of calls. This allows you to build user actions 
   // from other user actions.
   // The "interactive" buffer mutation functions, such as
   // gtk_text_buffer_insert_interactive(), automatically call begin/end
   // user action around the buffer operations they perform, so there's
   // no need to add extra calls if you user action consists solely of a
   // single call to one of those functions.
   void begin_user_action() {
      gtk_text_buffer_begin_user_action(&this);
   }

   // Copies the currently-selected text to a clipboard.
   // <clipboard>: the #GtkClipboard object to copy to
   void copy_clipboard(Clipboard* clipboard) {
      gtk_text_buffer_copy_clipboard(&this, clipboard);
   }

   // This is a convenience function which simply creates a child anchor
   // with gtk_text_child_anchor_new() and inserts it into the buffer
   // with gtk_text_buffer_insert_child_anchor(). The new anchor is
   // owned by the buffer; no reference count is returned to
   // the caller of gtk_text_buffer_create_child_anchor().
   // RETURNS: the created child anchor
   // <iter>: location in the buffer
   TextChildAnchor* create_child_anchor(TextIter* iter) {
      return gtk_text_buffer_create_child_anchor(&this, iter);
   }

   // Creates a mark at position @where. If @mark_name is %NULL, the mark
   // is anonymous; otherwise, the mark can be retrieved by name using
   // gtk_text_buffer_get_mark(). If a mark has left gravity, and text is
   // inserted at the mark's current location, the mark will be moved to
   // the left of the newly-inserted text. If the mark has right gravity
   // (@left_gravity = %FALSE), the mark will end up on the right of
   // newly-inserted text. The standard left-to-right cursor is a mark
   // with right gravity (when you type, the cursor stays on the right
   // side of the text you're typing).
   // The caller of this function does <emphasis>not</emphasis> own a 
   // reference to the returned #GtkTextMark, so you can ignore the 
   // return value if you like. Marks are owned by the buffer and go 
   // away when the buffer does.
   // Emits the "mark-set" signal as notification of the mark's initial
   // placement.
   // RETURNS: the new #GtkTextMark object
   // <mark_name>: name for mark, or %NULL
   // <where>: location to place mark
   // <left_gravity>: whether the mark has left gravity
   TextMark* create_mark(char* mark_name, TextIter* where, int left_gravity) {
      return gtk_text_buffer_create_mark(&this, mark_name, where, left_gravity);
   }

   // Unintrospectable method: create_tag() / gtk_text_buffer_create_tag()
   // Creates a tag and adds it to the tag table for @buffer.
   // Equivalent to calling gtk_text_tag_new() and then adding the
   // tag to the buffer's tag table. The returned tag is owned by
   // the buffer's tag table, so the ref count will be equal to one.
   // If @tag_name is %NULL, the tag is anonymous.
   // If @tag_name is non-%NULL, a tag called @tag_name must not already
   // exist in the tag table for this buffer.
   // The @first_property_name argument and subsequent arguments are a list
   // of properties to set on the tag, as with g_object_set().
   // RETURNS: a new tag
   // <tag_name>: name of the new tag, or %NULL
   // <first_property_name>: name of first property to set, or %NULL
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_text_buffer_create_tag create_tag; // Variadic
   +/

   // Copies the currently-selected text to a clipboard, then deletes
   // said text if it's editable.
   // <clipboard>: the #GtkClipboard object to cut to
   // <default_editable>: default editability of the buffer
   void cut_clipboard(Clipboard* clipboard, int default_editable) {
      gtk_text_buffer_cut_clipboard(&this, clipboard, default_editable);
   }

   // Deletes text between @start and @end. The order of @start and @end
   // is not actually relevant; gtk_text_buffer_delete() will reorder
   // them. This function actually emits the "delete-range" signal, and
   // the default handler of that signal deletes the text. Because the
   // buffer is modified, all outstanding iterators become invalid after
   // calling this function; however, the @start and @end will be
   // re-initialized to point to the location where text was deleted.
   // <start>: a position in @buffer
   // <end>: another position in @buffer
   void delete_(TextIter* start, TextIter* end) {
      gtk_text_buffer_delete(&this, start, end);
   }

   // Deletes all <emphasis>editable</emphasis> text in the given range.
   // Calls gtk_text_buffer_delete() for each editable sub-range of
   // [@start,@end). @start and @end are revalidated to point to
   // the location of the last deleted range, or left untouched if
   // no text was deleted.
   // RETURNS: whether some text was actually deleted
   // <start_iter>: start of range to delete
   // <end_iter>: end of range
   // <default_editable>: whether the buffer is editable by default
   int delete_interactive(TextIter* start_iter, TextIter* end_iter, int default_editable) {
      return gtk_text_buffer_delete_interactive(&this, start_iter, end_iter, default_editable);
   }

   // Deletes @mark, so that it's no longer located anywhere in the
   // buffer. Removes the reference the buffer holds to the mark, so if
   // you haven't called g_object_ref() on the mark, it will be freed. Even
   // if the mark isn't freed, most operations on @mark become
   // invalid, until it gets added to a buffer again with 
   // gtk_text_buffer_add_mark(). Use gtk_text_mark_get_deleted() to  
   // find out if a mark has been removed from its buffer.
   // The "mark-deleted" signal will be emitted as notification after 
   // the mark is deleted.
   // <mark>: a #GtkTextMark in @buffer
   void delete_mark(TextMark* mark) {
      gtk_text_buffer_delete_mark(&this, mark);
   }

   // Deletes the mark named @name; the mark must exist. See
   // gtk_text_buffer_delete_mark() for details.
   // <name>: name of a mark in @buffer
   void delete_mark_by_name(char* name) {
      gtk_text_buffer_delete_mark_by_name(&this, name);
   }

   // Deletes the range between the "insert" and "selection_bound" marks,
   // that is, the currently-selected text. If @interactive is %TRUE,
   // the editability of the selection will be considered (users can't delete
   // uneditable text).
   // RETURNS: whether there was a non-empty selection to delete
   // <interactive>: whether the deletion is caused by user interaction
   // <default_editable>: whether the buffer is editable by default
   int delete_selection(int interactive, int default_editable) {
      return gtk_text_buffer_delete_selection(&this, interactive, default_editable);
   }

   // This function deserializes rich text in format @format and inserts
   // it at @iter.
   // gtk_text_buffer_register_deserialize_format() or
   // gtk_text_buffer_register_deserialize_tagset() beforehand.
   // RETURNS: %TRUE on success, %FALSE otherwise.
   // <content_buffer>: the #GtkTextBuffer to deserialize into
   // <format>: the rich text format to use for deserializing
   // <iter>: insertion point for the deserialized text
   // <data>: data to deserialize
   // <length>: length of @data
   int deserialize(TextBuffer* content_buffer, Gdk2.Atom format, TextIter* iter, ubyte* data, size_t length, GLib2.Error** error=null) {
      return gtk_text_buffer_deserialize(&this, content_buffer, format, iter, data, length, error);
   }

   // This functions returns the value set with
   // gtk_text_buffer_deserialize_set_can_create_tags()
   // RETURNS: whether deserializing this format may create tags
   // <format>: a #GdkAtom representing a registered rich text format
   int deserialize_get_can_create_tags(Gdk2.Atom format) {
      return gtk_text_buffer_deserialize_get_can_create_tags(&this, format);
   }

   // Use this function to allow a rich text deserialization function to
   // create new tags in the receiving buffer. Note that using this
   // function is almost always a bad idea, because the rich text
   // functions you register should know how to map the rich text format
   // they handler to your text buffers set of tags.
   // The ability of creating new (arbitrary!) tags in the receiving buffer
   // is meant for special rich text formats like the internal one that
   // is registered using gtk_text_buffer_register_deserialize_tagset(),
   // because that format is essentially a dump of the internal structure
   // of the source buffer, including its tag names.
   // You should allow creation of tags only if you know what you are
   // doing, e.g. if you defined a tagset name for your application
   // suite's text buffers and you know that it's fine to receive new
   // tags from these buffers, because you know that your application can
   // handle the newly created tags.
   // <format>: a #GdkAtom representing a registered rich text format
   // <can_create_tags>: whether deserializing this format may create tags
   void deserialize_set_can_create_tags(Gdk2.Atom format, int can_create_tags) {
      gtk_text_buffer_deserialize_set_can_create_tags(&this, format, can_create_tags);
   }

   // Should be paired with a call to gtk_text_buffer_begin_user_action().
   // See that function for a full explanation.
   void end_user_action() {
      gtk_text_buffer_end_user_action(&this);
   }

   // Retrieves the first and last iterators in the buffer, i.e. the
   // entire buffer lies within the range [@start,@end).
   // <start>: iterator to initialize with first position in the buffer
   // <end>: iterator to initialize with the end iterator
   void get_bounds(/*out*/ TextIter* start, /*out*/ TextIter* end) {
      gtk_text_buffer_get_bounds(&this, start, end);
   }

   // Gets the number of characters in the buffer; note that characters
   // and bytes are not the same, you can't e.g. expect the contents of
   // the buffer in string form to be this many bytes long. The character
   // count is cached, so this function is very fast.
   // RETURNS: number of characters in the buffer
   int get_char_count() {
      return gtk_text_buffer_get_char_count(&this);
   }

   // This function returns the list of targets this text buffer can
   // provide for copying and as DND source. The targets in the list are
   // added with %info values from the #GtkTextBufferTargetInfo enum,
   // using gtk_target_list_add_rich_text_targets() and
   // gtk_target_list_add_text_targets().
   // RETURNS: the #GtkTargetList
   TargetList* get_copy_target_list() {
      return gtk_text_buffer_get_copy_target_list(&this);
   }

   // This function returns the rich text deserialize formats registered
   // with @buffer using gtk_text_buffer_register_deserialize_format() or
   // gtk_text_buffer_register_deserialize_tagset()
   // #GdkAtom<!-- -->s representing the registered formats.
   // RETURNS: an array of
   // <n_formats>: return location for the number of formats
   Gdk2.Atom* /*new container*/ get_deserialize_formats(/*out*/ int* n_formats) {
      return gtk_text_buffer_get_deserialize_formats(&this, n_formats);
   }

   // Initializes @iter with the "end iterator," one past the last valid
   // character in the text buffer. If dereferenced with
   // gtk_text_iter_get_char(), the end iterator has a character value of
   // 0. The entire buffer lies in the range from the first position in
   // the buffer (call gtk_text_buffer_get_start_iter() to get
   // character position 0) to the end iterator.
   // <iter>: iterator to initialize
   void get_end_iter(/*out*/ TextIter* iter) {
      gtk_text_buffer_get_end_iter(&this, iter);
   }

   // Indicates whether the buffer has some text currently selected.
   // RETURNS: %TRUE if the there is text selected
   int get_has_selection() {
      return gtk_text_buffer_get_has_selection(&this);
   }

   // Returns the mark that represents the cursor (insertion point).
   // Equivalent to calling gtk_text_buffer_get_mark() to get the mark
   // named "insert", but very slightly more efficient, and involves less
   // typing.
   // RETURNS: insertion point mark
   TextMark* get_insert() {
      return gtk_text_buffer_get_insert(&this);
   }

   // Obtains the location of @anchor within @buffer.
   // <iter>: an iterator to be initialized
   // <anchor>: a child anchor that appears in @buffer
   void get_iter_at_child_anchor(/*out*/ TextIter* iter, TextChildAnchor* anchor) {
      gtk_text_buffer_get_iter_at_child_anchor(&this, iter, anchor);
   }

   // Initializes @iter to the start of the given line.
   // <iter>: iterator to initialize
   // <line_number>: line number counting from 0
   void get_iter_at_line(/*out*/ TextIter* iter, int line_number) {
      gtk_text_buffer_get_iter_at_line(&this, iter, line_number);
   }

   // Obtains an iterator pointing to @byte_index within the given line.
   // beyond the end of the line.  Note <emphasis>bytes</emphasis>, not
   // characters; UTF-8 may encode one character as multiple bytes.
   // <iter>: iterator to initialize
   // <line_number>: line number counting from 0
   // <byte_index>: byte index from start of line
   void get_iter_at_line_index(/*out*/ TextIter* iter, int line_number, int byte_index) {
      gtk_text_buffer_get_iter_at_line_index(&this, iter, line_number, byte_index);
   }

   // Obtains an iterator pointing to @char_offset within the given
   // line. The @char_offset must exist, offsets off the end of the line
   // are not allowed. Note <emphasis>characters</emphasis>, not bytes;
   // UTF-8 may encode one character as multiple bytes.
   // <iter>: iterator to initialize
   // <line_number>: line number counting from 0
   // <char_offset>: char offset from start of line
   void get_iter_at_line_offset(/*out*/ TextIter* iter, int line_number, int char_offset) {
      gtk_text_buffer_get_iter_at_line_offset(&this, iter, line_number, char_offset);
   }

   // Initializes @iter with the current position of @mark.
   // <iter>: iterator to initialize
   // <mark>: a #GtkTextMark in @buffer
   void get_iter_at_mark(/*out*/ TextIter* iter, TextMark* mark) {
      gtk_text_buffer_get_iter_at_mark(&this, iter, mark);
   }

   // Initializes @iter to a position @char_offset chars from the start
   // of the entire buffer. If @char_offset is -1 or greater than the number
   // of characters in the buffer, @iter is initialized to the end iterator,
   // the iterator one past the last valid character in the buffer.
   // <iter>: iterator to initialize
   // <char_offset>: char offset from start of buffer, counting from 0, or -1
   void get_iter_at_offset(/*out*/ TextIter* iter, int char_offset) {
      gtk_text_buffer_get_iter_at_offset(&this, iter, char_offset);
   }

   // Obtains the number of lines in the buffer. This value is cached, so
   // the function is very fast.
   // RETURNS: number of lines in the buffer
   int get_line_count() {
      return gtk_text_buffer_get_line_count(&this);
   }

   // Returns the mark named @name in buffer @buffer, or %NULL if no such
   // mark exists in the buffer.
   // RETURNS: a #GtkTextMark, or %NULL
   // <name>: a mark name
   TextMark* get_mark(char* name) {
      return gtk_text_buffer_get_mark(&this, name);
   }

   // Indicates whether the buffer has been modified since the last call
   // to gtk_text_buffer_set_modified() set the modification flag to
   // %FALSE. Used for example to enable a "save" function in a text
   // editor.
   // RETURNS: %TRUE if the buffer has been modified
   int get_modified() {
      return gtk_text_buffer_get_modified(&this);
   }

   // This function returns the list of targets this text buffer supports
   // for pasting and as DND destination. The targets in the list are
   // added with %info values from the #GtkTextBufferTargetInfo enum,
   // using gtk_target_list_add_rich_text_targets() and
   // gtk_target_list_add_text_targets().
   // RETURNS: the #GtkTargetList
   TargetList* get_paste_target_list() {
      return gtk_text_buffer_get_paste_target_list(&this);
   }

   // Returns the mark that represents the selection bound.  Equivalent
   // to calling gtk_text_buffer_get_mark() to get the mark named
   // "selection_bound", but very slightly more efficient, and involves
   // less typing.
   // The currently-selected text in @buffer is the region between the
   // "selection_bound" and "insert" marks. If "selection_bound" and
   // "insert" are in the same place, then there is no current selection.
   // gtk_text_buffer_get_selection_bounds() is another convenient function
   // for handling the selection, if you just want to know whether there's a
   // selection and what its bounds are.
   // RETURNS: selection bound mark
   TextMark* get_selection_bound() {
      return gtk_text_buffer_get_selection_bound(&this);
   }

   // Returns %TRUE if some text is selected; places the bounds
   // of the selection in @start and @end (if the selection has length 0,
   // then @start and @end are filled in with the same value).
   // NULL, then they are not filled in, but the return value still indicates
   // whether text is selected.
   // RETURNS: whether the selection has nonzero length
   // <start>: iterator to initialize with selection start
   // <end>: iterator to initialize with selection end
   int get_selection_bounds(/*out*/ TextIter* start, /*out*/ TextIter* end) {
      return gtk_text_buffer_get_selection_bounds(&this, start, end);
   }

   // This function returns the rich text serialize formats registered
   // with @buffer using gtk_text_buffer_register_serialize_format() or
   // gtk_text_buffer_register_serialize_tagset()
   // #GdkAtom<!-- -->s representing the registered formats.
   // RETURNS: an array of
   // <n_formats>: return location for the number of formats
   Gdk2.Atom* /*new container*/ get_serialize_formats(/*out*/ int* n_formats) {
      return gtk_text_buffer_get_serialize_formats(&this, n_formats);
   }

   // Returns the text in the range [@start,@end). Excludes undisplayed
   // text (text marked with tags that set the invisibility attribute) if
   // 0xFFFC character whenever the buffer contains
   // embedded images, so byte and character indexes into
   // the returned string <emphasis>do</emphasis> correspond to byte
   // and character indexes into the buffer. Contrast with
   // gtk_text_buffer_get_text(). Note that 0xFFFC can occur in normal
   // text as well, so it is not a reliable indicator that a pixbuf or
   // widget is in the buffer.
   // RETURNS: an allocated UTF-8 string
   // <start>: start of a range
   // <end>: end of a range
   // <include_hidden_chars>: whether to include invisible text
   char* /*new*/ get_slice(TextIter* start, TextIter* end, int include_hidden_chars) {
      return gtk_text_buffer_get_slice(&this, start, end, include_hidden_chars);
   }

   // Initialized @iter with the first position in the text buffer. This
   // is the same as using gtk_text_buffer_get_iter_at_offset() to get
   // the iter at character offset 0.
   // <iter>: iterator to initialize
   void get_start_iter(/*out*/ TextIter* iter) {
      gtk_text_buffer_get_start_iter(&this, iter);
   }

   // Get the #GtkTextTagTable associated with this buffer.
   // RETURNS: the buffer's tag table
   TextTagTable* get_tag_table() {
      return gtk_text_buffer_get_tag_table(&this);
   }

   // Returns the text in the range [@start,@end). Excludes undisplayed
   // text (text marked with tags that set the invisibility attribute) if
   // representing embedded images, so byte and character indexes into
   // the returned string do <emphasis>not</emphasis> correspond to byte
   // and character indexes into the buffer. Contrast with
   // gtk_text_buffer_get_slice().
   // RETURNS: an allocated UTF-8 string
   // <start>: start of a range
   // <end>: end of a range
   // <include_hidden_chars>: whether to include invisible text
   char* /*new*/ get_text(TextIter* start, TextIter* end, int include_hidden_chars) {
      return gtk_text_buffer_get_text(&this, start, end, include_hidden_chars);
   }

   // Inserts @len bytes of @text at position @iter.  If @len is -1,
   // entirety. Emits the "insert-text" signal; insertion actually occurs
   // in the default handler for the signal. @iter is invalidated when
   // insertion occurs (because the buffer contents change), but the
   // default signal handler revalidates it to point to the end of the
   // inserted text.
   // <iter>: a position in the buffer
   // <text>: text in UTF-8 format
   // <len>: length of text in bytes, or -1
   void insert(TextIter* iter, char* text, int len) {
      gtk_text_buffer_insert(&this, iter, text, len);
   }

   // Simply calls gtk_text_buffer_insert(), using the current
   // cursor position as the insertion point.
   // <text>: text in UTF-8 format
   // <len>: length of text, in bytes
   void insert_at_cursor(char* text, int len) {
      gtk_text_buffer_insert_at_cursor(&this, text, len);
   }

   // Inserts a child widget anchor into the text buffer at @iter. The
   // anchor will be counted as one character in character counts, and
   // when obtaining the buffer contents as a string, will be represented
   // by the Unicode "object replacement character" 0xFFFC. Note that the
   // "slice" variants for obtaining portions of the buffer as a string
   // include this character for child anchors, but the "text" variants do
   // not. E.g. see gtk_text_buffer_get_slice() and
   // gtk_text_buffer_get_text(). Consider
   // gtk_text_buffer_create_child_anchor() as a more convenient
   // alternative to this function. The buffer will add a reference to
   // the anchor, so you can unref it after insertion.
   // <iter>: location to insert the anchor
   // <anchor>: a #GtkTextChildAnchor
   void insert_child_anchor(TextIter* iter, TextChildAnchor* anchor) {
      gtk_text_buffer_insert_child_anchor(&this, iter, anchor);
   }

   // Like gtk_text_buffer_insert(), but the insertion will not occur if
   // want to prevent insertions at ineditable locations if the insertion
   // results from a user action (is interactive).
   // have a tag affecting editability applied to it. Typically the
   // result of gtk_text_view_get_editable() is appropriate here.
   // RETURNS: whether text was actually inserted
   // <iter>: a position in @buffer
   // <text>: some UTF-8 text
   // <len>: length of text in bytes, or -1
   // <default_editable>: default editability of buffer
   int insert_interactive(TextIter* iter, char* text, int len, int default_editable) {
      return gtk_text_buffer_insert_interactive(&this, iter, text, len, default_editable);
   }

   // Calls gtk_text_buffer_insert_interactive() at the cursor
   // position.
   // have a tag affecting editability applied to it. Typically the
   // result of gtk_text_view_get_editable() is appropriate here.
   // RETURNS: whether text was actually inserted
   // <text>: text in UTF-8 format
   // <len>: length of text in bytes, or -1
   // <default_editable>: default editability of buffer
   int insert_interactive_at_cursor(char* text, int len, int default_editable) {
      return gtk_text_buffer_insert_interactive_at_cursor(&this, text, len, default_editable);
   }

   // Inserts an image into the text buffer at @iter. The image will be
   // counted as one character in character counts, and when obtaining
   // the buffer contents as a string, will be represented by the Unicode
   // "object replacement character" 0xFFFC. Note that the "slice"
   // variants for obtaining portions of the buffer as a string include
   // this character for pixbufs, but the "text" variants do
   // not. e.g. see gtk_text_buffer_get_slice() and
   // gtk_text_buffer_get_text().
   // <iter>: location to insert the pixbuf
   // <pixbuf>: a #GdkPixbuf
   void insert_pixbuf(TextIter* iter, GdkPixbuf2.Pixbuf* pixbuf) {
      gtk_text_buffer_insert_pixbuf(&this, iter, pixbuf);
   }

   // Copies text, tags, and pixbufs between @start and @end (the order
   // of @start and @end doesn't matter) and inserts the copy at @iter.
   // Used instead of simply getting/inserting text because it preserves
   // images and tags. If @start and @end are in a different buffer from
   // Implemented via emissions of the insert_text and apply_tag signals,
   // so expect those.
   // <iter>: a position in @buffer
   // <start>: a position in a #GtkTextBuffer
   // <end>: another position in the same buffer as @start
   void insert_range(TextIter* iter, TextIter* start, TextIter* end) {
      gtk_text_buffer_insert_range(&this, iter, start, end);
   }

   // Same as gtk_text_buffer_insert_range(), but does nothing if the
   // insertion point isn't editable. The @default_editable parameter
   // indicates whether the text is editable at @iter if no tags
   // enclosing @iter affect editability. Typically the result of
   // gtk_text_view_get_editable() is appropriate here.
   // RETURNS: whether an insertion was possible at @iter
   // <iter>: a position in @buffer
   // <start>: a position in a #GtkTextBuffer
   // <end>: another position in the same buffer as @start
   // <default_editable>: default editability of the buffer
   int insert_range_interactive(TextIter* iter, TextIter* start, TextIter* end, int default_editable) {
      return gtk_text_buffer_insert_range_interactive(&this, iter, start, end, default_editable);
   }

   // Unintrospectable method: insert_with_tags() / gtk_text_buffer_insert_with_tags()
   // Inserts @text into @buffer at @iter, applying the list of tags to
   // the newly-inserted text. The last tag specified must be NULL to
   // terminate the list. Equivalent to calling gtk_text_buffer_insert(),
   // then gtk_text_buffer_apply_tag() on the inserted text;
   // gtk_text_buffer_insert_with_tags() is just a convenience function.
   // <iter>: an iterator in @buffer
   // <text>: UTF-8 text
   // <len>: length of @text, or -1
   // <first_tag>: first tag to apply to @text
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_text_buffer_insert_with_tags insert_with_tags; // Variadic
   +/

   // Unintrospectable method: insert_with_tags_by_name() / gtk_text_buffer_insert_with_tags_by_name()
   // Same as gtk_text_buffer_insert_with_tags(), but allows you
   // to pass in tag names instead of tag objects.
   // <iter>: position in @buffer
   // <text>: UTF-8 text
   // <len>: length of @text, or -1
   // <first_tag_name>: name of a tag to apply to @text
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_text_buffer_insert_with_tags_by_name insert_with_tags_by_name; // Variadic
   +/

   // Moves @mark to the new location @where. Emits the "mark-set" signal
   // as notification of the move.
   // <mark>: a #GtkTextMark
   // <where>: new location for @mark in @buffer
   void move_mark(TextMark* mark, TextIter* where) {
      gtk_text_buffer_move_mark(&this, mark, where);
   }

   // Moves the mark named @name (which must exist) to location @where.
   // See gtk_text_buffer_move_mark() for details.
   // <name>: name of a mark
   // <where>: new location for mark
   void move_mark_by_name(char* name, TextIter* where) {
      gtk_text_buffer_move_mark_by_name(&this, name, where);
   }

   // Pastes the contents of a clipboard at the insertion point, or
   // we'll ask for the paste data and return, and at some point later
   // after the main loop runs, the paste data will be inserted.)
   // <clipboard>: the #GtkClipboard to paste from
   // <override_location>: location to insert pasted text, or %NULL for at the cursor
   // <default_editable>: whether the buffer is editable by default
   void paste_clipboard(Clipboard* clipboard, TextIter* override_location, int default_editable) {
      gtk_text_buffer_paste_clipboard(&this, clipboard, override_location, default_editable);
   }

   // This function moves the "insert" and "selection_bound" marks
   // simultaneously.  If you move them to the same place in two steps
   // with gtk_text_buffer_move_mark(), you will temporarily select a
   // region in between their old and new locations, which can be pretty
   // inefficient since the temporarily-selected region will force stuff
   // to be recalculated. This function moves them as a unit, which can
   // be optimized.
   // <where>: where to put the cursor
   void place_cursor(TextIter* where) {
      gtk_text_buffer_place_cursor(&this, where);
   }

   // This function registers a rich text deserialization @function along with
   // its @mime_type with the passed @buffer.
   // newly registered format's mime-type.
   // RETURNS: the #GdkAtom that corresponds to the
   // <mime_type>: the format's mime-type
   // <function>: the deserialize function to register
   // <user_data>: @function's user_data
   // <user_data_destroy>: a function to call when @user_data is no longer needed
   Gdk2.Atom register_deserialize_format(char* mime_type, TextBufferDeserializeFunc function_, void* user_data, GLib2.DestroyNotify user_data_destroy) {
      return gtk_text_buffer_register_deserialize_format(&this, mime_type, function_, user_data, user_data_destroy);
   }

   // This function registers GTK+'s internal rich text serialization
   // format with the passed @buffer. See
   // gtk_text_buffer_register_serialize_tagset() for details.
   // newly registered format's mime-type.
   // RETURNS: the #GdkAtom that corresponds to the
   // <tagset_name>: an optional tagset name, on %NULL
   Gdk2.Atom register_deserialize_tagset(char* tagset_name=null) {
      return gtk_text_buffer_register_deserialize_tagset(&this, tagset_name);
   }

   // This function registers a rich text serialization @function along with
   // its @mime_type with the passed @buffer.
   // newly registered format's mime-type.
   // RETURNS: the #GdkAtom that corresponds to the
   // <mime_type>: the format's mime-type
   // <function>: the serialize function to register
   // <user_data>: %function's user_data
   // <user_data_destroy>: a function to call when @user_data is no longer needed
   Gdk2.Atom register_serialize_format(char* mime_type, TextBufferSerializeFunc function_, void* user_data, GLib2.DestroyNotify user_data_destroy) {
      return gtk_text_buffer_register_serialize_format(&this, mime_type, function_, user_data, user_data_destroy);
   }

   // This function registers GTK+'s internal rich text serialization
   // format with the passed @buffer. The internal format does not comply
   // to any standard rich text format and only works between #GtkTextBuffer
   // instances. It is capable of serializing all of a text buffer's tags
   // and embedded pixbufs.
   // This function is just a wrapper around
   // gtk_text_buffer_register_serialize_format(). The mime type used
   // for registering is "application/x-gtk-text-buffer-rich-text", or
   // "application/x-gtk-text-buffer-rich-text;format=@tagset_name" if a
   // The @tagset_name can be used to restrict the transfer of rich text
   // to buffers with compatible sets of tags, in order to avoid unknown
   // tags from being pasted. It is probably the common case to pass an
   // identifier != %NULL here, since the %NULL tagset requires the
   // receiving buffer to deal with with pasting of arbitrary tags.
   // newly registered format's mime-type.
   // RETURNS: the #GdkAtom that corresponds to the
   // <tagset_name>: an optional tagset name, on %NULL
   Gdk2.Atom register_serialize_tagset(char* tagset_name=null) {
      return gtk_text_buffer_register_serialize_tagset(&this, tagset_name);
   }

   // Removes all tags in the range between @start and @end.  Be careful
   // with this function; it could remove tags added in code unrelated to
   // the code you're currently writing. That is, using this function is
   // probably a bad idea if you have two or more unrelated code sections
   // that add tags.
   // <start>: one bound of range to be untagged
   // <end>: other bound of range to be untagged
   void remove_all_tags(TextIter* start, TextIter* end) {
      gtk_text_buffer_remove_all_tags(&this, start, end);
   }

   // Removes a #GtkClipboard added with 
   // gtk_text_buffer_add_selection_clipboard().
   // <clipboard>: a #GtkClipboard added to @buffer by gtk_text_buffer_add_selection_clipboard()
   void remove_selection_clipboard(Clipboard* clipboard) {
      gtk_text_buffer_remove_selection_clipboard(&this, clipboard);
   }

   // Emits the "remove-tag" signal. The default handler for the signal
   // removes all occurrences of @tag from the given range. @start and
   // <tag>: a #GtkTextTag
   // <start>: one bound of range to be untagged
   // <end>: other bound of range to be untagged
   void remove_tag(TextTag* tag, TextIter* start, TextIter* end) {
      gtk_text_buffer_remove_tag(&this, tag, start, end);
   }

   // Calls gtk_text_tag_table_lookup() on the buffer's tag table to
   // get a #GtkTextTag, then calls gtk_text_buffer_remove_tag().
   // <name>: name of a #GtkTextTag
   // <start>: one bound of range to be untagged
   // <end>: other bound of range to be untagged
   void remove_tag_by_name(char* name, TextIter* start, TextIter* end) {
      gtk_text_buffer_remove_tag_by_name(&this, name, start, end);
   }

   // This function moves the "insert" and "selection_bound" marks
   // simultaneously.  If you move them in two steps
   // with gtk_text_buffer_move_mark(), you will temporarily select a
   // region in between their old and new locations, which can be pretty
   // inefficient since the temporarily-selected region will force stuff
   // to be recalculated. This function moves them as a unit, which can
   // be optimized.
   // <ins>: where to put the "insert" mark
   // <bound>: where to put the "selection_bound" mark
   void select_range(TextIter* ins, TextIter* bound) {
      gtk_text_buffer_select_range(&this, ins, bound);
   }

   // This function serializes the portion of text between @start
   // and @end in the rich text format represented by @format.
   // gtk_text_buffer_register_serialize_format() or
   // gtk_text_buffer_register_serialize_tagset() beforehand.
   // data, encoded as @format
   // RETURNS: the serialized
   // <content_buffer>: the #GtkTextBuffer to serialize
   // <format>: the rich text format to use for serializing
   // <start>: start of block of text to serialize
   // <end>: end of block of test to serialize
   // <length>: return location for the length of the serialized data
   ubyte* /*new*/ serialize(TextBuffer* content_buffer, Gdk2.Atom format, TextIter* start, TextIter* end, /*out*/ size_t* length) {
      return gtk_text_buffer_serialize(&this, content_buffer, format, start, end, length);
   }

   // Used to keep track of whether the buffer has been modified since the
   // last time it was saved. Whenever the buffer is saved to disk, call
   // gtk_text_buffer_set_modified (@buffer, FALSE). When the buffer is modified,
   // it will automatically toggled on the modified bit again. When the modified
   // bit flips, the buffer emits a "modified-changed" signal.
   // <setting>: modification flag setting
   void set_modified(int setting) {
      gtk_text_buffer_set_modified(&this, setting);
   }

   // Deletes current contents of @buffer, and inserts @text instead. If
   // <text>: UTF-8 text to insert
   // <len>: length of @text in bytes
   void set_text(char* text, int len) {
      gtk_text_buffer_set_text(&this, text, len);
   }

   // This function unregisters a rich text format that was previously
   // registered using gtk_text_buffer_register_deserialize_format() or
   // gtk_text_buffer_register_deserialize_tagset().
   // <format>: a #GdkAtom representing a registered rich text format.
   void unregister_deserialize_format(Gdk2.Atom format) {
      gtk_text_buffer_unregister_deserialize_format(&this, format);
   }

   // This function unregisters a rich text format that was previously
   // registered using gtk_text_buffer_register_serialize_format() or
   // gtk_text_buffer_register_serialize_tagset()
   // <format>: a #GdkAtom representing a registered rich text format.
   void unregister_serialize_format(Gdk2.Atom format) {
      gtk_text_buffer_unregister_serialize_format(&this, format);
   }

   // The ::apply-tag signal is emitted to apply a tag to a
   // range of text in a #GtkTextBuffer. 
   // Applying actually occurs in the default handler.
   // Note that if your handler runs before the default handler it must not 
   // invalidate the @start and @end iters (or has to revalidate them). 
   // gtk_text_buffer_apply_tag(),
   // gtk_text_buffer_insert_with_tags(),
   // gtk_text_buffer_insert_range().
   // <tag>: the applied tag
   // <start>: the start of the range the tag is applied to
   // <end>: the end of the range the tag is applied to
   extern (C) alias static void function (TextBuffer* this_, TextTag* tag, TextIter* start, TextIter* end, void* user_data=null) signal_apply_tag;

   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:"apply-tag", CB/*:signal_apply_tag*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"apply-tag",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::begin-user-action signal is emitted at the beginning of a single
   // user-visible operation on a #GtkTextBuffer.
   // gtk_text_buffer_begin_user_action(),
   // gtk_text_buffer_insert_interactive(),
   // gtk_text_buffer_insert_range_interactive(),
   // gtk_text_buffer_delete_interactive(),
   // gtk_text_buffer_backspace(),
   // gtk_text_buffer_delete_selection().
   extern (C) alias static void function (TextBuffer* this_, void* user_data=null) signal_begin_user_action;
   ulong signal_connect(string name:"begin-user-action", CB/*:signal_begin_user_action*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"begin-user-action",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::changed signal is emitted when the content of a #GtkTextBuffer 
   // has changed.
   extern (C) alias static void function (TextBuffer* this_, void* user_data=null) signal_changed;
   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);
   }

   // The ::delete-range signal is emitted to delete a range 
   // from a #GtkTextBuffer. 
   // Note that if your handler runs before the default handler it must not 
   // invalidate the @start and @end iters (or has to revalidate them). 
   // The default signal handler revalidates the @start and @end iters to 
   // both point point to the location where text was deleted. Handlers
   // which run after the default handler (see g_signal_connect_after())
   // do not have access to the deleted text.
   // <start>: the start of the range to be deleted
   // <end>: the end of the range to be deleted
   extern (C) alias static void function (TextBuffer* this_, TextIter* start, TextIter* end, void* user_data=null) signal_delete_range;
   ulong signal_connect(string name:"delete-range", CB/*:signal_delete_range*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-range",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::end-user-action signal is emitted at the end of a single
   // user-visible operation on the #GtkTextBuffer.
   // gtk_text_buffer_end_user_action(),
   // gtk_text_buffer_insert_interactive(),
   // gtk_text_buffer_insert_range_interactive(),
   // gtk_text_buffer_delete_interactive(),
   // gtk_text_buffer_backspace(),
   // gtk_text_buffer_delete_selection(),
   // gtk_text_buffer_backspace().
   extern (C) alias static void function (TextBuffer* this_, void* user_data=null) signal_end_user_action;
   ulong signal_connect(string name:"end-user-action", CB/*:signal_end_user_action*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"end-user-action",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::insert-child-anchor signal is emitted to insert a
   // #GtkTextChildAnchor in a #GtkTextBuffer.
   // Insertion actually occurs in the default handler.
   // Note that if your handler runs before the default handler it must
   // not invalidate the @location iter (or has to revalidate it). 
   // The default signal handler revalidates it to be placed after the 
   // inserted @anchor.
   // <location>: position to insert @anchor in @textbuffer
   // <anchor>: the #GtkTextChildAnchor to be inserted
   extern (C) alias static void function (TextBuffer* this_, TextIter* location, TextChildAnchor* anchor, void* user_data=null) signal_insert_child_anchor;
   ulong signal_connect(string name:"insert-child-anchor", CB/*:signal_insert_child_anchor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-child-anchor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::insert-pixbuf signal is emitted to insert a #GdkPixbuf 
   // in a #GtkTextBuffer. Insertion actually occurs in the default handler.
   // Note that if your handler runs before the default handler it must not 
   // invalidate the @location iter (or has to revalidate it). 
   // The default signal handler revalidates it to be placed after the 
   // inserted @pixbuf.
   // <location>: position to insert @pixbuf in @textbuffer
   // <pixbuf>: the #GdkPixbuf to be inserted
   extern (C) alias static void function (TextBuffer* this_, TextIter* location, GdkPixbuf2.Pixbuf* pixbuf, void* user_data=null) signal_insert_pixbuf;
   ulong signal_connect(string name:"insert-pixbuf", CB/*:signal_insert_pixbuf*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-pixbuf",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::insert-text signal is emitted to insert text in a #GtkTextBuffer.
   // Insertion actually occurs in the default handler.  
   // Note that if your handler runs before the default handler it must not 
   // invalidate the @location iter (or has to revalidate it). 
   // The default signal handler revalidates it to point to the end of the 
   // inserted text.
   // gtk_text_buffer_insert(), 
   // gtk_text_buffer_insert_range().
   // <location>: position to insert @text in @textbuffer
   // <text>: the UTF-8 text to be inserted
   // <len>: length of the inserted text in bytes
   extern (C) alias static void function (TextBuffer* this_, TextIter* location, char* text, int len, void* user_data=null) signal_insert_text;
   ulong signal_connect(string name:"insert-text", CB/*:signal_insert_text*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-text",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::mark-deleted signal is emitted as notification
   // after a #GtkTextMark is deleted. 
   // See also:
   // gtk_text_buffer_delete_mark().
   // <mark>: The mark that was deleted
   extern (C) alias static void function (TextBuffer* this_, TextMark* mark, void* user_data=null) signal_mark_deleted;
   ulong signal_connect(string name:"mark-deleted", CB/*:signal_mark_deleted*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mark-deleted",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::mark-set signal is emitted as notification
   // after a #GtkTextMark is set.
   // gtk_text_buffer_create_mark(),
   // gtk_text_buffer_move_mark().
   // <location>: The location of @mark in @textbuffer
   // <mark>: The mark that is set
   extern (C) alias static void function (TextBuffer* this_, TextIter* location, TextMark* mark, void* user_data=null) signal_mark_set;
   ulong signal_connect(string name:"mark-set", CB/*:signal_mark_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mark-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::modified-changed signal is emitted when the modified bit of a 
   // #GtkTextBuffer flips.
   // See also:
   // gtk_text_buffer_set_modified().
   extern (C) alias static void function (TextBuffer* this_, void* user_data=null) signal_modified_changed;
   ulong signal_connect(string name:"modified-changed", CB/*:signal_modified_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"modified-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The paste-done signal is emitted after paste operation has been completed.
   // This is useful to properly scroll the view to the end of the pasted text.
   // See gtk_text_buffer_paste_clipboard() for more details.
   extern (C) alias static void function (TextBuffer* this_, Clipboard* since, void* user_data=null) signal_paste_done;
   ulong signal_connect(string name:"paste-done", CB/*:signal_paste_done*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"paste-done",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::remove-tag signal is emitted to remove all occurrences of @tag from
   // a range of text in a #GtkTextBuffer. 
   // Removal actually occurs in the default handler.
   // Note that if your handler runs before the default handler it must not 
   // invalidate the @start and @end iters (or has to revalidate them). 
   // gtk_text_buffer_remove_tag().
   // <tag>: the tag to be removed
   // <start>: the start of the range the tag is removed from
   // <end>: the end of the range the tag is removed from
   extern (C) alias static void function (TextBuffer* this_, TextTag* tag, TextIter* start, TextIter* end, void* user_data=null) signal_remove_tag;
   ulong signal_connect(string name:"remove-tag", CB/*:signal_remove_tag*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"remove-tag",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TextBufferClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (TextBuffer* buffer, TextIter* pos, char* text, int length) insert_text;
   // <pixbuf>: a #GdkPixbuf
   extern (C) void function (TextBuffer* buffer, TextIter* pos, GdkPixbuf2.Pixbuf* pixbuf) insert_pixbuf;
   // <anchor>: a #GtkTextChildAnchor
   extern (C) void function (TextBuffer* buffer, TextIter* pos, TextChildAnchor* anchor) insert_child_anchor;
   extern (C) void function (TextBuffer* buffer, TextIter* start, TextIter* end) delete_range;
   extern (C) void function (TextBuffer* buffer) changed;
   extern (C) void function (TextBuffer* buffer) modified_changed;
   extern (C) void function (TextBuffer* buffer, TextIter* location, TextMark* mark) mark_set;
   extern (C) void function (TextBuffer* buffer, TextMark* mark) mark_deleted;
   // <tag>: a #GtkTextTag
   extern (C) void function (TextBuffer* buffer, TextTag* tag, TextIter* start_char, TextIter* end_char) apply_tag;
   // <tag>: a #GtkTextTag
   extern (C) void function (TextBuffer* buffer, TextTag* tag, TextIter* start_char, TextIter* end_char) remove_tag;
   extern (C) void function (TextBuffer* buffer) begin_user_action;
   extern (C) void function (TextBuffer* buffer) end_user_action;
   extern (C) void function (TextBuffer* buffer, Clipboard* clipboard) paste_done;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
}

extern (C) alias int function (TextBuffer* register_buffer, TextBuffer* content_buffer, TextIter* iter, ubyte* data, size_t length, int create_tags, void* user_data, GLib2.Error** error=null) TextBufferDeserializeFunc;

extern (C) alias ubyte* function (TextBuffer* register_buffer, TextBuffer* content_buffer, TextIter* start, TextIter* end, size_t* length, void* user_data) TextBufferSerializeFunc;

enum TextBufferTargetInfo {
   BUFFER_CONTENTS = -1,
   RICH_TEXT = -2,
   TEXT = -3
}
extern (C) alias int function (dchar ch, void* user_data) TextCharPredicate;

struct TextChildAnchor /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   void* segment;


   // Creates a new #GtkTextChildAnchor. Usually you would then insert
   // it into a #GtkTextBuffer with gtk_text_buffer_insert_child_anchor().
   // To perform the creation and insertion in one step, use the
   // convenience function gtk_text_buffer_create_child_anchor().
   // RETURNS: a new #GtkTextChildAnchor
   static TextChildAnchor* /*new*/ new_() {
      return gtk_text_child_anchor_new();
   }

   // Determines whether a child anchor has been deleted from
   // the buffer. Keep in mind that the child anchor will be
   // unreferenced when removed from the buffer, so you need to
   // hold your own reference (with g_object_ref()) if you plan
   // to use this function &mdash; otherwise all deleted child anchors
   // will also be finalized.
   // RETURNS: %TRUE if the child anchor has been deleted from its buffer
   int get_deleted() {
      return gtk_text_child_anchor_get_deleted(&this);
   }

   // Gets a list of all widgets anchored at this child anchor.
   // The returned list should be freed with g_list_free().
   // RETURNS: list of widgets anchored at @anchor
   GLib2.List* /*new container*/ get_widgets() {
      return gtk_text_child_anchor_get_widgets(&this);
   }
   void queue_resize(TextLayout* layout) {
      gtk_text_child_anchor_queue_resize(&this, layout);
   }
   void register_child(Widget* child, TextLayout* layout) {
      gtk_text_child_anchor_register_child(&this, child, layout);
   }
   void unregister_child(Widget* child) {
      gtk_text_child_anchor_unregister_child(&this, child);
   }
}

struct TextChildAnchorClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TextCursorDisplay {
   int x, y, height;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "is_strong", 1,
   uint, "is_weak", 1,
    uint, "__dummy32A", 30));
}

enum TextDirection {
   NONE = 0,
   LTR = 1,
   RTL = 2
}
extern (C) alias void function (OldEditable* editable, uint time_) TextFunction;

struct TextIter {
   private void* dummy1, dummy2;
   private int dummy3, dummy4, dummy5, dummy6, dummy7, dummy8;
   private void* dummy9, dummy10;
   private int dummy11, dummy12, dummy13;
   private void* dummy14;


   // Moves backward by one character offset. Returns %TRUE if movement
   // was possible; if @iter was the first in the buffer (character
   // offset 0), gtk_text_iter_backward_char () returns %FALSE for convenience when
   // writing loops.
   // RETURNS: whether movement was possible
   int backward_char() {
      return gtk_text_iter_backward_char(&this);
   }

   // Moves @count characters backward, if possible (if @count would move
   // past the start or end of the buffer, moves to the start or end of
   // the buffer).  The return value indicates whether the iterator moved
   // onto a dereferenceable position; if the iterator didn't move, or
   // moved onto the end iterator, then %FALSE is returned. If @count is 0,
   // the function does nothing and returns %FALSE.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of characters to move
   int backward_chars(int count) {
      return gtk_text_iter_backward_chars(&this, count);
   }

   // Like gtk_text_iter_forward_cursor_position(), but moves backward.
   // RETURNS: %TRUE if we moved
   int backward_cursor_position() {
      return gtk_text_iter_backward_cursor_position(&this);
   }

   // Moves up to @count cursor positions. See
   // gtk_text_iter_forward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   // <count>: number of positions to move
   int backward_cursor_positions(int count) {
      return gtk_text_iter_backward_cursor_positions(&this, count);
   }

   // Same as gtk_text_iter_forward_find_char(), but goes backward from @iter.
   // RETURNS: whether a match was found
   // <pred>: function to be called on each character
   // <user_data>: user data for @pred
   // <limit>: search limit, or %NULL for none
   int backward_find_char(TextCharPredicate pred, void* user_data, TextIter* limit=null) {
      return gtk_text_iter_backward_find_char(&this, pred, user_data, limit);
   }

   // Moves @iter to the start of the previous line. Returns %TRUE if
   // function returns %FALSE. Therefore if @iter was already on line 0,
   // but not at the start of the line, @iter is snapped to the start of
   // the line and the function returns %TRUE. (Note that this implies that
   // in a loop calling this function, the line number may not change on
   // every iteration, if your first iteration is on line 0.)
   // RETURNS: whether @iter moved
   int backward_line() {
      return gtk_text_iter_backward_line(&this);
   }

   // Moves @count lines backward, if possible (if @count would move
   // past the start or end of the buffer, moves to the start or end of
   // the buffer).  The return value indicates whether the iterator moved
   // onto a dereferenceable position; if the iterator didn't move, or
   // moved onto the end iterator, then %FALSE is returned. If @count is 0,
   // the function does nothing and returns %FALSE. If @count is negative,
   // moves forward by 0 - @count lines.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of lines to move backward
   int backward_lines(int count) {
      return gtk_text_iter_backward_lines(&this, count);
   }

   // Same as gtk_text_iter_forward_search(), but moves backward.
   // RETURNS: whether a match was found
   // <str>: search string
   // <flags>: bitmask of flags affecting the search
   // <match_start>: return location for start of match, or %NULL
   // <match_end>: return location for end of match, or %NULL
   // <limit>: location of last possible @match_start, or %NULL for start of buffer
   int backward_search(char* str, TextSearchFlags flags, /*out*/ TextIter* match_start=null, /*out*/ TextIter* match_end=null, TextIter* limit=null) {
      return gtk_text_iter_backward_search(&this, str, flags, match_start, match_end, limit);
   }

   // Moves backward to the previous sentence start; if @iter is already at
   // the start of a sentence, moves backward to the next one.  Sentence
   // boundaries are determined by Pango and should be correct for nearly
   // any language (if not, the correct fix would be to the Pango text
   // boundary algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int backward_sentence_start() {
      return gtk_text_iter_backward_sentence_start(&this);
   }

   // Calls gtk_text_iter_backward_sentence_start() up to @count times,
   // or until it returns %FALSE. If @count is negative, moves forward
   // instead of backward.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of sentences to move
   int backward_sentence_starts(int count) {
      return gtk_text_iter_backward_sentence_starts(&this, count);
   }

   // Moves backward to the next toggle (on or off) of the
   // #GtkTextTag @tag, or to the next toggle of any tag if
   // returns %FALSE, otherwise %TRUE. Does not return toggles
   // located at @iter, only toggles before @iter. Sets @iter
   // to the location of the toggle, or the start of the buffer
   // if no toggle is found.
   // RETURNS: whether we found a tag toggle before @iter
   // <tag>: a #GtkTextTag, or %NULL
   int backward_to_tag_toggle(TextTag* tag=null) {
      return gtk_text_iter_backward_to_tag_toggle(&this, tag);
   }

   // Moves @iter forward to the previous visible cursor position. See 
   // gtk_text_iter_backward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   int backward_visible_cursor_position() {
      return gtk_text_iter_backward_visible_cursor_position(&this);
   }

   // Moves up to @count visible cursor positions. See
   // gtk_text_iter_backward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   // <count>: number of positions to move
   int backward_visible_cursor_positions(int count) {
      return gtk_text_iter_backward_visible_cursor_positions(&this, count);
   }

   // Moves @iter to the start of the previous visible line. Returns %TRUE if
   // function returns %FALSE. Therefore if @iter was already on line 0,
   // but not at the start of the line, @iter is snapped to the start of
   // the line and the function returns %TRUE. (Note that this implies that
   // in a loop calling this function, the line number may not change on
   // every iteration, if your first iteration is on line 0.)
   // RETURNS: whether @iter moved
   int backward_visible_line() {
      return gtk_text_iter_backward_visible_line(&this);
   }

   // Moves @count visible lines backward, if possible (if @count would move
   // past the start or end of the buffer, moves to the start or end of
   // the buffer).  The return value indicates whether the iterator moved
   // onto a dereferenceable position; if the iterator didn't move, or
   // moved onto the end iterator, then %FALSE is returned. If @count is 0,
   // the function does nothing and returns %FALSE. If @count is negative,
   // moves forward by 0 - @count lines.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of lines to move backward
   int backward_visible_lines(int count) {
      return gtk_text_iter_backward_visible_lines(&this, count);
   }

   // Moves backward to the previous visible word start. (If @iter is currently 
   // on a word start, moves backward to the next one after that.) Word breaks
   // are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int backward_visible_word_start() {
      return gtk_text_iter_backward_visible_word_start(&this);
   }

   // Calls gtk_text_iter_backward_visible_word_start() up to @count times.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of times to move
   int backward_visible_word_starts(int count) {
      return gtk_text_iter_backward_visible_word_starts(&this, count);
   }

   // Moves backward to the previous word start. (If @iter is currently on a
   // word start, moves backward to the next one after that.) Word breaks
   // are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int backward_word_start() {
      return gtk_text_iter_backward_word_start(&this);
   }

   // Calls gtk_text_iter_backward_word_start() up to @count times.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of times to move
   int backward_word_starts(int count) {
      return gtk_text_iter_backward_word_starts(&this, count);
   }

   // Returns %TRUE if @tag is toggled on at exactly this point. If @tag
   // is %NULL, returns %TRUE if any tag is toggled on at this point. Note
   // that the gtk_text_iter_begins_tag () returns %TRUE if @iter is the
   // <emphasis>start</emphasis> of the tagged range;
   // gtk_text_iter_has_tag () tells you whether an iterator is
   // <emphasis>within</emphasis> a tagged range.
   // RETURNS: whether @iter is the start of a range tagged with @tag
   // <tag>: a #GtkTextTag, or %NULL
   int begins_tag(TextTag* tag=null) {
      return gtk_text_iter_begins_tag(&this, tag);
   }

   // Considering the default editability of the buffer, and tags that
   // affect editability, determines whether text inserted at @iter would
   // be editable. If text inserted at @iter would be editable then the
   // user should be allowed to insert text at @iter.
   // gtk_text_buffer_insert_interactive() uses this function to decide
   // whether insertions are allowed at a given position.
   // RETURNS: whether text inserted at @iter would be editable
   // <default_editability>: %TRUE if text is editable by default
   int can_insert(int default_editability) {
      return gtk_text_iter_can_insert(&this, default_editability);
   }

   // A qsort()-style function that returns negative if @lhs is less than
   // Ordering is in character offset order, i.e. the first character in the buffer
   // is less than the second character in the buffer.
   // RETURNS: -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
   // <rhs>: another #GtkTextIter
   int compare(TextIter* rhs) {
      return gtk_text_iter_compare(&this, rhs);
   }

   // Creates a dynamically-allocated copy of an iterator. This function
   // is not useful in applications, because iterators can be copied with a
   // simple assignment (<literal>GtkTextIter i = j;</literal>). The
   // function is used by language bindings.
   // RETURNS: a copy of the @iter, free with gtk_text_iter_free ()
   TextIter* /*new*/ copy() {
      return gtk_text_iter_copy(&this);
   }

   // Returns whether the character at @iter is within an editable region
   // of text.  Non-editable text is "locked" and can't be changed by the
   // user via #GtkTextView. This function is simply a convenience
   // wrapper around gtk_text_iter_get_attributes (). If no tags applied
   // to this text affect editability, @default_setting will be returned.
   // You don't want to use this function to decide whether text can be
   // inserted at @iter, because for insertion you don't want to know
   // whether the char at @iter is inside an editable range, you want to
   // know whether a new character inserted at @iter would be inside an
   // editable range. Use gtk_text_iter_can_insert() to handle this
   // case.
   // RETURNS: whether @iter is inside an editable range
   // <default_setting>: %TRUE if text is editable by default
   int editable(int default_setting) {
      return gtk_text_iter_editable(&this, default_setting);
   }

   // Returns %TRUE if @iter points to the start of the paragraph
   // delimiter characters for a line (delimiters will be either a
   // newline, a carriage return, a carriage return followed by a
   // newline, or a Unicode paragraph separator character). Note that an
   // iterator pointing to the \n of a \r\n pair will not be counted as
   // the end of a line, the line ends before the \r. The end iterator is
   // considered to be at the end of a line, even though there are no
   // paragraph delimiter chars there.
   // RETURNS: whether @iter is at the end of a line
   int ends_line() {
      return gtk_text_iter_ends_line(&this);
   }

   // Determines whether @iter ends a sentence.  Sentence boundaries are
   // determined by Pango and should be correct for nearly any language
   // (if not, the correct fix would be to the Pango text boundary
   // algorithms).
   // RETURNS: %TRUE if @iter is at the end of a sentence.
   int ends_sentence() {
      return gtk_text_iter_ends_sentence(&this);
   }

   // Returns %TRUE if @tag is toggled off at exactly this point. If @tag
   // is %NULL, returns %TRUE if any tag is toggled off at this point. Note
   // that the gtk_text_iter_ends_tag () returns %TRUE if @iter is the
   // <emphasis>end</emphasis> of the tagged range;
   // gtk_text_iter_has_tag () tells you whether an iterator is
   // <emphasis>within</emphasis> a tagged range.
   // RETURNS: whether @iter is the end of a range tagged with @tag
   // <tag>: a #GtkTextTag, or %NULL
   int ends_tag(TextTag* tag=null) {
      return gtk_text_iter_ends_tag(&this, tag);
   }

   // Determines whether @iter ends a natural-language word.  Word breaks
   // are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter is at the end of a word
   int ends_word() {
      return gtk_text_iter_ends_word(&this);
   }

   // Tests whether two iterators are equal, using the fastest possible
   // mechanism. This function is very fast; you can expect it to perform
   // better than e.g. getting the character offset for each iterator and
   // comparing the offsets yourself. Also, it's a bit faster than
   // gtk_text_iter_compare().
   // RETURNS: %TRUE if the iterators point to the same place in the buffer
   // <rhs>: another #GtkTextIter
   int equal(TextIter* rhs) {
      return gtk_text_iter_equal(&this, rhs);
   }

   // Moves @iter forward by one character offset. Note that images
   // embedded in the buffer occupy 1 character slot, so
   // gtk_text_iter_forward_char () may actually move onto an image instead
   // of a character, if you have images in your buffer.  If @iter is the
   // end iterator or one character before it, @iter will now point at
   // the end iterator, and gtk_text_iter_forward_char () returns %FALSE for
   // convenience when writing loops.
   // RETURNS: whether @iter moved and is dereferenceable
   int forward_char() {
      return gtk_text_iter_forward_char(&this);
   }

   // Moves @count characters if possible (if @count would move past the
   // start or end of the buffer, moves to the start or end of the
   // buffer). The return value indicates whether the new position of
   // (the last iterator in the buffer is not dereferenceable). If @count
   // is 0, the function does nothing and returns %FALSE.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of characters to move, may be negative
   int forward_chars(int count) {
      return gtk_text_iter_forward_chars(&this, count);
   }

   // Moves @iter forward by a single cursor position. Cursor positions
   // are (unsurprisingly) positions where the cursor can appear. Perhaps
   // surprisingly, there may not be a cursor position between all
   // characters. The most common example for European languages would be
   // a carriage return/newline sequence. For some Unicode characters,
   // the equivalent of say the letter "a" with an accent mark will be
   // represented as two characters, first the letter then a "combining
   // mark" that causes the accent to be rendered; so the cursor can't go
   // between those two characters. See also the #PangoLogAttr structure and
   // pango_break() function.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   int forward_cursor_position() {
      return gtk_text_iter_forward_cursor_position(&this);
   }

   // Moves up to @count cursor positions. See
   // gtk_text_iter_forward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   // <count>: number of positions to move
   int forward_cursor_positions(int count) {
      return gtk_text_iter_forward_cursor_positions(&this, count);
   }

   // Advances @iter, calling @pred on each character. If
   // If @pred never returns %TRUE, @iter is set to @limit if
   // RETURNS: whether a match was found
   // <pred>: a function to be called on each character
   // <user_data>: user data for @pred
   // <limit>: search limit, or %NULL for none
   int forward_find_char(TextCharPredicate pred, void* user_data, TextIter* limit=null) {
      return gtk_text_iter_forward_find_char(&this, pred, user_data, limit);
   }

   // Moves @iter to the start of the next line. If the iter is already on the
   // last line of the buffer, moves the iter to the end of the current line.
   // If after the operation, the iter is at the end of the buffer and not
   // dereferencable, returns %FALSE. Otherwise, returns %TRUE.
   // RETURNS: whether @iter can be dereferenced
   int forward_line() {
      return gtk_text_iter_forward_line(&this);
   }

   // Moves @count lines forward, if possible (if @count would move
   // past the start or end of the buffer, moves to the start or end of
   // the buffer).  The return value indicates whether the iterator moved
   // onto a dereferenceable position; if the iterator didn't move, or
   // moved onto the end iterator, then %FALSE is returned. If @count is 0,
   // the function does nothing and returns %FALSE. If @count is negative,
   // moves backward by 0 - @count lines.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of lines to move forward
   int forward_lines(int count) {
      return gtk_text_iter_forward_lines(&this, count);
   }

   // Searches forward for @str. Any match is returned by setting
   // first character after the match. The search will not continue past
   // may wish to use @limit to avoid locking up your UI on large
   // buffers.
   // If the #GTK_TEXT_SEARCH_VISIBLE_ONLY flag is present, the match may
   // have invisible text interspersed in @str. i.e. @str will be a
   // possibly-noncontiguous subsequence of the matched range. similarly,
   // if you specify #GTK_TEXT_SEARCH_TEXT_ONLY, the match may have
   // pixbufs or child widgets mixed inside the matched range. If these
   // flags are not given, the match must be exact; the special 0xFFFC
   // character in @str will match embedded pixbufs or child widgets.
   // RETURNS: whether a match was found
   // <str>: a search string
   // <flags>: flags affecting how the search is done
   // <match_start>: return location for start of match, or %NULL
   // <match_end>: return location for end of match, or %NULL
   // <limit>: bound for the search, or %NULL for the end of the buffer
   int forward_search(char* str, TextSearchFlags flags, /*out*/ TextIter* match_start=null, /*out*/ TextIter* match_end=null, TextIter* limit=null) {
      return gtk_text_iter_forward_search(&this, str, flags, match_start, match_end, limit);
   }

   // Moves forward to the next sentence end. (If @iter is at the end of
   // a sentence, moves to the next end of sentence.)  Sentence
   // boundaries are determined by Pango and should be correct for nearly
   // any language (if not, the correct fix would be to the Pango text
   // boundary algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int forward_sentence_end() {
      return gtk_text_iter_forward_sentence_end(&this);
   }

   // Calls gtk_text_iter_forward_sentence_end() @count times (or until
   // gtk_text_iter_forward_sentence_end() returns %FALSE). If @count is
   // negative, moves backward instead of forward.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of sentences to move
   int forward_sentence_ends(int count) {
      return gtk_text_iter_forward_sentence_ends(&this, count);
   }

   // Moves @iter forward to the "end iterator," which points one past the last
   // valid character in the buffer. gtk_text_iter_get_char() called on the
   // end iterator returns 0, which is convenient for writing loops.
   void forward_to_end() {
      gtk_text_iter_forward_to_end(&this);
   }

   // Moves the iterator to point to the paragraph delimiter characters,
   // which will be either a newline, a carriage return, a carriage
   // return/newline in sequence, or the Unicode paragraph separator
   // character. If the iterator is already at the paragraph delimiter
   // characters, moves to the paragraph delimiter characters for the
   // next line. If @iter is on the last line in the buffer, which does
   // not end in paragraph delimiters, moves to the end iterator (end of
   // the last line), and returns %FALSE.
   // RETURNS: %TRUE if we moved and the new location is not the end iterator
   int forward_to_line_end() {
      return gtk_text_iter_forward_to_line_end(&this);
   }

   // Moves forward to the next toggle (on or off) of the
   // #GtkTextTag @tag, or to the next toggle of any tag if
   // returns %FALSE, otherwise %TRUE. Does not return toggles
   // located at @iter, only toggles after @iter. Sets @iter to
   // the location of the toggle, or to the end of the buffer
   // if no toggle is found.
   // RETURNS: whether we found a tag toggle after @iter
   // <tag>: a #GtkTextTag, or %NULL
   int forward_to_tag_toggle(TextTag* tag=null) {
      return gtk_text_iter_forward_to_tag_toggle(&this, tag);
   }

   // Moves @iter forward to the next visible cursor position. See 
   // gtk_text_iter_forward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   int forward_visible_cursor_position() {
      return gtk_text_iter_forward_visible_cursor_position(&this);
   }

   // Moves up to @count visible cursor positions. See
   // gtk_text_iter_forward_cursor_position() for details.
   // RETURNS: %TRUE if we moved and the new position is dereferenceable
   // <count>: number of positions to move
   int forward_visible_cursor_positions(int count) {
      return gtk_text_iter_forward_visible_cursor_positions(&this, count);
   }

   // Moves @iter to the start of the next visible line. Returns %TRUE if there
   // was a next line to move to, and %FALSE if @iter was simply moved to
   // the end of the buffer and is now not dereferenceable, or if @iter was
   // already at the end of the buffer.
   // RETURNS: whether @iter can be dereferenced
   int forward_visible_line() {
      return gtk_text_iter_forward_visible_line(&this);
   }

   // Moves @count visible lines forward, if possible (if @count would move
   // past the start or end of the buffer, moves to the start or end of
   // the buffer).  The return value indicates whether the iterator moved
   // onto a dereferenceable position; if the iterator didn't move, or
   // moved onto the end iterator, then %FALSE is returned. If @count is 0,
   // the function does nothing and returns %FALSE. If @count is negative,
   // moves backward by 0 - @count lines.
   // RETURNS: whether @iter moved and is dereferenceable
   // <count>: number of lines to move forward
   int forward_visible_lines(int count) {
      return gtk_text_iter_forward_visible_lines(&this, count);
   }

   // Moves forward to the next visible word end. (If @iter is currently on a
   // word end, moves forward to the next one after that.) Word breaks
   // are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int forward_visible_word_end() {
      return gtk_text_iter_forward_visible_word_end(&this);
   }

   // Calls gtk_text_iter_forward_visible_word_end() up to @count times.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of times to move
   int forward_visible_word_ends(int count) {
      return gtk_text_iter_forward_visible_word_ends(&this, count);
   }

   // Moves forward to the next word end. (If @iter is currently on a
   // word end, moves forward to the next one after that.) Word breaks
   // are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   int forward_word_end() {
      return gtk_text_iter_forward_word_end(&this);
   }

   // Calls gtk_text_iter_forward_word_end() up to @count times.
   // RETURNS: %TRUE if @iter moved and is not the end iterator
   // <count>: number of times to move
   int forward_word_ends(int count) {
      return gtk_text_iter_forward_word_ends(&this, count);
   }

   // Free an iterator allocated on the heap. This function
   // is intended for use in language bindings, and is not
   // especially useful for applications, because iterators can
   // simply be allocated on the stack.
   void free() {
      gtk_text_iter_free(&this);
   }

   // Computes the effect of any tags applied to this spot in the
   // text. The @values parameter should be initialized to the default
   // settings you wish to use if no tags are in effect. You'd typically
   // obtain the defaults from gtk_text_view_get_default_attributes().
   // gtk_text_iter_get_attributes () will modify @values, applying the
   // effects of any tags present at @iter. If any tags affected @values,
   // the function returns %TRUE.
   // RETURNS: %TRUE if @values was modified
   // <values>: a #GtkTextAttributes to be filled in
   int get_attributes(/*out*/ TextAttributes* values) {
      return gtk_text_iter_get_attributes(&this, values);
   }

   // Returns the #GtkTextBuffer this iterator is associated with.
   // RETURNS: the buffer
   TextBuffer* get_buffer() {
      return gtk_text_iter_get_buffer(&this);
   }

   // Returns the number of bytes in the line containing @iter,
   // including the paragraph delimiters.
   // RETURNS: number of bytes in the line
   int get_bytes_in_line() {
      return gtk_text_iter_get_bytes_in_line(&this);
   }

   // Returns the Unicode character at this iterator.  (Equivalent to
   // operator* on a C++ iterator.)  If the element at this iterator is a
   // non-character element, such as an image embedded in the buffer, the
   // Unicode "unknown" character 0xFFFC is returned. If invoked on
   // the end iterator, zero is returned; zero is not a valid Unicode character.
   // So you can write a loop which ends when gtk_text_iter_get_char ()
   // returns 0.
   // RETURNS: a Unicode character, or 0 if @iter is not dereferenceable
   dchar get_char() {
      return gtk_text_iter_get_char(&this);
   }

   // Returns the number of characters in the line containing @iter,
   // including the paragraph delimiters.
   // RETURNS: number of characters in the line
   int get_chars_in_line() {
      return gtk_text_iter_get_chars_in_line(&this);
   }

   // If the location at @iter contains a child anchor, the
   // anchor is returned (with no new reference count added). Otherwise,
   // %NULL is returned.
   // RETURNS: the anchor at @iter
   TextChildAnchor* get_child_anchor() {
      return gtk_text_iter_get_child_anchor(&this);
   }

   // A convenience wrapper around gtk_text_iter_get_attributes (),
   // which returns the language in effect at @iter. If no tags affecting
   // language apply to @iter, the return value is identical to that of
   // gtk_get_default_language ().
   // RETURNS: language in effect at @iter
   Pango.Language* /*new*/ get_language() {
      return gtk_text_iter_get_language(&this);
   }

   // Returns the line number containing the iterator. Lines in
   // a #GtkTextBuffer are numbered beginning with 0 for the first
   // line in the buffer.
   // RETURNS: a line number
   int get_line() {
      return gtk_text_iter_get_line(&this);
   }

   // Returns the byte index of the iterator, counting
   // from the start of a newline-terminated line.
   // Remember that #GtkTextBuffer encodes text in
   // UTF-8, and that characters can require a variable
   // number of bytes to represent.
   // RETURNS: distance from start of line, in bytes
   int get_line_index() {
      return gtk_text_iter_get_line_index(&this);
   }

   // Returns the character offset of the iterator,
   // counting from the start of a newline-terminated line.
   // The first character on the line has offset 0.
   // RETURNS: offset from start of line
   int get_line_offset() {
      return gtk_text_iter_get_line_offset(&this);
   }

   // Returns a list of all #GtkTextMark at this location. Because marks
   // are not iterable (they don't take up any "space" in the buffer,
   // they are just marks in between iterable locations), multiple marks
   // can exist in the same place. The returned list is not in any
   // meaningful order.
   // RETURNS: list of #GtkTextMark
   GLib2.SList* /*new container*/ get_marks() {
      return gtk_text_iter_get_marks(&this);
   }

   // Returns the character offset of an iterator.
   // Each character in a #GtkTextBuffer has an offset,
   // starting with 0 for the first character in the buffer.
   // Use gtk_text_buffer_get_iter_at_offset () to convert an
   // offset back into an iterator.
   // RETURNS: a character offset
   int get_offset() {
      return gtk_text_iter_get_offset(&this);
   }

   // If the element at @iter is a pixbuf, the pixbuf is returned
   // (with no new reference count added). Otherwise,
   // %NULL is returned.
   // RETURNS: the pixbuf at @iter
   GdkPixbuf2.Pixbuf* get_pixbuf() {
      return gtk_text_iter_get_pixbuf(&this);
   }

   // Returns the text in the given range. A "slice" is an array of
   // characters encoded in UTF-8 format, including the Unicode "unknown"
   // character 0xFFFC for iterable non-character elements in the buffer,
   // such as images.  Because images are encoded in the slice, byte and
   // character offsets in the returned array will correspond to byte
   // offsets in the text buffer. Note that 0xFFFC can occur in normal
   // text as well, so it is not a reliable indicator that a pixbuf or
   // widget is in the buffer.
   // RETURNS: slice of text from the buffer
   // <end>: iterator at end of a range
   char* /*new*/ get_slice(TextIter* end) {
      return gtk_text_iter_get_slice(&this, end);
   }

   // Returns a list of tags that apply to @iter, in ascending order of
   // priority (highest-priority tags are last). The #GtkTextTag in the
   // list don't have a reference added, but you have to free the list
   // itself.
   // RETURNS: list of #GtkTextTag
   GLib2.SList* /*new container*/ get_tags() {
      return gtk_text_iter_get_tags(&this);
   }

   // Returns <emphasis>text</emphasis> in the given range.  If the range
   // contains non-text elements such as images, the character and byte
   // offsets in the returned string will not correspond to character and
   // byte offsets in the buffer. If you want offsets to correspond, see
   // gtk_text_iter_get_slice ().
   // RETURNS: array of characters from the buffer
   // <end>: iterator at end of a range
   char* /*new*/ get_text(TextIter* end) {
      return gtk_text_iter_get_text(&this, end);
   }

   // Returns a list of #GtkTextTag that are toggled on or off at this
   // point.  (If @toggled_on is %TRUE, the list contains tags that are
   // toggled on.) If a tag is toggled on at @iter, then some non-empty
   // range of characters following @iter has that tag applied to it.  If
   // a tag is toggled off, then some non-empty range following @iter
   // does <emphasis>not</emphasis> have the tag applied to it.
   // RETURNS: tags toggled at this point
   // <toggled_on>: %TRUE to get toggled-on tags
   GLib2.SList* /*new container*/ get_toggled_tags(int toggled_on) {
      return gtk_text_iter_get_toggled_tags(&this, toggled_on);
   }

   // Returns the number of bytes from the start of the
   // line to the given @iter, not counting bytes that
   // are invisible due to tags with the "invisible" flag
   // toggled on.
   // RETURNS: byte index of @iter with respect to the start of the line
   int get_visible_line_index() {
      return gtk_text_iter_get_visible_line_index(&this);
   }

   // Returns the offset in characters from the start of the
   // line to the given @iter, not counting characters that
   // are invisible due to tags with the "invisible" flag
   // toggled on.
   // RETURNS: offset in visible characters from the start of the line
   int get_visible_line_offset() {
      return gtk_text_iter_get_visible_line_offset(&this);
   }

   // Like gtk_text_iter_get_slice (), but invisible text is not included.
   // Invisible text is usually invisible because a #GtkTextTag with the
   // "invisible" attribute turned on has been applied to it.
   // RETURNS: slice of text from the buffer
   // <end>: iterator at end of range
   char* /*new*/ get_visible_slice(TextIter* end) {
      return gtk_text_iter_get_visible_slice(&this, end);
   }

   // Like gtk_text_iter_get_text (), but invisible text is not included.
   // Invisible text is usually invisible because a #GtkTextTag with the
   // "invisible" attribute turned on has been applied to it.
   // RETURNS: string containing visible text in the range
   // <end>: iterator at end of range
   char* /*new*/ get_visible_text(TextIter* end) {
      return gtk_text_iter_get_visible_text(&this, end);
   }

   // Returns %TRUE if @iter is within a range tagged with @tag.
   // RETURNS: whether @iter is tagged with @tag
   // <tag>: a #GtkTextTag
   int has_tag(TextTag* tag) {
      return gtk_text_iter_has_tag(&this, tag);
   }

   // Checks whether @iter falls in the range [@start, @end).
   // RETURNS: %TRUE if @iter is in the range
   // <start>: start of range
   // <end>: end of range
   int in_range(TextIter* start, TextIter* end) {
      return gtk_text_iter_in_range(&this, start, end);
   }

   // Determines whether @iter is inside a sentence (as opposed to in
   // between two sentences, e.g. after a period and before the first
   // letter of the next sentence).  Sentence boundaries are determined
   // by Pango and should be correct for nearly any language (if not, the
   // correct fix would be to the Pango text boundary algorithms).
   // RETURNS: %TRUE if @iter is inside a sentence.
   int inside_sentence() {
      return gtk_text_iter_inside_sentence(&this);
   }

   // Determines whether @iter is inside a natural-language word (as
   // opposed to say inside some whitespace).  Word breaks are determined
   // by Pango and should be correct for nearly any language (if not, the
   // correct fix would be to the Pango word break algorithms).
   // RETURNS: %TRUE if @iter is inside a word
   int inside_word() {
      return gtk_text_iter_inside_word(&this);
   }

   // See gtk_text_iter_forward_cursor_position() or #PangoLogAttr or
   // pango_break() for details on what a cursor position is.
   // RETURNS: %TRUE if the cursor can be placed at @iter
   int is_cursor_position() {
      return gtk_text_iter_is_cursor_position(&this);
   }

   // Returns %TRUE if @iter is the end iterator, i.e. one past the last
   // dereferenceable iterator in the buffer. gtk_text_iter_is_end () is
   // the most efficient way to check whether an iterator is the end
   // iterator.
   // RETURNS: whether @iter is the end iterator
   int is_end() {
      return gtk_text_iter_is_end(&this);
   }

   // Returns %TRUE if @iter is the first iterator in the buffer, that is
   // if @iter has a character offset of 0.
   // RETURNS: whether @iter is the first in the buffer
   int is_start() {
      return gtk_text_iter_is_start(&this);
   }

   // Swaps the value of @first and @second if @second comes before
   // in sequence. Most text buffer functions that take a range call this
   // automatically on your behalf, so there's no real reason to call it yourself
   // in those cases. There are some exceptions, such as gtk_text_iter_in_range(),
   // that expect a pre-sorted range.
   // <second>: another #GtkTextIter
   void order(TextIter* second) {
      gtk_text_iter_order(&this, second);
   }

   // Moves iterator @iter to the start of the line @line_number.  If
   // buffer, moves @iter to the start of the last line in the buffer.
   // <line_number>: line number (counted from 0)
   void set_line(int line_number) {
      gtk_text_iter_set_line(&this, line_number);
   }

   // Same as gtk_text_iter_set_line_offset(), but works with a
   // <emphasis>byte</emphasis> index. The given byte index must be at
   // the start of a character, it can't be in the middle of a UTF-8
   // encoded character.
   // <byte_on_line>: a byte index relative to the start of @iter's current line
   void set_line_index(int byte_on_line) {
      gtk_text_iter_set_line_index(&this, byte_on_line);
   }

   // Moves @iter within a line, to a new <emphasis>character</emphasis>
   // (not byte) offset. The given character offset must be less than or
   // equal to the number of characters in the line; if equal, @iter
   // moves to the start of the next line. See
   // gtk_text_iter_set_line_index() if you have a byte index rather than
   // a character offset.
   // <char_on_line>: a character offset relative to the start of @iter's current line
   void set_line_offset(int char_on_line) {
      gtk_text_iter_set_line_offset(&this, char_on_line);
   }

   // Sets @iter to point to @char_offset. @char_offset counts from the start
   // of the entire text buffer, starting with 0.
   // <char_offset>: a character number
   void set_offset(int char_offset) {
      gtk_text_iter_set_offset(&this, char_offset);
   }

   // Like gtk_text_iter_set_line_index(), but the index is in visible
   // bytes, i.e. text with a tag making it invisible is not counted
   // in the index.
   // <byte_on_line>: a byte index
   void set_visible_line_index(int byte_on_line) {
      gtk_text_iter_set_visible_line_index(&this, byte_on_line);
   }

   // Like gtk_text_iter_set_line_offset(), but the offset is in visible
   // characters, i.e. text with a tag making it invisible is not
   // counted in the offset.
   // <char_on_line>: a character offset
   void set_visible_line_offset(int char_on_line) {
      gtk_text_iter_set_visible_line_offset(&this, char_on_line);
   }

   // Returns %TRUE if @iter begins a paragraph,
   // i.e. if gtk_text_iter_get_line_offset () would return 0.
   // However this function is potentially more efficient than
   // gtk_text_iter_get_line_offset () because it doesn't have to compute
   // the offset, it just has to see whether it's 0.
   // RETURNS: whether @iter begins a line
   int starts_line() {
      return gtk_text_iter_starts_line(&this);
   }

   // Determines whether @iter begins a sentence.  Sentence boundaries are
   // determined by Pango and should be correct for nearly any language
   // (if not, the correct fix would be to the Pango text boundary
   // algorithms).
   // RETURNS: %TRUE if @iter is at the start of a sentence.
   int starts_sentence() {
      return gtk_text_iter_starts_sentence(&this);
   }

   // Determines whether @iter begins a natural-language word.  Word
   // breaks are determined by Pango and should be correct for nearly any
   // language (if not, the correct fix would be to the Pango word break
   // algorithms).
   // RETURNS: %TRUE if @iter is at the start of a word
   int starts_word() {
      return gtk_text_iter_starts_word(&this);
   }

   // This is equivalent to (gtk_text_iter_begins_tag () ||
   // gtk_text_iter_ends_tag ()), i.e. it tells you whether a range with
   // RETURNS: whether @tag is toggled on or off at @iter
   // <tag>: a #GtkTextTag, or %NULL
   int toggles_tag(TextTag* tag=null) {
      return gtk_text_iter_toggles_tag(&this, tag);
   }
}

struct TextLayout /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   int screen_width, width, height;
   TextBuffer* buffer;
   TextAttributes* default_style;
   Pango.Context* ltr_context, rtl_context;
   TextAttributes* one_style_cache;
   TextLineDisplay* one_display_cache;
   int wrap_loop_count;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "cursor_visible", 1,
   uint, "cursor_direction", 2,
   uint, "keyboard_direction", 2,
    uint, "__dummy32A", 27));
   char* preedit_string;
   Pango.AttrList* preedit_attrs;
   int preedit_len, preedit_cursor;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "overwrite_mode", 1,
    uint, "__dummy32B", 31));

   static TextLayout* /*new*/ new_() {
      return gtk_text_layout_new();
   }
   void changed(int y, int old_height, int new_height) {
      gtk_text_layout_changed(&this, y, old_height, new_height);
   }

   // If the iterator is not fully in the range @top <= y < @bottom,
   // then, if possible, move it the minimum distance so that the
   // iterator in this range.
   // RETURNS: %TRUE if the iterator was moved, otherwise %FALSE.
   // <iter>: a #GtkTextIter
   // <top>: the top of the range
   // <bottom>: the bottom the range
   int clamp_iter_to_vrange(TextIter* iter, int top, int bottom) {
      return gtk_text_layout_clamp_iter_to_vrange(&this, iter, top, bottom);
   }
   void cursors_changed(int y, int old_height, int new_height) {
      gtk_text_layout_cursors_changed(&this, y, old_height, new_height);
   }
   void default_style_changed() {
      gtk_text_layout_default_style_changed(&this);
   }
   void draw(Widget* widget, Gdk2.Drawable* drawable, Gdk2.GC* cursor_gc, int x_offset, int y_offset, int x, int y, int width, int height, GLib2.List** widgets) {
      gtk_text_layout_draw(&this, widget, drawable, cursor_gc, x_offset, y_offset, x, y, width, height, widgets);
   }
   void free_line_data(TextLine* line, TextLineData* line_data) {
      gtk_text_layout_free_line_data(&this, line, line_data);
   }
   void free_line_display(TextLineDisplay* display) {
      gtk_text_layout_free_line_display(&this, display);
   }

   // Unintrospectable method: get_buffer() / gtk_text_layout_get_buffer()
   // Gets the text buffer used by the layout. See
   // gtk_text_layout_set_buffer().
   // RETURNS: the text buffer used by the layout.
   TextBuffer* get_buffer() {
      return gtk_text_layout_get_buffer(&this);
   }

   // Given an iterator within a text layout, determine the positions of the
   // strong and weak cursors if the insertion point is at that
   // iterator. The position of each cursor is stored as a zero-width
   // rectangle. The strong cursor location is the location where
   // characters of the directionality equal to the base direction of the
   // paragraph are inserted.  The weak cursor location is the location
   // where characters of the directionality opposite to the base
   // direction of the paragraph are inserted.
   // <iter>: a #GtkTextIter
   // <strong_pos>: location to store the strong cursor position (may be %NULL)
   // <weak_pos>: location to store the weak cursor position (may be %NULL)
   void get_cursor_locations(TextIter* iter, Gdk2.Rectangle* strong_pos=null, Gdk2.Rectangle* weak_pos=null) {
      gtk_text_layout_get_cursor_locations(&this, iter, strong_pos, weak_pos);
   }

   // Returns whether the insertion cursor will be shown.
   // shown, even if the text is editable.
   // RETURNS: if %FALSE, the insertion cursor will not be
   int get_cursor_visible() {
      return gtk_text_layout_get_cursor_visible(&this);
   }
   void get_iter_at_line(TextIter* iter, TextLine* line, int byte_offset) {
      gtk_text_layout_get_iter_at_line(&this, iter, line, byte_offset);
   }
   void get_iter_at_pixel(TextIter* iter, int x, int y) {
      gtk_text_layout_get_iter_at_pixel(&this, iter, x, y);
   }
   void get_iter_at_position(TextIter* iter, int* trailing, int x, int y) {
      gtk_text_layout_get_iter_at_position(&this, iter, trailing, x, y);
   }
   void get_iter_location(TextIter* iter, Gdk2.Rectangle* rect) {
      gtk_text_layout_get_iter_location(&this, iter, rect);
   }

   // Get the iter at the beginning of the line which is displayed
   // at the given y.
   // <target_iter>: the iterator in which the result is stored
   // <y>: the y positition
   // <line_top>: location to store the y coordinate of the top of the line. (Can by %NULL)
   void get_line_at_y(TextIter* target_iter, int y, int* line_top) {
      gtk_text_layout_get_line_at_y(&this, target_iter, y, line_top);
   }
   // Unintrospectable method: get_line_display() / gtk_text_layout_get_line_display()
   TextLineDisplay* get_line_display(TextLine* line, int size_only) {
      return gtk_text_layout_get_line_display(&this, line, size_only);
   }

   // Find the range of y coordinates for the paragraph containing
   // the given iter.
   // <iter>: a #GtkTextIter
   // <y>: location to store the top of the paragraph in pixels, or %NULL. or %NULL.
   void get_line_yrange(TextIter* iter, int* y, int* height) {
      gtk_text_layout_get_line_yrange(&this, iter, y, height);
   }
   GLib2.SList* /*new container*/ get_lines(int top_y, int bottom_y, int* first_line_y) {
      return gtk_text_layout_get_lines(&this, top_y, bottom_y, first_line_y);
   }
   void get_size(int* width, int* height) {
      gtk_text_layout_get_size(&this, width, height);
   }
   void invalidate(TextIter* start, TextIter* end) {
      gtk_text_layout_invalidate(&this, start, end);
   }
   void invalidate_cursors(TextIter* start, TextIter* end) {
      gtk_text_layout_invalidate_cursors(&this, start, end);
   }

   // Check if there are any invalid regions in a #GtkTextLayout's buffer
   // RETURNS: %TRUE if any invalid regions were found
   int is_valid() {
      return gtk_text_layout_is_valid(&this);
   }

   // Tests whether an iterator is at the start of a display line.
   // <iter>: iterator to test
   int iter_starts_line(TextIter* iter) {
      return gtk_text_layout_iter_starts_line(&this, iter);
   }

   // Move to the beginning or end of a display line.
   // <direction>: if negative, move to beginning of line, otherwise
   int move_iter_to_line_end(TextIter* iter, int direction) {
      return gtk_text_layout_move_iter_to_line_end(&this, iter, direction);
   }

   // Move the iterator to the beginning of the next line. The
   // lines of a wrapped paragraph are treated as distinct for
   // this operation.
   // <iter>: a #GtkTextIter
   int move_iter_to_next_line(TextIter* iter) {
      return gtk_text_layout_move_iter_to_next_line(&this, iter);
   }

   // Move the iterator to the beginning of the previous line. The lines
   // of a wrapped paragraph are treated as distinct for this operation.
   // <iter>: a #GtkTextIter
   int move_iter_to_previous_line(TextIter* iter) {
      return gtk_text_layout_move_iter_to_previous_line(&this, iter);
   }

   // Keeping the iterator on the same line of the layout, move it to the
   // specified X coordinate. The lines of a wrapped paragraph are
   // treated as distinct for this operation.
   // <iter>: a #GtkTextIter
   // <x>: X coordinate
   void move_iter_to_x(TextIter* iter, int x) {
      gtk_text_layout_move_iter_to_x(&this, iter, x);
   }

   // Move the iterator a given number of characters visually, treating
   // it as the strong cursor position. If @count is positive, then the
   // new strong cursor position will be @count positions to the right of
   // the old cursor position. If @count is negative then the new strong
   // cursor position will be @count positions to the left of the old
   // cursor position.
   // In the presence of bidirection text, the correspondence
   // between logical and visual order will depend on the direction
   // of the current run, and there may be jumps when the cursor
   // is moved off of the end of a run.
   // <iter>: a #GtkTextIter
   // <count>: number of characters to move (negative moves left, positive moves right)
   int move_iter_visually(TextIter* iter, int count) {
      return gtk_text_layout_move_iter_visually(&this, iter, count);
   }
   void set_buffer(TextBuffer* buffer=null) {
      gtk_text_layout_set_buffer(&this, buffer);
   }
   void set_contexts(Pango.Context* ltr_context, Pango.Context* rtl_context) {
      gtk_text_layout_set_contexts(&this, ltr_context, rtl_context);
   }

   // Sets which text directions (left-to-right and/or right-to-left) for
   // which cursors will be drawn for the insertion point. The visual
   // point at which new text is inserted depends on whether the new
   // text is right-to-left or left-to-right, so it may be desired to
   // make the drawn position of the cursor depend on the keyboard state.
   // <direction>: the new direction(s) for which to draw cursors. %GTK_TEXT_DIR_NONE means draw cursors for both left-to-right insertion and right-to-left insertion. (The two cursors will be visually distinguished.)
   void set_cursor_direction(TextDirection direction) {
      gtk_text_layout_set_cursor_direction(&this, direction);
   }

   // Sets whether the insertion cursor should be shown. Generally,
   // widgets using #GtkTextLayout will hide the cursor when the
   // widget does not have the input focus.
   // <cursor_visible>: If %FALSE, then the insertion cursor will not be shown, even if the text is editable.
   void set_cursor_visible(int cursor_visible) {
      gtk_text_layout_set_cursor_visible(&this, cursor_visible);
   }
   void set_default_style(TextAttributes* values) {
      gtk_text_layout_set_default_style(&this, values);
   }

   // Sets the keyboard direction; this is used as for the bidirectional
   // base direction for the line with the cursor if the line contains
   // only neutral characters.
   // <keyboard_dir>: the current direction of the keyboard.
   void set_keyboard_direction(TextDirection keyboard_dir) {
      gtk_text_layout_set_keyboard_direction(&this, keyboard_dir);
   }

   // Sets overwrite mode
   // <overwrite>: overwrite mode
   void set_overwrite_mode(int overwrite) {
      gtk_text_layout_set_overwrite_mode(&this, overwrite);
   }

   // Set the preedit string and attributes. The preedit string is a
   // string showing text that is currently being edited and not
   // yet committed into the buffer.
   // <preedit_string>: a string to display at the insertion point
   // <preedit_attrs>: a #PangoAttrList of attributes that apply to @preedit_string
   // <cursor_pos>: position of cursor within preedit string in chars
   void set_preedit_string(char* preedit_string, Pango.AttrList* preedit_attrs, int cursor_pos) {
      gtk_text_layout_set_preedit_string(&this, preedit_string, preedit_attrs, cursor_pos);
   }
   void set_screen_width(int width) {
      gtk_text_layout_set_screen_width(&this, width);
   }
   void spew() {
      gtk_text_layout_spew(&this);
   }

   // Validate regions of a #GtkTextLayout. The ::changed signal will
   // be emitted for each region validated.
   // <max_pixels>: the maximum number of pixels to validate. (No more than one paragraph beyond this limit will be validated)
   void validate(int max_pixels) {
      gtk_text_layout_validate(&this, max_pixels);
   }

   // Ensure that a region of a #GtkTextLayout is valid. The ::changed
   // signal will be emitted if any lines are validated.
   // <y0_>: offset from the top of the line pointed to by @anchor at which to begin validation. (The offset here is in pixels after validation.)
   // <y1_>: offset from the top of the line pointed to by @anchor at which to end validation. (The offset here is in pixels after validation.)
   void validate_yrange(TextIter* anchor_line, int y0_, int y1_) {
      gtk_text_layout_validate_yrange(&this, anchor_line, y0_, y1_);
   }
   // Unintrospectable method: wrap() / gtk_text_layout_wrap()
   TextLineData* wrap(TextLine* line, TextLineData* line_data) {
      return gtk_text_layout_wrap(&this, line, line_data);
   }
   void wrap_loop_end() {
      gtk_text_layout_wrap_loop_end(&this);
   }
   void wrap_loop_start() {
      gtk_text_layout_wrap_loop_start(&this);
   }
   extern (C) alias static void function (TextLayout* this_, Object* object, int p0, int p1, void* user_data=null) signal_allocate_child;

   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:"allocate-child", CB/*:signal_allocate_child*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"allocate-child",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (TextLayout* this_, int object, int p0, int p1, void* user_data=null) signal_changed;
   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);
   }
   extern (C) alias static void function (TextLayout* this_, void* user_data=null) signal_invalidated;
   ulong signal_connect(string name:"invalidated", CB/*:signal_invalidated*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"invalidated",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TextLayoutClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (TextLayout* layout) invalidated;
   extern (C) void function (TextLayout* layout, int y, int old_height, int new_height) changed;
   // Unintrospectable functionp: wrap() / ()
   extern (C) TextLineData* function (TextLayout* layout, TextLine* line, TextLineData* line_data) wrap;
   extern (C) void function (TextLayout* layout, TextLine* line, Pango.LogAttr** attrs, int* n_attrs) get_log_attrs;
   extern (C) void function (TextLayout* layout, TextIter* start, TextIter* end) invalidate;
   extern (C) void function (TextLayout* layout, TextLine* line, TextLineData* line_data) free_line_data;
   extern (C) void function (TextLayout* layout, Widget* child, int x, int y) allocate_child;
   extern (C) void function (TextLayout* layout, TextIter* start, TextIter* end) invalidate_cursors;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

struct TextLine {
}

struct TextLineData {
}

struct TextLineDisplay {
   Pango.Layout* layout;
   GLib2.SList* cursors, shaped_objects;
   TextDirection direction;
   int width, total_width, height, x_offset, left_margin, right_margin, top_margin, bottom_margin, insert_index;
   int size_only;
   TextLine* line;
   Gdk2.Color* pg_bg_color;
   Gdk2.Rectangle block_cursor;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "cursors_invalid", 1,
   uint, "has_block_cursor", 1,
   uint, "cursor_at_line_end", 1,
    uint, "__dummy32A", 29));
}

struct TextLogAttrCache {
}

struct TextMark /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   void* segment;


   // Creates a text mark. Add it to a buffer using gtk_text_buffer_add_mark().
   // If @name is %NULL, the mark is anonymous; otherwise, the mark can be 
   // retrieved by name using gtk_text_buffer_get_mark(). If a mark has left 
   // gravity, and text is inserted at the mark's current location, the mark 
   // will be moved to the left of the newly-inserted text. If the mark has 
   // right gravity (@left_gravity = %FALSE), the mark will end up on the 
   // right of newly-inserted text. The standard left-to-right cursor is a 
   // mark with right gravity (when you type, the cursor stays on the right
   // side of the text you're typing).
   // RETURNS: new #GtkTextMark
   // <name>: mark name or %NULL
   // <left_gravity>: whether the mark should have left gravity
   static TextMark* /*new*/ new_(char* name, int left_gravity) {
      return gtk_text_mark_new(name, left_gravity);
   }

   // Gets the buffer this mark is located inside,
   // or %NULL if the mark is deleted.
   // RETURNS: the mark's #GtkTextBuffer
   TextBuffer* get_buffer() {
      return gtk_text_mark_get_buffer(&this);
   }

   // Returns %TRUE if the mark has been removed from its buffer
   // with gtk_text_buffer_delete_mark(). See gtk_text_buffer_add_mark()
   // for a way to add it to a buffer again.
   // RETURNS: whether the mark is deleted
   int get_deleted() {
      return gtk_text_mark_get_deleted(&this);
   }

   // Determines whether the mark has left gravity.
   // RETURNS: %TRUE if the mark has left gravity, %FALSE otherwise
   int get_left_gravity() {
      return gtk_text_mark_get_left_gravity(&this);
   }

   // Returns the mark name; returns NULL for anonymous marks.
   // RETURNS: mark name
   char* get_name() {
      return gtk_text_mark_get_name(&this);
   }

   // Returns %TRUE if the mark is visible (i.e. a cursor is displayed
   // for it).
   // RETURNS: %TRUE if visible
   int get_visible() {
      return gtk_text_mark_get_visible(&this);
   }

   // Sets the visibility of @mark; the insertion point is normally
   // visible, i.e. you can see it as a vertical bar. Also, the text
   // widget uses a visible mark to indicate where a drop will occur when
   // dragging-and-dropping text. Most other marks are not visible.
   // Marks are not visible by default.
   // <setting>: visibility of mark
   void set_visible(int setting) {
      gtk_text_mark_set_visible(&this, setting);
   }
}

struct TextMarkClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TextPendingScroll {
}

enum TextSearchFlags {
   VISIBLE_ONLY = 1,
   TEXT_ONLY = 2
}
struct TextTag /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   TextTagTable* table;
   char* name;
   int priority;
   TextAttributes* values;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "bg_color_set", 1,
   uint, "bg_stipple_set", 1,
   uint, "fg_color_set", 1,
   uint, "scale_set", 1,
   uint, "fg_stipple_set", 1,
   uint, "justification_set", 1,
   uint, "left_margin_set", 1,
   uint, "indent_set", 1,
   uint, "rise_set", 1,
   uint, "strikethrough_set", 1,
   uint, "right_margin_set", 1,
   uint, "pixels_above_lines_set", 1,
   uint, "pixels_below_lines_set", 1,
   uint, "pixels_inside_wrap_set", 1,
   uint, "tabs_set", 1,
   uint, "underline_set", 1,
   uint, "wrap_mode_set", 1,
   uint, "bg_full_height_set", 1,
   uint, "invisible_set", 1,
   uint, "editable_set", 1,
   uint, "language_set", 1,
   uint, "pg_bg_color_set", 1,
   uint, "accumulative_margin", 1,
   uint, "pad1", 1,
    uint, "__dummy32A", 8));


   // Creates a #GtkTextTag. Configure the tag using object arguments,
   // i.e. using g_object_set().
   // RETURNS: a new #GtkTextTag
   // <name>: tag name, or %NULL
   static TextTag* /*new*/ new_(char* name=null) {
      return gtk_text_tag_new(name);
   }

   // Emits the "event" signal on the #GtkTextTag.
   // RETURNS: result of signal emission (whether the event was handled)
   // <event_object>: object that received the event, such as a widget
   // <event>: the event
   // <iter>: location where the event was received
   int event(GObject2.Object* event_object, Gdk2.Event* event, TextIter* iter) {
      return gtk_text_tag_event(&this, event_object, event, iter);
   }

   // Get the tag priority.
   // RETURNS: The tag's priority.
   int get_priority() {
      return gtk_text_tag_get_priority(&this);
   }

   // Sets the priority of a #GtkTextTag. Valid priorities are
   // start at 0 and go to one less than gtk_text_tag_table_get_size().
   // Each tag in a table has a unique priority; setting the priority
   // of one tag shifts the priorities of all the other tags in the
   // table to maintain a unique priority for each tag. Higher priority
   // tags "win" if two tags both set the same text attribute. When adding
   // a tag to a tag table, it will be assigned the highest priority in
   // the table by default; so normally the precedence of a set of tags
   // is the order in which they were added to the table, or created with
   // gtk_text_buffer_create_tag(), which adds the tag to the buffer's table
   // automatically.
   // <priority>: the new priority
   void set_priority(int priority) {
      gtk_text_tag_set_priority(&this, priority);
   }

   // The ::event signal is emitted when an event occurs on a region of the
   // buffer marked with this tag.
   // event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the
   // <object>: the object the event was fired from (typically a #GtkTextView)
   // <event>: the event which triggered the signal
   // <iter>: a #GtkTextIter pointing at the location the event occured
   extern (C) alias static c_int function (TextTag* this_, GObject2.Object* object, Gdk2.Event* event, TextIter* iter, void* user_data=null) signal_event;

   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:"event", CB/*:signal_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TextTagClass {
   GObject2.ObjectClass parent_class;

   // RETURNS: result of signal emission (whether the event was handled)
   // <event_object>: object that received the event, such as a widget
   // <event>: the event
   // <iter>: location where the event was received
   extern (C) int function (TextTag* tag, GObject2.Object* event_object, Gdk2.Event* event, TextIter* iter) event;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// You may wish to begin by reading the <link linkend="TextWidget">text widget
// conceptual overview</link> which gives an overview of all the objects and data
// types related to the text widget and how they work together.
// <refsect2 id="GtkTextTagTable-BUILDER-UI">
// <title>GtkTextTagTables as GtkBuildable</title>
// <para>
// The GtkTextTagTable implementation of the GtkBuildable interface
// supports adding tags by specifying "tag" as the "type"
// attribute of a &lt;child&gt; element.
// </para>
// <example>
// <title>A UI definition fragment specifying tags</title>
// <programlisting><![CDATA[
// <object class="GtkTextTagTable">
// <child type="tag">
// <object class="GtkTextTag"/>
// </child>
// </object>
// ]]></programlisting>
// </example>
// </refsect2>
struct TextTagTable /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   GLib2.HashTable* hash;
   GLib2.SList* anonymous;
   int anon_count;
   GLib2.SList* buffers;


   // Creates a new #GtkTextTagTable. The table contains no tags by
   // default.
   // RETURNS: a new #GtkTextTagTable
   static TextTagTable* /*new*/ new_() {
      return gtk_text_tag_table_new();
   }

   // Add a tag to the table. The tag is assigned the highest priority
   // in the table.
   // the same name as an already-added tag.
   // <tag>: a #GtkTextTag
   void add(TextTag* tag) {
      gtk_text_tag_table_add(&this, tag);
   }

   // Calls @func on each tag in @table, with user data @data.
   // Note that the table may not be modified while iterating 
   // over it (you can't add/remove tags).
   // <func>: a function to call on each tag
   // <data>: user data
   void foreach_(TextTagTableForeach func, void* data) {
      gtk_text_tag_table_foreach(&this, func, data);
   }

   // Returns the size of the table (number of tags)
   // RETURNS: number of tags in @table
   int get_size() {
      return gtk_text_tag_table_get_size(&this);
   }

   // Look up a named tag.
   // RETURNS: The tag, or %NULL if none by that name is in the table.
   // <name>: name of a tag
   TextTag* lookup(char* name) {
      return gtk_text_tag_table_lookup(&this, name);
   }

   // Remove a tag from the table. This will remove the table's
   // reference to the tag, so be careful - the tag will end
   // up destroyed if you don't have a reference to it.
   // <tag>: a #GtkTextTag
   void remove(TextTag* tag) {
      gtk_text_tag_table_remove(&this, tag);
   }
   extern (C) alias static void function (TextTagTable* this_, TextTag* object, void* user_data=null) signal_tag_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:"tag-added", CB/*:signal_tag_added*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tag-added",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (TextTagTable* this_, TextTag* object, c_int p0, void* user_data=null) signal_tag_changed;
   ulong signal_connect(string name:"tag-changed", CB/*:signal_tag_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tag-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (TextTagTable* this_, TextTag* object, void* user_data=null) signal_tag_removed;
   ulong signal_connect(string name:"tag-removed", CB/*:signal_tag_removed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"tag-removed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TextTagTableClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (TextTagTable* table, TextTag* tag, int size_changed) tag_changed;
   extern (C) void function (TextTagTable* table, TextTag* tag) tag_added;
   extern (C) void function (TextTagTable* table, TextTag* tag) tag_removed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias void function (TextTag* tag, void* data) TextTagTableForeach;

struct TextView /* : Container */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance container;
   Container parent_instance;
   void** layout;
   TextBuffer* buffer;
   uint selection_drag_handler, scroll_timeout;
   int pixels_above_lines, pixels_below_lines, pixels_inside_wrap;
   WrapMode wrap_mode;
   Justification justify;
   int left_margin, right_margin, indent;
   Pango.TabArray* tabs;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "editable", 1,
   uint, "overwrite_mode", 1,
   uint, "cursor_visible", 1,
   uint, "need_im_reset", 1,
   uint, "accepts_tab", 1,
   uint, "width_changed", 1,
   uint, "onscreen_validated", 1,
   uint, "mouse_cursor_obscured", 1,
    uint, "__dummy32A", 24));
   TextWindow* text_window, left_window, right_window, top_window, bottom_window;
   Adjustment* hadjustment, vadjustment;
   int xoffset, yoffset, width, height, virtual_cursor_x, virtual_cursor_y;
   TextMark* first_para_mark;
   int first_para_pixels;
   TextMark* dnd_mark;
   uint blink_timeout, first_validate_idle, incremental_validate_idle;
   IMContext* im_context;
   Widget* popup_menu;
   int drag_start_x, drag_start_y;
   GLib2.SList* children;
   TextPendingScroll* pending_scroll;
   int pending_place_cursor_button;


   // Creates a new #GtkTextView. If you don't call gtk_text_view_set_buffer()
   // before using the text view, an empty default buffer will be created
   // for you. Get the buffer with gtk_text_view_get_buffer(). If you want
   // to specify your own buffer, consider gtk_text_view_new_with_buffer().
   // RETURNS: a new #GtkTextView
   static TextView* new_() {
      return gtk_text_view_new();
   }

   // Creates a new #GtkTextView widget displaying the buffer
   // this function is equivalent to gtk_text_view_new(). The
   // text view adds its own reference count to the buffer; it does not
   // take over an existing reference.
   // RETURNS: a new #GtkTextView.
   // <buffer>: a #GtkTextBuffer
   static TextView* new_with_buffer(TextBuffer* buffer) {
      return gtk_text_view_new_with_buffer(buffer);
   }

   // Adds a child widget in the text buffer, at the given @anchor.
   // <child>: a #GtkWidget
   // <anchor>: a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view
   void add_child_at_anchor(Widget* child, TextChildAnchor* anchor) {
      gtk_text_view_add_child_at_anchor(&this, child, anchor);
   }

   // Adds a child at fixed coordinates in one of the text widget's
   // windows. The window must have nonzero size (see
   // gtk_text_view_set_border_window_size()). Note that the child
   // coordinates are given relative to the #GdkWindow in question, and
   // that these coordinates have no sane relationship to scrolling. When
   // placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is
   // irrelevant, the child floats above all scrollable areas. But when
   // placing a child in one of the scrollable windows (border windows or
   // text window), you'll need to compute the child's correct position
   // in buffer coordinates any time scrolling occurs or buffer changes
   // occur, and then call gtk_text_view_move_child() to update the
   // child's position. Unfortunately there's no good way to detect that
   // scrolling has occurred, using the current API; a possible hack
   // would be to update all child positions when the scroll adjustments
   // change or the text buffer changes. See bug 64518 on
   // bugzilla.gnome.org for status of fixing this issue.
   // <child>: a #GtkWidget
   // <which_window>: which window the child should appear in
   // <xpos>: X position of child in window coordinates
   // <ypos>: Y position of child in window coordinates
   void add_child_in_window(Widget* child, TextWindowType which_window, int xpos, int ypos) {
      gtk_text_view_add_child_in_window(&this, child, which_window, xpos, ypos);
   }

   // Moves the given @iter backward by one display (wrapped) line.
   // A display line is different from a paragraph. Paragraphs are
   // separated by newlines or other paragraph separator characters.
   // Display lines are created by line-wrapping a paragraph. If
   // wrapping is turned off, display lines and paragraphs will be the
   // same. Display lines are divided differently for each view, since
   // they depend on the view's width; paragraphs are the same in all
   // views, since they depend on the contents of the #GtkTextBuffer.
   // RETURNS: %TRUE if @iter was moved and is not on the end iterator
   // <iter>: a #GtkTextIter
   int backward_display_line(TextIter* iter) {
      return gtk_text_view_backward_display_line(&this, iter);
   }

   // Moves the given @iter backward to the next display line start.
   // A display line is different from a paragraph. Paragraphs are
   // separated by newlines or other paragraph separator characters.
   // Display lines are created by line-wrapping a paragraph. If
   // wrapping is turned off, display lines and paragraphs will be the
   // same. Display lines are divided differently for each view, since
   // they depend on the view's width; paragraphs are the same in all
   // views, since they depend on the contents of the #GtkTextBuffer.
   // RETURNS: %TRUE if @iter was moved and is not on the end iterator
   // <iter>: a #GtkTextIter
   int backward_display_line_start(TextIter* iter) {
      return gtk_text_view_backward_display_line_start(&this, iter);
   }

   // Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window
   // Note that you can't convert coordinates for a nonexisting window (see 
   // gtk_text_view_set_border_window_size()).
   // <win>: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
   // <buffer_x>: buffer x coordinate
   // <buffer_y>: buffer y coordinate
   // <window_x>: window x coordinate return location or %NULL
   // <window_y>: window y coordinate return location or %NULL
   void buffer_to_window_coords(TextWindowType win, int buffer_x, int buffer_y, /*out*/ int* window_x=null, /*out*/ int* window_y=null) {
      gtk_text_view_buffer_to_window_coords(&this, win, buffer_x, buffer_y, window_x, window_y);
   }

   // Moves the given @iter forward by one display (wrapped) line.
   // A display line is different from a paragraph. Paragraphs are
   // separated by newlines or other paragraph separator characters.
   // Display lines are created by line-wrapping a paragraph. If
   // wrapping is turned off, display lines and paragraphs will be the
   // same. Display lines are divided differently for each view, since
   // they depend on the view's width; paragraphs are the same in all
   // views, since they depend on the contents of the #GtkTextBuffer.
   // RETURNS: %TRUE if @iter was moved and is not on the end iterator
   // <iter>: a #GtkTextIter
   int forward_display_line(TextIter* iter) {
      return gtk_text_view_forward_display_line(&this, iter);
   }

   // Moves the given @iter forward to the next display line end.
   // A display line is different from a paragraph. Paragraphs are
   // separated by newlines or other paragraph separator characters.
   // Display lines are created by line-wrapping a paragraph. If
   // wrapping is turned off, display lines and paragraphs will be the
   // same. Display lines are divided differently for each view, since
   // they depend on the view's width; paragraphs are the same in all
   // views, since they depend on the contents of the #GtkTextBuffer.
   // RETURNS: %TRUE if @iter was moved and is not on the end iterator
   // <iter>: a #GtkTextIter
   int forward_display_line_end(TextIter* iter) {
      return gtk_text_view_forward_display_line_end(&this, iter);
   }

   // Returns whether pressing the Tab key inserts a tab characters.
   // gtk_text_view_set_accepts_tab().
   // %FALSE if pressing the Tab key moves the keyboard focus.
   // RETURNS: %TRUE if pressing the Tab key inserts a tab character,
   int get_accepts_tab() {
      return gtk_text_view_get_accepts_tab(&this);
   }

   // Gets the width of the specified border window. See
   // gtk_text_view_set_border_window_size().
   // RETURNS: width of window
   // <type>: window to return size from
   int get_border_window_size(TextWindowType type) {
      return gtk_text_view_get_border_window_size(&this, type);
   }

   // Returns the #GtkTextBuffer being displayed by this text view.
   // The reference count on the buffer is not incremented; the caller
   // of this function won't own a new reference.
   // RETURNS: a #GtkTextBuffer
   TextBuffer* get_buffer() {
      return gtk_text_view_get_buffer(&this);
   }

   // Find out whether the cursor is being displayed.
   // RETURNS: whether the insertion mark is visible
   int get_cursor_visible() {
      return gtk_text_view_get_cursor_visible(&this);
   }

   // Obtains a copy of the default text attributes. These are the
   // attributes used for text unless a tag overrides them.
   // You'd typically pass the default attributes in to
   // gtk_text_iter_get_attributes() in order to get the
   // attributes in effect at a given text position.
   // The return value is a copy owned by the caller of this function,
   // and should be freed.
   // RETURNS: a new #GtkTextAttributes
   TextAttributes* /*new*/ get_default_attributes() {
      return gtk_text_view_get_default_attributes(&this);
   }

   // Returns the default editability of the #GtkTextView. Tags in the
   // buffer may override this setting for some ranges of text.
   // RETURNS: whether text is editable by default
   int get_editable() {
      return gtk_text_view_get_editable(&this);
   }

   // Gets the horizontal-scrolling #GtkAdjustment.
   // RETURNS: pointer to the horizontal #GtkAdjustment
   Adjustment* get_hadjustment() {
      return gtk_text_view_get_hadjustment(&this);
   }

   // Gets the default indentation of paragraphs in @text_view.
   // Tags in the view's buffer may override the default.
   // The indentation may be negative.
   // RETURNS: number of pixels of indentation
   int get_indent() {
      return gtk_text_view_get_indent(&this);
   }

   // Retrieves the iterator at buffer coordinates @x and @y. Buffer
   // coordinates are coordinates for the entire buffer, not just the
   // currently-displayed portion.  If you have coordinates from an
   // event, you have to convert those to buffer coordinates with
   // gtk_text_view_window_to_buffer_coords().
   // <iter>: a #GtkTextIter
   // <x>: x position, in buffer coordinates
   // <y>: y position, in buffer coordinates
   void get_iter_at_location(/*out*/ TextIter* iter, int x, int y) {
      gtk_text_view_get_iter_at_location(&this, iter, x, y);
   }

   // Retrieves the iterator pointing to the character at buffer 
   // coordinates @x and @y. Buffer coordinates are coordinates for 
   // the entire buffer, not just the currently-displayed portion.  
   // If you have coordinates from an event, you have to convert 
   // those to buffer coordinates with 
   // gtk_text_view_window_to_buffer_coords().
   // Note that this is different from gtk_text_view_get_iter_at_location(),
   // which returns cursor locations, i.e. positions <emphasis>between</emphasis>
   // characters.
   // <iter>: a #GtkTextIter
   // <trailing>: if non-%NULL, location to store an integer indicating where in the grapheme the user clicked. It will either be zero, or the number of characters in the grapheme. 0 represents the trailing edge of the grapheme.
   // <x>: x position, in buffer coordinates
   // <y>: y position, in buffer coordinates
   void get_iter_at_position(/*out*/ TextIter* iter, /*out*/ int* trailing, int x, int y) {
      gtk_text_view_get_iter_at_position(&this, iter, trailing, x, y);
   }

   // Gets a rectangle which roughly contains the character at @iter.
   // The rectangle position is in buffer coordinates; use
   // gtk_text_view_buffer_to_window_coords() to convert these
   // coordinates to coordinates for one of the windows in the text view.
   // <iter>: a #GtkTextIter
   // <location>: bounds of the character at @iter
   void get_iter_location(TextIter* iter, /*out*/ Gdk2.Rectangle* location) {
      gtk_text_view_get_iter_location(&this, iter, location);
   }

   // Gets the default justification of paragraphs in @text_view.
   // Tags in the buffer may override the default.
   // RETURNS: default justification
   Justification get_justification() {
      return gtk_text_view_get_justification(&this);
   }

   // Gets the default left margin size of paragraphs in the @text_view.
   // Tags in the buffer may override the default.
   // RETURNS: left margin in pixels
   int get_left_margin() {
      return gtk_text_view_get_left_margin(&this);
   }

   // Gets the #GtkTextIter at the start of the line containing
   // the coordinate @y. @y is in buffer coordinates, convert from
   // window coordinates with gtk_text_view_window_to_buffer_coords().
   // If non-%NULL, @line_top will be filled with the coordinate of the top
   // edge of the line.
   // <target_iter>: a #GtkTextIter
   // <y>: a y coordinate
   // <line_top>: return location for top coordinate of the line
   void get_line_at_y(/*out*/ TextIter* target_iter, int y, /*out*/ int* line_top) {
      gtk_text_view_get_line_at_y(&this, target_iter, y, line_top);
   }

   // Gets the y coordinate of the top of the line containing @iter,
   // and the height of the line. The coordinate is a buffer coordinate;
   // convert to window coordinates with gtk_text_view_buffer_to_window_coords().
   // <iter>: a #GtkTextIter
   // <y>: return location for a y coordinate
   // <height>: return location for a height
   void get_line_yrange(TextIter* iter, /*out*/ int* y, /*out*/ int* height) {
      gtk_text_view_get_line_yrange(&this, iter, y, height);
   }

   // Returns whether the #GtkTextView is in overwrite mode or not.
   // RETURNS: whether @text_view is in overwrite mode or not.
   int get_overwrite() {
      return gtk_text_view_get_overwrite(&this);
   }

   // Gets the default number of pixels to put above paragraphs.
   // RETURNS: default number of pixels above paragraphs
   int get_pixels_above_lines() {
      return gtk_text_view_get_pixels_above_lines(&this);
   }

   // Gets the value set by gtk_text_view_set_pixels_below_lines().
   // RETURNS: default number of blank pixels below paragraphs
   int get_pixels_below_lines() {
      return gtk_text_view_get_pixels_below_lines(&this);
   }

   // Gets the value set by gtk_text_view_set_pixels_inside_wrap().
   // RETURNS: default number of pixels of blank space between wrapped lines
   int get_pixels_inside_wrap() {
      return gtk_text_view_get_pixels_inside_wrap(&this);
   }

   // Gets the default right margin for text in @text_view. Tags
   // in the buffer may override the default.
   // RETURNS: right margin in pixels
   int get_right_margin() {
      return gtk_text_view_get_right_margin(&this);
   }

   // Gets the default tabs for @text_view. Tags in the buffer may
   // override the defaults. The returned array will be %NULL if
   // "standard" (8-space) tabs are used. Free the return value
   // with pango_tab_array_free().
   // tabs are used; must be freed with pango_tab_array_free().
   // RETURNS: copy of default tab array, or %NULL if "standard"
   Pango.TabArray* /*new*/ get_tabs() {
      return gtk_text_view_get_tabs(&this);
   }

   // Gets the vertical-scrolling #GtkAdjustment.
   // RETURNS: pointer to the vertical #GtkAdjustment
   Adjustment* get_vadjustment() {
      return gtk_text_view_get_vadjustment(&this);
   }

   // Fills @visible_rect with the currently-visible
   // region of the buffer, in buffer coordinates. Convert to window coordinates
   // with gtk_text_view_buffer_to_window_coords().
   // <visible_rect>: rectangle to fill
   void get_visible_rect(/*out*/ Gdk2.Rectangle* visible_rect) {
      gtk_text_view_get_visible_rect(&this, visible_rect);
   }

   // Retrieves the #GdkWindow corresponding to an area of the text view;
   // possible windows include the overall widget window, child windows
   // on the left, right, top, bottom, and the window that displays the
   // text buffer. Windows are %NULL and nonexistent if their width or
   // height is 0, and are nonexistent before the widget has been
   // realized.
   // RETURNS: a #GdkWindow, or %NULL
   // <win>: window to get
   Gdk2.Window* get_window(TextWindowType win) {
      return gtk_text_view_get_window(&this, win);
   }

   // Usually used to find out which window an event corresponds to.
   // If you connect to an event signal on @text_view, this function
   // should be called on <literal>event-&gt;window</literal> to
   // see which window it was.
   // RETURNS: the window type.
   // <window>: a window type
   TextWindowType get_window_type(Gdk2.Window* window) {
      return gtk_text_view_get_window_type(&this, window);
   }

   // Gets the line wrapping for the view.
   // RETURNS: the line wrap setting
   WrapMode get_wrap_mode() {
      return gtk_text_view_get_wrap_mode(&this);
   }

   // Allow the #GtkTextView input method to internally handle key press
   // and release events. If this function returns %TRUE, then no further
   // processing should be done for this key event. See
   // gtk_im_context_filter_keypress().
   // Note that you are expected to call this function from your handler
   // when overriding key event handling. This is needed in the case when
   // you need to insert your own key handling between the input method
   // and the default key event handling of the #GtkTextView.
   // |[
   // static gboolean
   // gtk_foo_bar_key_press_event (GtkWidget   *widget,
   // GdkEventKey *event)
   // {
   // if ((key->keyval == GDK_Return || key->keyval == GDK_KP_Enter))
   // {
   // if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (view), event))
   // return TRUE;
   // }
   // /&ast; Do some stuff &ast;/
   // return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
   // }
   // ]|
   // RETURNS: %TRUE if the input method handled the key event.
   // <event>: the key event
   int im_context_filter_keypress(Gdk2.EventKey* event) {
      return gtk_text_view_im_context_filter_keypress(&this, event);
   }

   // Updates the position of a child, as for gtk_text_view_add_child_in_window().
   // <child>: child widget already added to the text view
   // <xpos>: new X position in window coordinates
   // <ypos>: new Y position in window coordinates
   void move_child(Widget* child, int xpos, int ypos) {
      gtk_text_view_move_child(&this, child, xpos, ypos);
   }

   // Moves a mark within the buffer so that it's
   // located within the currently-visible text area.
   // RETURNS: %TRUE if the mark moved (wasn't already onscreen)
   // <mark>: a #GtkTextMark
   int move_mark_onscreen(TextMark* mark) {
      return gtk_text_view_move_mark_onscreen(&this, mark);
   }

   // Move the iterator a given number of characters visually, treating
   // it as the strong cursor position. If @count is positive, then the
   // new strong cursor position will be @count positions to the right of
   // the old cursor position. If @count is negative then the new strong
   // cursor position will be @count positions to the left of the old
   // cursor position.
   // In the presence of bi-directional text, the correspondence
   // between logical and visual order will depend on the direction
   // of the current run, and there may be jumps when the cursor
   // is moved off of the end of a run.
   // RETURNS: %TRUE if @iter moved and is not on the end iterator
   // <iter>: a #GtkTextIter
   // <count>: number of characters to move (negative moves left, positive moves right)
   int move_visually(TextIter* iter, int count) {
      return gtk_text_view_move_visually(&this, iter, count);
   }

   // Moves the cursor to the currently visible region of the
   // buffer, it it isn't there already.
   // RETURNS: %TRUE if the cursor had to be moved.
   int place_cursor_onscreen() {
      return gtk_text_view_place_cursor_onscreen(&this);
   }

   // Reset the input method context of the text view if needed.
   // This can be necessary in the case where modifying the buffer
   // would confuse on-going input method behavior.
   void reset_im_context() {
      gtk_text_view_reset_im_context(&this);
   }

   // Scrolls @text_view the minimum distance such that @mark is contained
   // within the visible area of the widget.
   // <mark>: a mark in the buffer for @text_view
   void scroll_mark_onscreen(TextMark* mark) {
      gtk_text_view_scroll_mark_onscreen(&this, mark);
   }

   // Scrolls @text_view so that @iter is on the screen in the position
   // indicated by @xalign and @yalign. An alignment of 0.0 indicates
   // left or top, 1.0 indicates right or bottom, 0.5 means center. 
   // If @use_align is %FALSE, the text scrolls the minimal distance to 
   // get the mark onscreen, possibly not scrolling at all. The effective 
   // screen for purposes of this function is reduced by a margin of size 
   // Note that this function uses the currently-computed height of the
   // lines in the text buffer. Line heights are computed in an idle 
   // handler; so this function may not have the desired effect if it's 
   // called before the height computations. To avoid oddness, consider 
   // using gtk_text_view_scroll_to_mark() which saves a point to be 
   // scrolled to after line validation.
   // RETURNS: %TRUE if scrolling occurred
   // <iter>: a #GtkTextIter
   // <within_margin>: margin as a [0.0,0.5) fraction of screen size
   // <use_align>: whether to use alignment arguments (if %FALSE, just get the mark onscreen)
   // <xalign>: horizontal alignment of mark within visible area
   // <yalign>: vertical alignment of mark within visible area
   int scroll_to_iter(TextIter* iter, double within_margin, int use_align, double xalign, double yalign) {
      return gtk_text_view_scroll_to_iter(&this, iter, within_margin, use_align, xalign, yalign);
   }

   // Scrolls @text_view so that @mark is on the screen in the position
   // indicated by @xalign and @yalign. An alignment of 0.0 indicates
   // left or top, 1.0 indicates right or bottom, 0.5 means center. 
   // If @use_align is %FALSE, the text scrolls the minimal distance to 
   // get the mark onscreen, possibly not scrolling at all. The effective 
   // screen for purposes of this function is reduced by a margin of size
   // <mark>: a #GtkTextMark
   // <within_margin>: margin as a [0.0,0.5) fraction of screen size
   // <use_align>: whether to use alignment arguments (if %FALSE, just get the mark onscreen)
   // <xalign>: horizontal alignment of mark within visible area
   // <yalign>: vertical alignment of mark within visible area
   void scroll_to_mark(TextMark* mark, double within_margin, int use_align, double xalign, double yalign) {
      gtk_text_view_scroll_to_mark(&this, mark, within_margin, use_align, xalign, yalign);
   }

   // Sets the behavior of the text widget when the Tab key is pressed. 
   // If @accepts_tab is %TRUE, a tab character is inserted. If @accepts_tab 
   // is %FALSE the keyboard focus is moved to the next widget in the focus 
   // chain.
   // <accepts_tab>: %TRUE if pressing the Tab key should insert a tab character, %FALSE, if pressing the Tab key should move the keyboard focus.
   void set_accepts_tab(int accepts_tab) {
      gtk_text_view_set_accepts_tab(&this, accepts_tab);
   }

   // Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT,
   // or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM.
   // Automatically destroys the corresponding window if the size is set
   // to 0, and creates the window if the size is set to non-zero.  This
   // function can only be used for the "border windows," it doesn't work
   // with #GTK_TEXT_WINDOW_WIDGET, #GTK_TEXT_WINDOW_TEXT, or
   // #GTK_TEXT_WINDOW_PRIVATE.
   // <type>: window to affect
   // <size>: width or height of the window
   void set_border_window_size(TextWindowType type, int size) {
      gtk_text_view_set_border_window_size(&this, type, size);
   }

   // Sets @buffer as the buffer being displayed by @text_view. The previous
   // buffer displayed by the text view is unreferenced, and a reference is
   // added to @buffer. If you owned a reference to @buffer before passing it
   // to this function, you must remove that reference yourself; #GtkTextView
   // will not "adopt" it.
   // <buffer>: a #GtkTextBuffer
   void set_buffer(TextBuffer* buffer=null) {
      gtk_text_view_set_buffer(&this, buffer);
   }

   // Toggles whether the insertion point is displayed. A buffer with no editable
   // text probably shouldn't have a visible cursor, so you may want to turn
   // the cursor off.
   // <setting>: whether to show the insertion cursor
   void set_cursor_visible(int setting) {
      gtk_text_view_set_cursor_visible(&this, setting);
   }

   // Sets the default editability of the #GtkTextView. You can override
   // this default setting with tags in the buffer, using the "editable"
   // attribute of tags.
   // <setting>: whether it's editable
   void set_editable(int setting) {
      gtk_text_view_set_editable(&this, setting);
   }

   // Sets the default indentation for paragraphs in @text_view.
   // Tags in the buffer may override the default.
   // <indent>: indentation in pixels
   void set_indent(int indent) {
      gtk_text_view_set_indent(&this, indent);
   }

   // Sets the default justification of text in @text_view.
   // Tags in the view's buffer may override the default.
   // <justification>: justification
   void set_justification(Justification justification) {
      gtk_text_view_set_justification(&this, justification);
   }

   // Sets the default left margin for text in @text_view.
   // Tags in the buffer may override the default.
   // <left_margin>: left margin in pixels
   void set_left_margin(int left_margin) {
      gtk_text_view_set_left_margin(&this, left_margin);
   }

   // Changes the #GtkTextView overwrite mode.
   // <overwrite>: %TRUE to turn on overwrite mode, %FALSE to turn it off
   void set_overwrite(int overwrite) {
      gtk_text_view_set_overwrite(&this, overwrite);
   }

   // Sets the default number of blank pixels above paragraphs in @text_view.
   // Tags in the buffer for @text_view may override the defaults.
   // <pixels_above_lines>: pixels above paragraphs
   void set_pixels_above_lines(int pixels_above_lines) {
      gtk_text_view_set_pixels_above_lines(&this, pixels_above_lines);
   }

   // Sets the default number of pixels of blank space
   // to put below paragraphs in @text_view. May be overridden
   // by tags applied to @text_view's buffer.
   // <pixels_below_lines>: pixels below paragraphs
   void set_pixels_below_lines(int pixels_below_lines) {
      gtk_text_view_set_pixels_below_lines(&this, pixels_below_lines);
   }

   // Sets the default number of pixels of blank space to leave between
   // display/wrapped lines within a paragraph. May be overridden by
   // tags in @text_view's buffer.
   // <pixels_inside_wrap>: default number of pixels between wrapped lines
   void set_pixels_inside_wrap(int pixels_inside_wrap) {
      gtk_text_view_set_pixels_inside_wrap(&this, pixels_inside_wrap);
   }

   // Sets the default right margin for text in the text view.
   // Tags in the buffer may override the default.
   // <right_margin>: right margin in pixels
   void set_right_margin(int right_margin) {
      gtk_text_view_set_right_margin(&this, right_margin);
   }

   // Sets the default tab stops for paragraphs in @text_view.
   // Tags in the buffer may override the default.
   // <tabs>: tabs as a #PangoTabArray
   void set_tabs(Pango.TabArray* tabs) {
      gtk_text_view_set_tabs(&this, tabs);
   }

   // Sets the line wrapping for the view.
   // <wrap_mode>: a #GtkWrapMode
   void set_wrap_mode(WrapMode wrap_mode) {
      gtk_text_view_set_wrap_mode(&this, wrap_mode);
   }

   // Determines whether @iter is at the start of a display line.
   // See gtk_text_view_forward_display_line() for an explanation of
   // display lines vs. paragraphs.
   // RETURNS: %TRUE if @iter begins a wrapped line
   // <iter>: a #GtkTextIter
   int starts_display_line(TextIter* iter) {
      return gtk_text_view_starts_display_line(&this, iter);
   }

   // Converts coordinates on the window identified by @win to buffer
   // coordinates, storing the result in (@buffer_x,@buffer_y).
   // Note that you can't convert coordinates for a nonexisting window (see 
   // gtk_text_view_set_border_window_size()).
   // <win>: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE
   // <window_x>: window x coordinate
   // <window_y>: window y coordinate
   // <buffer_x>: buffer x coordinate return location or %NULL
   // <buffer_y>: buffer y coordinate return location or %NULL
   void window_to_buffer_coords(TextWindowType win, int window_x, int window_y, /*out*/ int* buffer_x=null, /*out*/ int* buffer_y=null) {
      gtk_text_view_window_to_buffer_coords(&this, win, window_x, window_y, buffer_x, buffer_y);
   }

   // The ::backspace signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted when the user asks for it.
   // The default bindings for this signal are
   // Backspace and Shift-Backspace.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_backspace;

   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:"backspace", CB/*:signal_backspace*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"backspace",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::copy-clipboard signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to copy the selection to the clipboard.
   // The default bindings for this signal are
   // Ctrl-c and Ctrl-Insert.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_copy_clipboard;
   ulong signal_connect(string name:"copy-clipboard", CB/*:signal_copy_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"copy-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::cut-clipboard signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to cut the selection to the clipboard.
   // The default bindings for this signal are
   // Ctrl-x and Shift-Delete.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_cut_clipboard;
   ulong signal_connect(string name:"cut-clipboard", CB/*:signal_cut_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cut-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::delete-from-cursor signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted when the user initiates a text deletion.
   // If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection
   // if there is one, otherwise it deletes the requested number
   // of characters.
   // The default bindings for this signal are
   // Delete for deleting a character, Ctrl-Delete for 
   // deleting a word and Ctrl-Backspace for deleting a word 
   // backwords.
   // <type>: the granularity of the deletion, as a #GtkDeleteType
   // <count>: the number of @type units to delete
   extern (C) alias static void function (TextView* this_, DeleteType* type, int count, void* user_data=null) signal_delete_from_cursor;
   ulong signal_connect(string name:"delete-from-cursor", CB/*:signal_delete_from_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-from-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::insert-at-cursor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates the insertion of a 
   // fixed string at the cursor.
   // This signal has no default bindings.
   // <string>: the string to insert
   extern (C) alias static void function (TextView* this_, char* string_, void* user_data=null) signal_insert_at_cursor;
   ulong signal_connect(string name:"insert-at-cursor", CB/*:signal_insert_at_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"insert-at-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-cursor signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted when the user initiates a cursor movement. 
   // If the cursor is not visible in @text_view, this signal causes
   // the viewport to be moved instead.
   // Applications should not connect to it, but may emit it with 
   // g_signal_emit_by_name() if they need to control the cursor
   // programmatically.
   // The default bindings for this signal come in two variants,
   // the variant with the Shift modifier extends the selection,
   // the variant without the Shift modifer does not.
   // There are too many key combinations to list them all here.
   // <itemizedlist>
   // <listitem>Arrow keys move by individual characters/lines</listitem>
   // <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
   // <listitem>Home/End keys move to the ends of the buffer</listitem>
   // <listitem>PageUp/PageDown keys move vertically by pages</listitem>
   // <listitem>Ctrl-PageUp/PageDown keys move horizontally by pages</listitem>
   // </itemizedlist>
   // <step>: the granularity of the move, as a #GtkMovementStep
   // <count>: the number of @step units to move
   // <extend_selection>: %TRUE if the move should extend the selection
   extern (C) alias static void function (TextView* this_, MovementStep* step, int count, c_int extend_selection, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::move-viewport signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which can be bound to key combinations to allow the user
   // to move the viewport, i.e. change what part of the text view
   // is visible in a containing scrolled window.
   // There are no default bindings for this signal.
   // <step>: the granularity of the move, as a #GtkMovementStep
   // <count>: the number of @step units to move
   extern (C) alias static void function (TextView* this_, ScrollStep* step, int count, void* user_data=null) signal_move_viewport;
   ulong signal_connect(string name:"move-viewport", CB/*:signal_move_viewport*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-viewport",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::page-horizontally signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which can be bound to key combinations to allow the user
   // to initiate horizontal cursor movement by pages.  
   // This signal should not be used anymore, instead use the
   // #GtkTextview::move-cursor signal with the #GTK_MOVEMENT_HORIZONTAL_PAGES
   // granularity.
   // <count>: the number of @step units to move
   // <extend_selection>: %TRUE if the move should extend the selection
   extern (C) alias static void function (TextView* this_, int count, c_int extend_selection, void* user_data=null) signal_page_horizontally;
   ulong signal_connect(string name:"page-horizontally", CB/*:signal_page_horizontally*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"page-horizontally",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::paste-clipboard signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to paste the contents of the clipboard 
   // into the text view.
   // The default bindings for this signal are
   // Ctrl-v and Shift-Insert.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_paste_clipboard;
   ulong signal_connect(string name:"paste-clipboard", CB/*:signal_paste_clipboard*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"paste-clipboard",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::populate-popup signal gets emitted before showing the 
   // context menu of the text view.
   // If you need to add items to the context menu, connect
   // to this signal and append your menuitems to the @menu.
   // <menu>: the menu that is being populated
   extern (C) alias static void function (TextView* this_, Menu* menu, void* user_data=null) signal_populate_popup;
   ulong signal_connect(string name:"populate-popup", CB/*:signal_populate_popup*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"populate-popup",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // If an input method is used, the typed text will not immediately
   // be committed to the buffer. So if you are interested in the text,
   // connect to this signal.
   // This signal is only emitted if the text at the given position
   // is actually editable.
   // <preedit>: the current preedit string
   extern (C) alias static void function (TextView* this_, char* preedit, void* user_data=null) signal_preedit_changed;
   ulong signal_connect(string name:"preedit-changed", CB/*:signal_preedit_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"preedit-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::select-all signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to select or unselect the complete
   // contents of the text view.
   // The default bindings for this signal are Ctrl-a and Ctrl-/ 
   // for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
   // <select>: %TRUE to select, %FALSE to unselect
   extern (C) alias static void function (TextView* this_, c_int select, void* user_data=null) signal_select_all;
   ulong signal_connect(string name:"select-all", CB/*:signal_select_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::set-anchor signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user initiates setting the "anchor" 
   // mark. The "anchor" mark gets placed at the same position as the
   // "insert" mark.
   // This signal has no default bindings.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_set_anchor;
   ulong signal_connect(string name:"set-anchor", CB/*:signal_set_anchor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-anchor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Set the scroll adjustments for the text view. Usually scrolled containers
   // like #GtkScrolledWindow will emit this signal to connect two instances
   // of #GtkScrollbar to the scroll directions of the #GtkTextView.
   extern (C) alias static void function (TextView* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;
   ulong signal_connect(string name:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::toggle-cursor-visible signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to toggle the visibility of the cursor.
   // The default binding for this signal is F7.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_toggle_cursor_visible;
   ulong signal_connect(string name:"toggle-cursor-visible", CB/*:signal_toggle_cursor_visible*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-cursor-visible",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::toggle-overwrite signal is a 
   // <link linkend="keybinding-signals">keybinding signal</link> 
   // which gets emitted to toggle the overwrite mode of the text view.
   // The default bindings for this signal is Insert.
   extern (C) alias static void function (TextView* this_, void* user_data=null) signal_toggle_overwrite;
   ulong signal_connect(string name:"toggle-overwrite", CB/*:signal_toggle_overwrite*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-overwrite",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TextViewClass {
   ContainerClass parent_class;
   extern (C) void function (TextView* text_view, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
   extern (C) void function (TextView* text_view, Menu* menu) populate_popup;
   extern (C) void function (TextView* text_view, MovementStep step, int count, int extend_selection) move_cursor;
   extern (C) void function (TextView* text_view, int count, int extend_selection) page_horizontally;
   extern (C) void function (TextView* text_view) set_anchor;
   extern (C) void function (TextView* text_view, char* str) insert_at_cursor;
   extern (C) void function (TextView* text_view, DeleteType type, int count) delete_from_cursor;
   extern (C) void function (TextView* text_view) backspace;
   extern (C) void function (TextView* text_view) cut_clipboard;
   extern (C) void function (TextView* text_view) copy_clipboard;
   extern (C) void function (TextView* text_view) paste_clipboard;
   extern (C) void function (TextView* text_view) toggle_overwrite;
   extern (C) void function (TextView* text_view, DirectionType direction) move_focus;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
   extern (C) void function () _gtk_reserved7;
}

struct TextWindow {
}

enum TextWindowType {
   PRIVATE = 0,
   WIDGET = 1,
   TEXT = 2,
   LEFT = 3,
   RIGHT = 4,
   TOP = 5,
   BOTTOM = 6
}
struct ThemeEngine {
}

struct TipsQuery /* : Label */ {
   alias label this;
   alias label super_;
   Label label;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "emit_always", 1,
   uint, "in_query", 1,
    uint, "__dummy32A", 30));
   char* label_inactive, label_no_tip;
   Widget* caller, last_crossed;
   Gdk2.Cursor* query_cursor;

   static TipsQuery* new_() {
      return gtk_tips_query_new();
   }
   void set_caller(Widget* caller) {
      gtk_tips_query_set_caller(&this, caller);
   }
   void set_labels(char* label_inactive, char* label_no_tip) {
      gtk_tips_query_set_labels(&this, label_inactive, label_no_tip);
   }
   void start_query() {
      gtk_tips_query_start_query(&this);
   }
   void stop_query() {
      gtk_tips_query_stop_query(&this);
   }
   extern (C) alias static void function (TipsQuery* this_, void* user_data=null) signal_start_query;

   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:"start-query", CB/*:signal_start_query*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"start-query",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (TipsQuery* this_, void* user_data=null) signal_stop_query;
   ulong signal_connect(string name:"stop-query", CB/*:signal_stop_query*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"stop-query",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (TipsQuery* this_, Widget* object, char* p0, char* p1, void* user_data=null) signal_widget_entered;
   ulong signal_connect(string name:"widget-entered", CB/*:signal_widget_entered*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"widget-entered",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TipsQuery* this_, Widget* object, char* p0, char* p1, Gdk2.Event* p2, void* user_data=null) signal_widget_selected;
   ulong signal_connect(string name:"widget-selected", CB/*:signal_widget_selected*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"widget-selected",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TipsQueryClass {
   LabelClass parent_class;
   extern (C) void function (TipsQuery* tips_query) start_query;
   extern (C) void function (TipsQuery* tips_query) stop_query;
   extern (C) void function (TipsQuery* tips_query, Widget* widget, char* tip_text, char* tip_private) widget_entered;
   extern (C) int function (TipsQuery* tips_query, Widget* widget, char* tip_text, char* tip_private, Gdk2.EventButton* event) widget_selected;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ToggleAction /* : Action */ {
   alias parent this;
   alias parent super_;
   alias parent action;
   Action parent;
   private ToggleActionPrivate* private_data;


   // Creates a new #GtkToggleAction object. To add the action to
   // a #GtkActionGroup and set the accelerator for the action,
   // call gtk_action_group_add_action_with_accel().
   // RETURNS: a new #GtkToggleAction
   // <name>: A unique name for the action
   // <label>: The label displayed in menu items and on buttons, or %NULL
   // <tooltip>: A tooltip for the action, or %NULL
   // <stock_id>: The stock icon to display in widgets representing the action, or %NULL
   static ToggleAction* /*new*/ new_(char* name, char* label, char* tooltip, char* stock_id) {
      return gtk_toggle_action_new(name, label, tooltip, stock_id);
   }

   // Returns the checked state of the toggle action.
   // RETURNS: the checked state of the toggle action
   int get_active() {
      return gtk_toggle_action_get_active(&this);
   }

   // Returns whether the action should have proxies like a radio action.
   // RETURNS: whether the action should have proxies like a radio action.
   int get_draw_as_radio() {
      return gtk_toggle_action_get_draw_as_radio(&this);
   }

   // Sets the checked state on the toggle action.
   // <is_active>: whether the action should be checked or not
   void set_active(int is_active) {
      gtk_toggle_action_set_active(&this, is_active);
   }

   // Sets whether the action should have proxies like a radio action.
   // <draw_as_radio>: whether the action should have proxies like a radio action
   void set_draw_as_radio(int draw_as_radio) {
      gtk_toggle_action_set_draw_as_radio(&this, draw_as_radio);
   }
   // Emits the "toggled" signal on the toggle action.
   void toggled() {
      gtk_toggle_action_toggled(&this);
   }
   extern (C) alias static void function (ToggleAction* this_, void* user_data=null) signal_toggled;

   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:"toggled", CB/*:signal_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ToggleActionClass {
   ActionClass parent_class;
   extern (C) void function (ToggleAction* action) toggled;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ToggleActionEntry {
   char* name, stock_id, label, accelerator, tooltip;
   GObject2.Callback callback;
   int is_active;
}

struct ToggleActionPrivate {
}

struct ToggleButton /* : Button */ {
   alias button this;
   alias button super_;
   Button button;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "active", 1,
   uint, "draw_indicator", 1,
   uint, "inconsistent", 1,
    uint, "__dummy32A", 29));

   static ToggleButton* new_() {
      return gtk_toggle_button_new();
   }
   static ToggleButton* new_with_label(char* label) {
      return gtk_toggle_button_new_with_label(label);
   }

   // Creates a new #GtkToggleButton containing a label. The label
   // will be created using gtk_label_new_with_mnemonic(), so underscores
   // in @label indicate the mnemonic for the button.
   // RETURNS: a new #GtkToggleButton
   // <label>: the text of the button, with an underscore in front of the mnemonic character
   static ToggleButton* new_with_mnemonic(char* label) {
      return gtk_toggle_button_new_with_mnemonic(label);
   }
   int get_active() {
      return gtk_toggle_button_get_active(&this);
   }

   // Gets the value set by gtk_toggle_button_set_inconsistent().
   // RETURNS: %TRUE if the button is displayed as inconsistent, %FALSE otherwise
   int get_inconsistent() {
      return gtk_toggle_button_get_inconsistent(&this);
   }

   // Retrieves whether the button is displayed as a separate indicator
   // and label. See gtk_toggle_button_set_mode().
   // and label.
   // RETURNS: %TRUE if the togglebutton is drawn as a separate indicator
   int get_mode() {
      return gtk_toggle_button_get_mode(&this);
   }
   void set_active(int is_active) {
      gtk_toggle_button_set_active(&this, is_active);
   }

   // If the user has selected a range of elements (such as some text or
   // spreadsheet cells) that are affected by a toggle button, and the
   // current values in that range are inconsistent, you may want to
   // display the toggle in an "in between" state. This function turns on
   // "in between" display.  Normally you would turn off the inconsistent
   // state again if the user toggles the toggle button. This has to be
   // done manually, gtk_toggle_button_set_inconsistent() only affects
   // visual appearance, it doesn't affect the semantics of the button.
   // <setting>: %TRUE if state is inconsistent
   void set_inconsistent(int setting) {
      gtk_toggle_button_set_inconsistent(&this, setting);
   }

   // Sets whether the button is displayed as a separate indicator and label.
   // You can call this function on a checkbutton or a radiobutton with
   // This function only affects instances of classes like #GtkCheckButton
   // and #GtkRadioButton that derive from #GtkToggleButton,
   // not instances of #GtkToggleButton itself.
   // <draw_indicator>: if %TRUE, draw the button as a separate indicator and label; if %FALSE, draw the button like a normal button
   void set_mode(int draw_indicator) {
      gtk_toggle_button_set_mode(&this, draw_indicator);
   }
   void toggled() {
      gtk_toggle_button_toggled(&this);
   }
   extern (C) alias static void function (ToggleButton* this_, void* user_data=null) signal_toggled;

   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:"toggled", CB/*:signal_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ToggleButtonClass {
   ButtonClass parent_class;
   extern (C) void function (ToggleButton* toggle_button) toggled;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ToggleToolButton /* : ToolButton */ {
   alias parent this;
   alias parent super_;
   alias parent toolbutton;
   ToolButton parent;
   private ToggleToolButtonPrivate* priv;


   // Returns a new #GtkToggleToolButton
   // RETURNS: a newly created #GtkToggleToolButton
   static ToggleToolButton* new_() {
      return gtk_toggle_tool_button_new();
   }

   // Creates a new #GtkToggleToolButton containing the image and text from a
   // stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK
   // and #GTK_STOCK_APPLY.
   // It is an error if @stock_id is not a name of a stock item.
   // RETURNS: A new #GtkToggleToolButton
   // <stock_id>: the name of the stock item
   static ToggleToolButton* new_from_stock(char* stock_id) {
      return gtk_toggle_tool_button_new_from_stock(stock_id);
   }

   // Queries a #GtkToggleToolButton and returns its current state.
   // Returns %TRUE if the toggle button is pressed in and %FALSE if it is raised.
   // RETURNS: %TRUE if the toggle tool button is pressed in, %FALSE if not
   int get_active() {
      return gtk_toggle_tool_button_get_active(&this);
   }

   // Sets the status of the toggle tool button. Set to %TRUE if you
   // want the GtkToggleButton to be 'pressed in', and %FALSE to raise it.
   // This action causes the toggled signal to be emitted.
   // <is_active>: whether @button should be active
   void set_active(int is_active) {
      gtk_toggle_tool_button_set_active(&this, is_active);
   }
   // Emitted whenever the toggle tool button changes state.
   extern (C) alias static void function (ToggleToolButton* this_, void* user_data=null) signal_toggled;

   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:"toggled", CB/*:signal_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ToggleToolButtonClass {
   ToolButtonClass parent_class;
   extern (C) void function (ToggleToolButton* button) toggled;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ToggleToolButtonPrivate {
}

struct ToolButton /* : ToolItem */ {
   alias parent this;
   alias parent super_;
   alias parent toolitem;
   ToolItem parent;
   private ToolButtonPrivate* priv;


   // Creates a new %GtkToolButton using @icon_widget as icon and @label as
   // label.
   // RETURNS: A new #GtkToolButton
   // <icon_widget>: a #GtkMisc widget that will be used as icon widget, or %NULL
   // <label>: a string that will be used as label, or %NULL
   static ToolButton* new_(Widget* icon_widget=null, char* label=null) {
      return gtk_tool_button_new(icon_widget, label);
   }

   // Creates a new #GtkToolButton containing the image and text from a
   // stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK
   // and #GTK_STOCK_APPLY.
   // It is an error if @stock_id is not a name of a stock item.
   // RETURNS: A new #GtkToolButton
   // <stock_id>: the name of the stock item
   static ToolButton* new_from_stock(char* stock_id) {
      return gtk_tool_button_new_from_stock(stock_id);
   }

   // Returns the name of the themed icon for the tool button,
   // see gtk_tool_button_set_icon_name().
   // no themed icon
   // RETURNS: the icon name or %NULL if the tool button has
   char* get_icon_name() {
      return gtk_tool_button_get_icon_name(&this);
   }

   // Return the widget used as icon widget on @button.
   // See gtk_tool_button_set_icon_widget().
   // on @button, or %NULL.
   // RETURNS: The widget used as icon
   Widget* get_icon_widget() {
      return gtk_tool_button_get_icon_widget(&this);
   }

   // Returns the label used by the tool button, or %NULL if the tool button
   // doesn't have a label. or uses a the label from a stock item. The returned
   // string is owned by GTK+, and must not be modified or freed.
   // RETURNS: The label, or %NULL
   char* get_label() {
      return gtk_tool_button_get_label(&this);
   }

   // Returns the widget used as label on @button.
   // See gtk_tool_button_set_label_widget().
   // on @button, or %NULL.
   // RETURNS: The widget used as label
   Widget* get_label_widget() {
      return gtk_tool_button_get_label_widget(&this);
   }

   // Returns the name of the stock item. See gtk_tool_button_set_stock_id().
   // The returned string is owned by GTK+ and must not be freed or modifed.
   // RETURNS: the name of the stock item for @button.
   char* get_stock_id() {
      return gtk_tool_button_get_stock_id(&this);
   }

   // Returns whether underscores in the label property are used as mnemonics
   // on menu items on the overflow menu. See gtk_tool_button_set_use_underline().
   // mnemonics on menu items on the overflow menu.
   // RETURNS: %TRUE if underscores in the label property are used as
   int get_use_underline() {
      return gtk_tool_button_get_use_underline(&this);
   }

   // Sets the icon for the tool button from a named themed icon.
   // See the docs for #GtkIconTheme for more details.
   // The "icon_name" property only has an effect if not
   // overridden by non-%NULL "label", "icon_widget" and "stock_id"
   // properties.
   // <icon_name>: the name of the themed icon
   void set_icon_name(char* icon_name=null) {
      gtk_tool_button_set_icon_name(&this, icon_name);
   }

   // Sets @icon as the widget used as icon on @button. If @icon_widget is
   // %NULL the icon is determined by the "stock_id" property. If the
   // "stock_id" property is also %NULL, @button will not have an icon.
   // <icon_widget>: the widget used as icon, or %NULL
   void set_icon_widget(Widget* icon_widget=null) {
      gtk_tool_button_set_icon_widget(&this, icon_widget);
   }

   // Sets @label as the label used for the tool button. The "label" property
   // only has an effect if not overridden by a non-%NULL "label_widget" property.
   // If both the "label_widget" and "label" properties are %NULL, the label
   // is determined by the "stock_id" property. If the "stock_id" property is also
   // %NULL, @button will not have a label.
   // <label>: a string that will be used as label, or %NULL.
   void set_label(char* label=null) {
      gtk_tool_button_set_label(&this, label);
   }

   // Sets @label_widget as the widget that will be used as the label
   // for @button. If @label_widget is %NULL the "label" property is used
   // as label. If "label" is also %NULL, the label in the stock item
   // determined by the "stock_id" property is used as label. If
   // "stock_id" is also %NULL, @button does not have a label.
   // <label_widget>: the widget used as label, or %NULL
   void set_label_widget(Widget* label_widget=null) {
      gtk_tool_button_set_label_widget(&this, label_widget);
   }

   // Sets the name of the stock item. See gtk_tool_button_new_from_stock().
   // The stock_id property only has an effect if not
   // overridden by non-%NULL "label" and "icon_widget" properties.
   // <stock_id>: a name of a stock item, or %NULL
   void set_stock_id(char* stock_id=null) {
      gtk_tool_button_set_stock_id(&this, stock_id);
   }

   // If set, an underline in the label property indicates that the next character
   // should be used for the mnemonic accelerator key in the overflow menu. For
   // example, if the label property is "_Open" and @use_underline is %TRUE,
   // the label on the tool button will be "Open" and the item on the overflow
   // menu will have an underlined 'O'.
   // Labels shown on tool buttons never have mnemonics on them; this property
   // only affects the menu item on the overflow menu.
   // <use_underline>: whether the button label has the form "_Open"
   void set_use_underline(int use_underline) {
      gtk_tool_button_set_use_underline(&this, use_underline);
   }

   // This signal is emitted when the tool button is clicked with the mouse
   // or activated with the keyboard.
   extern (C) alias static void function (ToolButton* 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 ToolButtonClass {
   ToolItemClass parent_class;
   Type button_type;
   extern (C) void function (ToolButton* tool_item) clicked;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct ToolButtonPrivate {
}


// #GtkToolItem<!-- -->s are widgets that can appear on a toolbar. To
// create a toolbar item that contain something else than a button, use
// gtk_tool_item_new(). Use gtk_container_add() to add a child
// widget to the tool item.
// For toolbar items that contain buttons, see the #GtkToolButton,
// #GtkToggleToolButton and #GtkRadioToolButton classes.
// See the #GtkToolbar class for a description of the toolbar widget, and
// #GtkToolShell for a description of the tool shell interface.
struct ToolItem /* : Bin */ {
   alias parent this;
   alias parent super_;
   alias parent bin;
   Bin parent;
   private ToolItemPrivate* priv;


   // Creates a new #GtkToolItem
   // RETURNS: the new #GtkToolItem
   static ToolItem* new_() {
      return gtk_tool_item_new();
   }

   // Returns the ellipsize mode used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function to find out how text should
   // be ellipsized.
   // should be ellipsized.
   // RETURNS: a #PangoEllipsizeMode indicating how text in @tool_item
   Pango.EllipsizeMode get_ellipsize_mode() {
      return gtk_tool_item_get_ellipsize_mode(&this);
   }

   // Returns whether @tool_item is allocated extra space.
   // See gtk_tool_item_set_expand().
   // RETURNS: %TRUE if @tool_item is allocated extra space.
   int get_expand() {
      return gtk_tool_item_get_expand(&this);
   }

   // Returns whether @tool_item is the same size as other homogeneous
   // items. See gtk_tool_item_set_homogeneous().
   // items.
   // RETURNS: %TRUE if the item is the same size as other homogeneous
   int get_homogeneous() {
      return gtk_tool_item_get_homogeneous(&this);
   }

   // Returns the icon size used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function to find out what size icons
   // they should use.
   // used for @tool_item
   // RETURNS: a #GtkIconSize indicating the icon size
   int get_icon_size() {
      return gtk_tool_item_get_icon_size(&this);
   }

   // Returns whether @tool_item is considered important. See
   // gtk_tool_item_set_is_important()
   // RETURNS: %TRUE if @tool_item is considered important.
   int get_is_important() {
      return gtk_tool_item_get_is_important(&this);
   }

   // Returns the orientation used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function to find out what size icons
   // they should use.
   // used for @tool_item
   // RETURNS: a #GtkOrientation indicating the orientation
   Orientation get_orientation() {
      return gtk_tool_item_get_orientation(&this);
   }

   // If @menu_item_id matches the string passed to
   // gtk_tool_item_set_proxy_menu_item() return the corresponding #GtkMenuItem.
   // Custom subclasses of #GtkToolItem should use this function to
   // update their menu item when the #GtkToolItem changes. That the
   // will not inadvertently change a menu item that they did not create.
   // gtk_tool_item_set_proxy_menu_item(), if the @menu_item_id<!-- -->s
   // match.
   // RETURNS: The #GtkMenuItem passed to
   // <menu_item_id>: a string used to identify the menu item
   Widget* get_proxy_menu_item(char* menu_item_id) {
      return gtk_tool_item_get_proxy_menu_item(&this, menu_item_id);
   }

   // Returns the relief style of @tool_item. See gtk_button_set_relief_style().
   // Custom subclasses of #GtkToolItem should call this function in the handler
   // of the #GtkToolItem::toolbar_reconfigured signal to find out the
   // relief style of buttons.
   // for @tool_item.
   // RETURNS: a #GtkReliefStyle indicating the relief style used
   ReliefStyle get_relief_style() {
      return gtk_tool_item_get_relief_style(&this);
   }

   // Returns the text alignment used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function to find out how text should
   // be aligned.
   // used for @tool_item
   // RETURNS: a #gfloat indicating the horizontal text alignment
   float get_text_alignment() {
      return gtk_tool_item_get_text_alignment(&this);
   }

   // Returns the text orientation used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function to find out how text should
   // be orientated.
   // used for @tool_item
   // RETURNS: a #GtkOrientation indicating the text orientation
   Orientation get_text_orientation() {
      return gtk_tool_item_get_text_orientation(&this);
   }

   // Returns the size group used for labels in @tool_item.
   // Custom subclasses of #GtkToolItem should call this function
   // and use the size group for labels.
   // RETURNS: a #GtkSizeGroup
   SizeGroup* get_text_size_group() {
      return gtk_tool_item_get_text_size_group(&this);
   }

   // Returns the toolbar style used for @tool_item. Custom subclasses of
   // #GtkToolItem should call this function in the handler of the
   // GtkToolItem::toolbar_reconfigured signal to find out in what style
   // the toolbar is displayed and change themselves accordingly 
   // Possibilities are:
   // <itemizedlist>
   // <listitem> GTK_TOOLBAR_BOTH, meaning the tool item should show
   // both an icon and a label, stacked vertically </listitem>
   // <listitem> GTK_TOOLBAR_ICONS, meaning the toolbar shows
   // only icons </listitem>
   // <listitem> GTK_TOOLBAR_TEXT, meaning the tool item should only
   // show text</listitem>
   // <listitem> GTK_TOOLBAR_BOTH_HORIZ, meaning the tool item should show
   // both an icon and a label, arranged horizontally (however, note the 
   // #GtkToolButton::has_text_horizontally that makes tool buttons not
   // show labels when the toolbar style is GTK_TOOLBAR_BOTH_HORIZ.
   // </listitem>
   // </itemizedlist>
   // for @tool_item.
   // RETURNS: A #GtkToolbarStyle indicating the toolbar style used
   ToolbarStyle get_toolbar_style() {
      return gtk_tool_item_get_toolbar_style(&this);
   }

   // Returns whether @tool_item has a drag window. See
   // gtk_tool_item_set_use_drag_window().
   // RETURNS: %TRUE if @tool_item uses a drag window.
   int get_use_drag_window() {
      return gtk_tool_item_get_use_drag_window(&this);
   }

   // Returns whether the @tool_item is visible on toolbars that are
   // docked horizontally.
   // docked horizontally.
   // RETURNS: %TRUE if @tool_item is visible on toolbars that are
   int get_visible_horizontal() {
      return gtk_tool_item_get_visible_horizontal(&this);
   }

   // Returns whether @tool_item is visible when the toolbar is docked vertically.
   // See gtk_tool_item_set_visible_vertical().
   // RETURNS: Whether @tool_item is visible when the toolbar is docked vertically
   int get_visible_vertical() {
      return gtk_tool_item_get_visible_vertical(&this);
   }

   // Calling this function signals to the toolbar that the
   // overflow menu item for @tool_item has changed. If the
   // overflow menu is visible when this function it called,
   // the menu will be rebuilt.
   // The function must be called when the tool item changes what it
   // will do in response to the #GtkToolItem::create-menu-proxy signal.
   void rebuild_menu() {
      gtk_tool_item_rebuild_menu(&this);
   }

   // Returns the #GtkMenuItem that was last set by
   // gtk_tool_item_set_proxy_menu_item(), ie. the #GtkMenuItem
   // that is going to appear in the overflow menu.
   // overflow menu for @tool_item.
   // RETURNS: The #GtkMenuItem that is going to appear in the
   Widget* retrieve_proxy_menu_item() {
      return gtk_tool_item_retrieve_proxy_menu_item(&this);
   }

   // Sets whether @tool_item is allocated extra space when there
   // is more room on the toolbar then needed for the items. The
   // effect is that the item gets bigger when the toolbar gets bigger
   // and smaller when the toolbar gets smaller.
   // <expand>: Whether @tool_item is allocated extra space
   void set_expand(int expand) {
      gtk_tool_item_set_expand(&this, expand);
   }

   // Sets whether @tool_item is to be allocated the same size as other
   // homogeneous items. The effect is that all homogeneous items will have
   // the same width as the widest of the items.
   // <homogeneous>: whether @tool_item is the same size as other homogeneous items
   void set_homogeneous(int homogeneous) {
      gtk_tool_item_set_homogeneous(&this, homogeneous);
   }

   // Sets whether @tool_item should be considered important. The #GtkToolButton
   // class uses this property to determine whether to show or hide its label
   // when the toolbar style is %GTK_TOOLBAR_BOTH_HORIZ. The result is that
   // only tool buttons with the "is_important" property set have labels, an
   // effect known as "priority text"
   // <is_important>: whether the tool item should be considered important
   void set_is_important(int is_important) {
      gtk_tool_item_set_is_important(&this, is_important);
   }

   // Sets the #GtkMenuItem used in the toolbar overflow menu. The
   // should also be used with gtk_tool_item_get_proxy_menu_item().
   // <menu_item_id>: a string used to identify @menu_item
   // <menu_item>: a #GtkMenuItem to be used in the overflow menu
   void set_proxy_menu_item(char* menu_item_id, Widget* menu_item) {
      gtk_tool_item_set_proxy_menu_item(&this, menu_item_id, menu_item);
   }

   // Sets the #GtkTooltips object to be used for @tool_item, the
   // text to be displayed as tooltip on the item and the private text
   // to be used. See gtk_tooltips_set_tip().
   // <tooltips>: The #GtkTooltips object to be used
   // <tip_text>: text to be used as tooltip text for @tool_item
   // <tip_private>: text to be used as private tooltip text
   void set_tooltip(Tooltips* tooltips, char* tip_text=null, char* tip_private=null) {
      gtk_tool_item_set_tooltip(&this, tooltips, tip_text, tip_private);
   }

   // Sets the markup text to be displayed as tooltip on the item.
   // See gtk_widget_set_tooltip_markup().
   // <markup>: markup text to be used as tooltip for @tool_item
   void set_tooltip_markup(char* markup) {
      gtk_tool_item_set_tooltip_markup(&this, markup);
   }

   // Sets the text to be displayed as tooltip on the item.
   // See gtk_widget_set_tooltip_text().
   // <text>: text to be used as tooltip for @tool_item
   void set_tooltip_text(char* text) {
      gtk_tool_item_set_tooltip_text(&this, text);
   }

   // Sets whether @tool_item has a drag window. When %TRUE the
   // toolitem can be used as a drag source through gtk_drag_source_set().
   // When @tool_item has a drag window it will intercept all events,
   // even those that would otherwise be sent to a child of @tool_item.
   // <use_drag_window>: Whether @tool_item has a drag window.
   void set_use_drag_window(int use_drag_window) {
      gtk_tool_item_set_use_drag_window(&this, use_drag_window);
   }

   // Sets whether @tool_item is visible when the toolbar is docked horizontally.
   // <visible_horizontal>: Whether @tool_item is visible when in horizontal mode
   void set_visible_horizontal(int visible_horizontal) {
      gtk_tool_item_set_visible_horizontal(&this, visible_horizontal);
   }

   // Sets whether @tool_item is visible when the toolbar is docked
   // vertically. Some tool items, such as text entries, are too wide to be
   // useful on a vertically docked toolbar. If @visible_vertical is %FALSE
   // <visible_vertical>: whether @tool_item is visible when the toolbar is in vertical mode
   void set_visible_vertical(int visible_vertical) {
      gtk_tool_item_set_visible_vertical(&this, visible_vertical);
   }

   // Emits the signal #GtkToolItem::toolbar_reconfigured on @tool_item.
   // #GtkToolbar and other #GtkToolShell implementations use this function
   // to notify children, when some aspect of their configuration changes.
   void toolbar_reconfigured() {
      gtk_tool_item_toolbar_reconfigured(&this);
   }

   // This signal is emitted when the toolbar needs information from @tool_item
   // about whether the item should appear in the toolbar overflow menu. In
   // response the tool item should either
   // <itemizedlist>
   // <listitem>call gtk_tool_item_set_proxy_menu_item() with a %NULL
   // pointer and return %TRUE to indicate that the item should not appear
   // in the overflow menu
   // </listitem>
   // <listitem> call gtk_tool_item_set_proxy_menu_item() with a new menu
   // item and return %TRUE, or 
   // </listitem>
   // <listitem> return %FALSE to indicate that the signal was not
   // handled by the item. This means that
   // the item will not appear in the overflow menu unless a later handler
   // installs a menu item.
   // </listitem>
   // </itemizedlist>
   // The toolbar may cache the result of this signal. When the tool item changes
   // how it will respond to this signal it must call gtk_tool_item_rebuild_menu()
   // to invalidate the cache and ensure that the toolbar rebuilds its overflow
   // menu.
   // RETURNS: %TRUE if the signal was handled, %FALSE if not
   extern (C) alias static c_int function (ToolItem* this_, void* user_data=null) signal_create_menu_proxy;

   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:"create-menu-proxy", CB/*:signal_create_menu_proxy*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"create-menu-proxy",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the toolitem's tooltip changes.
   // Application developers can use gtk_tool_item_set_tooltip() to
   // set the item's tooltip.
   // need to use this signal anymore.
   // RETURNS: %TRUE if the signal was handled, %FALSE if not
   // <tooltips>: the #GtkTooltips
   // <tip_text>: the tooltip text
   // <tip_private>: the tooltip private text
   extern (C) alias static c_int function (ToolItem* this_, Tooltips* tooltips, char* tip_text, char* tip_private, void* user_data=null) signal_set_tooltip;
   ulong signal_connect(string name:"set-tooltip", CB/*:signal_set_tooltip*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-tooltip",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when some property of the toolbar that the
   // item is a child of changes. For custom subclasses of #GtkToolItem,
   // the default handler of this signal use the functions
   // <itemizedlist>
   // <listitem>gtk_tool_shell_get_orientation()</listitem>
   // <listitem>gtk_tool_shell_get_style()</listitem>
   // <listitem>gtk_tool_shell_get_icon_size()</listitem>
   // <listitem>gtk_tool_shell_get_relief_style()</listitem>
   // </itemizedlist>
   // to find out what the toolbar should look like and change
   // themselves accordingly.
   extern (C) alias static void function (ToolItem* this_, void* user_data=null) signal_toolbar_reconfigured;
   ulong signal_connect(string name:"toolbar-reconfigured", CB/*:signal_toolbar_reconfigured*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toolbar-reconfigured",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ToolItemClass {
   BinClass parent_class;
   extern (C) int function (ToolItem* tool_item) create_menu_proxy;
   extern (C) void function (ToolItem* tool_item) toolbar_reconfigured;
   extern (C) int function (ToolItem* tool_item, Tooltips* tooltips, char* tip_text, char* tip_private) set_tooltip;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// A #GtkToolItemGroup is used together with #GtkToolPalette to add
// #GtkToolItem<!-- -->s to a palette like container with different
// categories and drag and drop support.
struct ToolItemGroup /* : Container */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance container;
   Container parent_instance;
   ToolItemGroupPrivate* priv;


   // Creates a new tool item group with label @label.
   // RETURNS: a new #GtkToolItemGroup.
   // <label>: the label of the new group
   static ToolItemGroup* new_(char* label) {
      return gtk_tool_item_group_new(label);
   }

   // Gets whether @group is collapsed or expanded.
   // RETURNS: %TRUE if @group is collapsed, %FALSE if it is expanded
   int get_collapsed() {
      return gtk_tool_item_group_get_collapsed(&this);
   }

   // Gets the tool item at position (x, y).
   // RETURNS: the #GtkToolItem at position (x, y)
   // <x>: the x position
   // <y>: the y position
   ToolItem* get_drop_item(int x, int y) {
      return gtk_tool_item_group_get_drop_item(&this, x, y);
   }

   // Gets the ellipsization mode of @group.
   // RETURNS: the #PangoEllipsizeMode of @group
   Pango.EllipsizeMode get_ellipsize() {
      return gtk_tool_item_group_get_ellipsize(&this);
   }

   // Gets the relief mode of the header button of @group.
   // RETURNS: the #GtkReliefStyle
   ReliefStyle get_header_relief() {
      return gtk_tool_item_group_get_header_relief(&this);
   }

   // Gets the position of @item in @group as index.
   // RETURNS: the index of @item in @group or -1 if @item is no child of @group
   // <item>: a #GtkToolItem
   int get_item_position(ToolItem* item) {
      return gtk_tool_item_group_get_item_position(&this, item);
   }

   // Gets the label of @group.
   // and must not be modified. Note that %NULL is returned if a custom
   // label has been set with gtk_tool_item_group_set_label_widget()
   // RETURNS: the label of @group. The label is an internal string of @group
   char* get_label() {
      return gtk_tool_item_group_get_label(&this);
   }

   // Gets the label widget of @group.
   // See gtk_tool_item_group_set_label_widget().
   // RETURNS: the label widget of @group
   Widget* get_label_widget() {
      return gtk_tool_item_group_get_label_widget(&this);
   }

   // Gets the number of tool items in @group.
   // RETURNS: the number of tool items in @group
   uint get_n_items() {
      return gtk_tool_item_group_get_n_items(&this);
   }

   // Gets the tool item at @index in group.
   // RETURNS: the #GtkToolItem at index
   // <index>: the index
   ToolItem* get_nth_item(uint index) {
      return gtk_tool_item_group_get_nth_item(&this, index);
   }

   // Inserts @item at @position in the list of children of @group.
   // <item>: the #GtkToolItem to insert into @group
   // <position>: the position of @item in @group, starting with 0. The position -1 means end of list.
   void insert(ToolItem* item, int position) {
      gtk_tool_item_group_insert(&this, item, position);
   }

   // Sets whether the @group should be collapsed or expanded.
   // <collapsed>: whether the @group should be collapsed or expanded
   void set_collapsed(int collapsed) {
      gtk_tool_item_group_set_collapsed(&this, collapsed);
   }

   // Sets the ellipsization mode which should be used by labels in @group.
   // <ellipsize>: the #PangoEllipsizeMode labels in @group should use
   void set_ellipsize(Pango.EllipsizeMode ellipsize) {
      gtk_tool_item_group_set_ellipsize(&this, ellipsize);
   }

   // Set the button relief of the group header.
   // See gtk_button_set_relief() for details.
   // <style>: the #GtkReliefStyle
   void set_header_relief(ReliefStyle style) {
      gtk_tool_item_group_set_header_relief(&this, style);
   }

   // Sets the position of @item in the list of children of @group.
   // <item>: the #GtkToolItem to move to a new position, should be a child of @group.
   // <position>: the new position of @item in @group, starting with 0. The position -1 means end of list.
   void set_item_position(ToolItem* item, int position) {
      gtk_tool_item_group_set_item_position(&this, item, position);
   }

   // Sets the label of the tool item group. The label is displayed in the header
   // of the group.
   // <label>: the new human-readable label of of the group
   void set_label(char* label) {
      gtk_tool_item_group_set_label(&this, label);
   }

   // Sets the label of the tool item group.
   // The label widget is displayed in the header of the group, in place
   // of the usual label.
   // <label_widget>: the widget to be displayed in place of the usual label
   void set_label_widget(Widget* label_widget) {
      gtk_tool_item_group_set_label_widget(&this, label_widget);
   }
}

struct ToolItemGroupClass {
   ContainerClass parent_class;
}

struct ToolItemGroupPrivate {
}

struct ToolItemPrivate {
}


// A #GtkToolPalette allows you to add #GtkToolItem<!-- -->s to a palette-like
// container with different categories and drag and drop support.
// A #GtkToolPalette is created with a call to gtk_tool_palette_new().
// #GtkToolItem<!-- -->s cannot be added directly to a #GtkToolPalette - 
// instead they are added to a #GtkToolItemGroup which can than be added
// to a #GtkToolPalette. To add a #GtkToolItemGroup to a #GtkToolPalette,
// use gtk_container_add().
// |[
// GtkWidget *palette, *group;
// GtkToolItem *item;
// palette = gtk_tool_palette_new ();
// group = gtk_tool_item_group_new (_("Test Category"));
// gtk_container_add (GTK_CONTAINER (palette), group);
// item = gtk_tool_button_new_from_stock (GTK_STOCK_OK);
// gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
// ]|
// The easiest way to use drag and drop with #GtkToolPalette is to call
// gtk_tool_palette_add_drag_dest() with the desired drag source @palette
// and the desired drag target @widget. Then gtk_tool_palette_get_drag_item()
// can be used to get the dragged item in the #GtkWidget::drag-data-received
// signal handler of the drag target.
// |[
// static void
// passive_canvas_drag_data_received (GtkWidget        *widget,
// GdkDragContext   *context,
// gint              x,
// gint              y,
// GtkSelectionData *selection,
// guint             info,
// guint             time,
// gpointer          data)
// {
// GtkWidget *palette;
// GtkWidget *item;
// /<!-- -->* Get the dragged item *<!-- -->/
// palette = gtk_widget_get_ancestor (gtk_drag_get_source_widget (context),
// GTK_TYPE_TOOL_PALETTE);
// if (palette != NULL)
// item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),
// selection);
// /<!-- -->* Do something with item *<!-- -->/
// }
// GtkWidget *target, palette;
// palette = gtk_tool_palette_new ();
// target = gtk_drawing_area_new ();
// g_signal_connect (G_OBJECT (target), "drag-data-received",
// G_CALLBACK (passive_canvas_drag_data_received), NULL);
// gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette), target,
// GTK_DEST_DEFAULT_ALL,
// GTK_TOOL_PALETTE_DRAG_ITEMS,
// GDK_ACTION_COPY);
// ]|
struct ToolPalette /* : Container */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance container;
   Container parent_instance;
   ToolPalettePrivate* priv;


   // Creates a new tool palette.
   // RETURNS: a new #GtkToolPalette
   static ToolPalette* new_() {
      return gtk_tool_palette_new();
   }

   // Get the target entry for a dragged #GtkToolItemGroup.
   // RETURNS: the #GtkTargetEntry for a dragged group
   static TargetEntry* get_drag_target_group() {
      return gtk_tool_palette_get_drag_target_group();
   }

   // Gets the target entry for a dragged #GtkToolItem.
   // RETURNS: the #GtkTargetEntry for a dragged item.
   static TargetEntry* get_drag_target_item() {
      return gtk_tool_palette_get_drag_target_item();
   }

   // Sets @palette as drag source (see gtk_tool_palette_set_drag_source())
   // and sets @widget as a drag destination for drags from @palette.
   // See gtk_drag_dest_set().
   // <widget>: a #GtkWidget which should be a drag destination for @palette
   // <flags>: the flags that specify what actions GTK+ should take for drops on that widget
   // <targets>: the #GtkToolPaletteDragTarget<!-- -->s which the widget should support
   // <actions>: the #GdkDragAction<!-- -->s which the widget should suppport
   void add_drag_dest(Widget* widget, DestDefaults flags, ToolPaletteDragTargets targets, Gdk2.DragAction actions) {
      gtk_tool_palette_add_drag_dest(&this, widget, flags, targets, actions);
   }

   // Get the dragged item from the selection.
   // This could be a #GtkToolItem or a #GtkToolItemGroup.
   // RETURNS: the dragged item in selection
   // <selection>: a #GtkSelectionData
   Widget* get_drag_item(SelectionData* selection) {
      return gtk_tool_palette_get_drag_item(&this, selection);
   }

   // Gets the group at position (x, y).
   // if there is no such group
   // RETURNS: the #GtkToolItemGroup at position or %NULL
   // <x>: the x position
   // <y>: the y position
   ToolItemGroup* get_drop_group(int x, int y) {
      return gtk_tool_palette_get_drop_group(&this, x, y);
   }

   // Gets the item at position (x, y).
   // See gtk_tool_palette_get_drop_group().
   // RETURNS: the #GtkToolItem at position or %NULL if there is no such item
   // <x>: the x position
   // <y>: the y position
   ToolItem* get_drop_item(int x, int y) {
      return gtk_tool_palette_get_drop_item(&this, x, y);
   }

   // Gets whether @group is exclusive or not.
   // See gtk_tool_palette_set_exclusive().
   // RETURNS: %TRUE if @group is exclusive
   // <group>: a #GtkToolItemGroup which is a child of palette
   int get_exclusive(ToolItemGroup* group) {
      return gtk_tool_palette_get_exclusive(&this, group);
   }

   // Gets whether group should be given extra space.
   // See gtk_tool_palette_set_expand().
   // RETURNS: %TRUE if group should be given extra space, %FALSE otherwise
   // <group>: a #GtkToolItemGroup which is a child of palette
   int get_expand(ToolItemGroup* group) {
      return gtk_tool_palette_get_expand(&this, group);
   }

   // Gets the position of @group in @palette as index.
   // See gtk_tool_palette_set_group_position().
   // RETURNS: the index of group or -1 if @group is not a child of @palette
   // <group>: a #GtkToolItemGroup
   int get_group_position(ToolItemGroup* group) {
      return gtk_tool_palette_get_group_position(&this, group);
   }

   // Gets the horizontal adjustment of the tool palette.
   // RETURNS: the horizontal adjustment of @palette
   Adjustment* get_hadjustment() {
      return gtk_tool_palette_get_hadjustment(&this);
   }

   // Gets the size of icons in the tool palette.
   // See gtk_tool_palette_set_icon_size().
   // RETURNS: the #GtkIconSize of icons in the tool palette
   int get_icon_size() {
      return gtk_tool_palette_get_icon_size(&this);
   }

   // Gets the style (icons, text or both) of items in the tool palette.
   // RETURNS: the #GtkToolbarStyle of items in the tool palette.
   ToolbarStyle get_style() {
      return gtk_tool_palette_get_style(&this);
   }

   // Gets the vertical adjustment of the tool palette.
   // RETURNS: the vertical adjustment of @palette
   Adjustment* get_vadjustment() {
      return gtk_tool_palette_get_vadjustment(&this);
   }

   // Sets the tool palette as a drag source.
   // Enables all groups and items in the tool palette as drag sources
   // on button 1 and button 3 press with copy and move actions.
   // See gtk_drag_source_set().
   // <targets>: the #GtkToolPaletteDragTarget<!-- -->s which the widget should support
   void set_drag_source(ToolPaletteDragTargets targets) {
      gtk_tool_palette_set_drag_source(&this, targets);
   }

   // Sets whether the group should be exclusive or not.
   // If an exclusive group is expanded all other groups are collapsed.
   // <group>: a #GtkToolItemGroup which is a child of palette
   // <exclusive>: whether the group should be exclusive or not
   void set_exclusive(ToolItemGroup* group, int exclusive) {
      gtk_tool_palette_set_exclusive(&this, group, exclusive);
   }

   // Sets whether the group should be given extra space.
   // <group>: a #GtkToolItemGroup which is a child of palette
   // <expand>: whether the group should be given extra space
   void set_expand(ToolItemGroup* group, int expand) {
      gtk_tool_palette_set_expand(&this, group, expand);
   }

   // Sets the position of the group as an index of the tool palette.
   // If position is 0 the group will become the first child, if position is
   // -1 it will become the last child.
   // <group>: a #GtkToolItemGroup which is a child of palette
   // <position>: a new index for group
   void set_group_position(ToolItemGroup* group, int position) {
      gtk_tool_palette_set_group_position(&this, group, position);
   }

   // Sets the size of icons in the tool palette.
   // <icon_size>: the #GtkIconSize that icons in the tool palette shall have
   void set_icon_size(int icon_size) {
      gtk_tool_palette_set_icon_size(&this, icon_size);
   }

   // Sets the style (text, icons or both) of items in the tool palette.
   // <style>: the #GtkToolbarStyle that items in the tool palette shall have
   void set_style(ToolbarStyle style) {
      gtk_tool_palette_set_style(&this, style);
   }

   // Unsets the tool palette icon size set with gtk_tool_palette_set_icon_size(),
   // so that user preferences will be used to determine the icon size.
   void unset_icon_size() {
      gtk_tool_palette_unset_icon_size(&this);
   }

   // Unsets a toolbar style set with gtk_tool_palette_set_style(),
   // so that user preferences will be used to determine the toolbar style.
   void unset_style() {
      gtk_tool_palette_unset_style(&this);
   }

   // Set the scroll adjustments for the viewport.
   // Usually scrolled containers like GtkScrolledWindow will emit this
   // signal to connect two instances of GtkScrollbar to the scroll
   // directions of the GtkToolpalette.
   // <hadjustment>: The horizontal adjustment
   // <vadjustment>: The vertical adjustment
   extern (C) alias static void function (ToolPalette* this_, Adjustment* hadjustment, Adjustment* vadjustment, void* user_data=null) signal_set_scroll_adjustments;

   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:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ToolPaletteClass {
   ContainerClass parent_class;
   extern (C) void function (Widget* widget, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
}

// Flags used to specify the supported drag targets.
enum ToolPaletteDragTargets {
   ITEMS = 1,
   GROUPS = 2
}
struct ToolPalettePrivate {
}


// The #GtkToolShell interface allows container widgets to provide additional
// information when embedding #GtkToolItem widgets.
struct ToolShell {

   // Retrieves the current ellipsize mode for the tool shell. Tool items must not
   // call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
   // instead.
   // RETURNS: the current ellipsize mode of @shell
   Pango.EllipsizeMode get_ellipsize_mode() {
      return gtk_tool_shell_get_ellipsize_mode(&this);
   }

   // Retrieves the icon size for the tool shell. Tool items must not call this
   // function directly, but rely on gtk_tool_item_get_icon_size() instead.
   // RETURNS: the current size for icons of @shell
   int get_icon_size() {
      return gtk_tool_shell_get_icon_size(&this);
   }

   // Retrieves the current orientation for the tool shell. Tool items must not
   // call this function directly, but rely on gtk_tool_item_get_orientation()
   // instead.
   // RETURNS: the current orientation of @shell
   Orientation get_orientation() {
      return gtk_tool_shell_get_orientation(&this);
   }

   // Returns the relief style of buttons on @shell. Tool items must not call this
   // function directly, but rely on gtk_tool_item_get_relief_style() instead.
   // RETURNS: The relief style of buttons on @shell.
   ReliefStyle get_relief_style() {
      return gtk_tool_shell_get_relief_style(&this);
   }

   // Retrieves whether the tool shell has text, icons, or both. Tool items must
   // not call this function directly, but rely on gtk_tool_item_get_style()
   // instead.
   // RETURNS: the current style of @shell
   ToolbarStyle get_style() {
      return gtk_tool_shell_get_style(&this);
   }

   // Retrieves the current text alignment for the tool shell. Tool items must not
   // call this function directly, but rely on gtk_tool_item_get_text_alignment()
   // instead.
   // RETURNS: the current text alignment of @shell
   float get_text_alignment() {
      return gtk_tool_shell_get_text_alignment(&this);
   }

   // Retrieves the current text orientation for the tool shell. Tool items must not
   // call this function directly, but rely on gtk_tool_item_get_text_orientation()
   // instead.
   // RETURNS: the current text orientation of @shell
   Orientation get_text_orientation() {
      return gtk_tool_shell_get_text_orientation(&this);
   }

   // Retrieves the current text size group for the tool shell. Tool items must not
   // call this function directly, but rely on gtk_tool_item_get_text_size_group()
   // instead.
   // RETURNS: the current text size group of @shell
   SizeGroup* get_text_size_group() {
      return gtk_tool_shell_get_text_size_group(&this);
   }

   // Calling this function signals the tool shell that the overflow menu item for
   // tool items have changed. If there is an overflow menu and if it is visible
   // when this function it called, the menu will be rebuilt.
   // Tool items must not call this function directly, but rely on
   // gtk_tool_item_rebuild_menu() instead.
   void rebuild_menu() {
      gtk_tool_shell_rebuild_menu(&this);
   }
}

// Virtual function table for the #GtkToolShell interface.
struct ToolShellIface {
   private GObject2.TypeInterface g_iface;
   extern (C) IconSize function (ToolShell* shell) get_icon_size;
   // RETURNS: the current orientation of @shell
   extern (C) Orientation function (ToolShell* shell) get_orientation;
   // RETURNS: the current style of @shell
   extern (C) ToolbarStyle function (ToolShell* shell) get_style;
   // RETURNS: The relief style of buttons on @shell.
   extern (C) ReliefStyle function (ToolShell* shell) get_relief_style;
   extern (C) void function (ToolShell* shell) rebuild_menu;
   // RETURNS: the current text orientation of @shell
   extern (C) Orientation function (ToolShell* shell) get_text_orientation;
   // RETURNS: the current text alignment of @shell
   extern (C) float function (ToolShell* shell) get_text_alignment;
   // RETURNS: the current ellipsize mode of @shell
   extern (C) Pango.EllipsizeMode function (ToolShell* shell) get_ellipsize_mode;
   // RETURNS: the current text size group of @shell
   extern (C) SizeGroup* function (ToolShell* shell) get_text_size_group;
}

struct Toolbar /* : Container */ {
   alias container this;
   alias container super_;
   Container container;
   int num_children;
   GLib2.List* children;
   Orientation orientation;
   ToolbarStyle style;
   IconSize icon_size;
   Tooltips* tooltips;
   private int button_maxw, button_maxh;
   private uint _gtk_reserved1, _gtk_reserved2;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "style_set", 1,
   uint, "icon_size_set", 1,
    uint, "__dummy32A", 30));


   // Creates a new toolbar.
   // RETURNS: the newly-created toolbar.
   static Toolbar* new_() {
      return gtk_toolbar_new();
   }

   // Unintrospectable method: append_element() / gtk_toolbar_append_element()
   // Adds a new element to the end of a toolbar.
   // If @type == %GTK_TOOLBAR_CHILD_WIDGET, @widget is used as the new element.
   // If @type == %GTK_TOOLBAR_CHILD_RADIOBUTTON, @widget is used to determine
   // the radio group for the new element. In all other cases, @widget must
   // be %NULL.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar element as a #GtkWidget.
   // <type>: a value of type #GtkToolbarChildType that determines what @widget will be.
   // <widget>: a #GtkWidget, or %NULL.
   // <text>: the element's label.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   // <icon>: a #GtkWidget that provides pictorial representation of the element's function.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: any data you wish to pass to the callback.
   Widget* append_element(ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data) {
      return gtk_toolbar_append_element(&this, type, widget, text, tooltip_text, tooltip_private_text, icon, callback, user_data);
   }

   // Unintrospectable method: append_item() / gtk_toolbar_append_item()
   // Inserts a new item into the toolbar. You must specify the position
   // in the toolbar where it will be inserted.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar item as a #GtkWidget.
   // <text>: give your toolbar button a label.
   // <tooltip_text>: a string that appears when the user holds the mouse over this item.
   // <tooltip_private_text>: use with #GtkTipsQuery.
   // <icon>: a #GtkWidget that should be used as the button's icon.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: a pointer to any data you wish to be passed to the callback.
   Widget* append_item(char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data) {
      return gtk_toolbar_append_item(&this, text, tooltip_text, tooltip_private_text, icon, callback, user_data);
   }
   // Adds a new space to the end of the toolbar.
   void append_space() {
      gtk_toolbar_append_space(&this);
   }

   // Adds a widget to the end of the given toolbar.
   // <widget>: a #GtkWidget to add to the toolbar.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   void append_widget(Widget* widget, char* tooltip_text=null, char* tooltip_private_text=null) {
      gtk_toolbar_append_widget(&this, widget, tooltip_text, tooltip_private_text);
   }

   // Returns the position corresponding to the indicated point on
   // this function returns the position a new item should be
   // inserted.
   // RETURNS: The position corresponding to the point (@x, @y) on the toolbar.
   // <x>: x coordinate of a point on the toolbar
   // <y>: y coordinate of a point on the toolbar
   int get_drop_index(int x, int y) {
      return gtk_toolbar_get_drop_index(&this, x, y);
   }

   // Retrieves the icon size for the toolbar. See gtk_toolbar_set_icon_size().
   // the toolbar.
   // RETURNS: the current icon size for the icons on
   int get_icon_size() {
      return gtk_toolbar_get_icon_size(&this);
   }

   // Returns the position of @item on the toolbar, starting from 0.
   // It is an error if @item is not a child of the toolbar.
   // RETURNS: the position of item on the toolbar.
   // <item>: a #GtkToolItem that is a child of @toolbar
   int get_item_index(ToolItem* item) {
      return gtk_toolbar_get_item_index(&this, item);
   }

   // Returns the number of items on the toolbar.
   // RETURNS: the number of items on the toolbar
   int get_n_items() {
      return gtk_toolbar_get_n_items(&this);
   }

   // Returns the @n<!-- -->'th item on @toolbar, or %NULL if the
   // toolbar does not contain an @n<!-- -->'th item.
   // or %NULL if there isn't an @n<!-- -->'th item.
   // RETURNS: The @n<!-- -->'th #GtkToolItem on @toolbar,
   // <n>: A position on the toolbar
   ToolItem* get_nth_item(int n) {
      return gtk_toolbar_get_nth_item(&this, n);
   }

   // Retrieves the current orientation of the toolbar. See
   // gtk_toolbar_set_orientation().
   // RETURNS: the orientation
   Orientation get_orientation() {
      return gtk_toolbar_get_orientation(&this);
   }

   // Returns the relief style of buttons on @toolbar. See
   // gtk_button_set_relief().
   // RETURNS: The relief style of buttons on @toolbar.
   ReliefStyle get_relief_style() {
      return gtk_toolbar_get_relief_style(&this);
   }

   // Returns whether the toolbar has an overflow menu.
   // See gtk_toolbar_set_show_arrow().
   // RETURNS: %TRUE if the toolbar has an overflow menu.
   int get_show_arrow() {
      return gtk_toolbar_get_show_arrow(&this);
   }

   // Retrieves whether the toolbar has text, icons, or both . See
   // gtk_toolbar_set_style().
   // RETURNS: the current style of @toolbar
   ToolbarStyle get_style() {
      return gtk_toolbar_get_style(&this);
   }

   // Retrieves whether tooltips are enabled. See
   // gtk_toolbar_set_tooltips().
   // is now used instead.
   // RETURNS: %TRUE if tooltips are enabled
   int get_tooltips() {
      return gtk_toolbar_get_tooltips(&this);
   }

   // Insert a #GtkToolItem into the toolbar at position @pos. If @pos is
   // 0 the item is prepended to the start of the toolbar. If @pos is
   // negative, the item is appended to the end of the toolbar.
   // <item>: a #GtkToolItem
   // <pos>: the position of the new item
   void insert(ToolItem* item, int pos) {
      gtk_toolbar_insert(&this, item, pos);
   }

   // Unintrospectable method: insert_element() / gtk_toolbar_insert_element()
   // Inserts a new element in the toolbar at the given position. 
   // If @type == %GTK_TOOLBAR_CHILD_WIDGET, @widget is used as the new element.
   // If @type == %GTK_TOOLBAR_CHILD_RADIOBUTTON, @widget is used to determine
   // the radio group for the new element. In all other cases, @widget must
   // be %NULL.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar element as a #GtkWidget.
   // <type>: a value of type #GtkToolbarChildType that determines what @widget will be.
   // <widget>: a #GtkWidget, or %NULL.
   // <text>: the element's label.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   // <icon>: a #GtkWidget that provides pictorial representation of the element's function.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: any data you wish to pass to the callback.
   // <position>: the number of widgets to insert this element after.
   Widget* insert_element(ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data, int position) {
      return gtk_toolbar_insert_element(&this, type, widget, text, tooltip_text, tooltip_private_text, icon, callback, user_data, position);
   }

   // Unintrospectable method: insert_item() / gtk_toolbar_insert_item()
   // Inserts a new item into the toolbar. You must specify the position in the
   // toolbar where it will be inserted.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar item as a #GtkWidget.
   // <text>: give your toolbar button a label.
   // <tooltip_text>: a string that appears when the user holds the mouse over this item.
   // <tooltip_private_text>: use with #GtkTipsQuery.
   // <icon>: a #GtkWidget that should be used as the button's icon.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: a pointer to any data you wish to be passed to the callback.
   // <position>: the number of widgets to insert this item after.
   Widget* insert_item(char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data, int position) {
      return gtk_toolbar_insert_item(&this, text, tooltip_text, tooltip_private_text, icon, callback, user_data, position);
   }

   // Inserts a new space in the toolbar at the specified position.
   // <position>: the number of widgets after which a space should be inserted.
   void insert_space(int position) {
      gtk_toolbar_insert_space(&this, position);
   }

   // Unintrospectable method: insert_stock() / gtk_toolbar_insert_stock()
   // Inserts a stock item at the specified position of the toolbar.  If
   // except that underscores used to mark mnemonics are removed.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the inserted widget
   // <stock_id>: The id of the stock item you want to insert
   // <tooltip_text>: The text in the tooltip of the toolbar button
   // <tooltip_private_text>: The private text of the tooltip
   // <callback>: The callback called when the toolbar button is clicked.
   // <user_data>: user data passed to callback
   // <position>: The position the button shall be inserted at. -1 means at the end.
   Widget* insert_stock(char* stock_id, char* tooltip_text, char* tooltip_private_text, GObject2.Callback callback, void* user_data, int position) {
      return gtk_toolbar_insert_stock(&this, stock_id, tooltip_text, tooltip_private_text, callback, user_data, position);
   }

   // Inserts a widget in the toolbar at the given position.
   // <widget>: a #GtkWidget to add to the toolbar.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   // <position>: the number of widgets to insert this widget after.
   void insert_widget(Widget* widget, char* tooltip_text, char* tooltip_private_text, int position) {
      gtk_toolbar_insert_widget(&this, widget, tooltip_text, tooltip_private_text, position);
   }

   // Unintrospectable method: prepend_element() / gtk_toolbar_prepend_element()
   // Adds a new element to the beginning of a toolbar.
   // If @type == %GTK_TOOLBAR_CHILD_WIDGET, @widget is used as the new element.
   // If @type == %GTK_TOOLBAR_CHILD_RADIOBUTTON, @widget is used to determine
   // the radio group for the new element. In all other cases, @widget must
   // be %NULL.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar element as a #GtkWidget.
   // <type>: a value of type #GtkToolbarChildType that determines what @widget will be.
   // <widget>: a #GtkWidget, or %NULL
   // <text>: the element's label.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   // <icon>: a #GtkWidget that provides pictorial representation of the element's function.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: any data you wish to pass to the callback.
   Widget* prepend_element(ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data) {
      return gtk_toolbar_prepend_element(&this, type, widget, text, tooltip_text, tooltip_private_text, icon, callback, user_data);
   }

   // Unintrospectable method: prepend_item() / gtk_toolbar_prepend_item()
   // Adds a new button to the beginning (top or left edges) of the given toolbar.
   // arguments. Use G_CALLBACK() to cast the function to #GCallback.
   // RETURNS: the new toolbar item as a #GtkWidget.
   // <text>: give your toolbar button a label.
   // <tooltip_text>: a string that appears when the user holds the mouse over this item.
   // <tooltip_private_text>: use with #GtkTipsQuery.
   // <icon>: a #GtkWidget that should be used as the button's icon.
   // <callback>: the function to be executed when the button is pressed.
   // <user_data>: a pointer to any data you wish to be passed to the callback.
   Widget* prepend_item(char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data) {
      return gtk_toolbar_prepend_item(&this, text, tooltip_text, tooltip_private_text, icon, callback, user_data);
   }
   // Adds a new space to the beginning of the toolbar.
   void prepend_space() {
      gtk_toolbar_prepend_space(&this);
   }

   // Adds a widget to the beginning of the given toolbar.
   // <widget>: a #GtkWidget to add to the toolbar.
   // <tooltip_text>: the element's tooltip.
   // <tooltip_private_text>: used for context-sensitive help about this toolbar element.
   void prepend_widget(Widget* widget, char* tooltip_text=null, char* tooltip_private_text=null) {
      gtk_toolbar_prepend_widget(&this, widget, tooltip_text, tooltip_private_text);
   }

   // Removes a space from the specified position.
   // <position>: the index of the space to remove.
   void remove_space(int position) {
      gtk_toolbar_remove_space(&this, position);
   }

   // Highlights @toolbar to give an idea of what it would look like
   // if @item was added to @toolbar at the position indicated by @index_.
   // If @item is %NULL, highlighting is turned off. In that case @index_ 
   // is ignored.
   // The @tool_item passed to this function must not be part of any widget
   // hierarchy. When an item is set as drop highlight item it can not
   // added to any widget hierarchy or used as highlight item for another
   // toolbar.
   // <tool_item>: a #GtkToolItem, or %NULL to turn of highlighting
   // <index_>: a position on @toolbar
   void set_drop_highlight_item(ToolItem* tool_item, int index_) {
      gtk_toolbar_set_drop_highlight_item(&this, tool_item, index_);
   }

   // This function sets the size of stock icons in the toolbar. You
   // can call it both before you add the icons and after they've been
   // added. The size you set will override user preferences for the default
   // icon size.
   // This should only be used for special-purpose toolbars, normal
   // application toolbars should respect the user preferences for the
   // size of icons.
   // <icon_size>: The #GtkIconSize that stock icons in the toolbar shall have.
   void set_icon_size(int icon_size) {
      gtk_toolbar_set_icon_size(&this, icon_size);
   }

   // Sets whether a toolbar should appear horizontally or vertically.
   // <orientation>: a new #GtkOrientation.
   void set_orientation(Orientation orientation) {
      gtk_toolbar_set_orientation(&this, orientation);
   }

   // Sets whether to show an overflow menu when
   // items that there are not room are available through an
   // overflow menu.
   // <show_arrow>: Whether to show an overflow menu
   void set_show_arrow(int show_arrow) {
      gtk_toolbar_set_show_arrow(&this, show_arrow);
   }

   // Alters the view of @toolbar to display either icons only, text only, or both.
   // <style>: the new style for @toolbar.
   void set_style(ToolbarStyle style) {
      gtk_toolbar_set_style(&this, style);
   }

   // Sets if the tooltips of a toolbar should be active or not.
   // is now used instead.
   // <enable>: set to %FALSE to disable the tooltips, or %TRUE to enable them.
   void set_tooltips(int enable) {
      gtk_toolbar_set_tooltips(&this, enable);
   }

   // Unsets toolbar icon size set with gtk_toolbar_set_icon_size(), so that
   // user preferences will be used to determine the icon size.
   void unset_icon_size() {
      gtk_toolbar_unset_icon_size(&this);
   }

   // Unsets a toolbar style set with gtk_toolbar_set_style(), so that
   // user preferences will be used to determine the toolbar style.
   void unset_style() {
      gtk_toolbar_unset_style(&this);
   }

   // A keybinding signal used internally by GTK+. This signal can't
   // be used in application code
   // RETURNS: %TRUE if the signal was handled, %FALSE if not
   // <focus_home>: %TRUE if the first item should be focused
   extern (C) alias static c_int function (Toolbar* this_, c_int focus_home, void* user_data=null) signal_focus_home_or_end;

   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:"focus-home-or-end", CB/*:signal_focus_home_or_end*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"focus-home-or-end",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the orientation of the toolbar changes.
   // <orientation>: the new #GtkOrientation of the toolbar
   extern (C) alias static void function (Toolbar* this_, Orientation* orientation, void* user_data=null) signal_orientation_changed;
   ulong signal_connect(string name:"orientation-changed", CB/*:signal_orientation_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"orientation-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the user right-clicks the toolbar or uses the
   // keybinding to display a popup menu.
   // Application developers should handle this signal if they want
   // to display a context menu on the toolbar. The context-menu should
   // appear at the coordinates given by @x and @y. The mouse button
   // number is given by the @button parameter. If the menu was popped
   // up using the keybaord, @button is -1.
   // RETURNS: return %TRUE if the signal was handled, %FALSE if not
   // <x>: the x coordinate of the point where the menu should appear
   // <y>: the y coordinate of the point where the menu should appear
   // <button>: the mouse button the user pressed, or -1
   extern (C) alias static c_int function (Toolbar* this_, int x, int y, int button, void* user_data=null) signal_popup_context_menu;
   ulong signal_connect(string name:"popup-context-menu", CB/*:signal_popup_context_menu*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popup-context-menu",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when the style of the toolbar changes.
   // <style>: the new #GtkToolbarStyle of the toolbar
   extern (C) alias static void function (Toolbar* this_, ToolbarStyle* style, void* user_data=null) signal_style_changed;
   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);
   }
}

struct ToolbarChild {
   ToolbarChildType type;
   Widget* widget, icon, label;
}

enum ToolbarChildType {
   SPACE = 0,
   BUTTON = 1,
   TOGGLEBUTTON = 2,
   RADIOBUTTON = 3,
   WIDGET = 4
}
struct ToolbarClass {
   ContainerClass parent_class;
   extern (C) void function (Toolbar* toolbar, Orientation orientation) orientation_changed;
   extern (C) void function (Toolbar* toolbar, ToolbarStyle style) style_changed;
   extern (C) int function (Toolbar* toolbar, int x, int y, int button_number) popup_context_menu;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

struct ToolbarPrivate {
}

enum ToolbarSpaceStyle {
   EMPTY = 0,
   LINE = 1
}
enum ToolbarStyle {
   ICONS = 0,
   TEXT = 1,
   BOTH = 2,
   BOTH_HORIZ = 3
}
struct Tooltip /* : GObject.Object */ {
   alias method_parent this;
   alias method_parent super_;
   alias method_parent object;
   GObject2.Object method_parent;


   // Triggers a new tooltip query on @display, in order to update the current
   // visible tooltip, or to show/hide the current tooltip.  This function is
   // useful to call when, for example, the state of the widget changed by a
   // key press.
   // <display>: a #GdkDisplay
   static void trigger_tooltip_query(Gdk2.Display* display) {
      gtk_tooltip_trigger_tooltip_query(display);
   }

   // Replaces the widget packed into the tooltip with
   // away.
   // By default a box with a #GtkImage and #GtkLabel is embedded in 
   // the tooltip, which can be configured using gtk_tooltip_set_markup() 
   // and gtk_tooltip_set_icon().
   // <custom_widget>: a #GtkWidget, or %NULL to unset the old custom widget.
   void set_custom(Widget* custom_widget=null) {
      gtk_tooltip_set_custom(&this, custom_widget);
   }

   // Sets the icon of the tooltip (which is in front of the text) to be
   // <pixbuf>: a #GdkPixbuf, or %NULL
   void set_icon(GdkPixbuf2.Pixbuf* pixbuf=null) {
      gtk_tooltip_set_icon(&this, pixbuf);
   }

   // Sets the icon of the tooltip (which is in front of the text)
   // to be the icon indicated by @gicon with the size indicated
   // by @size. If @gicon is %NULL, the image will be hidden.
   // <gicon>: a #GIcon representing the icon, or %NULL
   // <size>: a stock icon size
   void set_icon_from_gicon(Gio2.Icon* gicon, int size) {
      gtk_tooltip_set_icon_from_gicon(&this, gicon, size);
   }

   // Sets the icon of the tooltip (which is in front of the text) to be
   // the icon indicated by @icon_name with the size indicated
   // by @size.  If @icon_name is %NULL, the image will be hidden.
   // <icon_name>: an icon name, or %NULL
   // <size>: a stock icon size
   void set_icon_from_icon_name(char* icon_name, int size) {
      gtk_tooltip_set_icon_from_icon_name(&this, icon_name, size);
   }

   // Sets the icon of the tooltip (which is in front of the text) to be
   // the stock item indicated by @stock_id with the size indicated
   // by @size.  If @stock_id is %NULL, the image will be hidden.
   // <stock_id>: a stock id, or %NULL
   // <size>: a stock icon size
   void set_icon_from_stock(char* stock_id, int size) {
      gtk_tooltip_set_icon_from_stock(&this, stock_id, size);
   }

   // Sets the text of the tooltip to be @markup, which is marked up
   // with the <link
   // linkend="PangoMarkupFormat">Pango text markup language</link>.
   // If @markup is %NULL, the label will be hidden.
   // <markup>: a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>) or %NULL
   void set_markup(char* markup=null) {
      gtk_tooltip_set_markup(&this, markup);
   }

   // Sets the text of the tooltip to be @text. If @text is %NULL, the label
   // will be hidden. See also gtk_tooltip_set_markup().
   // <text>: a text string or %NULL
   void set_text(char* text=null) {
      gtk_tooltip_set_text(&this, text);
   }

   // Sets the area of the widget, where the contents of this tooltip apply,
   // to be @rect (in widget coordinates).  This is especially useful for
   // properly setting tooltips on #GtkTreeView rows and cells, #GtkIconViews,
   // etc.
   // For setting tooltips on #GtkTreeView, please refer to the convenience
   // gtk_tree_view_set_tooltip_cell().
   // <rect>: a #GdkRectangle
   void set_tip_area(Gdk2.Rectangle* rect) {
      gtk_tooltip_set_tip_area(&this, rect);
   }
}

struct Tooltips /* : Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   Object parent_instance;
   private Widget* tip_window, tip_label;
   private TooltipsData* active_tips_data;
   private GLib2.List* tips_data_list;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "delay", 30,
   uint, "enabled", 1,
   uint, "have_grab", 1,
   uint, "use_sticky_delay", 1,
    uint, "__dummy64A", 31));
   private int timer_tag;
   private GLib2.TimeVal last_popdown;

   static Tooltips* new_() {
      return gtk_tooltips_new();
   }

   // Determines the tooltips and the widget they belong to from the window in 
   // which they are displayed. 
   // This function is mostly intended for use by accessibility technologies;
   // applications should have little use for it.
   // RETURNS: %TRUE if @tip_window is displaying tooltips, otherwise %FALSE.
   // <tip_window>: a #GtkWindow
   // <tooltips>: the return location for the tooltips which are displayed in @tip_window, or %NULL
   // <current_widget>: the return location for the widget whose tooltips are displayed, or %NULL
   static int get_info_from_tip_window(Window* tip_window, Tooltips** tooltips, Widget** current_widget) {
      return gtk_tooltips_get_info_from_tip_window(tip_window, tooltips, current_widget);
   }
   void disable() {
      gtk_tooltips_disable(&this);
   }
   void enable() {
      gtk_tooltips_enable(&this);
   }
   void force_window() {
      gtk_tooltips_force_window(&this);
   }
   void set_delay(uint delay) {
      gtk_tooltips_set_delay(&this, delay);
   }

   // Adds a tooltip containing the message @tip_text to the specified #GtkWidget.
   // <widget>: the #GtkWidget you wish to associate the tip with.
   // <tip_text>: a string containing the tip itself.
   // <tip_private>: a string of any further information that may be useful if the user gets stuck.
   void set_tip(Widget* widget, char* tip_text=null, char* tip_private=null) {
      gtk_tooltips_set_tip(&this, widget, tip_text, tip_private);
   }
}

struct TooltipsClass {
   ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TooltipsData {
   Tooltips* tooltips;
   Widget* widget;
   char* tip_text, tip_private;
}

extern (C) alias char* /*new*/ function (char* path, void* func_data) TranslateFunc;

extern (C) alias void function (TreeViewColumn* tree_column, CellRenderer* cell, TreeModel* tree_model, TreeIter* iter, void* data) TreeCellDataFunc;

extern (C) alias void function (TreeView* tree_view, TreePath* path, int children, void* user_data) TreeDestroyCountFunc;

struct TreeDragDest {

   // Asks the #GtkTreeDragDest to insert a row before the path @dest,
   // deriving the contents of the row from @selection_data. If @dest is
   // outside the tree so that inserting before it is impossible, %FALSE
   // will be returned. Also, %FALSE may be returned if the new row is
   // not created for some model-specific reason.  Should robustly handle
   // a @dest no longer found in the model!
   // RETURNS: whether a new row was created before position @dest
   // <dest>: row to drop in front of
   // <selection_data>: data to drop
   int drag_data_received(TreePath* dest, SelectionData* selection_data) {
      return gtk_tree_drag_dest_drag_data_received(&this, dest, selection_data);
   }

   // Determines whether a drop is possible before the given @dest_path,
   // at the same depth as @dest_path. i.e., can we drop the data in
   // exist; the return value will almost certainly be %FALSE if the
   // parent of @dest_path doesn't exist, though.
   // RETURNS: %TRUE if a drop is possible before @dest_path
   // <dest_path>: destination row
   // <selection_data>: the data being dragged
   int row_drop_possible(TreePath* dest_path, SelectionData* selection_data) {
      return gtk_tree_drag_dest_row_drop_possible(&this, dest_path, selection_data);
   }
}

struct TreeDragDestIface {
   GObject2.TypeInterface g_iface;

   // RETURNS: whether a new row was created before position @dest
   // <dest>: row to drop in front of
   // <selection_data>: data to drop
   extern (C) int function (TreeDragDest* drag_dest, TreePath* dest, SelectionData* selection_data) drag_data_received;

   // RETURNS: %TRUE if a drop is possible before @dest_path
   // <dest_path>: destination row
   // <selection_data>: the data being dragged
   extern (C) int function (TreeDragDest* drag_dest, TreePath* dest_path, SelectionData* selection_data) row_drop_possible;
}

struct TreeDragSource {

   // Asks the #GtkTreeDragSource to delete the row at @path, because
   // it was moved somewhere else via drag-and-drop. Returns %FALSE
   // if the deletion fails because @path no longer exists, or for
   // some model-specific reason. Should robustly handle a @path no
   // longer found in the model!
   // RETURNS: %TRUE if the row was successfully deleted
   // <path>: row that was being dragged
   int drag_data_delete(TreePath* path) {
      return gtk_tree_drag_source_drag_data_delete(&this, path);
   }

   // Asks the #GtkTreeDragSource to fill in @selection_data with a
   // representation of the row at @path. @selection_data->target gives
   // the required type of the data.  Should robustly handle a @path no
   // longer found in the model!
   // RETURNS: %TRUE if data of the required type was provided
   // <path>: row that was dragged
   // <selection_data>: a #GtkSelectionData to fill with data from the dragged row
   int drag_data_get(TreePath* path, /*out*/ SelectionData* selection_data) {
      return gtk_tree_drag_source_drag_data_get(&this, path, selection_data);
   }

   // Asks the #GtkTreeDragSource whether a particular row can be used as
   // the source of a DND operation. If the source doesn't implement
   // this interface, the row is assumed draggable.
   // RETURNS: %TRUE if the row can be dragged
   // <path>: row on which user is initiating a drag
   int row_draggable(TreePath* path) {
      return gtk_tree_drag_source_row_draggable(&this, path);
   }
}

struct TreeDragSourceIface {
   GObject2.TypeInterface g_iface;

   // RETURNS: %TRUE if the row can be dragged
   // <path>: row on which user is initiating a drag
   extern (C) int function (TreeDragSource* drag_source, TreePath* path) row_draggable;

   // RETURNS: %TRUE if data of the required type was provided
   // <path>: row that was dragged
   // <selection_data>: a #GtkSelectionData to fill with data from the dragged row
   extern (C) int function (TreeDragSource* drag_source, TreePath* path, /*out*/ SelectionData* selection_data) drag_data_get;

   // RETURNS: %TRUE if the row was successfully deleted
   // <path>: row that was being dragged
   extern (C) int function (TreeDragSource* drag_source, TreePath* path) drag_data_delete;
}

struct TreeIter {
   int stamp;
   void* user_data, user_data2, user_data3;


   // Creates a dynamically allocated tree iterator as a copy of @iter.  
   // This function is not intended for use in applications, because you 
   // can just copy the structs by value 
   // (<literal>GtkTreeIter new_iter = iter;</literal>).
   // You must free this iter with gtk_tree_iter_free().
   // RETURNS: a newly-allocated copy of @iter.
   TreeIter* /*new*/ copy() {
      return gtk_tree_iter_copy(&this);
   }

   // Frees an iterator that has been allocated by gtk_tree_iter_copy().
   // This function is mainly used for language bindings.
   void free() {
      gtk_tree_iter_free(&this);
   }
}

extern (C) alias int function (TreeModel* model, TreeIter* a, TreeIter* b, void* user_data) TreeIterCompareFunc;

struct TreeModel {

   // Creates a new #GtkTreeModel, with @child_model as the child_model
   // and @root as the virtual root.
   // RETURNS: A new #GtkTreeModel.
   // <root>: A #GtkTreePath or %NULL.
   TreeModel* /*new*/ filter_new(TreePath* root=null) {
      return gtk_tree_model_filter_new(&this, root);
   }

   // Calls func on each node in model in a depth-first fashion.
   // If @func returns %TRUE, then the tree ceases to be walked, and
   // gtk_tree_model_foreach() returns.
   // <func>: A function to be called on each row
   // <user_data>: User data to passed to func.
   void foreach_(TreeModelForeachFunc func, void* user_data) {
      gtk_tree_model_foreach(&this, func, user_data);
   }

   // Unintrospectable method: get() / gtk_tree_model_get()
   // Gets the value of one or more cells in the row referenced by @iter.
   // The variable argument list should contain integer column numbers,
   // each column number followed by a place to store the value being
   // retrieved.  The list is terminated by a -1. For example, to get a
   // value from column 0 with type %G_TYPE_STRING, you would
   // where <literal>place_string_here</literal> is a <type>gchar*</type> to be 
   // filled with the string.
   // Returned values with type %G_TYPE_OBJECT have to be unreferenced, values
   // with type %G_TYPE_STRING or %G_TYPE_BOXED have to be freed. Other values are
   // passed by value.
   // <iter>: a row in @tree_model
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_tree_model_get get; // Variadic
   +/

   // Returns the type of the column.
   // RETURNS: The type of the column.
   // <index_>: The column index.
   Type get_column_type(int index_) {
      return gtk_tree_model_get_column_type(&this, index_);
   }

   // Returns a set of flags supported by this interface.  The flags are a bitwise
   // combination of #GtkTreeModelFlags.  The flags supported should not change
   // during the lifecycle of the @tree_model.
   // RETURNS: The flags supported by this interface.
   TreeModelFlags get_flags() {
      return gtk_tree_model_get_flags(&this);
   }

   // Sets @iter to a valid iterator pointing to @path.
   // RETURNS: %TRUE, if @iter was set.
   // <iter>: The uninitialized #GtkTreeIter.
   // <path>: The #GtkTreePath.
   int get_iter(/*out*/ TreeIter* iter, TreePath* path) {
      return gtk_tree_model_get_iter(&this, iter, path);
   }

   // Initializes @iter with the first iterator in the tree (the one at the path
   // "0") and returns %TRUE.  Returns %FALSE if the tree is empty.
   // RETURNS: %TRUE, if @iter was set.
   // <iter>: The uninitialized #GtkTreeIter.
   int get_iter_first(/*out*/ TreeIter* iter) {
      return gtk_tree_model_get_iter_first(&this, iter);
   }

   // Sets @iter to a valid iterator pointing to @path_string, if it
   // exists. Otherwise, @iter is left invalid and %FALSE is returned.
   // RETURNS: %TRUE, if @iter was set.
   // <iter>: An uninitialized #GtkTreeIter.
   // <path_string>: A string representation of a #GtkTreePath.
   int get_iter_from_string(/*out*/ TreeIter* iter, char* path_string) {
      return gtk_tree_model_get_iter_from_string(&this, iter, path_string);
   }

   // Returns the number of columns supported by @tree_model.
   // RETURNS: The number of columns.
   int get_n_columns() {
      return gtk_tree_model_get_n_columns(&this);
   }

   // Returns a newly-created #GtkTreePath referenced by @iter.  This path should
   // be freed with gtk_tree_path_free().
   // RETURNS: a newly-created #GtkTreePath.
   // <iter>: The #GtkTreeIter.
   TreePath* /*new*/ get_path(TreeIter* iter) {
      return gtk_tree_model_get_path(&this, iter);
   }

   // Generates a string representation of the iter. This string is a ':'
   // separated list of numbers. For example, "4:10:0:3" would be an
   // acceptable return value for this string.
   // RETURNS: A newly-allocated string. Must be freed with g_free().
   // <iter>: An #GtkTreeIter.
   char* /*new*/ get_string_from_iter(TreeIter* iter) {
      return gtk_tree_model_get_string_from_iter(&this, iter);
   }

   // Unintrospectable method: get_valist() / gtk_tree_model_get_valist()
   // See gtk_tree_model_get(), this version takes a <type>va_list</type> 
   // for language bindings to use.
   // <iter>: a row in @tree_model
   // <var_args>: <type>va_list</type> of column/return location pairs
   void get_valist(TreeIter* iter, va_list var_args) {
      gtk_tree_model_get_valist(&this, iter, var_args);
   }

   // Initializes and sets @value to that at @column.
   // When done with @value, g_value_unset() needs to be called 
   // to free any allocated memory.
   // <iter>: The #GtkTreeIter.
   // <column>: The column to lookup the value at.
   // <value>: An empty #GValue to set.
   void get_value(TreeIter* iter, int column, /*out*/ GObject2.Value* value) {
      gtk_tree_model_get_value(&this, iter, column, value);
   }

   // Sets @iter to point to the first child of @parent.  If @parent has no
   // children, %FALSE is returned and @iter is set to be invalid.  @parent
   // will remain a valid node after this function has been called.
   // If @parent is %NULL returns the first node, equivalent to
   // <literal>gtk_tree_model_get_iter_first (tree_model, iter);</literal>
   // RETURNS: %TRUE, if @child has been set to the first child.
   // <iter>: The new #GtkTreeIter to be set to the child.
   // <parent>: The #GtkTreeIter, or %NULL
   int iter_children(/*out*/ TreeIter* iter, TreeIter* parent=null) {
      return gtk_tree_model_iter_children(&this, iter, parent);
   }

   // Returns %TRUE if @iter has children, %FALSE otherwise.
   // RETURNS: %TRUE if @iter has children.
   // <iter>: The #GtkTreeIter to test for children.
   int iter_has_child(TreeIter* iter) {
      return gtk_tree_model_iter_has_child(&this, iter);
   }

   // Returns the number of children that @iter has.  As a special case, if @iter
   // is %NULL, then the number of toplevel nodes is returned.
   // RETURNS: The number of children of @iter.
   // <iter>: The #GtkTreeIter, or %NULL.
   int iter_n_children(TreeIter* iter=null) {
      return gtk_tree_model_iter_n_children(&this, iter);
   }

   // Sets @iter to point to the node following it at the current level.  If there
   // is no next @iter, %FALSE is returned and @iter is set to be invalid.
   // RETURNS: %TRUE if @iter has been changed to the next node.
   // <iter>: The #GtkTreeIter.
   int iter_next(TreeIter* iter) {
      return gtk_tree_model_iter_next(&this, iter);
   }

   // Sets @iter to be the child of @parent, using the given index.  The first
   // index is 0.  If @n is too big, or @parent has no children, @iter is set
   // to an invalid iterator and %FALSE is returned.  @parent will remain a valid
   // node after this function has been called.  As a special case, if @parent is
   // %NULL, then the @n<!-- -->th root node is set.
   // RETURNS: %TRUE, if @parent has an @n<!-- -->th child.
   // <iter>: The #GtkTreeIter to set to the nth child.
   // <parent>: The #GtkTreeIter to get the child from, or %NULL.
   // <n>: Then index of the desired child.
   int iter_nth_child(/*out*/ TreeIter* iter, TreeIter* parent, int n) {
      return gtk_tree_model_iter_nth_child(&this, iter, parent, n);
   }

   // Sets @iter to be the parent of @child.  If @child is at the toplevel, and
   // doesn't have a parent, then @iter is set to an invalid iterator and %FALSE
   // is returned.  @child will remain a valid node after this function has been
   // called.
   // RETURNS: %TRUE, if @iter is set to the parent of @child.
   // <iter>: The new #GtkTreeIter to set to the parent.
   // <child>: The #GtkTreeIter.
   int iter_parent(/*out*/ TreeIter* iter, TreeIter* child) {
      return gtk_tree_model_iter_parent(&this, iter, child);
   }

   // Lets the tree ref the node.  This is an optional method for models to
   // implement.  To be more specific, models may ignore this call as it exists
   // primarily for performance reasons.
   // This function is primarily meant as a way for views to let caching model 
   // know when nodes are being displayed (and hence, whether or not to cache that
   // node.)  For example, a file-system based model would not want to keep the
   // entire file-hierarchy in memory, just the sections that are currently being
   // displayed by every current view.
   // A model should be expected to be able to get an iter independent of its
   // reffed state.
   // <iter>: The #GtkTreeIter.
   void ref_node(TreeIter* iter) {
      gtk_tree_model_ref_node(&this, iter);
   }

   // Emits the "row-changed" signal on @tree_model.
   // <path>: A #GtkTreePath pointing to the changed row
   // <iter>: A valid #GtkTreeIter pointing to the changed row
   void row_changed(TreePath* path, TreeIter* iter) {
      gtk_tree_model_row_changed(&this, path, iter);
   }

   // Emits the "row-deleted" signal on @tree_model.  This should be called by
   // models after a row has been removed.  The location pointed to by @path 
   // should be the location that the row previously was at.  It may not be a 
   // valid location anymore.
   // <path>: A #GtkTreePath pointing to the previous location of the deleted row.
   void row_deleted(TreePath* path) {
      gtk_tree_model_row_deleted(&this, path);
   }

   // Emits the "row-has-child-toggled" signal on @tree_model.  This should be
   // called by models after the child state of a node changes.
   // <path>: A #GtkTreePath pointing to the changed row
   // <iter>: A valid #GtkTreeIter pointing to the changed row
   void row_has_child_toggled(TreePath* path, TreeIter* iter) {
      gtk_tree_model_row_has_child_toggled(&this, path, iter);
   }

   // Emits the "row-inserted" signal on @tree_model
   // <path>: A #GtkTreePath pointing to the inserted row
   // <iter>: A valid #GtkTreeIter pointing to the inserted row
   void row_inserted(TreePath* path, TreeIter* iter) {
      gtk_tree_model_row_inserted(&this, path, iter);
   }

   // Emits the "rows-reordered" signal on @tree_model.  This should be called by
   // models when their rows have been reordered.
   // <path>: A #GtkTreePath pointing to the tree node whose children have been reordered
   // <iter>: A valid #GtkTreeIter pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0.
   // <new_order>: an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order<literal>[newpos] = oldpos</literal>.
   void rows_reordered(TreePath* path, TreeIter* iter, int* new_order) {
      gtk_tree_model_rows_reordered(&this, path, iter, new_order);
   }

   // Creates a new #GtkTreeModel, with @child_model as the child model.
   // RETURNS: A new #GtkTreeModel.
   TreeModel* /*new*/ sort_new_with_model() {
      return gtk_tree_model_sort_new_with_model(&this);
   }

   // Lets the tree unref the node.  This is an optional method for models to
   // implement.  To be more specific, models may ignore this call as it exists
   // primarily for performance reasons.
   // For more information on what this means, see gtk_tree_model_ref_node().
   // Please note that nodes that are deleted are not unreffed.
   // <iter>: The #GtkTreeIter.
   void unref_node(TreeIter* iter) {
      gtk_tree_model_unref_node(&this, iter);
   }

   // This signal is emitted when a row in the model has changed.
   // <path>: a #GtkTreePath identifying the changed row
   // <iter>: a valid #GtkTreeIter pointing to the changed row
   extern (C) alias static void function (TreeModel* this_, TreePath* path, TreeIter* iter, void* user_data=null) signal_row_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:"row-changed", CB/*:signal_row_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when a row has been deleted.
   // Note that no iterator is passed to the signal handler,
   // since the row is already deleted.
   // This should be called by models after a row has been removed.
   // The location pointed to by @path should be the location that
   // the row previously was at. It may not be a valid location anymore.
   // <path>: a #GtkTreePath identifying the row
   extern (C) alias static void function (TreeModel* this_, TreePath* path, void* user_data=null) signal_row_deleted;
   ulong signal_connect(string name:"row-deleted", CB/*:signal_row_deleted*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-deleted",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when a row has gotten the first child row or lost
   // its last child row.
   // <path>: a #GtkTreePath identifying the row
   // <iter>: a valid #GtkTreeIter pointing to the row
   extern (C) alias static void function (TreeModel* this_, TreePath* path, TreeIter* iter, void* user_data=null) signal_row_has_child_toggled;
   ulong signal_connect(string name:"row-has-child-toggled", CB/*:signal_row_has_child_toggled*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-has-child-toggled",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when a new row has been inserted in the model.
   // Note that the row may still be empty at this point, since
   // it is a common pattern to first insert an empty row, and 
   // then fill it with the desired values.
   // <path>: a #GtkTreePath identifying the new row
   // <iter>: a valid #GtkTreeIter pointing to the new row
   extern (C) alias static void function (TreeModel* this_, TreePath* path, TreeIter* iter, void* user_data=null) signal_row_inserted;
   ulong signal_connect(string name:"row-inserted", CB/*:signal_row_inserted*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-inserted",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal is emitted when the children of a node in the #GtkTreeModel
   // have been reordered. 
   // Note that this signal is <emphasis>not</emphasis> emitted
   // when rows are reordered by DND, since this is implemented
   // by removing and then reinserting the row.
   // <path>: a #GtkTreePath identifying the tree node whose children have been reordered
   // <iter>: a valid #GtkTreeIter pointing to the node whose
   // <new_order>: an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order<literal>[newpos] = oldpos</literal>.
   extern (C) alias static void function (TreeModel* this_, TreePath* path, TreeIter* iter, void* new_order, void* user_data=null) signal_rows_reordered;
   ulong signal_connect(string name:"rows-reordered", CB/*:signal_rows_reordered*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"rows-reordered",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TreeModelFilter /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private TreeModelFilterPrivate* priv;


   // This function should almost never be called. It clears the @filter
   // of any cached iterators that haven't been reffed with
   // gtk_tree_model_ref_node(). This might be useful if the child model
   // being filtered is static (and doesn't change often) and there has been
   // a lot of unreffed access to nodes. As a side effect of this function,
   // all unreffed iters will be invalid.
   void clear_cache() {
      gtk_tree_model_filter_clear_cache(&this);
   }

   // Sets @filter_iter to point to the row in @filter that corresponds to the
   // row pointed at by @child_iter.  If @filter_iter was not set, %FALSE is
   // returned.
   // valid iterator pointing to a visible row in child model.
   // RETURNS: %TRUE, if @filter_iter was set, i.e. if @child_iter is a
   // <filter_iter>: An uninitialized #GtkTreeIter.
   // <child_iter>: A valid #GtkTreeIter pointing to a row on the child model.
   int convert_child_iter_to_iter(/*out*/ TreeIter* filter_iter, TreeIter* child_iter) {
      return gtk_tree_model_filter_convert_child_iter_to_iter(&this, filter_iter, child_iter);
   }

   // Converts @child_path to a path relative to @filter. That is, @child_path
   // points to a path in the child model. The rerturned path will point to the
   // same row in the filtered model. If @child_path isn't a valid path on the
   // child model or points to a row which is not visible in @filter, then %NULL
   // is returned.
   // RETURNS: A newly allocated #GtkTreePath, or %NULL.
   // <child_path>: A #GtkTreePath to convert.
   TreePath* /*new*/ convert_child_path_to_path(TreePath* child_path) {
      return gtk_tree_model_filter_convert_child_path_to_path(&this, child_path);
   }

   // Sets @child_iter to point to the row pointed to by @filter_iter.
   // <child_iter>: An uninitialized #GtkTreeIter.
   // <filter_iter>: A valid #GtkTreeIter pointing to a row on @filter.
   void convert_iter_to_child_iter(/*out*/ TreeIter* child_iter, TreeIter* filter_iter) {
      gtk_tree_model_filter_convert_iter_to_child_iter(&this, child_iter, filter_iter);
   }

   // Converts @filter_path to a path on the child model of @filter. That is,
   // point to the same location in the model not being filtered. If @filter_path
   // does not point to a location in the child model, %NULL is returned.
   // RETURNS: A newly allocated #GtkTreePath, or %NULL.
   // <filter_path>: A #GtkTreePath to convert.
   TreePath* /*new*/ convert_path_to_child_path(TreePath* filter_path) {
      return gtk_tree_model_filter_convert_path_to_child_path(&this, filter_path);
   }

   // Returns a pointer to the child model of @filter.
   // RETURNS: A pointer to a #GtkTreeModel.
   TreeModel* get_model() {
      return gtk_tree_model_filter_get_model(&this);
   }

   // Emits ::row_changed for each row in the child model, which causes
   // the filter to re-evaluate whether a row is visible or not.
   void refilter() {
      gtk_tree_model_filter_refilter(&this);
   }

   // With the @n_columns and @types parameters, you give an array of column
   // types for this model (which will be exposed to the parent model/view).
   // The @func, @data and @destroy parameters are for specifying the modify
   // function. The modify function will get called for <emphasis>each</emphasis>
   // data access, the goal of the modify function is to return the data which 
   // should be displayed at the location specified using the parameters of the 
   // modify function.
   // <n_columns>: The number of columns in the filter model.
   // <types>: The #GType<!-- -->s of the columns.
   // <func>: A #GtkTreeModelFilterModifyFunc
   // <data>: User data to pass to the modify function, or %NULL.
   // <destroy>: Destroy notifier of @data, or %NULL.
   void set_modify_func(int n_columns, Type* types, TreeModelFilterModifyFunc func, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_model_filter_set_modify_func(&this, n_columns, types, func, data, destroy);
   }

   // Sets @column of the child_model to be the column where @filter should
   // look for visibility information. @columns should be a column of type
   // %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
   // if not.
   // <column>: A #gint which is the column containing the visible information.
   void set_visible_column(int column) {
      gtk_tree_model_filter_set_visible_column(&this, column);
   }

   // Sets the visible function used when filtering the @filter to be @func. The
   // function should return %TRUE if the given row should be visible and
   // %FALSE otherwise.
   // If the condition calculated by the function changes over time (e.g. because
   // it depends on some global parameters), you must call 
   // gtk_tree_model_filter_refilter() to keep the visibility information of 
   // the model uptodate.
   // Note that @func is called whenever a row is inserted, when it may still be
   // empty. The visible function should therefore take special care of empty
   // rows, like in the example below.
   // <informalexample><programlisting>
   // static gboolean
   // visible_func (GtkTreeModel *model,
   // GtkTreeIter  *iter,
   // gpointer      data)
   // {
   // /&ast; Visible if row is non-empty and first column is "HI" &ast;/
   // gchar *str;
   // gboolean visible = FALSE;
   // gtk_tree_model_get (model, iter, 0, &str, -1);
   // if (str && strcmp (str, "HI") == 0)
   // visible = TRUE;
   // g_free (str);
   // return visible;
   // }
   // </programlisting></informalexample>
   // <func>: A #GtkTreeModelFilterVisibleFunc, the visible function.
   // <data>: User data to pass to the visible function, or %NULL.
   // <destroy>: Destroy notifier of @data, or %NULL.
   void set_visible_func(TreeModelFilterVisibleFunc func, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_model_filter_set_visible_func(&this, func, data, destroy);
   }
}

struct TreeModelFilterClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
}

extern (C) alias void function (TreeModel* model, TreeIter* iter, GObject2.Value* value, int column, void* data) TreeModelFilterModifyFunc;

struct TreeModelFilterPrivate {
}

extern (C) alias int function (TreeModel* model, TreeIter* iter, void* data) TreeModelFilterVisibleFunc;

enum TreeModelFlags {
   ITERS_PERSIST = 1,
   LIST_ONLY = 2
}
extern (C) alias int function (TreeModel* model, TreePath* path, TreeIter* iter, void* data) TreeModelForeachFunc;

struct TreeModelIface {
   GObject2.TypeInterface g_iface;

   // <path>: A #GtkTreePath pointing to the changed row
   // <iter>: A valid #GtkTreeIter pointing to the changed row
   extern (C) void function (TreeModel* tree_model, TreePath* path, TreeIter* iter) row_changed;

   // <path>: A #GtkTreePath pointing to the inserted row
   // <iter>: A valid #GtkTreeIter pointing to the inserted row
   extern (C) void function (TreeModel* tree_model, TreePath* path, TreeIter* iter) row_inserted;

   // <path>: A #GtkTreePath pointing to the changed row
   // <iter>: A valid #GtkTreeIter pointing to the changed row
   extern (C) void function (TreeModel* tree_model, TreePath* path, TreeIter* iter) row_has_child_toggled;
   // <path>: A #GtkTreePath pointing to the previous location of the deleted row.
   extern (C) void function (TreeModel* tree_model, TreePath* path) row_deleted;

   // <path>: A #GtkTreePath pointing to the tree node whose children have been reordered
   // <iter>: A valid #GtkTreeIter pointing to the node whose children have been reordered, or %NULL if the depth of @path is 0.
   // <new_order>: an array of integers mapping the current position of each child to its old position before the re-ordering, i.e. @new_order<literal>[newpos] = oldpos</literal>.
   extern (C) void function (TreeModel* tree_model, TreePath* path, TreeIter* iter, int* new_order) rows_reordered;
   // RETURNS: The flags supported by this interface.
   extern (C) TreeModelFlags function (TreeModel* tree_model) get_flags;
   // RETURNS: The number of columns.
   extern (C) int function (TreeModel* tree_model) get_n_columns;

   // RETURNS: The type of the column.
   // <index_>: The column index.
   extern (C) Type function (TreeModel* tree_model, int index_) get_column_type;

   // RETURNS: %TRUE, if @iter was set.
   // <iter>: The uninitialized #GtkTreeIter.
   // <path>: The #GtkTreePath.
   extern (C) int function (TreeModel* tree_model, /*out*/ TreeIter* iter, TreePath* path) get_iter;

   // RETURNS: a newly-created #GtkTreePath.
   // <iter>: The #GtkTreeIter.
   extern (C) TreePath* /*new*/ function (TreeModel* tree_model, TreeIter* iter) get_path;

   // <iter>: The #GtkTreeIter.
   // <column>: The column to lookup the value at.
   // <value>: An empty #GValue to set.
   extern (C) void function (TreeModel* tree_model, TreeIter* iter, int column, /*out*/ GObject2.Value* value) get_value;

   // RETURNS: %TRUE if @iter has been changed to the next node.
   // <iter>: The #GtkTreeIter.
   extern (C) int function (TreeModel* tree_model, TreeIter* iter) iter_next;

   // RETURNS: %TRUE, if @child has been set to the first child.
   // <iter>: The new #GtkTreeIter to be set to the child.
   // <parent>: The #GtkTreeIter, or %NULL
   extern (C) int function (TreeModel* tree_model, /*out*/ TreeIter* iter, TreeIter* parent=null) iter_children;

   // RETURNS: %TRUE if @iter has children.
   // <iter>: The #GtkTreeIter to test for children.
   extern (C) int function (TreeModel* tree_model, TreeIter* iter) iter_has_child;

   // RETURNS: The number of children of @iter.
   // <iter>: The #GtkTreeIter, or %NULL.
   extern (C) int function (TreeModel* tree_model, TreeIter* iter=null) iter_n_children;

   // RETURNS: %TRUE, if @parent has an @n<!-- -->th child.
   // <iter>: The #GtkTreeIter to set to the nth child.
   // <parent>: The #GtkTreeIter to get the child from, or %NULL.
   // <n>: Then index of the desired child.
   extern (C) int function (TreeModel* tree_model, /*out*/ TreeIter* iter, TreeIter* parent, int n) iter_nth_child;

   // RETURNS: %TRUE, if @iter is set to the parent of @child.
   // <iter>: The new #GtkTreeIter to set to the parent.
   // <child>: The #GtkTreeIter.
   extern (C) int function (TreeModel* tree_model, /*out*/ TreeIter* iter, TreeIter* child) iter_parent;
   // <iter>: The #GtkTreeIter.
   extern (C) void function (TreeModel* tree_model, TreeIter* iter) ref_node;
   // <iter>: The #GtkTreeIter.
   extern (C) void function (TreeModel* tree_model, TreeIter* iter) unref_node;
}

struct TreeModelSort /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private void* root;
   private int stamp;
   private uint child_flags;
   private TreeModel* child_model;
   private int zero_ref_count;
   private GLib2.List* sort_list;
   private int sort_column_id;
   private SortType order;
   private TreeIterCompareFunc default_sort_func;
   private void* default_sort_data;
   private GLib2.DestroyNotify default_sort_destroy;
   private uint changed_id, inserted_id, has_child_toggled_id, deleted_id, reordered_id;


   // This function should almost never be called.  It clears the @tree_model_sort
   // of any cached iterators that haven't been reffed with
   // gtk_tree_model_ref_node().  This might be useful if the child model being
   // sorted is static (and doesn't change often) and there has been a lot of
   // unreffed access to nodes.  As a side effect of this function, all unreffed
   // iters will be invalid.
   void clear_cache() {
      gtk_tree_model_sort_clear_cache(&this);
   }

   // Sets @sort_iter to point to the row in @tree_model_sort that corresponds to
   // the row pointed at by @child_iter.  If @sort_iter was not set, %FALSE
   // valid iterator pointer to a visible row in the child model.
   // RETURNS: %TRUE, if @sort_iter was set, i.e. if @sort_iter is a
   // <sort_iter>: An uninitialized #GtkTreeIter.
   // <child_iter>: A valid #GtkTreeIter pointing to a row on the child model
   int convert_child_iter_to_iter(/*out*/ TreeIter* sort_iter, TreeIter* child_iter) {
      return gtk_tree_model_sort_convert_child_iter_to_iter(&this, sort_iter, child_iter);
   }

   // Converts @child_path to a path relative to @tree_model_sort.  That is,
   // point to the same row in the sorted model.  If @child_path isn't a valid 
   // path on the child model, then %NULL is returned.
   // RETURNS: A newly allocated #GtkTreePath, or %NULL
   // <child_path>: A #GtkTreePath to convert
   TreePath* /*new*/ convert_child_path_to_path(TreePath* child_path) {
      return gtk_tree_model_sort_convert_child_path_to_path(&this, child_path);
   }

   // Sets @child_iter to point to the row pointed to by @sorted_iter.
   // <child_iter>: An uninitialized #GtkTreeIter
   // <sorted_iter>: A valid #GtkTreeIter pointing to a row on @tree_model_sort.
   void convert_iter_to_child_iter(/*out*/ TreeIter* child_iter, TreeIter* sorted_iter) {
      gtk_tree_model_sort_convert_iter_to_child_iter(&this, child_iter, sorted_iter);
   }

   // Converts @sorted_path to a path on the child model of @tree_model_sort.  
   // That is, @sorted_path points to a location in @tree_model_sort.  The 
   // returned path will point to the same location in the model not being 
   // sorted.  If @sorted_path does not point to a location in the child model, 
   // %NULL is returned.
   // RETURNS: A newly allocated #GtkTreePath, or %NULL
   // <sorted_path>: A #GtkTreePath to convert
   TreePath* /*new*/ convert_path_to_child_path(TreePath* sorted_path) {
      return gtk_tree_model_sort_convert_path_to_child_path(&this, sorted_path);
   }

   // Returns the model the #GtkTreeModelSort is sorting.
   // RETURNS: the "child model" being sorted
   TreeModel* get_model() {
      return gtk_tree_model_sort_get_model(&this);
   }

   // <warning><para>
   // This function is slow. Only use it for debugging and/or testing purposes.
   // </para></warning>
   // Checks if the given iter is a valid iter for this #GtkTreeModelSort.
   // RETURNS: %TRUE if the iter is valid, %FALSE if the iter is invalid.
   // <iter>: A #GtkTreeIter.
   int iter_is_valid(TreeIter* iter) {
      return gtk_tree_model_sort_iter_is_valid(&this, iter);
   }

   // This resets the default sort function to be in the 'unsorted' state.  That
   // is, it is in the same order as the child model. It will re-sort the model
   // to be in the same order as the child model only if the #GtkTreeModelSort
   // is in 'unsorted' state.
   void reset_default_sort_func() {
      gtk_tree_model_sort_reset_default_sort_func(&this);
   }
}

struct TreeModelSortClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TreePath {

   // Creates a new #GtkTreePath.  This structure refers to a row.
   // RETURNS: A newly created #GtkTreePath.
   static TreePath* /*new*/ new_() {
      return gtk_tree_path_new();
   }

   // Creates a new #GtkTreePath.  The string representation of this path is "0"
   // RETURNS: A new #GtkTreePath.
   static TreePath* /*new*/ new_first() {
      return gtk_tree_path_new_first();
   }

   // Unintrospectable constructor: new_from_indices() / gtk_tree_path_new_from_indices()
   // Creates a new path with @first_index and @varargs as indices.
   // RETURNS: A newly created #GtkTreePath.
   // <first_index>: first integer
   alias gtk_tree_path_new_from_indices new_from_indices; // Variadic

   // Creates a new #GtkTreePath initialized to @path.  @path is expected to be a
   // colon separated list of numbers.  For example, the string "10:4:0" would
   // create a path of depth 3 pointing to the 11th child of the root node, the 5th
   // child of that 11th child, and the 1st child of that 5th child.  If an invalid
   // path string is passed in, %NULL is returned.
   // RETURNS: A newly-created #GtkTreePath, or %NULL
   // <path>: The string representation of a path.
   static TreePath* /*new*/ new_from_string(char* path) {
      return gtk_tree_path_new_from_string(path);
   }

   // Appends a new index to a path.  As a result, the depth of the path is
   // increased.
   // <index_>: The index.
   void append_index(int index_) {
      gtk_tree_path_append_index(&this, index_);
   }

   // Compares two paths.  If @a appears before @b in a tree, then -1 is returned.
   // If @b appears before @a, then 1 is returned.  If the two nodes are equal,
   // then 0 is returned.
   // RETURNS: The relative positions of @a and @b
   // <b>: A #GtkTreePath to compare with.
   int compare(TreePath* b) {
      return gtk_tree_path_compare(&this, b);
   }

   // Creates a new #GtkTreePath as a copy of @path.
   // RETURNS: A new #GtkTreePath.
   TreePath* /*new*/ copy() {
      return gtk_tree_path_copy(&this);
   }
   // Moves @path to point to the first child of the current path.
   void down() {
      gtk_tree_path_down(&this);
   }
   // Frees @path.
   void free() {
      gtk_tree_path_free(&this);
   }

   // Returns the current depth of @path.
   // RETURNS: The depth of @path
   int get_depth() {
      return gtk_tree_path_get_depth(&this);
   }

   // Returns the current indices of @path.  This is an array of integers, each
   // representing a node in a tree.  This value should not be freed.
   // RETURNS: The current indices, or %NULL.
   int* get_indices() {
      return gtk_tree_path_get_indices(&this);
   }

   // Returns the current indices of @path.
   // This is an array of integers, each representing a node in a tree.
   // It also returns the number of elements in the array.
   // The array should not be freed.
   // RETURNS: The current indices, or %NULL.
   // <depth>: Number of elements returned in the integer array
   int* get_indices_with_depth(/*out*/ int* depth) {
      return gtk_tree_path_get_indices_with_depth(&this, depth);
   }

   // Returns %TRUE if @descendant is a descendant of @path.
   // RETURNS: %TRUE if @descendant is contained inside @path
   // <descendant>: another #GtkTreePath
   int is_ancestor(TreePath* descendant) {
      return gtk_tree_path_is_ancestor(&this, descendant);
   }

   // Returns %TRUE if @path is a descendant of @ancestor.
   // RETURNS: %TRUE if @ancestor contains @path somewhere below it
   // <ancestor>: another #GtkTreePath
   int is_descendant(TreePath* ancestor) {
      return gtk_tree_path_is_descendant(&this, ancestor);
   }
   // Moves the @path to point to the next node at the current depth.
   void next() {
      gtk_tree_path_next(&this);
   }

   // Prepends a new index to a path.  As a result, the depth of the path is
   // increased.
   // <index_>: The index.
   void prepend_index(int index_) {
      gtk_tree_path_prepend_index(&this, index_);
   }

   // Moves the @path to point to the previous node at the current depth, 
   // if it exists.
   // RETURNS: %TRUE if @path has a previous node, and the move was made.
   int prev() {
      return gtk_tree_path_prev(&this);
   }

   // Generates a string representation of the path.  This string is a ':'
   // separated list of numbers.  For example, "4:10:0:3" would be an acceptable return value for this string.
   // RETURNS: A newly-allocated string.  Must be freed with g_free().
   char* /*new*/ to_string() {
      return gtk_tree_path_to_string(&this);
   }

   // Moves the @path to point to its parent node, if it has a parent.
   // RETURNS: %TRUE if @path has a parent, and the move was made.
   int up() {
      return gtk_tree_path_up(&this);
   }
}

struct TreeRowReference {

   // Creates a row reference based on @path.  This reference will keep pointing 
   // to the node pointed to by @path, so long as it exists.  It listens to all
   // signals emitted by @model, and updates its path appropriately.  If @path
   // isn't a valid path in @model, then %NULL is returned.
   // RETURNS: A newly allocated #GtkTreeRowReference, or %NULL
   // <model>: A #GtkTreeModel
   // <path>: A valid #GtkTreePath to monitor
   static TreeRowReference* /*new*/ new_(TreeModel* model, TreePath* path) {
      return gtk_tree_row_reference_new(model, path);
   }

   // You do not need to use this function.  Creates a row reference based on
   // so long as it exists.  If @path isn't a valid path in @model, then %NULL is
   // returned.  However, unlike references created with
   // gtk_tree_row_reference_new(), it does not listen to the model for changes.
   // The creator of the row reference must do this explicitly using
   // gtk_tree_row_reference_inserted(), gtk_tree_row_reference_deleted(),
   // gtk_tree_row_reference_reordered().
   // These functions must be called exactly once per proxy when the
   // corresponding signal on the model is emitted. This single call
   // updates all row references for that proxy. Since built-in GTK+
   // objects like #GtkTreeView already use this mechanism internally,
   // using them as the proxy object will produce unpredictable results.
   // Further more, passing the same object as @model and @proxy
   // doesn't work for reasons of internal implementation.
   // This type of row reference is primarily meant by structures that need to
   // carefully monitor exactly when a row reference updates itself, and is not
   // generally needed by most applications.
   // RETURNS: A newly allocated #GtkTreeRowReference, or %NULL
   // <proxy>: A proxy #GObject
   // <model>: A #GtkTreeModel
   // <path>: A valid #GtkTreePath to monitor
   static TreeRowReference* /*new*/ new_proxy(GObject2.Object* proxy, TreeModel* model, TreePath* path) {
      return gtk_tree_row_reference_new_proxy(proxy, model, path);
   }

   // Copies a #GtkTreeRowReference.
   // RETURNS: a copy of @reference.
   TreeRowReference* /*new*/ copy() {
      return gtk_tree_row_reference_copy(&this);
   }
   // Free's @reference. @reference may be %NULL.
   void free() {
      gtk_tree_row_reference_free(&this);
   }

   // Returns the model that the row reference is monitoring.
   // RETURNS: the model
   TreeModel* get_model() {
      return gtk_tree_row_reference_get_model(&this);
   }

   // Returns a path that the row reference currently points to, or %NULL if the
   // path pointed to is no longer valid.
   // RETURNS: A current path, or %NULL.
   TreePath* /*new*/ get_path() {
      return gtk_tree_row_reference_get_path(&this);
   }

   // Returns %TRUE if the @reference is non-%NULL and refers to a current valid
   // path.
   // RETURNS: %TRUE if @reference points to a valid path.
   int valid() {
      return gtk_tree_row_reference_valid(&this);
   }
}

struct TreeSelection /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private TreeView* tree_view;
   private SelectionMode type;
   private TreeSelectionFunc user_func;
   private void* user_data;
   private GLib2.DestroyNotify destroy;


   // Returns the number of rows that have been selected in @tree.
   // RETURNS: The number of rows selected.
   int count_selected_rows() {
      return gtk_tree_selection_count_selected_rows(&this);
   }

   // Gets the selection mode for @selection. See
   // gtk_tree_selection_set_mode().
   // RETURNS: the current selection mode
   SelectionMode get_mode() {
      return gtk_tree_selection_get_mode(&this);
   }

   // Unintrospectable method: get_select_function() / gtk_tree_selection_get_select_function()
   // Returns the current selection function.
   // RETURNS: The function.
   TreeSelectionFunc get_select_function() {
      return gtk_tree_selection_get_select_function(&this);
   }

   // Sets @iter to the currently selected node if @selection is set to
   // #GTK_SELECTION_SINGLE or #GTK_SELECTION_BROWSE.  @iter may be NULL if you
   // just want to test if @selection has any selected nodes.  @model is filled
   // with the current model as a convenience.  This function will not work if you
   // use @selection is #GTK_SELECTION_MULTIPLE.
   // RETURNS: TRUE, if there is a selected node.
   // <model>: A pointer to set to the #GtkTreeModel, or NULL.
   // <iter>: The #GtkTreeIter, or NULL.
   int get_selected(/*out*/ TreeModel** model=null, /*out*/ TreeIter* iter=null) {
      return gtk_tree_selection_get_selected(&this, model, iter);
   }

   // Creates a list of path of all selected rows. Additionally, if you are
   // planning on modifying the model after calling this function, you may
   // want to convert the returned list into a list of #GtkTreeRowReference<!-- -->s.
   // To do this, you can use gtk_tree_row_reference_new().
   // To free the return value, use:
   // |[
   // g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
   // g_list_free (list);
   // ]|
   // RETURNS: A #GList containing a #GtkTreePath for each selected row.
   // <model>: A pointer to set to the #GtkTreeModel, or %NULL.
   GLib2.List* /*new*/ get_selected_rows(/*out*/ TreeModel** model=null) {
      return gtk_tree_selection_get_selected_rows(&this, model);
   }

   // Returns the tree view associated with @selection.
   // RETURNS: A #GtkTreeView
   TreeView* get_tree_view() {
      return gtk_tree_selection_get_tree_view(&this);
   }

   // Unintrospectable method: get_user_data() / gtk_tree_selection_get_user_data()
   // Returns the user data for the selection function.
   // RETURNS: The user data.
   void* get_user_data() {
      return gtk_tree_selection_get_user_data(&this);
   }

   // Returns %TRUE if the row at @iter is currently selected.
   // RETURNS: %TRUE, if @iter is selected
   // <iter>: A valid #GtkTreeIter
   int iter_is_selected(TreeIter* iter) {
      return gtk_tree_selection_iter_is_selected(&this, iter);
   }

   // Returns %TRUE if the row pointed to by @path is currently selected.  If @path
   // does not point to a valid location, %FALSE is returned
   // RETURNS: %TRUE if @path is selected.
   // <path>: A #GtkTreePath to check selection on.
   int path_is_selected(TreePath* path) {
      return gtk_tree_selection_path_is_selected(&this, path);
   }

   // Selects all the nodes. @selection must be set to #GTK_SELECTION_MULTIPLE
   // mode.
   void select_all() {
      gtk_tree_selection_select_all(&this);
   }

   // Selects the specified iterator.
   // <iter>: The #GtkTreeIter to be selected.
   void select_iter(TreeIter* iter) {
      gtk_tree_selection_select_iter(&this, iter);
   }

   // Select the row at @path.
   // <path>: The #GtkTreePath to be selected.
   void select_path(TreePath* path) {
      gtk_tree_selection_select_path(&this, path);
   }

   // Selects a range of nodes, determined by @start_path and @end_path inclusive.
   // <start_path>: The initial node of the range.
   // <end_path>: The final node of the range.
   void select_range(TreePath* start_path, TreePath* end_path) {
      gtk_tree_selection_select_range(&this, start_path, end_path);
   }

   // Calls a function for each selected node. Note that you cannot modify
   // the tree or selection from within this function. As a result,
   // gtk_tree_selection_get_selected_rows() might be more useful.
   // <func>: The function to call for each selected node.
   // <data>: user data to pass to the function.
   void selected_foreach(TreeSelectionForeachFunc func, void* data) {
      gtk_tree_selection_selected_foreach(&this, func, data);
   }

   // Sets the selection mode of the @selection.  If the previous type was
   // #GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
   // previously selected.
   // <type>: The selection mode
   void set_mode(SelectionMode type) {
      gtk_tree_selection_set_mode(&this, type);
   }

   // Sets the selection function.  If set, this function is called before any node
   // is selected or unselected, giving some control over which nodes are selected.
   // The select function should return %TRUE if the state of the node may be toggled,
   // and %FALSE if the state of the node should be left unchanged.
   // <func>: The selection function.
   // <data>: The selection function's data.
   // <destroy>: The destroy function for user data.  May be NULL.
   void set_select_function(TreeSelectionFunc func, void* data, GLib2.DestroyNotify destroy) {
      gtk_tree_selection_set_select_function(&this, func, data, destroy);
   }
   // Unselects all the nodes.
   void unselect_all() {
      gtk_tree_selection_unselect_all(&this);
   }

   // Unselects the specified iterator.
   // <iter>: The #GtkTreeIter to be unselected.
   void unselect_iter(TreeIter* iter) {
      gtk_tree_selection_unselect_iter(&this, iter);
   }

   // Unselects the row at @path.
   // <path>: The #GtkTreePath to be unselected.
   void unselect_path(TreePath* path) {
      gtk_tree_selection_unselect_path(&this, path);
   }

   // Unselects a range of nodes, determined by @start_path and @end_path
   // inclusive.
   // <start_path>: The initial node of the range.
   // <end_path>: The initial node of the range.
   void unselect_range(TreePath* start_path, TreePath* end_path) {
      gtk_tree_selection_unselect_range(&this, start_path, end_path);
   }
   extern (C) alias static void function (TreeSelection* 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);
   }
}

struct TreeSelectionClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (TreeSelection* selection) changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias void function (TreeModel* model, TreePath* path, TreeIter* iter, void* data) TreeSelectionForeachFunc;

extern (C) alias int function (TreeSelection* selection, TreeModel* model, TreePath* path, int path_currently_selected, void* data) TreeSelectionFunc;

struct TreeSortable {

   // Fills in @sort_column_id and @order with the current sort column and the
   // order. It returns %TRUE unless the @sort_column_id is 
   // %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or 
   // %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
   // column ids.
   // RETURNS: %TRUE if the sort column is not one of the special sort
   // <sort_column_id>: The sort column id to be filled in
   // <order>: The #GtkSortType to be filled in
   int get_sort_column_id(int* sort_column_id, SortType* order) {
      return gtk_tree_sortable_get_sort_column_id(&this, sort_column_id, order);
   }

   // Returns %TRUE if the model has a default sort function. This is used
   // primarily by GtkTreeViewColumns in order to determine if a model can 
   // go back to the default state, or not.
   // RETURNS: %TRUE, if the model has a default sort function
   int has_default_sort_func() {
      return gtk_tree_sortable_has_default_sort_func(&this);
   }

   // Sets the default comparison function used when sorting to be @sort_func.  
   // If the current sort column id of @sortable is
   // %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using 
   // this function.
   // If @sort_func is %NULL, then there will be no default comparison function.
   // This means that once the model  has been sorted, it can't go back to the
   // default state. In this case, when the current sort column id of @sortable 
   // is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
   // <sort_func>: The comparison function
   // <user_data>: User data to pass to @sort_func, or %NULL
   // <destroy>: Destroy notifier of @user_data, or %NULL
   void set_default_sort_func(TreeIterCompareFunc sort_func, void* user_data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_sortable_set_default_sort_func(&this, sort_func, user_data, destroy);
   }

   // Sets the current sort column to be @sort_column_id. The @sortable will
   // resort itself to reflect this change, after emitting a
   // #GtkTreeSortable::sort-column-changed signal. @sort_column_id may either be
   // a regular column id, or one of the following special values:
   // <variablelist>
   // <varlistentry>
   // <term>%GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</term>
   // <listitem>the default sort function will be used, if it is set</listitem>
   // </varlistentry>
   // <varlistentry>
   // <term>%GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</term>
   // <listitem>no sorting will occur</listitem>
   // </varlistentry>
   // </variablelist>
   // <sort_column_id>: the sort column id to set
   // <order>: The sort order of the column
   void set_sort_column_id(int sort_column_id, SortType order) {
      gtk_tree_sortable_set_sort_column_id(&this, sort_column_id, order);
   }

   // Sets the comparison function used when sorting to be @sort_func. If the
   // current sort column id of @sortable is the same as @sort_column_id, then 
   // the model will sort using this function.
   // <sort_column_id>: the sort column id to set the function for
   // <sort_func>: The comparison function
   // <user_data>: User data to pass to @sort_func, or %NULL
   // <destroy>: Destroy notifier of @user_data, or %NULL
   void set_sort_func(int sort_column_id, TreeIterCompareFunc sort_func, void* user_data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_sortable_set_sort_func(&this, sort_column_id, sort_func, user_data, destroy);
   }
   // Emits a #GtkTreeSortable::sort-column-changed signal on @sortable.
   void sort_column_changed() {
      gtk_tree_sortable_sort_column_changed(&this);
   }

   // The ::sort-column-changed signal is emitted when the sort column
   // or sort order of @sortable is changed. The signal is emitted before
   // the contents of @sortable are resorted.
   extern (C) alias static void function (TreeSortable* this_, void* user_data=null) signal_sort_column_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:"sort-column-changed", CB/*:signal_sort_column_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"sort-column-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TreeSortableIface {
   GObject2.TypeInterface g_iface;
   extern (C) void function (TreeSortable* sortable) sort_column_changed;

   // RETURNS: %TRUE if the sort column is not one of the special sort
   // <sort_column_id>: The sort column id to be filled in
   // <order>: The #GtkSortType to be filled in
   extern (C) int function (TreeSortable* sortable, int* sort_column_id, SortType* order) get_sort_column_id;

   // <sort_column_id>: the sort column id to set
   // <order>: The sort order of the column
   extern (C) void function (TreeSortable* sortable, int sort_column_id, SortType order) set_sort_column_id;

   // <sort_column_id>: the sort column id to set the function for
   // <destroy>: Destroy notifier of @user_data, or %NULL
   extern (C) void function (TreeSortable* sortable, int sort_column_id, TreeIterCompareFunc func, void* data, GLib2.DestroyNotify destroy=null) set_sort_func;
   // <destroy>: Destroy notifier of @user_data, or %NULL
   extern (C) void function (TreeSortable* sortable, TreeIterCompareFunc func, void* data, GLib2.DestroyNotify destroy=null) set_default_sort_func;
   // RETURNS: %TRUE, if the model has a default sort function
   extern (C) int function (TreeSortable* sortable) has_default_sort_func;
}

struct TreeStore /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   int stamp;
   void* root, last;
   int n_columns, sort_column_id;
   GLib2.List* sort_list;
   SortType order;
   Type* column_headers;
   TreeIterCompareFunc default_sort_func;
   void* default_sort_data;
   GLib2.DestroyNotify default_sort_destroy;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "columns_dirty", 1,
    uint, "__dummy32A", 31));


   // Unintrospectable constructor: new() / gtk_tree_store_new()
   // Creates a new tree store as with @n_columns columns each of the types passed
   // in.  Note that only types derived from standard GObject fundamental types 
   // are supported. 
   // As an example, <literal>gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
   // GDK_TYPE_PIXBUF);</literal> will create a new #GtkTreeStore with three columns, of type
   // <type>int</type>, <type>string</type> and #GdkPixbuf respectively.
   // RETURNS: a new #GtkTreeStore
   // <n_columns>: number of columns in the tree store
   alias gtk_tree_store_new new_; // Variadic

   // Non vararg creation function.  Used primarily by language bindings.
   // RETURNS: a new #GtkTreeStore
   // <n_columns>: number of columns in the tree store
   // <types>: an array of #GType types for the columns, from first to last
   static TreeStore* /*new*/ newv(int n_columns, Type* types) {
      return gtk_tree_store_newv(n_columns, types);
   }

   // Appends a new row to @tree_store.  If @parent is non-%NULL, then it will append the
   // new row after the last child of @parent, otherwise it will append a row to
   // the top level.  @iter will be changed to point to this new row.  The row will
   // be empty after this function is called.  To fill in values, you need to call
   // gtk_tree_store_set() or gtk_tree_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the appended row
   // <parent>: A valid #GtkTreeIter, or %NULL
   void append(/*out*/ TreeIter* iter, TreeIter* parent=null) {
      gtk_tree_store_append(&this, iter, parent);
   }
   // Removes all rows from @tree_store
   void clear() {
      gtk_tree_store_clear(&this);
   }

   // Creates a new row at @position.  If parent is non-%NULL, then the row will be
   // made a child of @parent.  Otherwise, the row will be created at the toplevel.
   // If @position is larger than the number of rows at that level, then the new
   // row will be inserted to the end of the list.  @iter will be changed to point
   // to this new row.  The row will be empty after this function is called.  To
   // fill in values, you need to call gtk_tree_store_set() or
   // gtk_tree_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <parent>: A valid #GtkTreeIter, or %NULL
   // <position>: position to insert the new row
   void insert(/*out*/ TreeIter* iter, TreeIter* parent, int position) {
      gtk_tree_store_insert(&this, iter, parent, position);
   }

   // Inserts a new row after @sibling.  If @sibling is %NULL, then the row will be
   // prepended to @parent 's children.  If @parent and @sibling are %NULL, then
   // the row will be prepended to the toplevel.  If both @sibling and @parent are
   // set, then @parent must be the parent of @sibling.  When @sibling is set,
   // this function is called.  To fill in values, you need to call
   // gtk_tree_store_set() or gtk_tree_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <parent>: A valid #GtkTreeIter, or %NULL
   // <sibling>: A valid #GtkTreeIter, or %NULL
   void insert_after(/*out*/ TreeIter* iter, TreeIter* parent=null, TreeIter* sibling=null) {
      gtk_tree_store_insert_after(&this, iter, parent, sibling);
   }

   // Inserts a new row before @sibling.  If @sibling is %NULL, then the row will
   // be appended to @parent 's children.  If @parent and @sibling are %NULL, then
   // the row will be appended to the toplevel.  If both @sibling and @parent are
   // set, then @parent must be the parent of @sibling.  When @sibling is set,
   // this function is called.  To fill in values, you need to call
   // gtk_tree_store_set() or gtk_tree_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the new row
   // <parent>: A valid #GtkTreeIter, or %NULL
   // <sibling>: A valid #GtkTreeIter, or %NULL
   void insert_before(/*out*/ TreeIter* iter, TreeIter* parent=null, TreeIter* sibling=null) {
      gtk_tree_store_insert_before(&this, iter, parent, sibling);
   }

   // Unintrospectable method: insert_with_values() / gtk_tree_store_insert_with_values()
   // Creates a new row at @position.  @iter will be changed to point to this
   // new row.  If @position is larger than the number of rows on the list, then
   // the new row will be appended to the list.  The row will be filled with
   // the values given to this function.
   // Calling
   // <literal>gtk_tree_store_insert_with_values (tree_store, iter, position, ...)</literal>
   // has the same effect as calling
   // |[
   // gtk_tree_store_insert (tree_store, iter, position);
   // gtk_tree_store_set (tree_store, iter, ...);
   // ]|
   // with the different that the former will only emit a row_inserted signal,
   // while the latter will emit row_inserted, row_changed and if the tree store
   // is sorted, rows_reordered.  Since emitting the rows_reordered signal
   // repeatedly can affect the performance of the program,
   // gtk_tree_store_insert_with_values() should generally be preferred when
   // inserting rows in a sorted tree store.
   // <iter>: An unset #GtkTreeIter to set the new row, or %NULL.
   // <parent>: A valid #GtkTreeIter, or %NULL
   // <position>: position to insert the new row
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_tree_store_insert_with_values insert_with_values; // Variadic
   +/

   // A variant of gtk_tree_store_insert_with_values() which takes
   // the columns and values as two arrays, instead of varargs.  This
   // function is mainly intended for language bindings.
   // <iter>: An unset #GtkTreeIter to set the new row, or %NULL.
   // <parent>: A valid #GtkTreeIter, or %NULL
   // <position>: position to insert the new row
   // <columns>: an array of column numbers
   // <values>: an array of GValues
   // <n_values>: the length of the @columns and @values arrays
   void insert_with_valuesv(/*out*/ TreeIter* iter, TreeIter* parent, int position, int* columns, GObject2.Value* values, int n_values) {
      gtk_tree_store_insert_with_valuesv(&this, iter, parent, position, columns, values, n_values);
   }

   // Returns %TRUE if @iter is an ancestor of @descendant.  That is, @iter is the
   // parent (or grandparent or great-grandparent) of @descendant.
   // RETURNS: %TRUE, if @iter is an ancestor of @descendant
   // <iter>: A valid #GtkTreeIter
   // <descendant>: A valid #GtkTreeIter
   int is_ancestor(TreeIter* iter, TreeIter* descendant) {
      return gtk_tree_store_is_ancestor(&this, iter, descendant);
   }

   // Returns the depth of @iter.  This will be 0 for anything on the root level, 1
   // for anything down a level, etc.
   // RETURNS: The depth of @iter
   // <iter>: A valid #GtkTreeIter
   int iter_depth(TreeIter* iter) {
      return gtk_tree_store_iter_depth(&this, iter);
   }

   // purposes.
   // Checks if the given iter is a valid iter for this #GtkTreeStore.
   // RETURNS: %TRUE if the iter is valid, %FALSE if the iter is invalid.
   // <iter>: A #GtkTreeIter.
   int iter_is_valid(TreeIter* iter) {
      return gtk_tree_store_iter_is_valid(&this, iter);
   }

   // Moves @iter in @tree_store to the position after @position. @iter and
   // works with unsorted stores. If @position is %NULL, @iter will be moved
   // to the start of the level.
   // <iter>: A #GtkTreeIter.
   // <position>: A #GtkTreeIter.
   void move_after(TreeIter* iter, TreeIter* position=null) {
      gtk_tree_store_move_after(&this, iter, position);
   }

   // Moves @iter in @tree_store to the position before @position. @iter and
   // works with unsorted stores. If @position is %NULL, @iter will be
   // moved to the end of the level.
   // <iter>: A #GtkTreeIter.
   // <position>: A #GtkTreeIter or %NULL.
   void move_before(TreeIter* iter, TreeIter* position=null) {
      gtk_tree_store_move_before(&this, iter, position);
   }

   // Prepends a new row to @tree_store.  If @parent is non-%NULL, then it will prepend
   // the new row before the first child of @parent, otherwise it will prepend a row
   // to the top level.  @iter will be changed to point to this new row.  The row
   // will be empty after this function is called.  To fill in values, you need to
   // call gtk_tree_store_set() or gtk_tree_store_set_value().
   // <iter>: An unset #GtkTreeIter to set to the prepended row
   // <parent>: A valid #GtkTreeIter, or %NULL
   void prepend(/*out*/ TreeIter* iter, TreeIter* parent=null) {
      gtk_tree_store_prepend(&this, iter, parent);
   }

   // Removes @iter from @tree_store.  After being removed, @iter is set to the
   // next valid row at that level, or invalidated if it previously pointed to the
   // last one.
   // RETURNS: %TRUE if @iter is still valid, %FALSE if not.
   // <iter>: A valid #GtkTreeIter
   int remove(TreeIter* iter) {
      return gtk_tree_store_remove(&this, iter);
   }

   // Reorders the children of @parent in @tree_store to follow the order
   // indicated by @new_order. Note that this function only works with
   // unsorted stores.
   // <parent>: A #GtkTreeIter.
   // <new_order>: an array of integers mapping the new position of each child to its old position before the re-ordering, i.e. @new_order<literal>[newpos] = oldpos</literal>.
   void reorder(TreeIter* parent, int* new_order) {
      gtk_tree_store_reorder(&this, parent, new_order);
   }

   // Unintrospectable method: set() / gtk_tree_store_set()
   // Sets the value of one or more cells in the row referenced by @iter.
   // The variable argument list should contain integer column numbers,
   // each column number followed by the value to be set. 
   // The list is terminated by a -1. For example, to set column 0 with type
   // %G_TYPE_STRING to "Foo", you would write 
   // <literal>gtk_tree_store_set (store, iter, 0, "Foo", -1)</literal>.
   // The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it
   // will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED.
   // <iter>: A valid #GtkTreeIter for the row being modified
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_tree_store_set set; // Variadic
   +/

   // This function is meant primarily for #GObjects that inherit from 
   // #GtkTreeStore, and should only be used when constructing a new 
   // #GtkTreeStore.  It will not function after a row has been added, 
   // or a method on the #GtkTreeModel interface is called.
   // <n_columns>: Number of columns for the tree store
   // <types>: An array of #GType types, one for each column
   void set_column_types(int n_columns, Type* types) {
      gtk_tree_store_set_column_types(&this, n_columns, types);
   }

   // Unintrospectable method: set_valist() / gtk_tree_store_set_valist()
   // See gtk_tree_store_set(); this version takes a <type>va_list</type> for
   // use by language bindings.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <var_args>: <type>va_list</type> of column/value pairs
   void set_valist(TreeIter* iter, va_list var_args) {
      gtk_tree_store_set_valist(&this, iter, var_args);
   }

   // Sets the data in the cell specified by @iter and @column.
   // The type of @value must be convertible to the type of the
   // column.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <column>: column number to modify
   // <value>: new value for the cell
   void set_value(TreeIter* iter, int column, GObject2.Value* value) {
      gtk_tree_store_set_value(&this, iter, column, value);
   }

   // A variant of gtk_tree_store_set_valist() which takes
   // the columns and values as two arrays, instead of varargs.  This
   // function is mainly intended for language bindings or in case
   // the number of columns to change is not known until run-time.
   // <iter>: A valid #GtkTreeIter for the row being modified
   // <columns>: an array of column numbers
   // <values>: an array of GValues
   // <n_values>: the length of the @columns and @values arrays
   void set_valuesv(TreeIter* iter, int* columns, GObject2.Value* values, int n_values) {
      gtk_tree_store_set_valuesv(&this, iter, columns, values, n_values);
   }

   // Swaps @a and @b in the same level of @tree_store. Note that this function
   // only works with unsorted stores.
   // <a>: A #GtkTreeIter.
   // <b>: Another #GtkTreeIter.
   void swap(TreeIter* a, TreeIter* b) {
      gtk_tree_store_swap(&this, a, b);
   }
}

struct TreeStoreClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TreeView /* : Container */ {
   alias parent this;
   alias parent super_;
   alias parent container;
   Container parent;
   TreeViewPrivate* priv;


   // Creates a new #GtkTreeView widget.
   // RETURNS: A newly created #GtkTreeView widget.
   static TreeView* new_() {
      return gtk_tree_view_new();
   }

   // Creates a new #GtkTreeView widget with the model initialized to @model.
   // RETURNS: A newly created #GtkTreeView widget.
   // <model>: the model.
   static TreeView* new_with_model(TreeModel* model) {
      return gtk_tree_view_new_with_model(model);
   }

   // Appends @column to the list of columns. If @tree_view has "fixed_height"
   // mode enabled, then @column must have its "sizing" property set to be
   // GTK_TREE_VIEW_COLUMN_FIXED.
   // RETURNS: The number of columns in @tree_view after appending.
   // <column>: The #GtkTreeViewColumn to add.
   int append_column(TreeViewColumn* column) {
      return gtk_tree_view_append_column(&this, column);
   }
   // Recursively collapses all visible, expanded nodes in @tree_view.
   void collapse_all() {
      gtk_tree_view_collapse_all(&this);
   }

   // Collapses a row (hides its child rows, if they exist).
   // RETURNS: %TRUE if the row was collapsed.
   // <path>: path to a row in the @tree_view
   int collapse_row(TreePath* path) {
      return gtk_tree_view_collapse_row(&this, path);
   }

   // Resizes all columns to their optimal width. Only works after the
   // treeview has been realized.
   void columns_autosize() {
      gtk_tree_view_columns_autosize(&this);
   }

   // Converts bin_window coordinates to coordinates for the
   // tree (the full scrollable area of the tree).
   // <bx>: X coordinate relative to bin_window
   // <by>: Y coordinate relative to bin_window
   // <tx>: return location for tree X coordinate
   // <ty>: return location for tree Y coordinate
   void convert_bin_window_to_tree_coords(int bx, int by, /*out*/ int* tx, /*out*/ int* ty) {
      gtk_tree_view_convert_bin_window_to_tree_coords(&this, bx, by, tx, ty);
   }

   // Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
   // to widget relative coordinates.
   // <bx>: bin_window X coordinate
   // <by>: bin_window Y coordinate
   // <wx>: return location for widget X coordinate
   // <wy>: return location for widget Y coordinate
   void convert_bin_window_to_widget_coords(int bx, int by, /*out*/ int* wx, /*out*/ int* wy) {
      gtk_tree_view_convert_bin_window_to_widget_coords(&this, bx, by, wx, wy);
   }

   // Converts tree coordinates (coordinates in full scrollable area of the tree)
   // to bin_window coordinates.
   // <tx>: tree X coordinate
   // <ty>: tree Y coordinate
   // <bx>: return location for X coordinate relative to bin_window
   // <by>: return location for Y coordinate relative to bin_window
   void convert_tree_to_bin_window_coords(int tx, int ty, /*out*/ int* bx, /*out*/ int* by) {
      gtk_tree_view_convert_tree_to_bin_window_coords(&this, tx, ty, bx, by);
   }

   // Converts tree coordinates (coordinates in full scrollable area of the tree)
   // to widget coordinates.
   // <tx>: X coordinate relative to the tree
   // <ty>: Y coordinate relative to the tree
   // <wx>: return location for widget X coordinate
   // <wy>: return location for widget Y coordinate
   void convert_tree_to_widget_coords(int tx, int ty, /*out*/ int* wx, /*out*/ int* wy) {
      gtk_tree_view_convert_tree_to_widget_coords(&this, tx, ty, wx, wy);
   }

   // Converts widget coordinates to coordinates for the bin_window
   // (see gtk_tree_view_get_bin_window()).
   // <wx>: X coordinate relative to the widget
   // <wy>: Y coordinate relative to the widget
   // <bx>: return location for bin_window X coordinate
   // <by>: return location for bin_window Y coordinate
   void convert_widget_to_bin_window_coords(int wx, int wy, /*out*/ int* bx, /*out*/ int* by) {
      gtk_tree_view_convert_widget_to_bin_window_coords(&this, wx, wy, bx, by);
   }

   // Converts widget coordinates to coordinates for the
   // tree (the full scrollable area of the tree).
   // <wx>: X coordinate relative to the widget
   // <wy>: Y coordinate relative to the widget
   // <tx>: return location for tree X coordinate
   // <ty>: return location for tree Y coordinate
   void convert_widget_to_tree_coords(int wx, int wy, /*out*/ int* tx, /*out*/ int* ty) {
      gtk_tree_view_convert_widget_to_tree_coords(&this, wx, wy, tx, ty);
   }

   // Creates a #GdkPixmap representation of the row at @path.
   // This image is used for a drag icon.
   // RETURNS: a newly-allocated pixmap of the drag icon.
   // <path>: a #GtkTreePath in @tree_view
   Gdk2.Pixmap* create_row_drag_icon(TreePath* path) {
      return gtk_tree_view_create_row_drag_icon(&this, path);
   }

   // Turns @tree_view into a drop destination for automatic DND. Calling
   // this method sets #GtkTreeView:reorderable to %FALSE.
   // <targets>: the table of targets that the drag will support
   // <n_targets>: the number of items in @targets
   // <actions>: the bitmask of possible actions for a drag from this widget
   void enable_model_drag_dest(TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
      gtk_tree_view_enable_model_drag_dest(&this, targets, n_targets, actions);
   }

   // Turns @tree_view into a drag source for automatic DND. Calling this
   // method sets #GtkTreeView:reorderable to %FALSE.
   // <start_button_mask>: Mask of allowed buttons to start drag
   // <targets>: the table of targets that the drag will support
   // <n_targets>: the number of items in @targets
   // <actions>: the bitmask of possible actions for a drag from this widget
   void enable_model_drag_source(Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
      gtk_tree_view_enable_model_drag_source(&this, start_button_mask, targets, n_targets, actions);
   }
   // Recursively expands all nodes in the @tree_view.
   void expand_all() {
      gtk_tree_view_expand_all(&this);
   }

   // Opens the row so its children are visible.
   // RETURNS: %TRUE if the row existed and had children
   // <path>: path to a row
   // <open_all>: whether to recursively expand, or just expand immediate children
   int expand_row(TreePath* path, int open_all) {
      return gtk_tree_view_expand_row(&this, path, open_all);
   }

   // Expands the row at @path. This will also expand all parent rows of
   // <path>: path to a row.
   void expand_to_path(TreePath* path) {
      gtk_tree_view_expand_to_path(&this, path);
   }

   // Fills the bounding rectangle in bin_window coordinates for the cell at the
   // row specified by @path and the column specified by @column.  If @path is
   // %NULL, or points to a node not found in the tree, the @y and @height fields of
   // the rectangle will be filled with 0. If @column is %NULL, the @x and @width
   // fields will be filled with 0.  The returned rectangle is equivalent to the
   // areas tile to cover the entire bin window.  Contrast with the @cell_area,
   // returned by gtk_tree_view_get_cell_area(), which returns only the cell
   // itself, excluding surrounding borders and the tree expander area.
   // <path>: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
   // <column>: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
   // <rect>: rectangle to fill with cell background rect
   void get_background_area(TreePath* path, TreeViewColumn* column, /*out*/ Gdk2.Rectangle* rect) {
      gtk_tree_view_get_background_area(&this, path, column, rect);
   }

   // Returns the window that @tree_view renders to.
   // This is used primarily to compare to <literal>event->window</literal>
   // to confirm that the event on @tree_view is on the right window.
   // hasn't been realized yet
   // RETURNS: A #GdkWindow, or %NULL when @tree_view
   Gdk2.Window* get_bin_window() {
      return gtk_tree_view_get_bin_window(&this);
   }

   // Fills the bounding rectangle in bin_window coordinates for the cell at the
   // row specified by @path and the column specified by @column.  If @path is
   // %NULL, or points to a path not currently displayed, the @y and @height fields
   // of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
   // fields will be filled with 0.  The sum of all cell rects does not cover the
   // entire tree; there are extra pixels in between rows, for example. The
   // returned rectangle is equivalent to the @cell_area passed to
   // gtk_cell_renderer_render().  This function is only valid if @tree_view is
   // realized.
   // <path>: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
   // <column>: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
   // <rect>: rectangle to fill with cell rect
   void get_cell_area(TreePath* path, TreeViewColumn* column, /*out*/ Gdk2.Rectangle* rect) {
      gtk_tree_view_get_cell_area(&this, path, column, rect);
   }

   // Gets the #GtkTreeViewColumn at the given position in the #tree_view.
   // position is outside the range of columns.
   // RETURNS: The #GtkTreeViewColumn, or %NULL if the
   // <n>: The position of the column, counting from 0.
   TreeViewColumn* get_column(int n) {
      return gtk_tree_view_get_column(&this, n);
   }

   // Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
   // The returned list must be freed with g_list_free ().
   // RETURNS: A list of #GtkTreeViewColumn s
   GLib2.List* /*new container*/ get_columns() {
      return gtk_tree_view_get_columns(&this);
   }

   // Fills in @path and @focus_column with the current path and focus column.  If
   // the cursor isn't currently set, then *@path will be %NULL.  If no column
   // currently has focus, then *@focus_column will be %NULL.
   // The returned #GtkTreePath must be freed with gtk_tree_path_free() when
   // you are done with it.
   // <path>: A pointer to be filled with the current cursor path, or %NULL
   // <focus_column>: A pointer to be filled with the current focus column, or %NULL
   void get_cursor(/*out*/ TreePath** path=null, /*out*/ TreeViewColumn** focus_column=null) {
      gtk_tree_view_get_cursor(&this, path, focus_column);
   }

   // Determines the destination row for a given position.  @drag_x and
   // meaningful if @tree_view is realized.  Therefore this function will always
   // return %FALSE if @tree_view is not realized or does not have a model.
   // is indeed the case.
   // RETURNS: whether there is a row at the given position, %TRUE if this
   // <drag_x>: the position to determine the destination row for
   // <drag_y>: the position to determine the destination row for
   // <path>: Return location for the path of the highlighted row, or %NULL.
   // <pos>: Return location for the drop position, or %NULL
   int get_dest_row_at_pos(int drag_x, int drag_y, /*out*/ TreePath** path=null, /*out*/ TreeViewDropPosition* pos=null) {
      return gtk_tree_view_get_dest_row_at_pos(&this, drag_x, drag_y, path, pos);
   }

   // Gets information about the row that is highlighted for feedback.
   // <path>: Return location for the path of the highlighted row, or %NULL.
   // <pos>: Return location for the drop position, or %NULL
   void get_drag_dest_row(/*out*/ TreePath** path=null, /*out*/ TreeViewDropPosition* pos=null) {
      gtk_tree_view_get_drag_dest_row(&this, path, pos);
   }

   // Returns whether or not the tree allows to start interactive searching 
   // by typing in text.
   // RETURNS: whether or not to let the user search interactively
   int get_enable_search() {
      return gtk_tree_view_get_enable_search(&this);
   }

   // Returns whether or not tree lines are drawn in @tree_view.
   // otherwise.
   // RETURNS: %TRUE if tree lines are drawn in @tree_view, %FALSE
   int get_enable_tree_lines() {
      return gtk_tree_view_get_enable_tree_lines(&this);
   }

   // Returns the column that is the current expander column.
   // This column has the expander arrow drawn next to it.
   // RETURNS: The expander column.
   TreeViewColumn* get_expander_column() {
      return gtk_tree_view_get_expander_column(&this);
   }

   // Returns whether fixed height mode is turned on for @tree_view.
   // RETURNS: %TRUE if @tree_view is in fixed height mode
   int get_fixed_height_mode() {
      return gtk_tree_view_get_fixed_height_mode(&this);
   }

   // Returns which grid lines are enabled in @tree_view.
   // are enabled.
   // RETURNS: a #GtkTreeViewGridLines value indicating which grid lines
   TreeViewGridLines get_grid_lines() {
      return gtk_tree_view_get_grid_lines(&this);
   }

   // Gets the #GtkAdjustment currently being used for the horizontal aspect.
   // if none is currently being used.
   // RETURNS: A #GtkAdjustment object, or %NULL
   Adjustment* get_hadjustment() {
      return gtk_tree_view_get_hadjustment(&this);
   }

   // Returns whether all header columns are clickable.
   // RETURNS: %TRUE if all header columns are clickable, otherwise %FALSE
   int get_headers_clickable() {
      return gtk_tree_view_get_headers_clickable(&this);
   }

   // Returns %TRUE if the headers on the @tree_view are visible.
   // RETURNS: Whether the headers are visible or not.
   int get_headers_visible() {
      return gtk_tree_view_get_headers_visible(&this);
   }

   // Returns whether hover expansion mode is turned on for @tree_view.
   // RETURNS: %TRUE if @tree_view is in hover expansion mode
   int get_hover_expand() {
      return gtk_tree_view_get_hover_expand(&this);
   }

   // Returns whether hover selection mode is turned on for @tree_view.
   // RETURNS: %TRUE if @tree_view is in hover selection mode
   int get_hover_selection() {
      return gtk_tree_view_get_hover_selection(&this);
   }

   // Returns the amount, in pixels, of extra indentation for child levels
   // in @tree_view.
   // RETURNS: the amount of extra indentation for child levels in
   int get_level_indentation() {
      return gtk_tree_view_get_level_indentation(&this);
   }

   // Returns the model the #GtkTreeView is based on.  Returns %NULL if the
   // model is unset.
   // RETURNS: A #GtkTreeModel, or %NULL if none is currently being used.
   TreeModel* get_model() {
      return gtk_tree_view_get_model(&this);
   }

   // Finds the path at the point (@x, @y), relative to bin_window coordinates
   // (please see gtk_tree_view_get_bin_window()).
   // That is, @x and @y are relative to an events coordinates. @x and @y must
   // come from an event on the @tree_view only where <literal>event->window ==
   // gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
   // things like popup menus. If @path is non-%NULL, then it will be filled
   // with the #GtkTreePath at that point.  This path should be freed with
   // gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
   // with the column at that point.  @cell_x and @cell_y return the coordinates
   // relative to the cell background (i.e. the @background_area passed to
   // gtk_cell_renderer_render()).  This function is only meaningful if
   // if @tree_view is not realized or does not have a model.
   // For converting widget coordinates (eg. the ones you get from
   // GtkWidget::query-tooltip), please see
   // gtk_tree_view_convert_widget_to_bin_window_coords().
   // RETURNS: %TRUE if a row exists at that coordinate.
   // <x>: The x position to be identified (relative to bin_window).
   // <y>: The y position to be identified (relative to bin_window).
   // <path>: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
   // <column>: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
   // <cell_x>: A pointer where the X coordinate relative to the cell can be placed, or %NULL
   // <cell_y>: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
   int get_path_at_pos(int x, int y, /*out*/ TreePath** path=null, /*out*/ TreeViewColumn** column=null, /*out*/ int* cell_x=null, /*out*/ int* cell_y=null) {
      return gtk_tree_view_get_path_at_pos(&this, x, y, path, column, cell_x, cell_y);
   }

   // Retrieves whether the user can reorder the tree via drag-and-drop. See
   // gtk_tree_view_set_reorderable().
   // RETURNS: %TRUE if the tree can be reordered.
   int get_reorderable() {
      return gtk_tree_view_get_reorderable(&this);
   }

   // Unintrospectable method: get_row_separator_func() / gtk_tree_view_get_row_separator_func()
   // Returns the current row separator function.
   // RETURNS: the current row separator function.
   TreeViewRowSeparatorFunc get_row_separator_func() {
      return gtk_tree_view_get_row_separator_func(&this);
   }

   // Returns whether rubber banding is turned on for @tree_view.  If the
   // selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
   // user to select multiple rows by dragging the mouse.
   // RETURNS: %TRUE if rubber banding in @tree_view is enabled.
   int get_rubber_banding() {
      return gtk_tree_view_get_rubber_banding(&this);
   }

   // Gets the setting set by gtk_tree_view_set_rules_hint().
   // RETURNS: %TRUE if rules are useful for the user of this tree
   int get_rules_hint() {
      return gtk_tree_view_get_rules_hint(&this);
   }

   // Gets the column searched on by the interactive search code.
   // RETURNS: the column the interactive search code searches in.
   int get_search_column() {
      return gtk_tree_view_get_search_column(&this);
   }

   // Returns the #GtkEntry which is currently in use as interactive search
   // entry for @tree_view.  In case the built-in entry is being used, %NULL
   // will be returned.
   // RETURNS: the entry currently in use as search entry.
   Entry* get_search_entry() {
      return gtk_tree_view_get_search_entry(&this);
   }

   // Unintrospectable method: get_search_equal_func() / gtk_tree_view_get_search_equal_func()
   // Returns the compare function currently in use.
   // RETURNS: the currently used compare function for the search code.
   TreeViewSearchEqualFunc get_search_equal_func() {
      return gtk_tree_view_get_search_equal_func(&this);
   }

   // Unintrospectable method: get_search_position_func() / gtk_tree_view_get_search_position_func()
   // Returns the positioning function currently in use.
   // RETURNS: the currently used function for positioning the search dialog.
   TreeViewSearchPositionFunc get_search_position_func() {
      return gtk_tree_view_get_search_position_func(&this);
   }

   // Gets the #GtkTreeSelection associated with @tree_view.
   // RETURNS: A #GtkTreeSelection object.
   TreeSelection* get_selection() {
      return gtk_tree_view_get_selection(&this);
   }

   // Returns whether or not expanders are drawn in @tree_view.
   // otherwise.
   // RETURNS: %TRUE if expanders are drawn in @tree_view, %FALSE
   int get_show_expanders() {
      return gtk_tree_view_get_show_expanders(&this);
   }

   // Returns the column of @tree_view's model which is being used for
   // displaying tooltips on @tree_view's rows.
   // used, or -1 if this is disabled.
   // RETURNS: the index of the tooltip column that is currently being
   int get_tooltip_column() {
      return gtk_tree_view_get_tooltip_column(&this);
   }

   // This function is supposed to be used in a #GtkWidget::query-tooltip
   // signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
   // which are received in the signal handler, should be passed to this
   // function without modification.
   // The return value indicates whether there is a tree view row at the given
   // coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
   // tooltips the row returned will be the cursor row.  When %TRUE, then any of
   // that row and the corresponding model.  @x and @y will always be converted
   // to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
   // RETURNS: whether or not the given tooltip context points to a row.
   // <x>: the x coordinate (relative to widget coordinates)
   // <y>: the y coordinate (relative to widget coordinates)
   // <keyboard_tip>: whether this is a keyboard tooltip or not
   // <model>: a pointer to receive a #GtkTreeModel or %NULL
   // <path>: a pointer to receive a #GtkTreePath or %NULL
   // <iter>: a pointer to receive a #GtkTreeIter or %NULL
   int get_tooltip_context(/*inout*/ int* x, /*inout*/ int* y, int keyboard_tip, /*out*/ TreeModel** model=null, /*out*/ TreePath** path=null, /*out*/ TreeIter* iter=null) {
      return gtk_tree_view_get_tooltip_context(&this, x, y, keyboard_tip, model, path, iter);
   }

   // Gets the #GtkAdjustment currently being used for the vertical aspect.
   // if none is currently being used.
   // RETURNS: A #GtkAdjustment object, or %NULL
   Adjustment* get_vadjustment() {
      return gtk_tree_view_get_vadjustment(&this);
   }

   // Sets @start_path and @end_path to be the first and last visible path.
   // Note that there may be invisible paths in between.
   // The paths should be freed with gtk_tree_path_free() after use.
   // RETURNS: %TRUE, if valid paths were placed in @start_path and @end_path.
   // <start_path>: Return location for start of region, or %NULL.
   // <end_path>: Return location for end of region, or %NULL.
   int get_visible_range(/*out*/ TreePath** start_path=null, /*out*/ TreePath** end_path=null) {
      return gtk_tree_view_get_visible_range(&this, start_path, end_path);
   }

   // Fills @visible_rect with the currently-visible region of the
   // buffer, in tree coordinates. Convert to bin_window coordinates with
   // gtk_tree_view_convert_tree_to_bin_window_coords().
   // Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
   // scrollable area of the tree.
   // <visible_rect>: rectangle to fill
   void get_visible_rect(/*out*/ Gdk2.Rectangle* visible_rect) {
      gtk_tree_view_get_visible_rect(&this, visible_rect);
   }

   // This inserts the @column into the @tree_view at @position.  If @position is
   // -1, then the column is inserted at the end. If @tree_view has
   // "fixed_height" mode enabled, then @column must have its "sizing" property
   // set to be GTK_TREE_VIEW_COLUMN_FIXED.
   // RETURNS: The number of columns in @tree_view after insertion.
   // <column>: The #GtkTreeViewColumn to be inserted.
   // <position>: The position to insert @column in.
   int insert_column(TreeViewColumn* column, int position) {
      return gtk_tree_view_insert_column(&this, column, position);
   }

   // Unintrospectable method: insert_column_with_attributes() / gtk_tree_view_insert_column_with_attributes()
   // Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
   // the end.  The column is initialized with the attributes given. If @tree_view
   // has "fixed_height" mode enabled, then the new column will have its sizing
   // property set to be GTK_TREE_VIEW_COLUMN_FIXED.
   // RETURNS: The number of columns in @tree_view after insertion.
   // <position>: The position to insert the new column in.
   // <title>: The title to set the header to.
   // <cell>: The #GtkCellRenderer.
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_tree_view_insert_column_with_attributes insert_column_with_attributes; // Variadic
   +/

   // Convenience function that inserts a new column into the #GtkTreeView
   // with the given cell renderer and a #GtkCellDataFunc to set cell renderer
   // attributes (normally using data from the model). See also
   // gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
   // If @tree_view has "fixed_height" mode enabled, then the new column will have its
   // "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
   // RETURNS: number of columns in the tree view post-insert
   // <position>: Position to insert, -1 for append
   // <title>: column title
   // <cell>: cell renderer for column
   // <func>: function to set attributes of cell renderer
   // <data>: data for @func
   // <dnotify>: destroy notifier for @data
   int insert_column_with_data_func(int position, char* title, CellRenderer* cell, TreeCellDataFunc func, void* data, GLib2.DestroyNotify dnotify) {
      return gtk_tree_view_insert_column_with_data_func(&this, position, title, cell, func, data, dnotify);
   }

   // Returns whether a rubber banding operation is currently being done
   // in @tree_view.
   // done in @tree_view.
   // RETURNS: %TRUE if a rubber banding operation is currently being
   int is_rubber_banding_active() {
      return gtk_tree_view_is_rubber_banding_active(&this);
   }

   // Calls @func on all expanded rows.
   // <func>: A function to be called
   // <data>: User data to be passed to the function.
   void map_expanded_rows(TreeViewMappingFunc func, void* data) {
      gtk_tree_view_map_expanded_rows(&this, func, data);
   }

   // Moves @column to be after to @base_column.  If @base_column is %NULL, then
   // <column>: The #GtkTreeViewColumn to be moved.
   // <base_column>: The #GtkTreeViewColumn to be moved relative to, or %NULL.
   void move_column_after(TreeViewColumn* column, TreeViewColumn* base_column=null) {
      gtk_tree_view_move_column_after(&this, column, base_column);
   }

   // Removes @column from @tree_view.
   // RETURNS: The number of columns in @tree_view after removing.
   // <column>: The #GtkTreeViewColumn to remove.
   int remove_column(TreeViewColumn* column) {
      return gtk_tree_view_remove_column(&this, column);
   }

   // Activates the cell determined by @path and @column.
   // <path>: The #GtkTreePath to be activated.
   // <column>: The #GtkTreeViewColumn to be activated.
   void row_activated(TreePath* path, TreeViewColumn* column) {
      gtk_tree_view_row_activated(&this, path, column);
   }

   // Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
   // RETURNS: %TRUE if #path is expanded.
   // <path>: A #GtkTreePath to test expansion state.
   int row_expanded(TreePath* path) {
      return gtk_tree_view_row_expanded(&this, path);
   }

   // Moves the alignments of @tree_view to the position specified by @column and
   // if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
   // or @path need to be non-%NULL.  @row_align determines where the row is
   // placed, and @col_align determines where @column is placed.  Both are expected
   // to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
   // right/bottom alignment, 0.5 means center.
   // If @use_align is %FALSE, then the alignment arguments are ignored, and the
   // tree does the minimum amount of work to scroll the cell onto the screen.
   // This means that the cell will be scrolled to the edge closest to its current
   // position.  If the cell is currently visible on the screen, nothing is done.
   // This function only works if the model is set, and @path is a valid row on the
   // model.  If the model changes before the @tree_view is realized, the centered
   // path will be modified to reflect this change.
   // <path>: The path of the row to move to, or %NULL.
   // <column>: The #GtkTreeViewColumn to move horizontally to, or %NULL.
   // <use_align>: whether to use alignment arguments, or %FALSE.
   // <row_align>: The vertical alignment of the row specified by @path.
   // <col_align>: The horizontal alignment of the column specified by @column.
   void scroll_to_cell(TreePath* path, TreeViewColumn* column, int use_align, float row_align, float col_align) {
      gtk_tree_view_scroll_to_cell(&this, path, column, use_align, row_align, col_align);
   }

   // Scrolls the tree view such that the top-left corner of the visible
   // area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
   // in tree coordinates.  The @tree_view must be realized before
   // this function is called.  If it isn't, you probably want to be
   // using gtk_tree_view_scroll_to_cell().
   // If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
   // <tree_x>: X coordinate of new top-left pixel of visible area, or -1
   // <tree_y>: Y coordinate of new top-left pixel of visible area, or -1
   void scroll_to_point(int tree_x, int tree_y) {
      gtk_tree_view_scroll_to_point(&this, tree_x, tree_y);
   }

   // Sets a user function for determining where a column may be dropped when
   // dragged.  This function is called on every column pair in turn at the
   // beginning of a column drag to determine where a drop can take place.  The
   // dragged, the two #GtkTreeViewColumn s determining the drop spot, and
   // are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
   // dropped everywhere.
   // <func>: A function to determine which columns are reorderable, or %NULL.
   // <user_data>: User data to be passed to @func, or %NULL
   // <destroy>: Destroy notifier for @user_data, or %NULL
   void set_column_drag_function(TreeViewColumnDropFunc func=null, void* user_data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_view_set_column_drag_function(&this, func, user_data, destroy);
   }

   // Sets the current keyboard focus to be at @path, and selects it.  This is
   // useful when you want to focus the user's attention on a particular row.  If
   // it. Additionally, if @focus_column is specified, and @start_editing is 
   // %TRUE, then editing should be started in the specified cell.  
   // This function is often followed by @gtk_widget_grab_focus (@tree_view) 
   // in order to give keyboard focus to the widget.  Please note that editing 
   // can only happen when the widget is realized.
   // If @path is invalid for @model, the current cursor (if any) will be unset
   // and the function will return without failing.
   // <path>: A #GtkTreePath
   // <focus_column>: A #GtkTreeViewColumn, or %NULL
   // <start_editing>: %TRUE if the specified cell should start being edited.
   void set_cursor(TreePath* path, TreeViewColumn* focus_column, int start_editing) {
      gtk_tree_view_set_cursor(&this, path, focus_column, start_editing);
   }

   // Sets the current keyboard focus to be at @path, and selects it.  This is
   // useful when you want to focus the user's attention on a particular row.  If
   // it. If @focus_column and @focus_cell are not %NULL, and @focus_column
   // contains 2 or more editable or activatable cells, then focus is given to
   // the cell specified by @focus_cell. Additionally, if @focus_column is
   // specified, and @start_editing is %TRUE, then editing should be started in
   // the specified cell.  This function is often followed by
   // widget.  Please note that editing can only happen when the widget is
   // realized.
   // If @path is invalid for @model, the current cursor (if any) will be unset
   // and the function will return without failing.
   // <path>: A #GtkTreePath
   // <focus_column>: A #GtkTreeViewColumn, or %NULL
   // <focus_cell>: A #GtkCellRenderer, or %NULL
   // <start_editing>: %TRUE if the specified cell should start being edited.
   void set_cursor_on_cell(TreePath* path, TreeViewColumn* focus_column, CellRenderer* focus_cell, int start_editing) {
      gtk_tree_view_set_cursor_on_cell(&this, path, focus_column, focus_cell, start_editing);
   }

   // This function should almost never be used.  It is meant for private use by
   // ATK for determining the number of visible children that are removed when the
   // user collapses a row, or a row is deleted.
   // <func>: Function to be called when a view row is destroyed, or %NULL
   // <data>: User data to be passed to @func, or %NULL
   // <destroy>: Destroy notifier for @data, or %NULL
   void set_destroy_count_func(TreeDestroyCountFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_view_set_destroy_count_func(&this, func, data, destroy);
   }

   // Sets the row that is highlighted for feedback.
   // <path>: The path of the row to highlight, or %NULL.
   // <pos>: Specifies whether to drop before, after or into the row
   void set_drag_dest_row(TreePath* path, TreeViewDropPosition pos) {
      gtk_tree_view_set_drag_dest_row(&this, path, pos);
   }

   // If @enable_search is set, then the user can type in text to search through
   // the tree interactively (this is sometimes called "typeahead find").
   // Note that even if this is %FALSE, the user can still initiate a search 
   // using the "start-interactive-search" key binding.
   // <enable_search>: %TRUE, if the user can search interactively
   void set_enable_search(int enable_search) {
      gtk_tree_view_set_enable_search(&this, enable_search);
   }

   // Sets whether to draw lines interconnecting the expanders in @tree_view.
   // This does not have any visible effects for lists.
   // <enabled>: %TRUE to enable tree line drawing, %FALSE otherwise.
   void set_enable_tree_lines(int enabled) {
      gtk_tree_view_set_enable_tree_lines(&this, enabled);
   }

   // Sets the column to draw the expander arrow at. It must be in @tree_view.  
   // If @column is %NULL, then the expander arrow is always at the first 
   // visible column.
   // If you do not want expander arrow to appear in your tree, set the 
   // expander column to a hidden column.
   // <column>: %NULL, or the column to draw the expander arrow at.
   void set_expander_column(TreeViewColumn* column) {
      gtk_tree_view_set_expander_column(&this, column);
   }

   // Enables or disables the fixed height mode of @tree_view. 
   // Fixed height mode speeds up #GtkTreeView by assuming that all 
   // rows have the same height. 
   // Only enable this option if all rows are the same height and all
   // columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
   // <enable>: %TRUE to enable fixed height mode
   void set_fixed_height_mode(int enable) {
      gtk_tree_view_set_fixed_height_mode(&this, enable);
   }

   // Sets which grid lines to draw in @tree_view.
   // <grid_lines>: a #GtkTreeViewGridLines value indicating which grid lines to enable.
   void set_grid_lines(TreeViewGridLines grid_lines) {
      gtk_tree_view_set_grid_lines(&this, grid_lines);
   }

   // Sets the #GtkAdjustment for the current horizontal aspect.
   // <adjustment>: The #GtkAdjustment to set, or %NULL
   void set_hadjustment(Adjustment* adjustment=null) {
      gtk_tree_view_set_hadjustment(&this, adjustment);
   }

   // Allow the column title buttons to be clicked.
   // <setting>: %TRUE if the columns are clickable.
   void set_headers_clickable(int setting) {
      gtk_tree_view_set_headers_clickable(&this, setting);
   }

   // Sets the visibility state of the headers.
   // <headers_visible>: %TRUE if the headers are visible
   void set_headers_visible(int headers_visible) {
      gtk_tree_view_set_headers_visible(&this, headers_visible);
   }

   // Enables of disables the hover expansion mode of @tree_view.
   // Hover expansion makes rows expand or collapse if the pointer 
   // moves over them.
   // <expand>: %TRUE to enable hover selection mode
   void set_hover_expand(int expand) {
      gtk_tree_view_set_hover_expand(&this, expand);
   }

   // Enables of disables the hover selection mode of @tree_view.
   // Hover selection makes the selected row follow the pointer.
   // Currently, this works only for the selection modes 
   // %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
   // <hover>: %TRUE to enable hover selection mode
   void set_hover_selection(int hover) {
      gtk_tree_view_set_hover_selection(&this, hover);
   }

   // Sets the amount of extra indentation for child levels to use in @tree_view
   // in addition to the default indentation.  The value should be specified in
   // pixels, a value of 0 disables this feature and in this case only the default
   // indentation will be used.
   // This does not have any visible effects for lists.
   // <indentation>: the amount, in pixels, of extra indentation in @tree_view.
   void set_level_indentation(int indentation) {
      gtk_tree_view_set_level_indentation(&this, indentation);
   }

   // Sets the model for a #GtkTreeView.  If the @tree_view already has a model
   // set, it will remove it before setting the new model.  If @model is %NULL,
   // then it will unset the old model.
   // <model>: The model.
   void set_model(TreeModel* model=null) {
      gtk_tree_view_set_model(&this, model);
   }

   // This function is a convenience function to allow you to reorder
   // models that support the #GtkDragSourceIface and the
   // #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
   // these.  If @reorderable is %TRUE, then the user can reorder the
   // model by dragging and dropping rows. The developer can listen to
   // these changes by connecting to the model's row_inserted and
   // row_deleted signals. The reordering is implemented by setting up
   // the tree view as a drag source and destination. Therefore, drag and
   // drop can not be used in a reorderable view for any other purpose.
   // This function does not give you any degree of control over the order -- any
   // reordering is allowed.  If more control is needed, you should probably
   // handle drag and drop manually.
   // <reorderable>: %TRUE, if the tree can be reordered.
   void set_reorderable(int reorderable) {
      gtk_tree_view_set_reorderable(&this, reorderable);
   }

   // Sets the row separator function, which is used to determine
   // whether a row should be drawn as a separator. If the row separator
   // function is %NULL, no separators are drawn. This is the default value.
   // <func>: a #GtkTreeViewRowSeparatorFunc
   // <data>: user data to pass to @func, or %NULL
   // <destroy>: destroy notifier for @data, or %NULL
   void set_row_separator_func(TreeViewRowSeparatorFunc func, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_view_set_row_separator_func(&this, func, data, destroy);
   }

   // Enables or disables rubber banding in @tree_view.  If the selection mode
   // is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
   // multiple rows by dragging the mouse.
   // <enable>: %TRUE to enable rubber banding
   void set_rubber_banding(int enable) {
      gtk_tree_view_set_rubber_banding(&this, enable);
   }

   // This function tells GTK+ that the user interface for your
   // application requires users to read across tree rows and associate
   // cells with one another. By default, GTK+ will then render the tree
   // with alternating row colors. Do <emphasis>not</emphasis> use it
   // just because you prefer the appearance of the ruled tree; that's a
   // question for the theme. Some themes will draw tree rows in
   // alternating colors even when rules are turned off, and users who
   // prefer that appearance all the time can choose those themes. You
   // should call this function only as a <emphasis>semantic</emphasis>
   // hint to the theme engine that your tree makes alternating colors
   // useful from a functional standpoint (since it has lots of columns,
   // generally).
   // <setting>: %TRUE if the tree requires reading across rows
   void set_rules_hint(int setting) {
      gtk_tree_view_set_rules_hint(&this, setting);
   }

   // Sets @column as the column where the interactive search code should
   // search in for the current model. 
   // If the search column is set, users can use the "start-interactive-search"
   // key binding to bring up search popup. The enable-search property controls
   // whether simply typing text will also start an interactive search.
   // Note that @column refers to a column of the current model. The search 
   // column is reset to -1 when the model is changed.
   // <column>: the column of the model to search in, or -1 to disable searching
   void set_search_column(int column) {
      gtk_tree_view_set_search_column(&this, column);
   }

   // Sets the entry which the interactive search code will use for this
   // in our interface at all time at a fixed position.  Passing %NULL for
   // entry again.
   // <entry>: the entry the interactive search code of @tree_view should use or %NULL
   void set_search_entry(Entry* entry=null) {
      gtk_tree_view_set_search_entry(&this, entry);
   }

   // Sets the compare function for the interactive search capabilities; note
   // that somewhat like strcmp() returning 0 for equality
   // #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
   // <search_equal_func>: the compare function to use during the search
   // <search_user_data>: user data to pass to @search_equal_func, or %NULL
   // <search_destroy>: Destroy notifier for @search_user_data, or %NULL
   void set_search_equal_func(TreeViewSearchEqualFunc search_equal_func, void* search_user_data=null, GLib2.DestroyNotify search_destroy=null) {
      gtk_tree_view_set_search_equal_func(&this, search_equal_func, search_user_data, search_destroy);
   }

   // Sets the function to use when positioning the search dialog.
   // <func>: the function to use to position the search dialog, or %NULL to use the default search position function
   // <data>: user data to pass to @func, or %NULL
   // <destroy>: Destroy notifier for @data, or %NULL
   void set_search_position_func(TreeViewSearchPositionFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null) {
      gtk_tree_view_set_search_position_func(&this, func, data, destroy);
   }

   // Sets whether to draw and enable expanders and indent child rows in
   // and there will be no way to expand and collapse rows by default.  Also
   // note that hiding the expanders will disable the default indentation.  You
   // can set a custom indentation in this case using
   // gtk_tree_view_set_level_indentation().
   // This does not have any visible effects for lists.
   // <enabled>: %TRUE to enable expander drawing, %FALSE otherwise.
   void set_show_expanders(int enabled) {
      gtk_tree_view_set_show_expanders(&this, enabled);
   }

   // Sets the tip area of @tooltip to the area @path, @column and @cell have
   // in common.  For example if @path is %NULL and @column is set, the tip
   // area will be set to the full area covered by @column.  See also
   // gtk_tooltip_set_tip_area().
   // Note that if @path is not specified and @cell is set and part of a column
   // containing the expander, the tooltip might not show and hide at the correct
   // position.  In such cases @path must be set to the current node under the
   // mouse cursor for this function to operate correctly.
   // See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
   // <tooltip>: a #GtkTooltip
   // <path>: a #GtkTreePath or %NULL
   // <column>: a #GtkTreeViewColumn or %NULL
   // <cell>: a #GtkCellRenderer or %NULL
   void set_tooltip_cell(Tooltip* tooltip, TreePath* path=null, TreeViewColumn* column=null, CellRenderer* cell=null) {
      gtk_tree_view_set_tooltip_cell(&this, tooltip, path, column, cell);
   }

   // If you only plan to have simple (text-only) tooltips on full rows, you
   // can use this function to have #GtkTreeView handle these automatically
   // for you. @column should be set to the column in @tree_view's model
   // containing the tooltip texts, or -1 to disable this feature.
   // When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
   // Note that the signal handler sets the text with gtk_tooltip_set_markup(),
   // so &amp;, &lt;, etc have to be escaped in the text.
   // <column>: an integer, which is a valid column number for @tree_view's model
   void set_tooltip_column(int column) {
      gtk_tree_view_set_tooltip_column(&this, column);
   }

   // Sets the tip area of @tooltip to be the area covered by the row at @path.
   // See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
   // See also gtk_tooltip_set_tip_area().
   // <tooltip>: a #GtkTooltip
   // <path>: a #GtkTreePath
   void set_tooltip_row(Tooltip* tooltip, TreePath* path) {
      gtk_tree_view_set_tooltip_row(&this, tooltip, path);
   }

   // Sets the #GtkAdjustment for the current vertical aspect.
   // <adjustment>: The #GtkAdjustment to set, or %NULL
   void set_vadjustment(Adjustment* adjustment=null) {
      gtk_tree_view_set_vadjustment(&this, adjustment);
   }

   // Converts tree coordinates (coordinates in full scrollable area of the tree)
   // to bin_window coordinates.
   // incorrect.  For converting bin_window coordinates to coordinates relative
   // to bin_window, please see
   // gtk_tree_view_convert_bin_window_to_widget_coords().
   // <tx>: tree X coordinate
   // <ty>: tree Y coordinate
   // <wx>: return location for X coordinate relative to bin_window
   // <wy>: return location for Y coordinate relative to bin_window
   void tree_to_widget_coords(int tx, int ty, int* wx, int* wy) {
      gtk_tree_view_tree_to_widget_coords(&this, tx, ty, wx, wy);
   }

   // Undoes the effect of
   // gtk_tree_view_enable_model_drag_dest(). Calling this method sets
   // #GtkTreeView:reorderable to %FALSE.
   void unset_rows_drag_dest() {
      gtk_tree_view_unset_rows_drag_dest(&this);
   }

   // Undoes the effect of
   // gtk_tree_view_enable_model_drag_source(). Calling this method sets
   // #GtkTreeView:reorderable to %FALSE.
   void unset_rows_drag_source() {
      gtk_tree_view_unset_rows_drag_source(&this);
   }

   // Converts bin_window coordinates to coordinates for the
   // tree (the full scrollable area of the tree).
   // incorrect.  For converting coordinates relative to the widget to
   // bin_window coordinates, please see
   // gtk_tree_view_convert_widget_to_bin_window_coords().
   // <wx>: X coordinate relative to bin_window
   // <wy>: Y coordinate relative to bin_window
   // <tx>: return location for tree X coordinate
   // <ty>: return location for tree Y coordinate
   void widget_to_tree_coords(int wx, int wy, int* tx, int* ty) {
      gtk_tree_view_widget_to_tree_coords(&this, wx, wy, tx, ty);
   }
   // The number of columns of the treeview has changed.
   extern (C) alias static void function (TreeView* this_, void* user_data=null) signal_columns_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:"columns-changed", CB/*:signal_columns_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"columns-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   // The position of the cursor (focused cell) has changed.
   extern (C) alias static void function (TreeView* this_, void* user_data=null) signal_cursor_changed;
   ulong signal_connect(string name:"cursor-changed", CB/*:signal_cursor_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"cursor-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, c_int object, c_int p0, c_int p1, void* user_data=null) signal_expand_collapse_cursor_row;
   ulong signal_connect(string name:"expand-collapse-cursor-row", CB/*:signal_expand_collapse_cursor_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"expand-collapse-cursor-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, MovementStep* object, int p0, void* user_data=null) signal_move_cursor;
   ulong signal_connect(string name:"move-cursor", CB/*:signal_move_cursor*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-cursor",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The "row-activated" signal is emitted when the method
   // gtk_tree_view_row_activated() is called or the user double clicks 
   // a treeview row. It is also emitted when a non-editable row is 
   // Enter is pressed.
   // For selection handling refer to the <link linkend="TreeWidget">tree 
   // widget conceptual overview</link> as well as #GtkTreeSelection.
   // <path>: the #GtkTreePath for the activated row
   // <column>: the #GtkTreeViewColumn in which the activation occurred
   extern (C) alias static void function (TreeView* this_, TreePath* path, TreeViewColumn* column, void* user_data=null) signal_row_activated;
   ulong signal_connect(string name:"row-activated", CB/*:signal_row_activated*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-activated",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The given row has been collapsed (child nodes are hidden).
   // <iter>: the tree iter of the collapsed row
   // <path>: a tree path that points to the row
   extern (C) alias static void function (TreeView* this_, TreeIter* iter, TreePath* path, void* user_data=null) signal_row_collapsed;
   ulong signal_connect(string name:"row-collapsed", CB/*:signal_row_collapsed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-collapsed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The given row has been expanded (child nodes are shown).
   // <iter>: the tree iter of the expanded row
   // <path>: a tree path that points to the row
   extern (C) alias static void function (TreeView* this_, TreeIter* iter, TreePath* path, void* user_data=null) signal_row_expanded;
   ulong signal_connect(string name:"row-expanded", CB/*:signal_row_expanded*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"row-expanded",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, void* user_data=null) signal_select_all;
   ulong signal_connect(string name:"select-all", CB/*:signal_select_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, void* user_data=null) signal_select_cursor_parent;
   ulong signal_connect(string name:"select-cursor-parent", CB/*:signal_select_cursor_parent*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-cursor-parent",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, c_int object, void* user_data=null) signal_select_cursor_row;
   ulong signal_connect(string name:"select-cursor-row", CB/*:signal_select_cursor_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"select-cursor-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Set the scroll adjustments for the tree view. Usually scrolled containers
   // like #GtkScrolledWindow will emit this signal to connect two instances
   // of #GtkScrollbar to the scroll directions of the #GtkTreeView.
   extern (C) alias static void function (TreeView* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;
   ulong signal_connect(string name:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, void* user_data=null) signal_start_interactive_search;
   ulong signal_connect(string name:"start-interactive-search", CB/*:signal_start_interactive_search*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"start-interactive-search",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The given row is about to be collapsed (hide its children nodes). Use this
   // signal if you need to control the collapsibility of individual rows.
   // RETURNS: %FALSE to allow collapsing, %TRUE to reject
   // <iter>: the tree iter of the row to collapse
   // <path>: a tree path that points to the row
   extern (C) alias static c_int function (TreeView* this_, TreeIter* iter, TreePath* path, void* user_data=null) signal_test_collapse_row;
   ulong signal_connect(string name:"test-collapse-row", CB/*:signal_test_collapse_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"test-collapse-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The given row is about to be expanded (show its children nodes). Use this
   // signal if you need to control the expandability of individual rows.
   // RETURNS: %FALSE to allow expansion, %TRUE to reject
   // <iter>: the tree iter of the row to expand
   // <path>: a tree path that points to the row
   extern (C) alias static c_int function (TreeView* this_, TreeIter* iter, TreePath* path, void* user_data=null) signal_test_expand_row;
   ulong signal_connect(string name:"test-expand-row", CB/*:signal_test_expand_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"test-expand-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, void* user_data=null) signal_toggle_cursor_row;
   ulong signal_connect(string name:"toggle-cursor-row", CB/*:signal_toggle_cursor_row*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"toggle-cursor-row",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (TreeView* this_, void* user_data=null) signal_unselect_all;
   ulong signal_connect(string name:"unselect-all", CB/*:signal_unselect_all*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unselect-all",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct TreeViewClass {
   ContainerClass parent_class;
   extern (C) void function (TreeView* tree_view, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;

   // <path>: The #GtkTreePath to be activated.
   // <column>: The #GtkTreeViewColumn to be activated.
   extern (C) void function (TreeView* tree_view, TreePath* path, TreeViewColumn* column) row_activated;
   extern (C) int function (TreeView* tree_view, TreeIter* iter, TreePath* path) test_expand_row;
   extern (C) int function (TreeView* tree_view, TreeIter* iter, TreePath* path) test_collapse_row;
   extern (C) void function (TreeView* tree_view, TreeIter* iter, TreePath* path) row_expanded;
   extern (C) void function (TreeView* tree_view, TreeIter* iter, TreePath* path) row_collapsed;
   extern (C) void function (TreeView* tree_view) columns_changed;
   extern (C) void function (TreeView* tree_view) cursor_changed;
   extern (C) int function (TreeView* tree_view, MovementStep step, int count) move_cursor;
   extern (C) int function (TreeView* tree_view) select_all;
   extern (C) int function (TreeView* tree_view) unselect_all;
   extern (C) int function (TreeView* tree_view, int start_editing) select_cursor_row;
   extern (C) int function (TreeView* tree_view) toggle_cursor_row;
   extern (C) int function (TreeView* tree_view, int logical, int expand, int open_all) expand_collapse_cursor_row;
   extern (C) int function (TreeView* tree_view) select_cursor_parent;
   extern (C) int function (TreeView* tree_view) start_interactive_search;
   extern (C) void function () _gtk_reserved0;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct TreeViewColumn /* : Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   Object parent;
   Widget* tree_view, button, child, arrow, alignment;
   Gdk2.Window* window;
   CellEditable* editable_widget;
   float xalign;
   uint property_changed_signal;
   int spacing;
   TreeViewColumnSizing column_type;
   int requested_width, button_request, resized_width, width, fixed_width, min_width, max_width, drag_x, drag_y;
   char* title;
   GLib2.List* cell_list;
   uint sort_clicked_signal, sort_column_changed_signal;
   int sort_column_id;
   SortType sort_order;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "visible", 1,
   uint, "resizable", 1,
   uint, "clickable", 1,
   uint, "dirty", 1,
   uint, "show_sort_indicator", 1,
   uint, "maybe_reordered", 1,
   uint, "reorderable", 1,
   uint, "use_resized_width", 1,
   uint, "expand", 1,
    uint, "__dummy32A", 23));


   // Creates a new #GtkTreeViewColumn.
   // RETURNS: A newly created #GtkTreeViewColumn.
   static TreeViewColumn* new_() {
      return gtk_tree_view_column_new();
   }

   // Unintrospectable constructor: new_with_attributes() / gtk_tree_view_column_new_with_attributes()
   // Creates a new #GtkTreeViewColumn with a number of default values.  This is
   // equivalent to calling gtk_tree_view_column_set_title(),
   // gtk_tree_view_column_pack_start(), and
   // gtk_tree_view_column_set_attributes() on the newly created #GtkTreeViewColumn.
   // Here's a simple example:
   // |[
   // enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS };
   // ...
   // {
   // GtkTreeViewColumn *column;
   // GtkCellRenderer   *renderer = gtk_cell_renderer_text_new ();
   // column = gtk_tree_view_column_new_with_attributes ("Title",
   // renderer,
   // "text", TEXT_COLUMN,
   // "foreground", COLOR_COLUMN,
   // NULL);
   // }
   // ]|
   // RETURNS: A newly created #GtkTreeViewColumn.
   // <title>: The title to set the header to.
   // <cell>: The #GtkCellRenderer.
   alias gtk_tree_view_column_new_with_attributes new_with_attributes; // Variadic

   // Adds an attribute mapping to the list in @tree_column.  The @column is the
   // column of the model to get a value from, and the @attribute is the
   // parameter on @cell_renderer to be set from the value. So for example
   // if column 2 of the model contains strings, you could have the
   // "text" attribute of a #GtkCellRendererText get its values from
   // column 2.
   // <cell_renderer>: the #GtkCellRenderer to set attributes on
   // <attribute>: An attribute on the renderer
   // <column>: The column position on the model to get the attribute from.
   void add_attribute(CellRenderer* cell_renderer, char* attribute, int column) {
      gtk_tree_view_column_add_attribute(&this, cell_renderer, attribute, column);
   }

   // Obtains the horizontal position and size of a cell in a column. If the
   // cell is not found in the column, @start_pos and @width are not changed and
   // %FALSE is returned.
   // RETURNS: %TRUE if @cell belongs to @tree_column.
   // <cell_renderer>: a #GtkCellRenderer
   // <start_pos>: return location for the horizontal position of @cell within
   // <width>: return location for the width of @cell, may be %NULL
   int cell_get_position(CellRenderer* cell_renderer, int* start_pos, int* width) {
      return gtk_tree_view_column_cell_get_position(&this, cell_renderer, start_pos, width);
   }

   // Obtains the width and height needed to render the column.  This is used
   // primarily by the #GtkTreeView.
   // <cell_area>: The area a cell in the column will be allocated, or %NULL
   // <x_offset>: location to return x offset of a cell relative to @cell_area, or %NULL
   // <y_offset>: location to return y offset of a cell relative to @cell_area, or %NULL
   // <width>: location to return width needed to render a cell, or %NULL
   // <height>: location to return height needed to render a cell, or %NULL
   void cell_get_size(Gdk2.Rectangle* cell_area=null, /*out*/ int* x_offset=null, /*out*/ int* y_offset=null, /*out*/ int* width=null, /*out*/ int* height=null) {
      gtk_tree_view_column_cell_get_size(&this, cell_area, x_offset, y_offset, width, height);
   }

   // Returns %TRUE if any of the cells packed into the @tree_column are visible.
   // For this to be meaningful, you must first initialize the cells with
   // gtk_tree_view_column_cell_set_cell_data()
   // RETURNS: %TRUE, if any of the cells packed into the @tree_column are currently visible
   int cell_is_visible() {
      return gtk_tree_view_column_cell_is_visible(&this);
   }

   // Sets the cell renderer based on the @tree_model and @iter.  That is, for
   // every attribute mapping in @tree_column, it will get a value from the set
   // column on the @iter, and use that value to set the attribute on the cell
   // renderer.  This is used primarily by the #GtkTreeView.
   // <tree_model>: The #GtkTreeModel to to get the cell renderers attributes from.
   // <iter>: The #GtkTreeIter to to get the cell renderer's attributes from.
   // <is_expander>: %TRUE, if the row has children
   // <is_expanded>: %TRUE, if the row has visible children
   void cell_set_cell_data(TreeModel* tree_model, TreeIter* iter, int is_expander, int is_expanded) {
      gtk_tree_view_column_cell_set_cell_data(&this, tree_model, iter, is_expander, is_expanded);
   }
   // Unsets all the mappings on all renderers on the @tree_column.
   void clear() {
      gtk_tree_view_column_clear(&this);
   }

   // Clears all existing attributes previously set with
   // gtk_tree_view_column_set_attributes().
   // <cell_renderer>: a #GtkCellRenderer to clear the attribute mapping on.
   void clear_attributes(CellRenderer* cell_renderer) {
      gtk_tree_view_column_clear_attributes(&this, cell_renderer);
   }
   // Emits the "clicked" signal on the column.  This function will only work if
   void clicked() {
      gtk_tree_view_column_clicked(&this);
   }

   // Sets the current keyboard focus to be at @cell, if the column contains
   // 2 or more editable and activatable cells.
   // <cell>: A #GtkCellRenderer
   void focus_cell(CellRenderer* cell) {
      gtk_tree_view_column_focus_cell(&this, cell);
   }

   // Returns the current x alignment of @tree_column.  This value can range
   // between 0.0 and 1.0.
   // RETURNS: The current alignent of @tree_column.
   float get_alignment() {
      return gtk_tree_view_column_get_alignment(&this);
   }

   // Unintrospectable method: get_cell_renderers() / gtk_tree_view_column_get_cell_renderers()
   // Returns a newly-allocated #GList of all the cell renderers in the column,
   // in no particular order.  The list must be freed with g_list_free().
   // RETURNS: A list of #GtkCellRenderers
   GLib2.List* get_cell_renderers() {
      return gtk_tree_view_column_get_cell_renderers(&this);
   }

   // Returns %TRUE if the user can click on the header for the column.
   // RETURNS: %TRUE if user can click the column header.
   int get_clickable() {
      return gtk_tree_view_column_get_clickable(&this);
   }

   // Return %TRUE if the column expands to take any available space.
   // RETURNS: %TRUE, if the column expands
   int get_expand() {
      return gtk_tree_view_column_get_expand(&this);
   }

   // Gets the fixed width of the column.  This value is only meaning may not be
   // the actual width of the column on the screen, just what is requested.
   // RETURNS: the fixed width of the column
   int get_fixed_width() {
      return gtk_tree_view_column_get_fixed_width(&this);
   }

   // Returns the maximum width in pixels of the @tree_column, or -1 if no maximum
   // width is set.
   // RETURNS: The maximum width of the @tree_column.
   int get_max_width() {
      return gtk_tree_view_column_get_max_width(&this);
   }

   // Returns the minimum width in pixels of the @tree_column, or -1 if no minimum
   // width is set.
   // RETURNS: The minimum width of the @tree_column.
   int get_min_width() {
      return gtk_tree_view_column_get_min_width(&this);
   }

   // Returns %TRUE if the @tree_column can be reordered by the user.
   // RETURNS: %TRUE if the @tree_column can be reordered by the user.
   int get_reorderable() {
      return gtk_tree_view_column_get_reorderable(&this);
   }

   // Returns %TRUE if the @tree_column can be resized by the end user.
   // RETURNS: %TRUE, if the @tree_column can be resized.
   int get_resizable() {
      return gtk_tree_view_column_get_resizable(&this);
   }

   // Returns the current type of @tree_column.
   // RETURNS: The type of @tree_column.
   TreeViewColumnSizing get_sizing() {
      return gtk_tree_view_column_get_sizing(&this);
   }

   // Gets the logical @sort_column_id that the model sorts on when this
   // column is selected for sorting.
   // See gtk_tree_view_column_set_sort_column_id().
   // this column can't be used for sorting.
   // RETURNS: the current @sort_column_id for this column, or -1 if
   int get_sort_column_id() {
      return gtk_tree_view_column_get_sort_column_id(&this);
   }

   // Gets the value set by gtk_tree_view_column_set_sort_indicator().
   // RETURNS: whether the sort indicator arrow is displayed
   int get_sort_indicator() {
      return gtk_tree_view_column_get_sort_indicator(&this);
   }

   // Gets the value set by gtk_tree_view_column_set_sort_order().
   // RETURNS: the sort order the sort indicator is indicating
   SortType get_sort_order() {
      return gtk_tree_view_column_get_sort_order(&this);
   }

   // Returns the spacing of @tree_column.
   // RETURNS: the spacing of @tree_column.
   int get_spacing() {
      return gtk_tree_view_column_get_spacing(&this);
   }

   // Returns the title of the widget.
   // modified or freed.
   // RETURNS: the title of the column. This string should not be
   char* get_title() {
      return gtk_tree_view_column_get_title(&this);
   }

   // Returns the #GtkTreeView wherein @tree_column has been inserted.
   // If @column is currently not inserted in any tree view, %NULL is
   // returned.
   // been inserted if any, %NULL otherwise.
   // RETURNS: The tree view wherein @column has
   Widget* get_tree_view() {
      return gtk_tree_view_column_get_tree_view(&this);
   }

   // Returns %TRUE if @tree_column is visible.
   // the tree will show the column.
   // RETURNS: whether the column is visible or not.  If it is visible, then
   int get_visible() {
      return gtk_tree_view_column_get_visible(&this);
   }

   // Returns the #GtkWidget in the button on the column header.
   // If a custom widget has not been set then %NULL is returned.
   // header, or %NULL
   // RETURNS: The #GtkWidget in the column
   Widget* get_widget() {
      return gtk_tree_view_column_get_widget(&this);
   }

   // Returns the current size of @tree_column in pixels.
   // RETURNS: The current width of @tree_column.
   int get_width() {
      return gtk_tree_view_column_get_width(&this);
   }

   // Adds the @cell to end of the column. If @expand is %FALSE, then the @cell
   // is allocated no more space than it needs. Any unused space is divided
   // evenly between cells for which @expand is %TRUE.
   // <cell>: The #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @tree_column.
   void pack_end(CellRenderer* cell, int expand) {
      gtk_tree_view_column_pack_end(&this, cell, expand);
   }

   // Packs the @cell into the beginning of the column. If @expand is %FALSE, then
   // the @cell is allocated no more space than it needs. Any unused space is divided
   // evenly between cells for which @expand is %TRUE.
   // <cell>: The #GtkCellRenderer.
   // <expand>: %TRUE if @cell is to be given extra space allocated to @tree_column.
   void pack_start(CellRenderer* cell, int expand) {
      gtk_tree_view_column_pack_start(&this, cell, expand);
   }

   // Flags the column, and the cell renderers added to this column, to have
   // their sizes renegotiated.
   void queue_resize() {
      gtk_tree_view_column_queue_resize(&this);
   }

   // Sets the alignment of the title or custom widget inside the column header.
   // The alignment determines its location inside the button -- 0.0 for left, 0.5
   // for center, 1.0 for right.
   // <xalign>: The alignment, which is between [0.0 and 1.0] inclusive.
   void set_alignment(float xalign) {
      gtk_tree_view_column_set_alignment(&this, xalign);
   }

   // Unintrospectable method: set_attributes() / gtk_tree_view_column_set_attributes()
   // Sets the attributes in the list as the attributes of @tree_column.
   // The attributes should be in attribute/column order, as in
   // gtk_tree_view_column_add_attribute(). All existing attributes
   // are removed, and replaced with the new attributes.
   // <cell_renderer>: the #GtkCellRenderer we're setting the attributes of
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_tree_view_column_set_attributes set_attributes; // Variadic
   +/

   // Sets the #GtkTreeViewColumnFunc to use for the column.  This
   // function is used instead of the standard attributes mapping for
   // setting the column value, and should set the value of @tree_column's
   // cell renderer as appropriate.  @func may be %NULL to remove an
   // older one.
   // <cell_renderer>: A #GtkCellRenderer
   // <func>: The #GtkTreeViewColumnFunc to use.
   // <func_data>: The user data for @func.
   // <destroy>: The destroy notification for @func_data
   void set_cell_data_func(CellRenderer* cell_renderer, TreeCellDataFunc func, void* func_data, GLib2.DestroyNotify destroy) {
      gtk_tree_view_column_set_cell_data_func(&this, cell_renderer, func, func_data, destroy);
   }

   // Sets the header to be active if @active is %TRUE.  When the header is active,
   // then it can take keyboard focus, and can be clicked.
   // <clickable>: %TRUE if the header is active.
   void set_clickable(int clickable) {
      gtk_tree_view_column_set_clickable(&this, clickable);
   }

   // Sets the column to take available extra space.  This space is shared equally
   // amongst all columns that have the expand set to %TRUE.  If no column has this
   // option set, then the last column gets all extra space.  By default, every
   // column is created with this %FALSE.
   // <expand>: %TRUE if the column should take available extra space, %FALSE if not
   void set_expand(int expand) {
      gtk_tree_view_column_set_expand(&this, expand);
   }

   // Sets the size of the column in pixels.  This is meaningful only if the sizing
   // type is #GTK_TREE_VIEW_COLUMN_FIXED.  The size of the column is clamped to
   // the min/max width for the column.  Please note that the min/max width of the
   // column doesn't actually affect the "fixed_width" property of the widget, just
   // the actual size when displayed.
   // <fixed_width>: The size to set @tree_column to. Must be greater than 0.
   void set_fixed_width(int fixed_width) {
      gtk_tree_view_column_set_fixed_width(&this, fixed_width);
   }

   // Sets the maximum width of the @tree_column.  If @max_width is -1, then the
   // maximum width is unset.  Note, the column can actually be wider than max
   // width if it's the last column in a view.  In this case, the column expands to
   // fill any extra space.
   // <max_width>: The maximum width of the column in pixels, or -1.
   void set_max_width(int max_width) {
      gtk_tree_view_column_set_max_width(&this, max_width);
   }

   // Sets the minimum width of the @tree_column.  If @min_width is -1, then the
   // minimum width is unset.
   // <min_width>: The minimum width of the column in pixels, or -1.
   void set_min_width(int min_width) {
      gtk_tree_view_column_set_min_width(&this, min_width);
   }

   // If @reorderable is %TRUE, then the column can be reordered by the end user
   // dragging the header.
   // <reorderable>: %TRUE, if the column can be reordered.
   void set_reorderable(int reorderable) {
      gtk_tree_view_column_set_reorderable(&this, reorderable);
   }

   // If @resizable is %TRUE, then the user can explicitly resize the column by
   // grabbing the outer edge of the column button.  If resizable is %TRUE and
   // sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
   // mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY.
   // <resizable>: %TRUE, if the column can be resized
   void set_resizable(int resizable) {
      gtk_tree_view_column_set_resizable(&this, resizable);
   }

   // Sets the growth behavior of @tree_column to @type.
   // <type>: The #GtkTreeViewColumnSizing.
   void set_sizing(TreeViewColumnSizing type) {
      gtk_tree_view_column_set_sizing(&this, type);
   }

   // Sets the logical @sort_column_id that this column sorts on when this column 
   // is selected for sorting.  Doing so makes the column header clickable.
   // <sort_column_id>: The @sort_column_id of the model to sort on.
   void set_sort_column_id(int sort_column_id) {
      gtk_tree_view_column_set_sort_column_id(&this, sort_column_id);
   }

   // Call this function with a @setting of %TRUE to display an arrow in
   // the header button indicating the column is sorted. Call
   // gtk_tree_view_column_set_sort_order() to change the direction of
   // the arrow.
   // <setting>: %TRUE to display an indicator that the column is sorted
   void set_sort_indicator(int setting) {
      gtk_tree_view_column_set_sort_indicator(&this, setting);
   }

   // Changes the appearance of the sort indicator. 
   // This <emphasis>does not</emphasis> actually sort the model.  Use
   // gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
   // support.  This function is primarily for custom sorting behavior, and should
   // be used in conjunction with gtk_tree_sortable_set_sort_column() to do
   // that. For custom models, the mechanism will vary. 
   // The sort indicator changes direction to indicate normal sort or reverse sort.
   // Note that you must have the sort indicator enabled to see anything when 
   // calling this function; see gtk_tree_view_column_set_sort_indicator().
   // <order>: sort order that the sort indicator should indicate
   void set_sort_order(SortType order) {
      gtk_tree_view_column_set_sort_order(&this, order);
   }

   // Sets the spacing field of @tree_column, which is the number of pixels to
   // place between cell renderers packed into it.
   // <spacing>: distance between cell renderers in pixels.
   void set_spacing(int spacing) {
      gtk_tree_view_column_set_spacing(&this, spacing);
   }

   // Sets the title of the @tree_column.  If a custom widget has been set, then
   // this value is ignored.
   // <title>: The title of the @tree_column.
   void set_title(char* title) {
      gtk_tree_view_column_set_title(&this, title);
   }

   // Sets the visibility of @tree_column.
   // <visible>: %TRUE if the @tree_column is visible.
   void set_visible(int visible) {
      gtk_tree_view_column_set_visible(&this, visible);
   }

   // Sets the widget in the header to be @widget.  If widget is %NULL, then the
   // header button is set with a #GtkLabel set to the title of @tree_column.
   // <widget>: A child #GtkWidget, or %NULL.
   void set_widget(Widget* widget=null) {
      gtk_tree_view_column_set_widget(&this, widget);
   }
   extern (C) alias static void function (TreeViewColumn* 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 TreeViewColumnClass {
   ObjectClass parent_class;
   extern (C) void function (TreeViewColumn* tree_column) clicked;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias int function (TreeView* tree_view, TreeViewColumn* column, TreeViewColumn* prev_column, TreeViewColumn* next_column, void* data) TreeViewColumnDropFunc;

enum TreeViewColumnSizing {
   GROW_ONLY = 0,
   AUTOSIZE = 1,
   FIXED = 2
}
enum TreeViewDropPosition {
   BEFORE = 0,
   AFTER = 1,
   INTO_OR_BEFORE = 2,
   INTO_OR_AFTER = 3
}
enum TreeViewGridLines {
   NONE = 0,
   HORIZONTAL = 1,
   VERTICAL = 2,
   BOTH = 3
}
extern (C) alias void function (TreeView* tree_view, TreePath* path, void* user_data) TreeViewMappingFunc;

enum TreeViewMode {
   LINE = 0,
   ITEM = 1
}
struct TreeViewPrivate {
}

extern (C) alias int function (TreeModel* model, TreeIter* iter, void* data) TreeViewRowSeparatorFunc;

extern (C) alias int function (TreeModel* model, int column, char* key, TreeIter* iter, void* search_data) TreeViewSearchEqualFunc;

extern (C) alias void function (TreeView* tree_view, Widget* search_dialog, void* user_data) TreeViewSearchPositionFunc;

struct TypeInfo {
   char* type_name;
   uint object_size, class_size;
   ClassInitFunc class_init_func;
   ObjectInitFunc object_init_func;
   void* reserved_1, reserved_2;
   ClassInitFunc base_class_init_func;
}

struct UIManager /* : GObject.Object */ {
   alias parent this;
   alias parent super_;
   alias parent object;
   GObject2.Object parent;
   private UIManagerPrivate* private_data;


   // Creates a new ui manager object.
   // RETURNS: a new ui manager object.
   static UIManager* /*new*/ new_() {
      return gtk_ui_manager_new();
   }

   // Adds a UI element to the current contents of @self. 
   // If @type is %GTK_UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or 
   // separator if such an element can be inserted at the place determined by 
   // the place determined by @path.
   // If @path points to a menuitem or toolitem, the new element will be inserted
   // before or after this item, depending on @top.
   // <merge_id>: the merge id for the merged UI, see gtk_ui_manager_new_merge_id()
   // <path>: a path
   // <name>: the name for the added UI element
   // <action>: the name of the action to be proxied, or %NULL to add a separator
   // <type>: the type of UI element to add.
   // <top>: if %TRUE, the UI element is added before its siblings, otherwise it is added after its siblings.
   void add_ui(uint merge_id, char* path, char* name, char* action, UIManagerItemType type, int top) {
      gtk_ui_manager_add_ui(&this, merge_id, path, name, action, type, top);
   }

   // Parses a file containing a <link linkend="XML-UI">UI definition</link> and 
   // merges it with the current contents of @self. 
   // to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,
   // the return value is 0.
   // RETURNS: The merge id for the merged UI. The merge id can be used
   // <filename>: the name of the file to parse
   uint add_ui_from_file(char* filename, GLib2.Error** error=null) {
      return gtk_ui_manager_add_ui_from_file(&this, filename, error);
   }

   // Parses a string containing a <link linkend="XML-UI">UI definition</link> and 
   // merges it with the current contents of @self. An enclosing &lt;ui&gt; 
   // element is added if it is missing.
   // to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,
   // the return value is 0.
   // RETURNS: The merge id for the merged UI. The merge id can be used
   // <buffer>: the string to parse
   // <length>: the length of @buffer (may be -1 if @buffer is nul-terminated)
   uint add_ui_from_string(char* buffer, ssize_t length, GLib2.Error** error=null) {
      return gtk_ui_manager_add_ui_from_string(&this, buffer, length, error);
   }

   // Makes sure that all pending updates to the UI have been completed.
   // This may occasionally be necessary, since #GtkUIManager updates the 
   // UI in an idle function. A typical example where this function is
   // useful is to enforce that the menubar and toolbar have been added to 
   // the main window before showing it:
   // |[
   // gtk_container_add (GTK_CONTAINER (window), vbox); 
   // g_signal_connect (merge, "add-widget", 
   // G_CALLBACK (add_widget), vbox);
   // gtk_ui_manager_add_ui_from_file (merge, "my-menus");
   // gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");
   // gtk_ui_manager_ensure_update (merge);  
   // gtk_widget_show (window);
   // ]|
   void ensure_update() {
      gtk_ui_manager_ensure_update(&this);
   }

   // Returns the #GtkAccelGroup associated with @self.
   // RETURNS: the #GtkAccelGroup.
   AccelGroup* get_accel_group() {
      return gtk_ui_manager_get_accel_group(&this);
   }

   // Looks up an action by following a path. See gtk_ui_manager_get_widget()
   // for more information about paths.
   // or %NULL if no widget was found.
   // RETURNS: the action whose proxy widget is found by following the path,
   // <path>: a path
   Action* get_action(char* path) {
      return gtk_ui_manager_get_action(&this, path);
   }

   // Returns the list of action groups associated with @self.
   // action groups. The list is owned by GTK+
   // and should not be modified.
   // RETURNS: a #GList of
   GLib2.List* get_action_groups() {
      return gtk_ui_manager_get_action_groups(&this);
   }

   // Returns whether menus generated by this #GtkUIManager
   // will have tearoff menu items.
   // RETURNS: whether tearoff menu items are added
   int get_add_tearoffs() {
      return gtk_ui_manager_get_add_tearoffs(&this);
   }

   // Obtains a list of all toplevel widgets of the requested types.
   // all toplevel widgets of the requested types.  Free the returned list with g_slist_free().
   // RETURNS: a newly-allocated #GSList of
   // <types>: specifies the types of toplevel widgets to include. Allowed types are #GTK_UI_MANAGER_MENUBAR, #GTK_UI_MANAGER_TOOLBAR and #GTK_UI_MANAGER_POPUP.
   GLib2.SList* /*new container*/ get_toplevels(UIManagerItemType types) {
      return gtk_ui_manager_get_toplevels(&this, types);
   }

   // Creates a <link linkend="XML-UI">UI definition</link> of the merged UI.
   // the merged UI.
   // RETURNS: A newly allocated string containing an XML representation of
   char* /*new*/ get_ui() {
      return gtk_ui_manager_get_ui(&this);
   }

   // Looks up a widget by following a path. 
   // The path consists of the names specified in the XML description of the UI. 
   // separated by '/'. Elements which don't have a name or action attribute in 
   // the XML (e.g. &lt;popup&gt;) can be addressed by their XML element name 
   // (e.g. "popup"). The root element ("/ui") can be omitted in the path.
   // Note that the widget found by following a path that ends in a &lt;menu&gt;
   // element is the menuitem to which the menu is attached, not the menu itself.
   // Also note that the widgets constructed by a ui manager are not tied to 
   // the lifecycle of the ui manager. If you add the widgets returned by this 
   // function to some container or explicitly ref them, they will survive the
   // destruction of the ui manager.
   // was found.
   // RETURNS: the widget found by following the path, or %NULL if no widget
   // <path>: a path
   Widget* get_widget(char* path) {
      return gtk_ui_manager_get_widget(&this, path);
   }

   // Inserts an action group into the list of action groups associated 
   // with @self. Actions in earlier groups hide actions with the same 
   // name in later groups.
   // <action_group>: the action group to be inserted
   // <pos>: the position at which the group will be inserted.
   void insert_action_group(ActionGroup* action_group, int pos) {
      gtk_ui_manager_insert_action_group(&this, action_group, pos);
   }

   // Returns an unused merge id, suitable for use with 
   // gtk_ui_manager_add_ui().
   // RETURNS: an unused merge id.
   uint new_merge_id() {
      return gtk_ui_manager_new_merge_id(&this);
   }

   // Removes an action group from the list of action groups associated 
   // with @self.
   // <action_group>: the action group to be removed
   void remove_action_group(ActionGroup* action_group) {
      gtk_ui_manager_remove_action_group(&this, action_group);
   }

   // Unmerges the part of @self<!-- -->s content identified by @merge_id.
   // <merge_id>: a merge id as returned by gtk_ui_manager_add_ui_from_string()
   void remove_ui(uint merge_id) {
      gtk_ui_manager_remove_ui(&this, merge_id);
   }

   // Sets the "add_tearoffs" property, which controls whether menus 
   // generated by this #GtkUIManager will have tearoff menu items. 
   // Note that this only affects regular menus. Generated popup 
   // menus never have tearoff menu items.
   // <add_tearoffs>: whether tearoff menu items are added
   void set_add_tearoffs(int add_tearoffs) {
      gtk_ui_manager_set_add_tearoffs(&this, add_tearoffs);
   }

   // The "actions-changed" signal is emitted whenever the set of actions
   // changes.
   extern (C) alias static void function (UIManager* 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);
   }

   // The add_widget signal is emitted for each generated menubar and toolbar.
   // It is not emitted for generated popup menus, which can be obtained by 
   // gtk_ui_manager_get_widget().
   // <widget>: the added widget
   extern (C) alias static void function (UIManager* this_, Widget* widget, void* user_data=null) signal_add_widget;
   ulong signal_connect(string name:"add-widget", CB/*:signal_add_widget*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"add-widget",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The connect_proxy signal is emitted after connecting a proxy to 
   // an action in the group. 
   // This is intended for simple customizations for which a custom action
   // class would be too clumsy, e.g. showing tooltips for menuitems in the
   // statusbar.
   // <action>: the action
   // <proxy>: the proxy
   extern (C) alias static void function (UIManager* this_, Action* action, Widget* proxy, void* user_data=null) signal_connect_proxy;
   ulong signal_connect(string name:"connect-proxy", CB/*:signal_connect_proxy*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"connect-proxy",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The disconnect_proxy signal is emitted after disconnecting a proxy 
   // from an action in the group.
   // <action>: the action
   // <proxy>: the proxy
   extern (C) alias static void function (UIManager* this_, Action* action, Widget* proxy, void* user_data=null) signal_disconnect_proxy;
   ulong signal_connect(string name:"disconnect-proxy", CB/*:signal_disconnect_proxy*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"disconnect-proxy",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The post_activate signal is emitted just after the @action
   // is activated.
   // This is intended for applications to get notification
   // just after any action is activated.
   // <action>: the action
   extern (C) alias static void function (UIManager* this_, Action* action, void* user_data=null) signal_post_activate;
   ulong signal_connect(string name:"post-activate", CB/*:signal_post_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"post-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The pre_activate signal is emitted just before the @action
   // is activated.
   // This is intended for applications to get notification
   // just before any action is activated.
   // <action>: the action
   extern (C) alias static void function (UIManager* this_, Action* action, void* user_data=null) signal_pre_activate;
   ulong signal_connect(string name:"pre-activate", CB/*:signal_pre_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"pre-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct UIManagerClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function (UIManager* merge, Widget* widget) add_widget;
   extern (C) void function (UIManager* merge) actions_changed;
   extern (C) void function (UIManager* merge, Action* action, Widget* proxy) connect_proxy;
   extern (C) void function (UIManager* merge, Action* action, Widget* proxy) disconnect_proxy;
   extern (C) void function (UIManager* merge, Action* action) pre_activate;
   extern (C) void function (UIManager* merge, Action* action) post_activate;

   // RETURNS: the widget found by following the path, or %NULL if no widget
   // <path>: a path
   extern (C) Widget* function (UIManager* manager, char* path) get_widget;

   // RETURNS: the action whose proxy widget is found by following the path,
   // <path>: a path
   extern (C) Action* function (UIManager* manager, char* path) get_action;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
}

enum UIManagerItemType {
   AUTO = 0,
   MENUBAR = 1,
   MENU = 2,
   TOOLBAR = 4,
   PLACEHOLDER = 8,
   POPUP = 16,
   MENUITEM = 32,
   TOOLITEM = 64,
   SEPARATOR = 128,
   ACCELERATOR = 256,
   POPUP_WITH_ACCELS = 512
}
struct UIManagerPrivate {
}

enum Unit {
   PIXEL = 0,
   POINTS = 1,
   INCH = 2,
   MM = 3
}
enum UpdateType {
   CONTINUOUS = 0,
   DISCONTINUOUS = 1,
   DELAYED = 2
}

// A #GtkVBox is a container that organizes child widgets into a single column.
// Use the #GtkBox packing interface to determine the arrangement,
// spacing, height, and alignment of #GtkVBox children.
// All children are allocated the same width.
struct VBox /* : Box */ {
   alias box this;
   alias box super_;
   Box box;


   // Creates a new #GtkVBox.
   // RETURNS: a new #GtkVBox.
   // <homogeneous>: %TRUE if all children are to be given equal space allotments.
   // <spacing>: the number of pixels to place by default between children.
   static VBox* new_(int homogeneous, int spacing) {
      return gtk_vbox_new(homogeneous, spacing);
   }
}

struct VBoxClass {
   BoxClass parent_class;
}

struct VButtonBox /* : ButtonBox */ {
   alias button_box this;
   alias button_box super_;
   alias button_box buttonbox;
   ButtonBox button_box;


   // Creates a new vertical button box.
   // RETURNS: a new button box #GtkWidget.
   static VButtonBox* new_() {
      return gtk_vbutton_box_new();
   }

   // Retrieves the current layout used to arrange buttons in button box widgets.
   // RETURNS: the current #GtkButtonBoxStyle.
   static ButtonBoxStyle get_layout_default() {
      return gtk_vbutton_box_get_layout_default();
   }

   // Retrieves the current default spacing for vertical button boxes. This is the number of pixels
   // to be placed between the buttons when they are arranged.
   // RETURNS: the default number of pixels between buttons.
   static int get_spacing_default() {
      return gtk_vbutton_box_get_spacing_default();
   }

   // Sets a new layout mode that will be used by all button boxes.
   // <layout>: a new #GtkButtonBoxStyle.
   static void set_layout_default(ButtonBoxStyle layout) {
      gtk_vbutton_box_set_layout_default(layout);
   }

   // Changes the default spacing that is placed between widgets in an
   // vertical button box.
   // <spacing>: an integer value.
   static void set_spacing_default(int spacing) {
      gtk_vbutton_box_set_spacing_default(spacing);
   }
}

struct VButtonBoxClass {
   ButtonBoxClass parent_class;
}


// The VPaned widget is a container widget with two
// children arranged vertically. The division between
// the two panes is adjustable by the user by dragging
// a handle. See #GtkPaned for details.
struct VPaned /* : Paned */ {
   alias paned this;
   alias paned super_;
   Paned paned;


   // Create a new #GtkVPaned
   // RETURNS: the new #GtkVPaned
   static VPaned* new_() {
      return gtk_vpaned_new();
   }
}

struct VPanedClass {
   PanedClass parent_class;
}


// <note>
// This widget is considered too specialized/little-used for
// GTK+, and will be removed in GTK 3.  If your application needs this widget,
// feel free to use it, as the widget is useful in some applications; it's just
// not of general interest. However, we are not accepting new features for the
// widget, and it will move out of the GTK+ distribution.
// </note>
// The VRuler widget is a widget arranged vertically creating a ruler that is
// utilized around other widgets such as a text widget. The ruler is used to show
// the location of the mouse on the window and to show the size of the window in
// specified units. The available units of measurement are GTK_PIXELS, GTK_INCHES
// and GTK_CENTIMETERS. GTK_PIXELS is the default unit of measurement.
struct VRuler /* : Ruler */ {
   alias ruler this;
   alias ruler super_;
   Ruler ruler;


   // Creates a new vertical ruler
   // unmaintained and too specialized. There is no replacement.
   // RETURNS: a new #GtkVRuler.
   static VRuler* new_() {
      return gtk_vruler_new();
   }
}

struct VRulerClass {
   RulerClass parent_class;
}


// The #GtkVScale widget is used to allow the user to select a value using
// a vertical slider. To create one, use gtk_hscale_new_with_range().
// The position to show the current value, and the number of decimal places
// shown can be set using the parent #GtkScale class's functions.
struct VScale /* : Scale */ {
   alias scale this;
   alias scale super_;
   Scale scale;


   // Creates a new #GtkVScale.
   // RETURNS: a new #GtkVScale.
   // <adjustment>: the #GtkAdjustment which sets the range of the scale.
   static VScale* new_(Adjustment* adjustment) {
      return gtk_vscale_new(adjustment);
   }

   // Creates a new vertical scale widget that lets the user input a
   // number between @min and @max (including @min and @max) with the
   // increment @step.  @step must be nonzero; it's the distance the
   // slider moves when using the arrow keys to adjust the scale value.
   // Note that the way in which the precision is derived works best if @step
   // is a power of ten. If the resulting precision is not suitable for your
   // needs, use gtk_scale_set_digits() to correct it.
   // RETURNS: a new #GtkVScale
   // <min>: minimum value
   // <max>: maximum value
   // <step>: step increment (tick size) used with keyboard shortcuts
   static VScale* new_with_range(double min, double max, double step) {
      return gtk_vscale_new_with_range(min, max, step);
   }
}

struct VScaleClass {
   ScaleClass parent_class;
}


// The #GtkVScrollbar widget is a widget arranged vertically creating a
// scrollbar. See #GtkScrollbar for details on
// scrollbars. #GtkAdjustment pointers may be added to handle the
// adjustment of the scrollbar or it may be left %NULL in which case one
// will be created for you. See #GtkScrollbar for a description of what the
// fields in an adjustment represent for a scrollbar.
struct VScrollbar /* : Scrollbar */ {
   alias scrollbar this;
   alias scrollbar super_;
   Scrollbar scrollbar;


   // Creates a new vertical scrollbar.
   // RETURNS: the new #GtkVScrollbar
   // <adjustment>: the #GtkAdjustment to use, or %NULL to create a new adjustment
   static VScrollbar* new_(Adjustment* adjustment=null) {
      return gtk_vscrollbar_new(adjustment);
   }
}

struct VScrollbarClass {
   ScrollbarClass parent_class;
}


// The #GtkVSeparator widget is a vertical separator, used to group the
// widgets within a window. It displays a vertical line with a shadow to
// make it appear sunken into the interface.
struct VSeparator /* : Separator */ {
   alias separator this;
   alias separator super_;
   Separator separator;


   // Creates a new #GtkVSeparator.
   // RETURNS: a new #GtkVSeparator.
   static VSeparator* new_() {
      return gtk_vseparator_new();
   }
}

struct VSeparatorClass {
   SeparatorClass parent_class;
}


// The #GtkViewport widget acts as an adaptor class, implementing
// scrollability for child widgets that lack their own scrolling
// capabilities. Use #GtkViewport to scroll child widgets such as
// #GtkTable, #GtkBox, and so on.
// If a widget has native scrolling abilities, such as #GtkTextView,
// #GtkTreeView or #GtkIconview, it can be added to a #GtkScrolledWindow
// with gtk_container_add(). If a widget does not, you must first add the
// widget to a #GtkViewport, then add the viewport to the scrolled window.
// The convenience function gtk_scrolled_window_add_with_viewport() does
// exactly this, so you can ignore the presence of the viewport.
struct Viewport /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   ShadowType shadow_type;
   Gdk2.Window* view_window, bin_window;
   Adjustment* hadjustment, vadjustment;


   // Creates a new #GtkViewport with the given adjustments.
   // RETURNS: a new #GtkViewport.
   // <hadjustment>: horizontal adjustment.
   // <vadjustment>: vertical adjustment.
   static Viewport* new_(Adjustment* hadjustment, Adjustment* vadjustment) {
      return gtk_viewport_new(hadjustment, vadjustment);
   }

   // Gets the bin window of the #GtkViewport.
   // RETURNS: a #GdkWindow
   Gdk2.Window* get_bin_window() {
      return gtk_viewport_get_bin_window(&this);
   }

   // Returns the horizontal adjustment of the viewport.
   // RETURNS: the horizontal adjustment of @viewport.
   Adjustment* get_hadjustment() {
      return gtk_viewport_get_hadjustment(&this);
   }

   // Gets the shadow type of the #GtkViewport. See
   // gtk_viewport_set_shadow_type().
   // RETURNS: the shadow type
   ShadowType get_shadow_type() {
      return gtk_viewport_get_shadow_type(&this);
   }

   // Returns the vertical adjustment of the viewport.
   // RETURNS: the vertical adjustment of @viewport.
   Adjustment* get_vadjustment() {
      return gtk_viewport_get_vadjustment(&this);
   }

   // Gets the view window of the #GtkViewport.
   // RETURNS: a #GdkWindow
   Gdk2.Window* get_view_window() {
      return gtk_viewport_get_view_window(&this);
   }

   // Sets the horizontal adjustment of the viewport.
   // <adjustment>: a #GtkAdjustment.
   void set_hadjustment(Adjustment* adjustment=null) {
      gtk_viewport_set_hadjustment(&this, adjustment);
   }

   // Sets the shadow type of the viewport.
   // <type>: the new shadow type.
   void set_shadow_type(ShadowType type) {
      gtk_viewport_set_shadow_type(&this, type);
   }

   // Sets the vertical adjustment of the viewport.
   // <adjustment>: a #GtkAdjustment.
   void set_vadjustment(Adjustment* adjustment=null) {
      gtk_viewport_set_vadjustment(&this, adjustment);
   }

   // Set the scroll adjustments for the viewport. Usually scrolled containers
   // like #GtkScrolledWindow will emit this signal to connect two instances
   // of #GtkScrollbar to the scroll directions of the #GtkViewport.
   extern (C) alias static void function (Viewport* this_, Adjustment* object, Adjustment* p0, void* user_data=null) signal_set_scroll_adjustments;

   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:"set-scroll-adjustments", CB/*:signal_set_scroll_adjustments*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-scroll-adjustments",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct ViewportClass {
   BinClass parent_class;
   extern (C) void function (Viewport* viewport, Adjustment* hadjustment, Adjustment* vadjustment) set_scroll_adjustments;
}

enum Visibility {
   NONE = 0,
   PARTIAL = 1,
   FULL = 2
}

// #GtkVolumeButton is a subclass of #GtkScaleButton that has
// been tailored for use as a volume control widget with suitable
// icons, tooltips and accessible labels.
struct VolumeButton /* : ScaleButton */ {
   alias parent this;
   alias parent super_;
   alias parent scalebutton;
   ScaleButton parent;


   // Creates a #GtkVolumeButton, with a range between 0.0 and 1.0, with
   // a stepping of 0.02. Volume values can be obtained and modified using
   // the functions from #GtkScaleButton.
   // RETURNS: a new #GtkVolumeButton
   static VolumeButton* new_() {
      return gtk_volume_button_new();
   }
}

struct VolumeButtonClass {
   ScaleButtonClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}


// GtkWidget is the base class all widgets in GTK+ derive from. It manages the
// widget lifecycle, states and style.
// <refsect2 id="style-properties">
// <para>
// <structname>GtkWidget</structname> introduces <firstterm>style
// properties</firstterm> - these are basically object properties that are stored
// not on the object, but in the style object associated to the widget. Style
// properties are set in <link linkend="gtk-Resource-Files">resource files</link>.
// This mechanism is used for configuring such things as the location of the
// scrollbar arrows through the theme, giving theme authors more control over the
// look of applications without the need to write a theme engine in C.
// </para>
// <para>
// Use gtk_widget_class_install_style_property() to install style properties for
// a widget class, gtk_widget_class_find_style_property() or
// gtk_widget_class_list_style_properties() to get information about existing
// style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or
// gtk_widget_style_get_valist() to obtain the value of a style property.
// </para>
// </refsect2>
// <refsect2 id="GtkWidget-BUILDER-UI">
// <title>GtkWidget as GtkBuildable</title>
// <para>
// The GtkWidget implementation of the GtkBuildable interface supports a
// custom &lt;accelerator&gt; element, which has attributes named key,
// modifiers and signal and allows to specify accelerators.
// </para>
// <example>
// <title>A UI definition fragment specifying an accelerator</title>
// <programlisting><![CDATA[
// <object class="GtkButton">
// <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
// </object>
// ]]></programlisting>
// </example>
// <para>
// In addition to accelerators, <structname>GtkWidget</structname> also support a
// custom &lt;accessible&gt; element, which supports actions and relations.
// Properties on the accessible implementation of an object can be set by accessing the
// internal child "accessible" of a <structname>GtkWidget</structname>.
// </para>
// <example>
// <title>A UI definition fragment specifying an accessible</title>
// <programlisting><![CDATA[
// <object class="GtkButton" id="label1"/>
// <property name="label">I am a Label for a Button</property>
// </object>
// <object class="GtkButton" id="button1">
// <accessibility>
// <action action_name="click" translatable="yes">Click the button.</action>
// <relation target="label1" type="labelled-by"/>
// </accessibility>
// <child internal-child="accessible">
// <object class="AtkObject" id="a11y-button1">
// <property name="AtkObject::name">Clickable Button</property>
// </object>
// </child>
// </object>
// ]]></programlisting>
// </example>
// </refsect2>
struct Widget /* : Object */ {
   alias object this;
   alias object super_;
   Object object;
   ushort private_flags;
   ubyte state, saved_state;
   char* name;
   Style* style;
   Requisition requisition;
   Allocation allocation;
   Gdk2.Window* window;
   Widget* parent;


   // Unintrospectable constructor: new() / gtk_widget_new()
   // This is a convenience function for creating a widget and setting
   // its properties in one go. For example you might write:
   // <literal>gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign",
   // 0.0, NULL)</literal> to create a left-aligned label. Equivalent to
   // g_object_new(), but returns a widget so you don't have to
   // cast the object yourself.
   // RETURNS: a new #GtkWidget of type @widget_type
   // <type>: type ID of the widget to create
   // <first_property_name>: name of first property to set
   alias gtk_widget_new new_; // Variadic

   // Obtains the default colormap used to create widgets.
   // RETURNS: default widget colormap
   static Gdk2.Colormap* get_default_colormap() {
      return gtk_widget_get_default_colormap();
   }

   // Obtains the current default reading direction. See
   // gtk_widget_set_default_direction().
   // RETURNS: the current default direction.
   static TextDirection get_default_direction() {
      return gtk_widget_get_default_direction();
   }

   // Returns the default style used by all widgets initially.
   // by GTK+ and should not be modified or freed.
   // RETURNS: the default style. This #GtkStyle object is owned
   static Style* get_default_style() {
      return gtk_widget_get_default_style();
   }

   // Obtains the visual of the default colormap. Not really useful;
   // used to be useful before gdk_colormap_get_visual() existed.
   // RETURNS: visual of the default colormap
   static Gdk2.Visual* get_default_visual() {
      return gtk_widget_get_default_visual();
   }
   // Removes a colormap pushed with gtk_widget_push_colormap().
   static void pop_colormap() {
      gtk_widget_pop_colormap();
   }
   // Cancels the effect of a previous call to gtk_widget_push_composite_child().
   static void pop_composite_child() {
      gtk_widget_pop_composite_child();
   }

   // Pushes @cmap onto a global stack of colormaps; the topmost
   // colormap on the stack will be used to create all widgets.
   // Remove @cmap with gtk_widget_pop_colormap(). There's little
   // reason to use this function.
   // <cmap>: a #GdkColormap
   static void push_colormap(Gdk2.Colormap* cmap) {
      gtk_widget_push_colormap(cmap);
   }

   // Makes all newly-created widgets as composite children until
   // the corresponding gtk_widget_pop_composite_child() call.
   // A composite child is a child that's an implementation detail of the
   // container it's inside and should not be visible to people using the
   // container. Composite children aren't treated differently by GTK (but
   // see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI 
   // builders might want to treat them in a different way.
   // Here is a simple example:
   // |[
   // gtk_widget_push_composite_child ();
   // scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
   // gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
   // gtk_widget_pop_composite_child ();
   // gtk_widget_set_parent (scrolled_window->hscrollbar, 
   // GTK_WIDGET (scrolled_window));
   // g_object_ref (scrolled_window->hscrollbar);
   // ]|
   static void push_composite_child() {
      gtk_widget_push_composite_child();
   }

   // Sets the default colormap to use when creating widgets.
   // gtk_widget_push_colormap() is a better function to use if
   // you only want to affect a few widgets, rather than all widgets.
   // <colormap>: a #GdkColormap
   static void set_default_colormap(Gdk2.Colormap* colormap) {
      gtk_widget_set_default_colormap(colormap);
   }

   // Sets the default reading direction for widgets where the
   // direction has not been explicitly set by gtk_widget_set_direction().
   // <dir>: the new default direction. This cannot be %GTK_TEXT_DIR_NONE.
   static void set_default_direction(TextDirection dir) {
      gtk_widget_set_default_direction(dir);
   }

   // For widgets that can be "activated" (buttons, menu items, etc.)
   // this function activates them. Activation is what happens when you
   // press Enter on a widget during key navigation. If @widget isn't 
   // activatable, the function returns %FALSE.
   // RETURNS: %TRUE if the widget was activatable
   int activate() {
      return gtk_widget_activate(&this);
   }

   // Installs an accelerator for this @widget in @accel_group that causes
   // The @accel_group needs to be added to the widget's toplevel via
   // gtk_window_add_accel_group(), and the signal must be of type %G_RUN_ACTION.
   // Accelerators added through this function are not user changeable during
   // runtime. If you want to support accelerators that can be changed by the
   // user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
   // gtk_menu_item_set_accel_path() instead.
   // <accel_signal>: widget signal to emit on accelerator activation
   // <accel_group>: accel group for this widget, added to its toplevel
   // <accel_key>: GDK keyval of the accelerator
   // <accel_mods>: modifier key combination of the accelerator
   // <accel_flags>: flag accelerators, e.g. %GTK_ACCEL_VISIBLE
   void add_accelerator(char* accel_signal, AccelGroup* accel_group, uint accel_key, Gdk2.ModifierType accel_mods, AccelFlags accel_flags) {
      gtk_widget_add_accelerator(&this, accel_signal, accel_group, accel_key, accel_mods, accel_flags);
   }

   // Adds the events in the bitfield @events to the event mask for
   // <events>: an event mask, see #GdkEventMask
   void add_events(int events) {
      gtk_widget_add_events(&this, events);
   }

   // Adds a widget to the list of mnemonic labels for
   // this widget. (See gtk_widget_list_mnemonic_labels()). Note the
   // list of mnemonic labels for the widget is cleared when the
   // widget is destroyed, so the caller must make sure to update
   // its internal state at this point as well, by using a connection
   // to the #GtkWidget::destroy signal or a weak notifier.
   // <label>: a #GtkWidget that acts as a mnemonic label for @widget
   void add_mnemonic_label(Widget* label) {
      gtk_widget_add_mnemonic_label(&this, label);
   }

   // Determines whether an accelerator that activates the signal
   // identified by @signal_id can currently be activated.
   // This is done by emitting the #GtkWidget::can-activate-accel
   // signal on @widget; if the signal isn't overridden by a
   // handler or in a derived widget, then the default check is
   // that the widget must be sensitive, and the widget and all
   // its ancestors mapped.
   // RETURNS: %TRUE if the accelerator can be activated.
   // <signal_id>: the ID of a signal installed on @widget
   int can_activate_accel(uint signal_id) {
      return gtk_widget_can_activate_accel(&this, signal_id);
   }

   // This function is used by custom widget implementations; if you're
   // writing an app, you'd use gtk_widget_grab_focus() to move the focus
   // to a particular widget, and gtk_container_set_focus_chain() to
   // change the focus tab order. So you may want to investigate those
   // functions instead.
   // gtk_widget_child_focus() is called by containers as the user moves
   // around the window using keyboard shortcuts. @direction indicates
   // what kind of motion is taking place (up, down, left, right, tab
   // forward, tab backward). gtk_widget_child_focus() emits the
   // #GtkWidget::focus signal; widgets override the default handler
   // for this signal in order to implement appropriate focus behavior.
   // The default ::focus handler for a widget should return %TRUE if
   // moving in @direction left the focus on a focusable location inside
   // that widget, and %FALSE if moving in @direction moved the focus
   // outside the widget. If returning %TRUE, widgets normally
   // call gtk_widget_grab_focus() to place the focus accordingly;
   // if returning %FALSE, they don't modify the current focus location.
   // This function replaces gtk_container_focus() from GTK+ 1.2.  
   // It was necessary to check that the child was visible, sensitive, 
   // and focusable before calling gtk_container_focus(). 
   // gtk_widget_child_focus() returns %FALSE if the widget is not 
   // currently in a focusable state, so there's no need for those checks.
   // RETURNS: %TRUE if focus ended up inside @widget
   // <direction>: direction of focus movement
   int child_focus(DirectionType direction) {
      return gtk_widget_child_focus(&this, direction);
   }

   // Emits a #GtkWidget::child-notify signal for the 
   // <link linkend="child-properties">child property</link> @child_property 
   // on @widget.
   // This is the analogue of g_object_notify() for child properties.
   // <child_property>: the name of a child property installed on the class of @widget<!-- -->'s parent
   void child_notify(char* child_property) {
      gtk_widget_child_notify(&this, child_property);
   }

   // Same as gtk_widget_path(), but always uses the name of a widget's type,
   // never uses a custom name set with gtk_widget_set_name().
   // <path_length>: location to store the length of the class path, or %NULL
   // <path>: location to store the class path as an allocated string, or %NULL
   // <path_reversed>: location to store the reverse class path as an allocated string, or %NULL
   void class_path(/*out*/ uint* path_length=null, /*out*/ char** path=null, /*out*/ char** path_reversed=null) {
      gtk_widget_class_path(&this, path_length, path, path_reversed);
   }

   // Creates a new #PangoContext with the appropriate font map,
   // font description, and base direction for drawing text for
   // this widget. See also gtk_widget_get_pango_context().
   // RETURNS: the new #PangoContext
   Pango.Context* /*new*/ create_pango_context() {
      return gtk_widget_create_pango_context(&this);
   }

   // Creates a new #PangoLayout with the appropriate font map,
   // font description, and base direction for drawing text for
   // this widget.
   // If you keep a #PangoLayout created in this way around, in order to
   // notify the layout of changes to the base direction or font of this
   // widget, you must call pango_layout_context_changed() in response to
   // the #GtkWidget::style-set and #GtkWidget::direction-changed signals
   // for the widget.
   // RETURNS: the new #PangoLayout
   // <text>: text to set on the layout (can be %NULL)
   Pango.Layout* /*new*/ create_pango_layout(char* text) {
      return gtk_widget_create_pango_layout(&this, text);
   }

   // Destroys a widget. Equivalent to gtk_object_destroy(), except that
   // you don't have to cast the widget to #GtkObject. When a widget is
   // destroyed, it will break any references it holds to other objects.
   // If the widget is inside a container, the widget will be removed
   // from the container. If the widget is a toplevel (derived from
   // #GtkWindow), it will be removed from the list of toplevels, and the
   // reference GTK+ holds to it will be removed. Removing a
   // widget from its container or the list of toplevels results in the
   // widget being finalized, unless you've added additional references
   // to the widget with g_object_ref().
   // In most cases, only toplevel widgets (windows) require explicit
   // destruction, because when you destroy a toplevel its children will
   // be destroyed as well.
   void destroy() {
      gtk_widget_destroy(&this);
   }

   // This function sets *@widget_pointer to %NULL if @widget_pointer !=
   // %NULL.  It's intended to be used as a callback connected to the
   // "destroy" signal of a widget. You connect gtk_widget_destroyed()
   // as a signal handler, and pass the address of your widget variable
   // as user data. Then when the widget is destroyed, the variable will
   // be set to %NULL. Useful for example to avoid multiple copies
   // of the same dialog.
   // <widget_pointer>: address of a variable that contains @widget
   void destroyed(/*inout*/ Widget** widget_pointer) {
      gtk_widget_destroyed(&this, widget_pointer);
   }

   // In GTK+ 1.2, this function would immediately render the
   // region @area of a widget, by invoking the virtual draw method of a
   // widget. In GTK+ 2.0, the draw method is gone, and instead
   // gtk_widget_draw() simply invalidates the specified region of the
   // widget, then updates the invalid region of the widget immediately.
   // Usually you don't want to update the region immediately for
   // performance reasons, so in general gtk_widget_queue_draw_area() is
   // a better choice if you want to draw a region of a widget.
   // <area>: area to draw
   void draw(Gdk2.Rectangle* area) {
      gtk_widget_draw(&this, area);
   }

   // Ensures that @widget has a style (@widget->style). Not a very useful
   // function; most of the time, if you want the style, the widget is
   // realized, and realized widgets are guaranteed to have a style
   // already.
   void ensure_style() {
      gtk_widget_ensure_style(&this);
   }

   // Notifies the user about an input-related error on this widget. 
   // If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
   // gdk_window_beep(), otherwise it does nothing.
   // Note that the effect of gdk_window_beep() can be configured in many
   // ways, depending on the windowing backend and the desktop environment
   // or window manager that is used.
   void error_bell() {
      gtk_widget_error_bell(&this);
   }

   // Rarely-used function. This function is used to emit
   // the event signals on a widget (those signals should never
   // be emitted without using this function to do so).
   // If you want to synthesize an event though, don't use this function;
   // instead, use gtk_main_do_event() so the event will behave as if
   // it were in the event queue. Don't synthesize expose events; instead,
   // use gdk_window_invalidate_rect() to invalidate a region of the
   // window.
   // the event was handled)
   // RETURNS: return from the event signal emission (%TRUE if
   // <event>: a #GdkEvent
   int event(Gdk2.Event* event) {
      return gtk_widget_event(&this, event);
   }

   // Stops emission of #GtkWidget::child-notify signals on @widget. The 
   // signals are queued until gtk_widget_thaw_child_notify() is called 
   // on @widget. 
   // This is the analogue of g_object_freeze_notify() for child properties.
   void freeze_child_notify() {
      gtk_widget_freeze_child_notify(&this);
   }

   // Returns the accessible object that describes the widget to an
   // assistive technology. 
   // If no accessibility library is loaded (i.e. no ATK implementation library is 
   // loaded via <envar>GTK_MODULES</envar> or via another application library, 
   // such as libgnome), then this #AtkObject instance may be a no-op. Likewise, 
   // if no class-specific #AtkObject implementation is available for the widget 
   // instance in question, it will inherit an #AtkObject implementation from the 
   // first ancestor class for which such an implementation is defined.
   // The documentation of the <ulink url="http://developer.gnome.org/doc/API/2.0/atk/index.html">ATK</ulink>
   // library contains more information about accessible objects and their uses.
   // RETURNS: the #AtkObject associated with @widget
   Atk.Object* get_accessible() {
      return gtk_widget_get_accessible(&this);
   }

   // Unintrospectable method: get_action() / gtk_widget_get_action()
   // Returns the #GtkAction that @widget is a proxy for. 
   // See also gtk_action_get_proxies().
   // %NULL, if it is not attached to an action.
   // RETURNS: the action that a widget is a proxy for, or
   Action* get_action() {
      return gtk_widget_get_action(&this);
   }

   // Retrieves the widget's allocation.
   // <allocation>: a pointer to a #GtkAllocation to copy to
   void get_allocation(/*out*/ Allocation* allocation) {
      gtk_widget_get_allocation(&this, allocation);
   }

   // Gets the first ancestor of @widget with type @widget_type. For example,
   // <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</literal> gets 
   // the first #GtkBox that's an ancestor of @widget. No reference will be 
   // added to the returned widget; it should not be unreferenced. See note 
   // about checking for a toplevel #GtkWindow in the docs for 
   // gtk_widget_get_toplevel().
   // Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor() 
   // considers @widget to be an ancestor of itself.
   // RETURNS: the ancestor widget, or %NULL if not found
   // <widget_type>: ancestor type
   Widget* get_ancestor(Type widget_type) {
      return gtk_widget_get_ancestor(&this, widget_type);
   }

   // Determines whether the application intends to draw on the widget in
   // an #GtkWidget::expose-event handler.
   // See gtk_widget_set_app_paintable()
   // RETURNS: %TRUE if the widget is app paintable
   int get_app_paintable() {
      return gtk_widget_get_app_paintable(&this);
   }

   // Determines whether @widget can be a default widget. See
   // gtk_widget_set_can_default().
   // RETURNS: %TRUE if @widget can be a default widget, %FALSE otherwise
   int get_can_default() {
      return gtk_widget_get_can_default(&this);
   }

   // Determines whether @widget can own the input focus. See
   // gtk_widget_set_can_focus().
   // RETURNS: %TRUE if @widget can own the input focus, %FALSE otherwise
   int get_can_focus() {
      return gtk_widget_get_can_focus(&this);
   }

   // This function is only for use in widget implementations. Obtains
   // geometry on the widget (e.g. with gtk_widget_set_size_request()),
   // in which case it returns that geometry instead of the widget's
   // requisition.
   // This function differs from gtk_widget_size_request() in that
   // it retrieves the last size request value from @widget->requisition,
   // while gtk_widget_size_request() actually calls the "size_request" method
   // on @widget to compute the size request and fill in @widget->requisition,
   // and only then returns @widget->requisition.
   // Because this function does not call the "size_request" method, it
   // can only be used when you know that @widget->requisition is
   // up-to-date, that is, gtk_widget_size_request() has been called
   // since the last time a resize was queued. In general, only container
   // implementations have this information; applications should use
   // gtk_widget_size_request().
   // <requisition>: a #GtkRequisition to be filled in
   void get_child_requisition(Requisition* requisition) {
      gtk_widget_get_child_requisition(&this, requisition);
   }

   // Gets the value set with gtk_widget_set_child_visible().
   // If you feel a need to use this function, your code probably
   // needs reorganization. 
   // This function is only useful for container implementations and
   // never should be called by an application.
   // RETURNS: %TRUE if the widget is mapped with the parent.
   int get_child_visible() {
      return gtk_widget_get_child_visible(&this);
   }

   // Returns the clipboard object for the given selection to
   // be used with @widget. @widget must have a #GdkDisplay
   // associated with it, so must be attached to a toplevel
   // window.
   // clipboard already exists, a new one will
   // be created. Once a clipboard object has
   // been created, it is persistent for all time.
   // RETURNS: the appropriate clipboard object. If no
   // <selection>: a #GdkAtom which identifies the clipboard to use. %GDK_SELECTION_CLIPBOARD gives the default clipboard. Another common value is %GDK_SELECTION_PRIMARY, which gives the primary X selection.
   Clipboard* get_clipboard(Gdk2.Atom selection) {
      return gtk_widget_get_clipboard(&this, selection);
   }

   // Gets the colormap that will be used to render @widget. No reference will
   // be added to the returned colormap; it should not be unreferenced.
   // RETURNS: the colormap used by @widget
   Gdk2.Colormap* get_colormap() {
      return gtk_widget_get_colormap(&this);
   }

   // Obtains the composite name of a widget. 
   // a composite child. The string should be freed when it is no 
   // longer needed.
   // RETURNS: the composite name of @widget, or %NULL if @widget is not
   char* /*new*/ get_composite_name() {
      return gtk_widget_get_composite_name(&this);
   }

   // Gets the reading direction for a particular widget. See
   // gtk_widget_set_direction().
   // RETURNS: the reading direction for the widget.
   TextDirection get_direction() {
      return gtk_widget_get_direction(&this);
   }

   // Get the #GdkDisplay for the toplevel window associated with
   // this widget. This function can only be called after the widget
   // has been added to a widget hierarchy with a #GtkWindow at the top.
   // In general, you should only create display specific
   // resources when a widget has been realized, and you should
   // free those resources when the widget is unrealized.
   // RETURNS: the #GdkDisplay for the toplevel for this widget.
   Gdk2.Display* get_display() {
      return gtk_widget_get_display(&this);
   }

   // Determines whether the widget is double buffered.
   // See gtk_widget_set_double_buffered()
   // RETURNS: %TRUE if the widget is double buffered
   int get_double_buffered() {
      return gtk_widget_get_double_buffered(&this);
   }

   // Returns the event mask for the widget (a bitfield containing flags
   // from the #GdkEventMask enumeration). These are the events that the widget
   // will receive.
   // RETURNS: event mask for @widget
   int get_events() {
      return gtk_widget_get_events(&this);
   }

   // Retrieves the extension events the widget will receive; see
   // gdk_input_set_extension_events().
   // RETURNS: extension events for @widget
   Gdk2.ExtensionMode get_extension_events() {
      return gtk_widget_get_extension_events(&this);
   }

   // Returns the current value of the has-tooltip property.  See
   // GtkWidget:has-tooltip for more information.
   // RETURNS: current value of has-tooltip on @widget.
   int get_has_tooltip() {
      return gtk_widget_get_has_tooltip(&this);
   }

   // Determines whether @widget has a #GdkWindow of its own. See
   // gtk_widget_set_has_window().
   // RETURNS: %TRUE if @widget has a window, %FALSE otherwise
   int get_has_window() {
      return gtk_widget_get_has_window(&this);
   }

   // Whether the widget is mapped.
   // RETURNS: %TRUE if the widget is mapped, %FALSE otherwise.
   int get_mapped() {
      return gtk_widget_get_mapped(&this);
   }

   // Returns the current modifier style for the widget. (As set by
   // gtk_widget_modify_style().) If no style has previously set, a new
   // #GtkRcStyle will be created with all values unset, and set as the
   // modifier style for the widget. If you make changes to this rc
   // style, you must call gtk_widget_modify_style(), passing in the
   // returned rc style, to make sure that your changes take effect.
   // normally end up destroying it, because gtk_widget_modify_style() copies
   // the passed-in style and sets the copy as the new modifier style,
   // thus dropping any reference to the old modifier style. Add a reference
   // to the modifier style if you want to keep it alive.
   // owned by the widget. If you want to keep a pointer to value this
   // around, you must add a refcount using g_object_ref().
   // RETURNS: the modifier style for the widget. This rc style is
   RcStyle* get_modifier_style() {
      return gtk_widget_get_modifier_style(&this);
   }

   // Retrieves the name of a widget. See gtk_widget_set_name() for the
   // significance of widget names.
   // should not be modified or freed
   // RETURNS: name of the widget. This string is owned by GTK+ and
   char* get_name() {
      return gtk_widget_get_name(&this);
   }

   // Returns the current value of the GtkWidget:no-show-all property, 
   // which determines whether calls to gtk_widget_show_all() and 
   // gtk_widget_hide_all() will affect this widget.
   // RETURNS: the current value of the "no-show-all" property.
   int get_no_show_all() {
      return gtk_widget_get_no_show_all(&this);
   }

   // Gets a #PangoContext with the appropriate font map, font description,
   // and base direction for this widget. Unlike the context returned
   // by gtk_widget_create_pango_context(), this context is owned by
   // the widget (it can be used until the screen for the widget changes
   // or the widget is removed from its toplevel), and will be updated to
   // match any changes to the widget's attributes.
   // If you create and keep a #PangoLayout using this context, you must
   // deal with changes to the context by calling pango_layout_context_changed()
   // on the layout in response to the #GtkWidget::style-set and 
   // #GtkWidget::direction-changed signals for the widget.
   // RETURNS: the #PangoContext for the widget.
   Pango.Context* get_pango_context() {
      return gtk_widget_get_pango_context(&this);
   }

   // Returns the parent container of @widget.
   // RETURNS: the parent container of @widget, or %NULL
   Widget* get_parent() {
      return gtk_widget_get_parent(&this);
   }

   // Gets @widget's parent window.
   // RETURNS: the parent window of @widget.
   Gdk2.Window* get_parent_window() {
      return gtk_widget_get_parent_window(&this);
   }

   // Obtains the location of the mouse pointer in widget coordinates.
   // Widget coordinates are a bit odd; for historical reasons, they are
   // defined as @widget->window coordinates for widgets that are not
   // #GTK_NO_WINDOW widgets, and are relative to @widget->allocation.x,
   // <x>: return location for the X coordinate, or %NULL
   // <y>: return location for the Y coordinate, or %NULL
   void get_pointer(/*out*/ int* x=null, /*out*/ int* y=null) {
      gtk_widget_get_pointer(&this, x, y);
   }

   // Determines whether @widget is realized.
   // RETURNS: %TRUE if @widget is realized, %FALSE otherwise
   int get_realized() {
      return gtk_widget_get_realized(&this);
   }

   // Determines whether @widget is alyways treated as default widget
   // withing its toplevel when it has the focus, even if another widget
   // is the default.
   // See gtk_widget_set_receives_default().
   // %FALSE otherwise
   // RETURNS: %TRUE if @widget acts as default widget when focussed,
   int get_receives_default() {
      return gtk_widget_get_receives_default(&this);
   }

   // Retrieves the widget's requisition.
   // This function should only be used by widget implementations in
   // order to figure whether the widget's requisition has actually
   // changed after some internal state change (so that they can call
   // gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
   // Normally, gtk_widget_size_request() should be used.
   // <requisition>: a pointer to a #GtkRequisition to copy to
   void get_requisition(/*out*/ Requisition* requisition) {
      gtk_widget_get_requisition(&this, requisition);
   }

   // Get the root window where this widget is located. This function can
   // only be called after the widget has been added to a widget
   // hierarchy with #GtkWindow at the top.
   // The root window is useful for such purposes as creating a popup
   // #GdkWindow associated with the window. In general, you should only
   // create display specific resources when a widget has been realized,
   // and you should free those resources when the widget is unrealized.
   // RETURNS: the #GdkWindow root window for the toplevel for this widget.
   Gdk2.Window* get_root_window() {
      return gtk_widget_get_root_window(&this);
   }

   // Get the #GdkScreen from the toplevel window associated with
   // this widget. This function can only be called after the widget
   // has been added to a widget hierarchy with a #GtkWindow
   // at the top.
   // In general, you should only create screen specific
   // resources when a widget has been realized, and you should
   // free those resources when the widget is unrealized.
   // RETURNS: the #GdkScreen for the toplevel for this widget.
   Gdk2.Screen* get_screen() {
      return gtk_widget_get_screen(&this);
   }

   // Returns the widget's sensitivity (in the sense of returning
   // the value that has been set using gtk_widget_set_sensitive()).
   // The effective sensitivity of a widget is however determined by both its
   // own and its parent widget's sensitivity. See gtk_widget_is_sensitive().
   // RETURNS: %TRUE if the widget is sensitive
   int get_sensitive() {
      return gtk_widget_get_sensitive(&this);
   }

   // Gets the settings object holding the settings (global property
   // settings, RC file information, etc) used for this widget.
   // Note that this function can only be called when the #GtkWidget
   // is attached to a toplevel, since the settings object is specific
   // to a particular #GdkScreen.
   // RETURNS: the relevant #GtkSettings object
   Settings* get_settings() {
      return gtk_widget_get_settings(&this);
   }

   // Gets the size request that was explicitly set for the widget using
   // gtk_widget_set_size_request(). A value of -1 stored in @width or
   // and the natural requisition of the widget will be used intead. See
   // gtk_widget_set_size_request(). To get the size a widget will
   // actually use, call gtk_widget_size_request() instead of
   // this function.
   // <width>: return location for width, or %NULL
   // <height>: return location for height, or %NULL
   void get_size_request(/*out*/ int* width=null, /*out*/ int* height=null) {
      gtk_widget_get_size_request(&this, width, height);
   }

   // Unintrospectable method: get_snapshot() / gtk_widget_get_snapshot()
   // Create a #GdkPixmap of the contents of the widget and its children.
   // Works even if the widget is obscured. The depth and visual of the
   // resulting pixmap is dependent on the widget being snapshot and likely
   // differs from those of a target widget displaying the pixmap.
   // The function gdk_pixbuf_get_from_drawable() can be used to convert
   // the pixmap to a visual independant representation.
   // The snapshot area used by this function is the @widget's allocation plus
   // any extra space occupied by additional windows belonging to this widget
   // (such as the arrows of a spin button).
   // Thus, the resulting snapshot pixmap is possibly larger than the allocation.
   // If @clip_rect is non-%NULL, the resulting pixmap is shrunken to
   // match the specified clip_rect. The (x,y) coordinates of @clip_rect are
   // interpreted widget relative. If width or height of @clip_rect are 0 or
   // negative, the width or height of the resulting pixmap will be shrunken
   // by the respective amount.
   // For instance a @clip_rect <literal>{ +5, +5, -10, -10 }</literal> will
   // chop off 5 pixels at each side of the snapshot pixmap.
   // If non-%NULL, @clip_rect will contain the exact widget-relative snapshot
   // coordinates upon return. A @clip_rect of <literal>{ -1, -1, 0, 0 }</literal>
   // can be used to preserve the auto-grown snapshot area and use @clip_rect
   // as a pure output parameter.
   // The returned pixmap can be %NULL, if the resulting @clip_area was empty.
   // RETURNS: #GdkPixmap snapshot of the widget
   // <clip_rect>: a #GdkRectangle or %NULL
   Gdk2.Pixmap* get_snapshot(Gdk2.Rectangle* clip_rect=null) {
      return gtk_widget_get_snapshot(&this, clip_rect);
   }

   // Returns the widget's state. See gtk_widget_set_state().
   // RETURNS: the state of @widget.
   StateType get_state() {
      return gtk_widget_get_state(&this);
   }

   // Simply an accessor function that returns @widget->style.
   // RETURNS: the widget's #GtkStyle
   Style* get_style() {
      return gtk_widget_get_style(&this);
   }

   // Gets the contents of the tooltip for @widget.
   // returned string with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. You should free the
   char* /*new*/ get_tooltip_markup() {
      return gtk_widget_get_tooltip_markup(&this);
   }

   // Gets the contents of the tooltip for @widget.
   // returned string with g_free() when done.
   // RETURNS: the tooltip text, or %NULL. You should free the
   char* /*new*/ get_tooltip_text() {
      return gtk_widget_get_tooltip_text(&this);
   }

   // Returns the #GtkWindow of the current tooltip. This can be the
   // GtkWindow created by default, or the custom tooltip window set
   // using gtk_widget_set_tooltip_window().
   // RETURNS: The #GtkWindow of the current tooltip.
   Window* get_tooltip_window() {
      return gtk_widget_get_tooltip_window(&this);
   }

   // This function returns the topmost widget in the container hierarchy
   // returned as the topmost widget. No reference will be added to the
   // returned widget; it should not be unreferenced.
   // Note the difference in behavior vs. gtk_widget_get_ancestor();
   // <literal>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</literal> 
   // would return
   // %NULL if @widget wasn't inside a toplevel window, and if the
   // window was inside a #GtkWindow-derived widget which was in turn
   // inside the toplevel #GtkWindow. While the second case may
   // seem unlikely, it actually happens when a #GtkPlug is embedded
   // inside a #GtkSocket within the same application.
   // To reliably find the toplevel #GtkWindow, use
   // gtk_widget_get_toplevel() and check if the %TOPLEVEL flags
   // is set on the result.
   // |[
   // GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
   // if (gtk_widget_is_toplevel (toplevel))
   // {
   // /&ast; Perform action on toplevel. &ast;/
   // }
   // ]|
   // if there's no ancestor.
   // RETURNS: the topmost ancestor of @widget, or @widget itself
   Widget* get_toplevel() {
      return gtk_widget_get_toplevel(&this);
   }

   // Determines whether the widget is visible. Note that this doesn't
   // take into account whether the widget's parent is also visible
   // or the widget is obscured in any way.
   // See gtk_widget_set_visible().
   // RETURNS: %TRUE if the widget is visible
   int get_visible() {
      return gtk_widget_get_visible(&this);
   }

   // Gets the visual that will be used to render @widget.
   // RETURNS: the visual for @widget
   Gdk2.Visual* get_visual() {
      return gtk_widget_get_visual(&this);
   }

   // Returns the widget's window if it is realized, %NULL otherwise
   // RETURNS: @widget's window.
   Gdk2.Window* get_window() {
      return gtk_widget_get_window(&this);
   }

   // Causes @widget to become the default widget. @widget must have the
   // %GTK_CAN_DEFAULT flag set; typically you have to set this flag
   // yourself by calling <literal>gtk_widget_set_can_default (@widget,
   // %TRUE)</literal>. The default widget is activated when 
   // the user presses Enter in a window. Default widgets must be 
   // activatable, that is, gtk_widget_activate() should affect them.
   void grab_default() {
      gtk_widget_grab_default(&this);
   }

   // Causes @widget to have the keyboard focus for the #GtkWindow it's
   // inside. @widget must be a focusable widget, such as a #GtkEntry;
   // something like #GtkFrame won't work.
   // More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
   // gtk_widget_set_can_focus() to modify that flag.
   // The widget also needs to be realized and mapped. This is indicated by the
   // related signals. Grabbing the focus immediately after creating the widget
   // will likely fail and cause critical warnings.
   void grab_focus() {
      gtk_widget_grab_focus(&this);
   }

   // Determines whether @widget is the current default widget within its
   // toplevel. See gtk_widget_set_can_default().
   // its toplevel, %FALSE otherwise
   // RETURNS: %TRUE if @widget is the current default widget within
   int has_default() {
      return gtk_widget_has_default(&this);
   }

   // Determines if the widget has the global input focus. See
   // gtk_widget_is_focus() for the difference between having the global
   // input focus, and only having the focus within a toplevel.
   // RETURNS: %TRUE if the widget has the global input focus.
   int has_focus() {
      return gtk_widget_has_focus(&this);
   }

   // Determines whether the widget is currently grabbing events, so it
   // is the only widget receiving input events (keyboard and mouse).
   // See also gtk_grab_add().
   // RETURNS: %TRUE if the widget is in the grab_widgets stack
   int has_grab() {
      return gtk_widget_has_grab(&this);
   }

   // Determines if the widget style has been looked up through the rc mechanism.
   // mechanism, %FALSE otherwise.
   // RETURNS: %TRUE if the widget has been looked up through the rc
   int has_rc_style() {
      return gtk_widget_has_rc_style(&this);
   }

   // Checks whether there is a #GdkScreen is associated with
   // this widget. All toplevel widgets have an associated
   // screen, and all widgets added into a hierarchy with a toplevel
   // window at the top.
   // with the widget.
   // RETURNS: %TRUE if there is a #GdkScreen associcated
   int has_screen() {
      return gtk_widget_has_screen(&this);
   }

   // Reverses the effects of gtk_widget_show(), causing the widget to be
   // hidden (invisible to the user).
   void hide() {
      gtk_widget_hide(&this);
   }
   // Recursively hides a widget and any child widgets.
   void hide_all() {
      gtk_widget_hide_all(&this);
   }

   // Utility function; intended to be connected to the #GtkWidget::delete-event
   // signal on a #GtkWindow. The function calls gtk_widget_hide() on its
   // argument, then returns %TRUE. If connected to ::delete-event, the
   // result is that clicking the close button for a window (on the
   // window frame, top right corner usually) will hide but not destroy
   // the window. By default, GTK+ destroys windows when ::delete-event
   // is received.
   // RETURNS: %TRUE
   int hide_on_delete() {
      return gtk_widget_hide_on_delete(&this);
   }

   // Sets an input shape for this widget's GDK window. This allows for
   // windows which react to mouse click in a nonrectangular region, see 
   // gdk_window_input_shape_combine_mask() for more information.
   // <shape_mask>: shape to be added, or %NULL to remove an existing shape
   // <offset_x>: X position of shape mask with respect to @window
   // <offset_y>: Y position of shape mask with respect to @window
   void input_shape_combine_mask(Gdk2.Bitmap* shape_mask, int offset_x, int offset_y) {
      gtk_widget_input_shape_combine_mask(&this, shape_mask, offset_x, offset_y);
   }

   // Computes the intersection of a @widget's area and @area, storing
   // the intersection in @intersection, and returns %TRUE if there was
   // an intersection.  @intersection may be %NULL if you're only
   // interested in whether there was an intersection.
   // RETURNS: %TRUE if there was an intersection
   // <area>: a rectangle
   // <intersection>: rectangle to store intersection of @widget and @area
   int intersect(Gdk2.Rectangle* area, Gdk2.Rectangle* intersection) {
      return gtk_widget_intersect(&this, area, intersection);
   }

   // Determines whether @widget is somewhere inside @ancestor, possibly with
   // intermediate containers.
   // grandchild, great grandchild, etc.
   // RETURNS: %TRUE if @ancestor contains @widget as a child,
   // <ancestor>: another #GtkWidget
   int is_ancestor(Widget* ancestor) {
      return gtk_widget_is_ancestor(&this, ancestor);
   }

   // Whether @widget can rely on having its alpha channel
   // drawn correctly. On X11 this function returns whether a
   // compositing manager is running for @widget's screen.
   // Please note that the semantics of this call will change
   // in the future if used on a widget that has a composited
   // window in its hierarchy (as set by gdk_window_set_composited()).
   // channel being drawn correctly.
   // RETURNS: %TRUE if the widget can rely on its alpha
   int is_composited() {
      return gtk_widget_is_composited(&this);
   }

   // Determines whether @widget can be drawn to. A widget can be drawn
   // to if it is mapped and visible.
   // RETURNS: %TRUE if @widget is drawable, %FALSE otherwise
   int is_drawable() {
      return gtk_widget_is_drawable(&this);
   }

   // Determines if the widget is the focus widget within its
   // toplevel. (This does not mean that the %HAS_FOCUS flag is
   // necessarily set; %HAS_FOCUS will only be set if the
   // toplevel widget additionally has the global input focus.)
   // RETURNS: %TRUE if the widget is the focus widget.
   int is_focus() {
      return gtk_widget_is_focus(&this);
   }

   // Returns the widget's effective sensitivity, which means
   // it is sensitive itself and also its parent widget is sensntive
   // RETURNS: %TRUE if the widget is effectively sensitive
   int is_sensitive() {
      return gtk_widget_is_sensitive(&this);
   }

   // Determines whether @widget is a toplevel widget. Currently only
   // #GtkWindow and #GtkInvisible are toplevel widgets. Toplevel
   // widgets have no parent widget.
   // RETURNS: %TRUE if @widget is a toplevel, %FALSE otherwise
   int is_toplevel() {
      return gtk_widget_is_toplevel(&this);
   }

   // This function should be called whenever keyboard navigation within
   // a single widget hits a boundary. The function emits the
   // #GtkWidget::keynav-failed signal on the widget and its return
   // value should be interpreted in a way similar to the return value of
   // gtk_widget_child_focus():
   // When %TRUE is returned, stay in the widget, the failed keyboard
   // navigation is Ok and/or there is nowhere we can/should move the
   // focus to.
   // When %FALSE is returned, the caller should continue with keyboard
   // navigation outside the widget, e.g. by calling
   // gtk_widget_child_focus() on the widget's toplevel.
   // The default ::keynav-failed handler returns %TRUE for 
   // %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other 
   // values of #GtkDirectionType, it looks at the 
   // #GtkSettings:gtk-keynav-cursor-only setting and returns %FALSE 
   // if the setting is %TRUE. This way the entire user interface
   // becomes cursor-navigatable on input devices such as mobile phones
   // which only have cursor keys but no tab key.
   // Whenever the default handler returns %TRUE, it also calls
   // gtk_widget_error_bell() to notify the user of the failed keyboard
   // navigation.
   // A use case for providing an own implementation of ::keynav-failed 
   // (either by connecting to it or by overriding it) would be a row of
   // #GtkEntry widgets where the user should be able to navigate the
   // entire row with the cursor keys, as e.g. known from user interfaces 
   // that require entering license keys.
   // if the emitting widget should try to handle the keyboard
   // navigation attempt in its parent container(s).
   // RETURNS: %TRUE if stopping keyboard navigation is fine, %FALSE
   // <direction>: direction of focus movement
   int keynav_failed(DirectionType direction) {
      return gtk_widget_keynav_failed(&this, direction);
   }

   // Lists the closures used by @widget for accelerator group connections
   // with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
   // The closures can be used to monitor accelerator changes on @widget,
   // by connecting to the @GtkAccelGroup::accel-changed signal of the
   // #GtkAccelGroup of a closure which can be found out with
   // gtk_accel_group_from_accel_closure().
   // a newly allocated #GList of closures
   GLib2.List* /*new container*/ list_accel_closures() {
      return gtk_widget_list_accel_closures(&this);
   }

   // Returns a newly allocated list of the widgets, normally labels, for 
   // which this widget is a the target of a mnemonic (see for example, 
   // gtk_label_set_mnemonic_widget()).
   // The widgets in the list are not individually referenced. If you
   // want to iterate through the list and perform actions involving
   // callbacks that might destroy the widgets, you
   // <emphasis>must</emphasis> call <literal>g_list_foreach (result,
   // (GFunc)g_object_ref, NULL)</literal> first, and then unref all the
   // widgets afterwards.
   // mnemonic labels; free this list
   // with g_list_free() when you are done with it.
   // RETURNS: the list of
   GLib2.List* /*new container*/ list_mnemonic_labels() {
      return gtk_widget_list_mnemonic_labels(&this);
   }

   // This function is only for use in widget implementations. Causes
   // a widget to be mapped if it isn't already.
   void map() {
      gtk_widget_map(&this);
   }

   // Emits the #GtkWidget::mnemonic-activate signal.
   // The default handler for this signal activates the @widget if
   // is %TRUE.
   // RETURNS: %TRUE if the signal has been handled
   // <group_cycling>: %TRUE if there are other widgets with the same mnemonic
   int mnemonic_activate(int group_cycling) {
      return gtk_widget_mnemonic_activate(&this, group_cycling);
   }

   // Sets the base color for a widget in a particular state.
   // All other style values are left untouched. The base color
   // is the background color used along with the text color
   // (see gtk_widget_modify_text()) for widgets such as #GtkEntry
   // and #GtkTextView. See also gtk_widget_modify_style().
   // Note that "no window" widgets (which have the %GTK_NO_WINDOW flag set)
   // draw on their parent container's window and thus may not draw any 
   // background themselves. This is the case for e.g. #GtkLabel. To modify 
   // the background of such widgets, you have to set the base color on their 
   // parent; if you want to set the background of a rectangular area around 
   // a label, try placing the label in a #GtkEventBox widget and setting 
   // the base color on that.
   // <state>: the state for which to set the base color
   // <color>: the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_base().
   void modify_base(StateType state, Gdk2.Color* color=null) {
      gtk_widget_modify_base(&this, state, color);
   }

   // Sets the background color for a widget in a particular state.
   // All other style values are left untouched. See also
   // gtk_widget_modify_style(). 
   // Note that "no window" widgets (which have the %GTK_NO_WINDOW flag set)
   // draw on their parent container's window and thus may not draw any 
   // background themselves. This is the case for e.g. #GtkLabel. To modify 
   // the background of such widgets, you have to set the background color 
   // on their parent; if you want to set the background of a rectangular 
   // area around a label, try placing the label in a #GtkEventBox widget 
   // and setting the background color on that.
   // <state>: the state for which to set the background color
   // <color>: the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_bg().
   void modify_bg(StateType state, Gdk2.Color* color=null) {
      gtk_widget_modify_bg(&this, state, color);
   }

   // Sets the cursor color to use in a widget, overriding the
   // #GtkWidget:cursor-color and #GtkWidget:secondary-cursor-color
   // style properties. All other style values are left untouched. 
   // See also gtk_widget_modify_style().
   // <primary>: the color to use for primary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_cursor().
   // <secondary>: the color to use for secondary cursor (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_cursor().
   void modify_cursor(Gdk2.Color* primary, Gdk2.Color* secondary) {
      gtk_widget_modify_cursor(&this, primary, secondary);
   }

   // Sets the foreground color for a widget in a particular state.
   // All other style values are left untouched. See also
   // gtk_widget_modify_style().
   // <state>: the state for which to set the foreground color
   // <color>: the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_fg().
   void modify_fg(StateType state, Gdk2.Color* color=null) {
      gtk_widget_modify_fg(&this, state, color);
   }

   // Sets the font to use for a widget.  All other style values are left
   // untouched. See also gtk_widget_modify_style().
   // <font_desc>: the font description to use, or %NULL to undo the effect of previous calls to gtk_widget_modify_font().
   void modify_font(Pango.FontDescription* font_desc=null) {
      gtk_widget_modify_font(&this, font_desc);
   }

   // Modifies style values on the widget. Modifications made using this
   // technique take precedence over style values set via an RC file,
   // however, they will be overriden if a style is explicitely set on
   // the widget using gtk_widget_set_style(). The #GtkRcStyle structure
   // is designed so each field can either be set or unset, so it is
   // possible, using this function, to modify some style values and
   // leave the others unchanged.
   // Note that modifications made with this function are not cumulative
   // with previous calls to gtk_widget_modify_style() or with such
   // functions as gtk_widget_modify_fg(). If you wish to retain
   // previous values, you must first call gtk_widget_get_modifier_style(),
   // make your modifications to the returned style, then call
   // gtk_widget_modify_style() with that style. On the other hand,
   // if you first call gtk_widget_modify_style(), subsequent calls
   // to such functions gtk_widget_modify_fg() will have a cumulative
   // effect with the initial modifications.
   // <style>: the #GtkRcStyle holding the style modifications
   void modify_style(RcStyle* style) {
      gtk_widget_modify_style(&this, style);
   }

   // Sets the text color for a widget in a particular state.  All other
   // style values are left untouched. The text color is the foreground
   // color used along with the base color (see gtk_widget_modify_base())
   // for widgets such as #GtkEntry and #GtkTextView. See also
   // gtk_widget_modify_style().
   // <state>: the state for which to set the text color
   // <color>: the color to assign (does not need to be allocated), or %NULL to undo the effect of previous calls to of gtk_widget_modify_text().
   void modify_text(StateType state, Gdk2.Color* color=null) {
      gtk_widget_modify_text(&this, state, color);
   }

   // Obtains the full path to @widget. The path is simply the name of a
   // widget and all its parents in the container hierarchy, separated by
   // periods. The name of a widget comes from
   // gtk_widget_get_name(). Paths are used to apply styles to a widget
   // in gtkrc configuration files. Widget names are the type of the
   // widget by default (e.g. "GtkButton") or can be set to an
   // application-specific value with gtk_widget_set_name(). By setting
   // the name of a widget, you allow users or theme authors to apply
   // styles to that specific widget in their gtkrc
   // file. @path_reversed_p fills in the path in reverse order,
   // i.e. starting with @widget's name instead of starting with the name
   // of @widget's outermost ancestor.
   // <path_length>: location to store length of the path, or %NULL
   // <path>: location to store allocated path string, or %NULL
   // <path_reversed>: location to store allocated reverse path string, or %NULL
   void path(/*out*/ uint* path_length=null, /*out*/ char** path=null, /*out*/ char** path_reversed=null) {
      gtk_widget_path(&this, path_length, path, path_reversed);
   }
   // This function does the same as gtk_widget_queue_draw().
   void queue_clear() {
      gtk_widget_queue_clear(&this);
   }

   // This function is no longer different from
   // gtk_widget_queue_draw_area(), though it once was. Now it just calls
   // gtk_widget_queue_draw_area(). Originally
   // gtk_widget_queue_clear_area() would force a redraw of the
   // background for %GTK_NO_WINDOW widgets, and
   // gtk_widget_queue_draw_area() would not. Now both functions ensure
   // the background will be redrawn.
   // <x>: x coordinate of upper-left corner of rectangle to redraw
   // <y>: y coordinate of upper-left corner of rectangle to redraw
   // <width>: width of region to draw
   // <height>: height of region to draw
   void queue_clear_area(int x, int y, int width, int height) {
      gtk_widget_queue_clear_area(&this, x, y, width, height);
   }

   // Equivalent to calling gtk_widget_queue_draw_area() for the
   // entire area of a widget.
   void queue_draw() {
      gtk_widget_queue_draw(&this);
   }

   // Invalidates the rectangular area of @widget defined by @x, @y,
   // widget's window and all its child windows. Once the main loop
   // becomes idle (after the current batch of events has been processed,
   // roughly), the window will receive expose events for the union of
   // all regions that have been invalidated.
   // Normally you would only use this function in widget
   // implementations. You might also use it, or
   // gdk_window_invalidate_rect() directly, to schedule a redraw of a
   // #GtkDrawingArea or some portion thereof.
   // Frequently you can just call gdk_window_invalidate_rect() or
   // gdk_window_invalidate_region() instead of this function. Those
   // functions will invalidate only a single window, instead of the
   // widget and all its children.
   // The advantage of adding to the invalidated region compared to
   // simply drawing immediately is efficiency; using an invalid region
   // ensures that you only have to redraw one time.
   // <x>: x coordinate of upper-left corner of rectangle to redraw
   // <y>: y coordinate of upper-left corner of rectangle to redraw
   // <width>: width of region to draw
   // <height>: height of region to draw
   void queue_draw_area(int x, int y, int width, int height) {
      gtk_widget_queue_draw_area(&this, x, y, width, height);
   }

   // This function is only for use in widget implementations.
   // Flags a widget to have its size renegotiated; should
   // be called when a widget for some reason has a new size request.
   // For example, when you change the text in a #GtkLabel, #GtkLabel
   // queues a resize to ensure there's enough space for the new text.
   void queue_resize() {
      gtk_widget_queue_resize(&this);
   }

   // This function works like gtk_widget_queue_resize(), 
   // except that the widget is not invalidated.
   void queue_resize_no_redraw() {
      gtk_widget_queue_resize_no_redraw(&this);
   }

   // Creates the GDK (windowing system) resources associated with a
   // widget.  For example, @widget->window will be created when a widget
   // is realized.  Normally realization happens implicitly; if you show
   // a widget and all its parent containers, then the widget will be
   // realized and mapped automatically.
   // Realizing a widget requires all
   // the widget's parent widgets to be realized; calling
   // gtk_widget_realize() realizes the widget's parents in addition to
   // when you realize it, bad things will happen.
   // This function is primarily used in widget implementations, and
   // isn't very useful otherwise. Many times when you think you might
   // need it, a better approach is to connect to a signal that will be
   // called after the widget is realized automatically, such as
   // GtkWidget::expose-event. Or simply g_signal_connect () to the
   // GtkWidget::realize signal.
   void realize() {
      gtk_widget_realize(&this);
   }

   // Unintrospectable method: ref() / gtk_widget_ref()
   // Adds a reference to a widget. This function is exactly the same
   // as calling g_object_ref(), and exists mostly for historical
   // reasons. It can still be convenient to avoid casting a widget
   // to a #GObject, it saves a small amount of typing.
   // RETURNS: the widget that was referenced
   Widget* ref_() {
      return gtk_widget_ref(&this);
   }

   // Unintrospectable method: region_intersect() / gtk_widget_region_intersect()
   // Computes the intersection of a @widget's area and @region, returning
   // the intersection. The result may be empty, use gdk_region_empty() to
   // check.
   // RETURNS: A newly allocated region holding the intersection of @widget and @region. The coordinates of the return value are relative to @widget->window for %NO_WINDOW widgets, and relative to the parent window of @widget->window for widgets with their own window.
   // <region>: a #GdkRegion, in the same coordinate system as for %NO_WINDOW widgets; relative to the parent window of @widget->window for widgets with their own window.
   Gdk2.Region* region_intersect(Gdk2.Region* region) {
      return gtk_widget_region_intersect(&this, region);
   }

   // Removes an accelerator from @widget, previously installed with
   // gtk_widget_add_accelerator().
   // RETURNS: whether an accelerator was installed and could be removed
   // <accel_group>: accel group for this widget
   // <accel_key>: GDK keyval of the accelerator
   // <accel_mods>: modifier key combination of the accelerator
   int remove_accelerator(AccelGroup* accel_group, uint accel_key, Gdk2.ModifierType accel_mods) {
      return gtk_widget_remove_accelerator(&this, accel_group, accel_key, accel_mods);
   }

   // Removes a widget from the list of mnemonic labels for
   // this widget. (See gtk_widget_list_mnemonic_labels()). The widget
   // must have previously been added to the list with
   // gtk_widget_add_mnemonic_label().
   // <label>: a #GtkWidget that was previously set as a mnemnic label for
   void remove_mnemonic_label(Widget* label) {
      gtk_widget_remove_mnemonic_label(&this, label);
   }

   // A convenience function that uses the theme engine and RC file
   // settings for @widget to look up @stock_id and render it to
   // a pixbuf. @stock_id should be a stock icon ID such as
   // #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size
   // such as #GTK_ICON_SIZE_MENU. @detail should be a string that
   // identifies the widget or code doing the rendering, so that
   // theme engines can special-case rendering for that widget or code.
   // The pixels in the returned #GdkPixbuf are shared with the rest of
   // the application and should not be modified. The pixbuf should be freed
   // after use with g_object_unref().
   // stock ID wasn't known
   // RETURNS: a new pixbuf, or %NULL if the
   // <stock_id>: a stock ID
   // <size>: (type int) a stock size. A size of (GtkIconSize)-1 means render at the size of the source and don't scale (if there are multiple source sizes, GTK+ picks one of the available sizes).
   // <detail>: render detail to pass to theme engine
   GdkPixbuf2.Pixbuf* /*new*/ render_icon(char* stock_id, IconSize size, char* detail=null) {
      return gtk_widget_render_icon(&this, stock_id, size, detail);
   }

   // Moves a widget from one #GtkContainer to another, handling reference
   // count issues to avoid destroying the widget.
   // <new_parent>: a #GtkContainer to move the widget into
   void reparent(Widget* new_parent) {
      gtk_widget_reparent(&this, new_parent);
   }

   // Reset the styles of @widget and all descendents, so when
   // they are looked up again, they get the correct values
   // for the currently loaded RC file settings.
   // This function is not useful for applications.
   void reset_rc_styles() {
      gtk_widget_reset_rc_styles(&this);
   }
   // Recursively resets the shape on this widget and its descendants.
   void reset_shapes() {
      gtk_widget_reset_shapes(&this);
   }

   // Very rarely-used function. This function is used to emit
   // an expose event signals on a widget. This function is not
   // normally used directly. The only time it is used is when
   // propagating an expose event to a child %NO_WINDOW widget, and
   // that is normally done using gtk_container_propagate_expose().
   // If you want to force an area of a window to be redrawn, 
   // use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
   // To cause the redraw to be done immediately, follow that call
   // with a call to gdk_window_process_updates().
   // the event was handled)
   // RETURNS: return from the event signal emission (%TRUE if
   // <event>: a expose #GdkEvent
   int send_expose(Gdk2.Event* event) {
      return gtk_widget_send_expose(&this, event);
   }

   // Sends the focus change @event to @widget
   // This function is not meant to be used by applications. The only time it
   // should be used is when it is necessary for a #GtkWidget to assign focus
   // to a widget that is semantically owned by the first widget even though
   // it's not a direct child - for instance, a search entry in a floating
   // window similar to the quick search in #GtkTreeView.
   // An example of its usage is:
   // |[
   // GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
   // fevent->focus_change.type = GDK_FOCUS_CHANGE;
   // fevent->focus_change.in = TRUE;
   // fevent->focus_change.window = gtk_widget_get_window (widget);
   // if (fevent->focus_change.window != NULL)
   // g_object_ref (fevent->focus_change.window);
   // gtk_widget_send_focus_change (widget, fevent);
   // gdk_event_free (event);
   // ]|
   // if the event was handled, and %FALSE otherwise
   // RETURNS: the return value from the event signal emission: %TRUE
   // <event>: a #GdkEvent of type GDK_FOCUS_CHANGE
   int send_focus_change(Gdk2.Event* event) {
      return gtk_widget_send_focus_change(&this, event);
   }

   // Unintrospectable method: set() / gtk_widget_set()
   // Precursor of g_object_set().
   // <first_property_name>: name of first property to set
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_widget_set set; // Variadic
   +/

   // Given an accelerator group, @accel_group, and an accelerator path,
   // key binding that is defined for @accel_path is pressed, @widget
   // will be activated.  This removes any accelerators (for any
   // accelerator group) installed by previous calls to
   // gtk_widget_set_accel_path(). Associating accelerators with
   // paths allows them to be modified by the user and the modifications
   // to be saved for future use. (See gtk_accel_map_save().)
   // This function is a low level function that would most likely
   // be used by a menu creation system like #GtkUIManager. If you
   // use #GtkUIManager, setting up accelerator paths will be done
   // automatically.
   // Even when you you aren't using #GtkUIManager, if you only want to
   // set up accelerators on menu items gtk_menu_item_set_accel_path()
   // provides a somewhat more convenient interface.
   // Note that @accel_path string will be stored in a #GQuark. Therefore, if you
   // pass a static string, you can save some memory by interning it first with 
   // g_intern_static_string().
   // <accel_path>: path used to look up the accelerator
   // <accel_group>: a #GtkAccelGroup.
   void set_accel_path(char* accel_path=null, AccelGroup* accel_group=null) {
      gtk_widget_set_accel_path(&this, accel_path, accel_group);
   }

   // Sets the widget's allocation.  This should not be used
   // directly, but from within a widget's size_allocate method.
   // <allocation>: a pointer to a #GtkAllocation to copy from
   void set_allocation(Allocation* allocation) {
      gtk_widget_set_allocation(&this, allocation);
   }

   // Sets whether the application intends to draw on the widget in
   // an #GtkWidget::expose-event handler. 
   // This is a hint to the widget and does not affect the behavior of 
   // the GTK+ core; many widgets ignore this flag entirely. For widgets 
   // that do pay attention to the flag, such as #GtkEventBox and #GtkWindow, 
   // the effect is to suppress default themed drawing of the widget's 
   // background. (Children of the widget will still be drawn.) The application 
   // is then entirely responsible for drawing the widget background.
   // Note that the background is still drawn when the widget is mapped.
   // If this is not suitable (e.g. because you want to make a transparent
   // window using an RGBA visual), you can work around this by doing:
   // |[
   // gtk_widget_realize (window);
   // gdk_window_set_back_pixmap (window->window, NULL, FALSE);
   // gtk_widget_show (window);
   // ]|
   // <app_paintable>: %TRUE if the application will paint on the widget
   void set_app_paintable(int app_paintable) {
      gtk_widget_set_app_paintable(&this, app_paintable);
   }

   // Specifies whether @widget can be a default widget. See
   // gtk_widget_grab_default() for details about the meaning of
   // "default".
   // <can_default>: whether or not @widget can be a default widget.
   void set_can_default(int can_default) {
      gtk_widget_set_can_default(&this, can_default);
   }

   // Specifies whether @widget can own the input focus. See
   // gtk_widget_grab_focus() for actually setting the input focus on a
   // widget.
   // <can_focus>: whether or not @widget can own the input focus.
   void set_can_focus(int can_focus) {
      gtk_widget_set_can_focus(&this, can_focus);
   }

   // Sets whether @widget should be mapped along with its when its parent
   // is mapped and @widget has been shown with gtk_widget_show(). 
   // The child visibility can be set for widget before it is added to
   // a container with gtk_widget_set_parent(), to avoid mapping
   // children unnecessary before immediately unmapping them. However
   // it will be reset to its default state of %TRUE when the widget
   // is removed from a container.
   // Note that changing the child visibility of a widget does not
   // queue a resize on the widget. Most of the time, the size of
   // a widget is computed from all visible children, whether or
   // not they are mapped. If this is not the case, the container
   // can queue a resize itself.
   // This function is only useful for container implementations and
   // never should be called by an application.
   // <is_visible>: if %TRUE, @widget should be mapped along with its parent.
   void set_child_visible(int is_visible) {
      gtk_widget_set_child_visible(&this, is_visible);
   }

   // Sets the colormap for the widget to the given value. Widget must not
   // have been previously realized. This probably should only be used
   // from an <function>init()</function> function (i.e. from the constructor 
   // for the widget).
   // <colormap>: a colormap
   void set_colormap(Gdk2.Colormap* colormap) {
      gtk_widget_set_colormap(&this, colormap);
   }

   // Sets a widgets composite name. The widget must be
   // a composite child of its parent; see gtk_widget_push_composite_child().
   // <name>: the name to set
   void set_composite_name(char* name) {
      gtk_widget_set_composite_name(&this, name);
   }

   // Sets the reading direction on a particular widget. This direction
   // controls the primary direction for widgets containing text,
   // and also the direction in which the children of a container are
   // packed. The ability to set the direction is present in order
   // so that correct localization into languages with right-to-left
   // reading directions can be done. Generally, applications will
   // let the default reading direction present, except for containers
   // where the containers are arranged in an order that is explicitely
   // visual rather than logical (such as buttons for text justification).
   // If the direction is set to %GTK_TEXT_DIR_NONE, then the value
   // set by gtk_widget_set_default_direction() will be used.
   // <dir>: the new direction
   void set_direction(TextDirection dir) {
      gtk_widget_set_direction(&this, dir);
   }

   // Widgets are double buffered by default; you can use this function
   // to turn off the buffering. "Double buffered" simply means that
   // gdk_window_begin_paint_region() and gdk_window_end_paint() are called
   // automatically around expose events sent to the
   // widget. gdk_window_begin_paint() diverts all drawing to a widget's
   // window to an offscreen buffer, and gdk_window_end_paint() draws the
   // buffer to the screen. The result is that users see the window
   // update in one smooth step, and don't see individual graphics
   // primitives being rendered.
   // In very simple terms, double buffered widgets don't flicker,
   // so you would only use this function to turn off double buffering
   // if you had special needs and really knew what you were doing.
   // expose events, since even the clearing to the background color or 
   // pixmap will not happen automatically (as it is done in 
   // gdk_window_begin_paint()).
   // <double_buffered>: %TRUE to double-buffer a widget
   void set_double_buffered(int double_buffered) {
      gtk_widget_set_double_buffered(&this, double_buffered);
   }

   // Sets the event mask (see #GdkEventMask) for a widget. The event
   // mask determines which events a widget will receive. Keep in mind
   // that different widgets have different default event masks, and by
   // changing the event mask you may disrupt a widget's functionality,
   // so be careful. This function must be called while a widget is
   // unrealized. Consider gtk_widget_add_events() for widgets that are
   // already realized, or if you want to preserve the existing event
   // mask. This function can't be used with #GTK_NO_WINDOW widgets;
   // to get events on those widgets, place them inside a #GtkEventBox
   // and receive events on the event box.
   // <events>: event mask
   void set_events(int events) {
      gtk_widget_set_events(&this, events);
   }

   // Sets the extension events mask to @mode. See #GdkExtensionMode
   // and gdk_input_set_extension_events().
   // <mode>: bitfield of extension events to receive
   void set_extension_events(Gdk2.ExtensionMode mode) {
      gtk_widget_set_extension_events(&this, mode);
   }

   // Sets the has-tooltip property on @widget to @has_tooltip.  See
   // GtkWidget:has-tooltip for more information.
   // <has_tooltip>: whether or not @widget has a tooltip.
   void set_has_tooltip(int has_tooltip) {
      gtk_widget_set_has_tooltip(&this, has_tooltip);
   }

   // Specifies whether @widget has a #GdkWindow of its own. Note that
   // all realized widgets have a non-%NULL "window" pointer
   // (gtk_widget_get_window() never returns a %NULL window when a widget
   // is realized), but for many of them it's actually the #GdkWindow of
   // one of its parent widgets. Widgets that do not create a %window for
   // themselves in GtkWidget::realize() must announce this by
   // calling this function with @has_window = %FALSE.
   // This function should only be called by widget implementations,
   // and they should call it in their init() function.
   // <has_window>: whether or not @widget has a window.
   void set_has_window(int has_window) {
      gtk_widget_set_has_window(&this, has_window);
   }

   // Marks the widget as being realized.
   // This function should only ever be called in a derived widget's
   // "map" or "unmap" implementation.
   // <mapped>: %TRUE to mark the widget as mapped
   void set_mapped(int mapped) {
      gtk_widget_set_mapped(&this, mapped);
   }

   // Widgets can be named, which allows you to refer to them from a
   // gtkrc file. You can apply a style to widgets with a particular name
   // in the gtkrc file. See the documentation for gtkrc files (on the
   // same page as the docs for #GtkRcStyle).
   // Note that widget names are separated by periods in paths (see 
   // gtk_widget_path()), so names with embedded periods may cause confusion.
   // <name>: name for the widget
   void set_name(char* name) {
      gtk_widget_set_name(&this, name);
   }

   // Sets the #GtkWidget:no-show-all property, which determines whether 
   // calls to gtk_widget_show_all() and gtk_widget_hide_all() will affect 
   // this widget. 
   // This is mostly for use in constructing widget hierarchies with externally
   // controlled visibility, see #GtkUIManager.
   // <no_show_all>: the new value for the "no-show-all" property
   void set_no_show_all(int no_show_all) {
      gtk_widget_set_no_show_all(&this, no_show_all);
   }

   // This function is useful only when implementing subclasses of 
   // #GtkContainer.
   // Sets the container as the parent of @widget, and takes care of
   // some details such as updating the state and style of the child
   // to reflect its new location. The opposite function is
   // gtk_widget_unparent().
   // <parent>: parent container
   void set_parent(Widget* parent) {
      gtk_widget_set_parent(&this, parent);
   }

   // Sets a non default parent window for @widget.
   // <parent_window>: the new parent window.
   void set_parent_window(Gdk2.Window* parent_window) {
      gtk_widget_set_parent_window(&this, parent_window);
   }

   // Marks the widget as being realized.
   // This function should only ever be called in a derived widget's
   // "realize" or "unrealize" implementation.
   // <realized>: %TRUE to mark the widget as realized
   void set_realized(int realized) {
      gtk_widget_set_realized(&this, realized);
   }

   // Specifies whether @widget will be treated as the default widget
   // within its toplevel when it has the focus, even if another widget
   // is the default.
   // See gtk_widget_grab_default() for details about the meaning of
   // "default".
   // <receives_default>: whether or not @widget can be a default widget.
   void set_receives_default(int receives_default) {
      gtk_widget_set_receives_default(&this, receives_default);
   }

   // Sets whether the entire widget is queued for drawing when its size 
   // allocation changes. By default, this setting is %TRUE and
   // the entire widget is redrawn on every size change. If your widget
   // leaves the upper left unchanged when made bigger, turning this
   // setting off will improve performance.
   // Note that for %NO_WINDOW widgets setting this flag to %FALSE turns
   // its position changes; this is to allow containers that don't draw
   // anything to avoid excess invalidations. If you set this flag on a
   // %NO_WINDOW widget that <emphasis>does</emphasis> draw on @widget->window, 
   // you are responsible for invalidating both the old and new allocation 
   // of the widget when the widget is moved and responsible for invalidating
   // regions newly when the widget increases size.
   // <redraw_on_allocate>: if %TRUE, the entire widget will be redrawn when it is allocated to a new size. Otherwise, only the new portion of the widget will be redrawn.
   void set_redraw_on_allocate(int redraw_on_allocate) {
      gtk_widget_set_redraw_on_allocate(&this, redraw_on_allocate);
   }

   // For widgets that support scrolling, sets the scroll adjustments and
   // returns %TRUE.  For widgets that don't support scrolling, does
   // nothing and returns %FALSE. Widgets that don't support scrolling
   // can be scrolled by placing them in a #GtkViewport, which does
   // support scrolling.
   // RETURNS: %TRUE if the widget supports scrolling
   // <hadjustment>: an adjustment for horizontal scrolling, or %NULL
   // <vadjustment>: an adjustment for vertical scrolling, or %NULL
   int set_scroll_adjustments(Adjustment* hadjustment=null, Adjustment* vadjustment=null) {
      return gtk_widget_set_scroll_adjustments(&this, hadjustment, vadjustment);
   }

   // Sets the sensitivity of a widget. A widget is sensitive if the user
   // can interact with it. Insensitive widgets are "grayed out" and the
   // user can't interact with them. Insensitive widgets are known as
   // "inactive", "disabled", or "ghosted" in some other toolkits.
   // <sensitive>: %TRUE to make the widget sensitive
   void set_sensitive(int sensitive) {
      gtk_widget_set_sensitive(&this, sensitive);
   }

   // Sets the minimum size of a widget; that is, the widget's size
   // request will be @width by @height. You can use this function to
   // force a widget to be either larger or smaller than it normally
   // would be.
   // In most cases, gtk_window_set_default_size() is a better choice for
   // toplevel windows than this function; setting the default size will
   // still allow users to shrink the window. Setting the size request
   // will force them to leave the window at least as large as the size
   // request. When dealing with window sizes,
   // gtk_window_set_geometry_hints() can be a useful function as well.
   // Note the inherent danger of setting any fixed size - themes,
   // translations into other languages, different fonts, and user action
   // can all change the appropriate size for a given widget. So, it's
   // basically impossible to hardcode a size that will always be
   // correct.
   // The size request of a widget is the smallest size a widget can
   // accept while still functioning well and drawing itself correctly.
   // However in some strange cases a widget may be allocated less than
   // its requested size, and in many cases a widget may be allocated more
   // space than it requested.
   // If the size request in a given direction is -1 (unset), then
   // the "natural" size request of the widget will be used instead.
   // Widgets can't actually be allocated a size less than 1 by 1, but
   // you can pass 0,0 to this function to mean "as small as possible."
   // <width>: width @widget should request, or -1 to unset
   // <height>: height @widget should request, or -1 to unset
   void set_size_request(int width, int height) {
      gtk_widget_set_size_request(&this, width, height);
   }

   // This function is for use in widget implementations. Sets the state
   // of a widget (insensitive, prelighted, etc.) Usually you should set
   // the state using wrapper functions such as gtk_widget_set_sensitive().
   // <state>: new state for @widget
   void set_state(StateType state) {
      gtk_widget_set_state(&this, state);
   }

   // Sets the #GtkStyle for a widget (@widget->style). You probably don't
   // want to use this function; it interacts badly with themes, because
   // themes work by replacing the #GtkStyle. Instead, use
   // gtk_widget_modify_style().
   // <style>: a #GtkStyle, or %NULL to remove the effect of a previous gtk_widget_set_style() and go back to the default style
   void set_style(Style* style=null) {
      gtk_widget_set_style(&this, style);
   }

   // Sets @markup as the contents of the tooltip, which is marked up with
   // the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
   // This function will take care of setting GtkWidget:has-tooltip to %TRUE
   // and of the default handler for the GtkWidget::query-tooltip signal.
   // See also the GtkWidget:tooltip-markup property and
   // gtk_tooltip_set_markup().
   // <markup>: the contents of the tooltip for @widget, or %NULL
   void set_tooltip_markup(char* markup=null) {
      gtk_widget_set_tooltip_markup(&this, markup);
   }

   // Sets @text as the contents of the tooltip. This function will take
   // care of setting GtkWidget:has-tooltip to %TRUE and of the default
   // handler for the GtkWidget::query-tooltip signal.
   // See also the GtkWidget:tooltip-text property and gtk_tooltip_set_text().
   // <text>: the contents of the tooltip for @widget
   void set_tooltip_text(char* text) {
      gtk_widget_set_tooltip_text(&this, text);
   }

   // Replaces the default, usually yellow, window used for displaying
   // tooltips with @custom_window. GTK+ will take care of showing and
   // hiding @custom_window at the right moment, to behave likewise as
   // the default tooltip window. If @custom_window is %NULL, the default
   // tooltip window will be used.
   // If the custom window should have the default theming it needs to
   // have the name "gtk-tooltip", see gtk_widget_set_name().
   // <custom_window>: a #GtkWindow, or %NULL
   void set_tooltip_window(Window* custom_window=null) {
      gtk_widget_set_tooltip_window(&this, custom_window);
   }

   // Sets the position of a widget. The funny "u" in the name comes from
   // the "user position" hint specified by the X Window System, and
   // exists for legacy reasons. This function doesn't work if a widget
   // is inside a container; it's only really useful on #GtkWindow.
   // Don't use this function to center dialogs over the main application
   // window; most window managers will do the centering on your behalf
   // if you call gtk_window_set_transient_for(), and it's really not
   // possible to get the centering to work correctly in all cases from
   // application code. But if you insist, use gtk_window_set_position()
   // to set #GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering
   // manually.
   // Note that although @x and @y can be individually unset, the position
   // is not honoured unless both @x and @y are set.
   // <x>: x position; -1 to unset x; -2 to leave x unchanged
   // <y>: y position; -1 to unset y; -2 to leave y unchanged
   void set_uposition(int x, int y) {
      gtk_widget_set_uposition(&this, x, y);
   }

   // Sets the minimum size of a widget; that is, the widget's size
   // request will be @width by @height. You can use this function to
   // force a widget to be either larger or smaller than it is. The
   // strange "usize" name dates from the early days of GTK+, and derives
   // from X Window System terminology. In many cases,
   // gtk_window_set_default_size() is a better choice for toplevel
   // windows than this function; setting the default size will still
   // allow users to shrink the window. Setting the usize will force them
   // to leave the window at least as large as the usize. When dealing
   // with window sizes, gtk_window_set_geometry_hints() can be a useful
   // function as well.
   // Note the inherent danger of setting any fixed size - themes,
   // translations into other languages, different fonts, and user action
   // can all change the appropriate size for a given widget. So, it's
   // basically impossible to hardcode a size that will always be
   // correct.
   // <width>: minimum width, or -1 to unset
   // <height>: minimum height, or -1 to unset
   void set_usize(int width, int height) {
      gtk_widget_set_usize(&this, width, height);
   }

   // Sets the visibility state of @widget. Note that setting this to
   // %TRUE doesn't mean the widget is actually viewable, see
   // gtk_widget_get_visible().
   // This function simply calls gtk_widget_show() or gtk_widget_hide()
   // but is nicer to use when the visibility of the widget depends on
   // some condition.
   // <visible>: whether the widget should be shown or not
   void set_visible(int visible) {
      gtk_widget_set_visible(&this, visible);
   }

   // Sets a widget's window. This function should only be used in a
   // widget's GtkWidget::realize() implementation. The %window passed is
   // usually either new window created with gdk_window_new(), or the
   // window of its parent widget as returned by
   // gtk_widget_get_parent_window().
   // Widgets must indicate whether they will create their own #GdkWindow
   // by calling gtk_widget_set_has_window(). This is usually done in the
   // widget's init() function.
   // <window>: a #GdkWindow
   void set_window(Gdk2.Window* window) {
      gtk_widget_set_window(&this, window);
   }

   // Sets a shape for this widget's GDK window. This allows for
   // transparent windows etc., see gdk_window_shape_combine_mask()
   // for more information.
   // <shape_mask>: shape to be added, or %NULL to remove an existing shape
   // <offset_x>: X position of shape mask with respect to @window
   // <offset_y>: Y position of shape mask with respect to @window
   void shape_combine_mask(Gdk2.Bitmap* shape_mask, int offset_x, int offset_y) {
      gtk_widget_shape_combine_mask(&this, shape_mask, offset_x, offset_y);
   }

   // Flags a widget to be displayed. Any widget that isn't shown will
   // not appear on the screen. If you want to show all the widgets in a
   // container, it's easier to call gtk_widget_show_all() on the
   // container, instead of individually showing the widgets.
   // Remember that you have to show the containers containing a widget,
   // in addition to the widget itself, before it will appear onscreen.
   // When a toplevel container is shown, it is immediately realized and
   // mapped; other shown widgets are realized and mapped when their
   // toplevel container is realized and mapped.
   void show() {
      gtk_widget_show(&this);
   }

   // Recursively shows a widget, and any child widgets (if the widget is
   // a container).
   void show_all() {
      gtk_widget_show_all(&this);
   }

   // Shows a widget. If the widget is an unmapped toplevel widget
   // (i.e. a #GtkWindow that has not yet been shown), enter the main
   // loop and wait for the window to actually be mapped. Be careful;
   // because the main loop is running, anything can happen during
   // this function.
   void show_now() {
      gtk_widget_show_now(&this);
   }

   // This function is only used by #GtkContainer subclasses, to assign a size
   // and position to their child widgets.
   // <allocation>: position and size to be allocated to @widget
   void size_allocate(Allocation* allocation) {
      gtk_widget_size_allocate(&this, allocation);
   }

   // This function is typically used when implementing a #GtkContainer
   // subclass.  Obtains the preferred size of a widget. The container
   // uses this information to arrange its child widgets and decide what
   // size allocations to give them with gtk_widget_size_allocate().
   // You can also call this function from an application, with some
   // caveats. Most notably, getting a size request requires the widget
   // to be associated with a screen, because font information may be
   // needed. Multihead-aware applications should keep this in mind.
   // Also remember that the size request is not necessarily the size
   // a widget will actually be allocated.
   // See also gtk_widget_get_child_requisition().
   // <requisition>: a #GtkRequisition to be filled in
   void size_request(Requisition* requisition) {
      gtk_widget_size_request(&this, requisition);
   }

   // This function attaches the widget's #GtkStyle to the widget's
   // #GdkWindow. It is a replacement for
   // <programlisting>
   // widget->style = gtk_style_attach (widget->style, widget->window);
   // </programlisting>
   // and should only ever be called in a derived widget's "realize"
   // implementation which does not chain up to its parent class'
   // "realize" implementation, because one of the parent classes
   // (finally #GtkWidget) would attach the style itself.
   void style_attach() {
      gtk_widget_style_attach(&this);
   }

   // Unintrospectable method: style_get() / gtk_widget_style_get()
   // Gets the values of a multiple style properties of @widget.
   // <first_property_name>: the name of the first property to get
   /+ Not available -- variadic methods unsupported - use the C function directly.
      alias gtk_widget_style_get style_get; // Variadic
   +/

   // Gets the value of a style property of @widget.
   // <property_name>: the name of a style property
   // <value>: location to return the property value
   void style_get_property(char* property_name, GObject2.Value* value) {
      gtk_widget_style_get_property(&this, property_name, value);
   }

   // Unintrospectable method: style_get_valist() / gtk_widget_style_get_valist()
   // Non-vararg variant of gtk_widget_style_get(). Used primarily by language 
   // bindings.
   // <first_property_name>: the name of the first property to get
   // <var_args>: a <type>va_list</type> of pairs of property names and locations to return the property values, starting with the location for @first_property_name.
   void style_get_valist(char* first_property_name, va_list var_args) {
      gtk_widget_style_get_valist(&this, first_property_name, var_args);
   }

   // Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
   // This causes all queued #GtkWidget::child-notify signals on @widget to be 
   // emitted.
   void thaw_child_notify() {
      gtk_widget_thaw_child_notify(&this);
   }

   // Translate coordinates relative to @src_widget's allocation to coordinates
   // relative to @dest_widget's allocations. In order to perform this
   // operation, both widgets must be realized, and must share a common
   // toplevel.
   // was no common ancestor. In this case, nothing is stored in
   // *@dest_x and *@dest_y. Otherwise %TRUE.
   // RETURNS: %FALSE if either widget was not realized, or there
   // <dest_widget>: a #GtkWidget
   // <src_x>: X position relative to @src_widget
   // <src_y>: Y position relative to @src_widget
   // <dest_x>: location to store X position relative to @dest_widget
   // <dest_y>: location to store Y position relative to @dest_widget
   int translate_coordinates(Widget* dest_widget, int src_x, int src_y, /*out*/ int* dest_x, /*out*/ int* dest_y) {
      return gtk_widget_translate_coordinates(&this, dest_widget, src_x, src_y, dest_x, dest_y);
   }

   // Triggers a tooltip query on the display where the toplevel of @widget
   // is located. See gtk_tooltip_trigger_tooltip_query() for more
   // information.
   void trigger_tooltip_query() {
      gtk_widget_trigger_tooltip_query(&this);
   }

   // This function is only for use in widget implementations. Causes
   // a widget to be unmapped if it's currently mapped.
   void unmap() {
      gtk_widget_unmap(&this);
   }

   // This function is only for use in widget implementations.
   // Should be called by implementations of the remove method
   // on #GtkContainer, to dissociate a child from the container.
   void unparent() {
      gtk_widget_unparent(&this);
   }

   // This function is only useful in widget implementations.
   // Causes a widget to be unrealized (frees all GDK resources
   // associated with the widget, such as @widget->window).
   void unrealize() {
      gtk_widget_unrealize(&this);
   }
   // Inverse of gtk_widget_ref(). Equivalent to g_object_unref().
   void unref() {
      gtk_widget_unref(&this);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_accel_closures_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:"accel-closures-changed", CB/*:signal_accel_closures_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"accel-closures-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::button-press-event signal will be emitted when a button
   // (typically from a mouse) is pressed.
   // To receive this signal, the #GdkWindow associated to the 
   // widget needs to enable the #GDK_BUTTON_PRESS_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventButton which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventButton* event, void* user_data=null) signal_button_press_event;
   ulong signal_connect(string name:"button-press-event", CB/*:signal_button_press_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"button-press-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::button-release-event signal will be emitted when a button
   // (typically from a mouse) is released.
   // To receive this signal, the #GdkWindow associated to the 
   // widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventButton which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventButton* event, void* user_data=null) signal_button_release_event;
   ulong signal_connect(string name:"button-release-event", CB/*:signal_button_release_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"button-release-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Determines whether an accelerator that activates the signal
   // identified by @signal_id can currently be activated.
   // This signal is present to allow applications and derived
   // widgets to override the default #GtkWidget handling
   // for determining whether an accelerator can be activated.
   // RETURNS: %TRUE if the signal can be activated.
   // <signal_id>: the ID of a signal installed on @widget
   extern (C) alias static c_int function (Widget* this_, c_uint signal_id, void* user_data=null) signal_can_activate_accel;
   ulong signal_connect(string name:"can-activate-accel", CB/*:signal_can_activate_accel*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"can-activate-accel",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Unintrospectable glib:signal: child-notify() / ()
   // The ::child-notify signal is emitted for each 
   // <link linkend="child-properties">child property</link>  that has
   // changed on an object. The signal's detail holds the property name.
   // <pspec>: the #GParamSpec of the changed child property
   extern (C) alias static void function (Widget* this_, void* pspec, void* user_data=null) signal_child_notify;
   ulong signal_connect(string name:"child-notify", CB/*:signal_child_notify*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"child-notify",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::client-event will be emitted when the @widget's window
   // receives a message (via a ClientMessage event) from another
   // application.
   // the event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for
   // <event>: the #GdkEventClient which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventClient* event, void* user_data=null) signal_client_event;
   ulong signal_connect(string name:"client-event", CB/*:signal_client_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"client-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::composited-changed signal is emitted when the composited
   // status of @widget<!-- -->s screen changes. 
   // See gdk_screen_is_composited().
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_composited_changed;
   ulong signal_connect(string name:"composited-changed", CB/*:signal_composited_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"composited-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::configure-event signal will be emitted when the size, position or
   // stacking of the @widget's window has changed.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
   // automatically for all new windows.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventConfigure which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventConfigure* event, void* user_data=null) signal_configure_event;
   ulong signal_connect(string name:"configure-event", CB/*:signal_configure_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"configure-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a redirected window belonging to @widget gets drawn into.
   // The region/area members of the event shows what area of the redirected
   // drawable was drawn into.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventExpose event
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_damage_event;
   ulong signal_connect(string name:"damage-event", CB/*:signal_damage_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"damage-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::delete-event signal is emitted if a user requests that
   // a toplevel window is closed. The default handler for this signal
   // destroys the window. Connecting gtk_widget_hide_on_delete() to
   // this signal will cause the window to be hidden instead, so that
   // it can later be shown again without reconstructing it.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the event which triggered this signal
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_delete_event;
   ulong signal_connect(string name:"delete-event", CB/*:signal_delete_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"delete-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::destroy-event signal is emitted when a #GdkWindow is destroyed.
   // You rarely get this signal, because most widgets disconnect themselves 
   // from their window before they destroy it, so no widget owns the 
   // window at destroy time.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
   // automatically for all new windows.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the event which triggered this signal
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_destroy_event;
   ulong signal_connect(string name:"destroy-event", CB/*:signal_destroy_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"destroy-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::direction-changed signal is emitted when the text direction
   // of a widget changes.
   // <previous_direction>: the previous text direction of @widget
   extern (C) alias static void function (Widget* this_, TextDirection* previous_direction, void* user_data=null) signal_direction_changed;
   ulong signal_connect(string name:"direction-changed", CB/*:signal_direction_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"direction-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-begin signal is emitted on the drag source when a drag is 
   // started. A typical reason to connect to this signal is to set up a 
   // custom drag icon with gtk_drag_source_set_icon().
   // Note that some widgets set up a drag icon in the default handler of
   // this signal, so you may have to use g_signal_connect_after() to
   // override what the default handler did.
   // <drag_context>: the drag context
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, void* user_data=null) signal_drag_begin;
   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);
   }

   // The ::drag-data-delete signal is emitted on the drag source when a drag 
   // with the action %GDK_ACTION_MOVE is successfully completed. The signal 
   // handler is responsible for deleting the data that has been dropped. What 
   // "delete" means depends on the context of the drag operation.
   // <drag_context>: the drag context
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, void* user_data=null) signal_drag_data_delete;
   ulong signal_connect(string name:"drag-data-delete", CB/*:signal_drag_data_delete*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-data-delete",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-data-get signal is emitted on the drag source when the drop 
   // site requests the data which is dragged. It is the responsibility of 
   // the signal handler to fill @data with the data in the format which 
   // is indicated by @info. See gtk_selection_data_set() and 
   // gtk_selection_data_set_text().
   // <drag_context>: the drag context
   // <data>: the #GtkSelectionData to be filled with the dragged data
   // <info>: the info that has been registered with the target in the #GtkTargetList
   // <time>: the timestamp at which the data was requested
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, SelectionData* data, c_uint info, c_uint time, void* user_data=null) signal_drag_data_get;
   ulong signal_connect(string name:"drag-data-get", CB/*:signal_drag_data_get*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-data-get",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-data-received signal is emitted on the drop site when the 
   // dragged data has been received. If the data was received in order to 
   // determine whether the drop will be accepted, the handler is expected 
   // to call gdk_drag_status() and <emphasis>not</emphasis> finish the drag. 
   // If the data was received in response to a #GtkWidget::drag-drop signal 
   // (and this is the last target to be received), the handler for this 
   // signal is expected to process the received data and then call 
   // gtk_drag_finish(), setting the @success parameter depending on whether 
   // the data was processed successfully. 
   // The handler may inspect and modify @drag_context->action before calling 
   // gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as shown in the 
   // following example:
   // |[
   // void  
   // drag_data_received (GtkWidget          *widget,
   // GdkDragContext     *drag_context,
   // gint                x,
   // gint                y,
   // GtkSelectionData   *data,
   // guint               info,
   // guint               time)
   // {
   // if ((data->length >= 0) && (data->format == 8))
   // {
   // if (drag_context->action == GDK_ACTION_ASK) 
   // {
   // GtkWidget *dialog;
   // gint response;
   // dialog = gtk_message_dialog_new (NULL,
   // GTK_DIALOG_MODAL | 
   // GTK_DIALOG_DESTROY_WITH_PARENT,
   // GTK_MESSAGE_INFO,
   // GTK_BUTTONS_YES_NO,
   // "Move the data ?\n");
   // response = gtk_dialog_run (GTK_DIALOG (dialog));
   // gtk_widget_destroy (dialog);
   // if (response == GTK_RESPONSE_YES)
   // drag_context->action = GDK_ACTION_MOVE;
   // else
   // drag_context->action = GDK_ACTION_COPY;
   // }
   // gtk_drag_finish (drag_context, TRUE, FALSE, time);
   // return;
   // }
   // gtk_drag_finish (drag_context, FALSE, FALSE, time);
   // }
   // ]|
   // <drag_context>: the drag context
   // <x>: where the drop happened
   // <y>: where the drop happened
   // <data>: the received data
   // <info>: the info that has been registered with the target in the #GtkTargetList
   // <time>: the timestamp at which the data was received
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, int x, int y, SelectionData* data, c_uint info, c_uint time, void* user_data=null) signal_drag_data_received;
   ulong signal_connect(string name:"drag-data-received", CB/*:signal_drag_data_received*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-data-received",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-drop signal is emitted on the drop site when the user drops 
   // the data onto the widget. The signal handler must determine whether 
   // the cursor position is in a drop zone or not. If it is not in a drop 
   // zone, it returns %FALSE and no further processing is necessary. 
   // Otherwise, the handler returns %TRUE. In this case, the handler must 
   // ensure that gtk_drag_finish() is called to let the source know that 
   // the drop is done. The call to gtk_drag_finish() can be done either 
   // directly or in a #GtkWidget::drag-data-received handler which gets 
   // triggered by calling gtk_drag_get_data() to receive the data for one 
   // or more of the supported targets.
   // RETURNS: whether the cursor position is in a drop zone
   // <drag_context>: the drag context
   // <x>: the x coordinate of the current cursor position
   // <y>: the y coordinate of the current cursor position
   // <time>: the timestamp of the motion event
   extern (C) alias static c_int function (Widget* this_, Gdk2.DragContext* drag_context, int x, int y, c_uint time, void* user_data=null) signal_drag_drop;
   ulong signal_connect(string name:"drag-drop", CB/*:signal_drag_drop*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-drop",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-end signal is emitted on the drag source when a drag is 
   // finished.  A typical reason to connect to this signal is to undo 
   // things done in #GtkWidget::drag-begin.
   // <drag_context>: the drag context
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, 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);
   }

   // The ::drag-failed signal is emitted on the drag source when a drag has
   // failed. The signal handler may hook custom code to handle a failed DND
   // operation based on the type of error, it returns %TRUE is the failure has
   // been already handled (not showing the default "drag operation failed"
   // animation), otherwise it returns %FALSE.
   // RETURNS: %TRUE if the failed drag operation has been already handled.
   // <drag_context>: the drag context
   // <result>: the result of the drag operation
   extern (C) alias static c_int function (Widget* this_, Gdk2.DragContext* drag_context, DragResult* result, void* user_data=null) signal_drag_failed;
   ulong signal_connect(string name:"drag-failed", CB/*:signal_drag_failed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-failed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::drag-leave signal is emitted on the drop site when the cursor 
   // leaves the widget. A typical reason to connect to this signal is to 
   // undo things done in #GtkWidget::drag-motion, e.g. undo highlighting 
   // with gtk_drag_unhighlight()
   // <drag_context>: the drag context
   // <time>: the timestamp of the motion event
   extern (C) alias static void function (Widget* this_, Gdk2.DragContext* drag_context, c_uint time, void* user_data=null) signal_drag_leave;
   ulong signal_connect(string name:"drag-leave", CB/*:signal_drag_leave*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"drag-leave",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The drag-motion signal is emitted on the drop site when the user
   // moves the cursor over the widget during a drag. The signal handler
   // must determine whether the cursor position is in a drop zone or not.
   // If it is not in a drop zone, it returns %FALSE and no further processing
   // is necessary. Otherwise, the handler returns %TRUE. In this case, the
   // handler is responsible for providing the necessary information for
   // displaying feedback to the user, by calling gdk_drag_status().
   // If the decision whether the drop will be accepted or rejected can't be
   // made based solely on the cursor position and the type of the data, the
   // handler may inspect the dragged data by calling gtk_drag_get_data() and
   // defer the gdk_drag_status() call to the #GtkWidget::drag-data-received
   // handler. Note that you cannot not pass #GTK_DEST_DEFAULT_DROP,
   // #GTK_DEST_DEFAULT_MOTION or #GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set()
   // when using the drag-motion signal that way.
   // Also note that there is no drag-enter signal. The drag receiver has to
   // keep track of whether he has received any drag-motion signals since the
   // last #GtkWidget::drag-leave and if not, treat the drag-motion signal as
   // an "enter" signal. Upon an "enter", the handler will typically highlight
   // the drop site with gtk_drag_highlight().
   // |[
   // static void
   // drag_motion (GtkWidget *widget,
   // GdkDragContext *context,
   // gint x,
   // gint y,
   // guint time)
   // {
   // GdkAtom target;
   // PrivateData *private_data = GET_PRIVATE_DATA (widget);
   // if (!private_data->drag_highlight) 
   // {
   // private_data->drag_highlight = 1;
   // gtk_drag_highlight (widget);
   // }
   // target = gtk_drag_dest_find_target (widget, context, NULL);
   // if (target == GDK_NONE)
   // gdk_drag_status (context, 0, time);
   // else 
   // {
   // private_data->pending_status = context->suggested_action;
   // gtk_drag_get_data (widget, context, target, time);
   // }
   // return TRUE;
   // }
   // static void
   // drag_data_received (GtkWidget        *widget,
   // GdkDragContext   *context,
   // gint              x,
   // gint              y,
   // GtkSelectionData *selection_data,
   // guint             info,
   // guint             time)
   // {
   // PrivateData *private_data = GET_PRIVATE_DATA (widget);
   // if (private_data->suggested_action) 
   // {
   // private_data->suggested_action = 0;
   // /&ast; We are getting this data due to a request in drag_motion,
   // * rather than due to a request in drag_drop, so we are just
   // * supposed to call gdk_drag_status (), not actually paste in 
   // * the data.
   // &ast;/
   // str = gtk_selection_data_get_text (selection_data);
   // if (!data_is_acceptable (str)) 
   // gdk_drag_status (context, 0, time);
   // else
   // gdk_drag_status (context, private_data->suggested_action, time);
   // }
   // else
   // {
   // /&ast; accept the drop &ast;/
   // }
   // }
   // ]|
   // RETURNS: whether the cursor position is in a drop zone
   // <drag_context>: the drag context
   // <x>: the x coordinate of the current cursor position
   // <y>: the y coordinate of the current cursor position
   // <time>: the timestamp of the motion event
   extern (C) alias static c_int function (Widget* this_, Gdk2.DragContext* drag_context, int x, int y, c_uint time, 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);
   }

   // The ::enter-notify-event will be emitted when the pointer enters
   // the @widget's window.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_ENTER_NOTIFY_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventCrossing which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventCrossing* event, void* user_data=null) signal_enter_notify_event;
   ulong signal_connect(string name:"enter-notify-event", CB/*:signal_enter_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"enter-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The GTK+ main loop will emit three signals for each GDK event delivered
   // signal that matches the type of event delivered (e.g. 
   // #GtkWidget::key-press-event) and finally a generic 
   // #GtkWidget::event-after signal.
   // and to cancel the emission of the second specific ::event signal.
   // %FALSE to propagate the event further and to allow the emission of 
   // the second signal. The ::event-after signal is emitted regardless of
   // the return value.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event
   // <event>: the #GdkEvent which triggered this signal
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_event;
   ulong signal_connect(string name:"event", CB/*:signal_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // After the emission of the #GtkWidget::event signal and (optionally) 
   // the second more specific signal, ::event-after will be emitted 
   // regardless of the previous two signals handlers return values.
   // <event>: the #GdkEvent which triggered this signal
   extern (C) alias static void function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_event_after;
   ulong signal_connect(string name:"event-after", CB/*:signal_event_after*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"event-after",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::expose-event signal is emitted when an area of a previously
   // obscured #GdkWindow is made visible and needs to be redrawn.
   // #GTK_NO_WINDOW widgets will get a synthesized event from their parent
   // widget.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_EXPOSURE_MASK mask.
   // Note that the ::expose-event signal has been replaced by a ::draw
   // signal in GTK+ 3. The <link linkend="http://library.gnome.org/devel/gtk3/3.0/gtk-migrating-2-to-3.html">GTK+ 3 migration guide</link>
   // for hints on how to port from ::expose-event to ::draw.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventExpose which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventExpose* event, void* user_data=null) signal_expose_event;
   ulong signal_connect(string name:"expose-event", CB/*:signal_expose_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"expose-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // RETURNS: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
   // <returns>: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
   extern (C) alias static c_int function (Widget* this_, DirectionType* returns, void* user_data=null) signal_focus;
   ulong signal_connect(string name:"focus", CB/*:signal_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::focus-in-event signal will be emitted when the keyboard focus
   // enters the @widget's window.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_FOCUS_CHANGE_MASK mask.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventFocus which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventFocus* event, void* user_data=null) signal_focus_in_event;
   ulong signal_connect(string name:"focus-in-event", CB/*:signal_focus_in_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"focus-in-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::focus-out-event signal will be emitted when the keyboard focus
   // leaves the @widget's window.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_FOCUS_CHANGE_MASK mask.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventFocus which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventFocus* event, void* user_data=null) signal_focus_out_event;
   ulong signal_connect(string name:"focus-out-event", CB/*:signal_focus_out_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"focus-out-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when a pointer or keyboard grab on a window belonging 
   // to @widget gets broken. 
   // On X11, this happens when the grab window becomes unviewable 
   // (i.e. it or one of its ancestors is unmapped), or if the same 
   // application grabs the pointer or keyboard again.
   // the event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for
   // <event>: the #GdkEventGrabBroken event
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* event, void* user_data=null) signal_grab_broken_event;
   ulong signal_connect(string name:"grab-broken-event", CB/*:signal_grab_broken_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"grab-broken-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_grab_focus;
   ulong signal_connect(string name:"grab-focus", CB/*:signal_grab_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"grab-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::grab-notify signal is emitted when a widget becomes
   // shadowed by a GTK+ grab (not a pointer or keyboard grab) on 
   // another widget, or when it becomes unshadowed due to a grab 
   // being removed.
   // A widget is shadowed by a gtk_grab_add() when the topmost 
   // grab widget in the grab stack of its window group is not 
   // its ancestor.
   // <was_grabbed>: %FALSE if the widget becomes shadowed, %TRUE if it becomes unshadowed
   extern (C) alias static void function (Widget* this_, c_int was_grabbed, void* user_data=null) signal_grab_notify;
   ulong signal_connect(string name:"grab-notify", CB/*:signal_grab_notify*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"grab-notify",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_hide;
   ulong signal_connect(string name:"hide", CB/*:signal_hide*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"hide",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::hierarchy-changed signal is emitted when the
   // anchored state of a widget changes. A widget is
   // <firstterm>anchored</firstterm> when its toplevel
   // ancestor is a #GtkWindow. This signal is emitted when
   // a widget changes from un-anchored to anchored or vice-versa.
   // <previous_toplevel>: the previous toplevel ancestor, or %NULL if the widget was previously unanchored
   extern (C) alias static void function (Widget* this_, Widget* previous_toplevel=null, void* user_data=null) signal_hierarchy_changed;
   ulong signal_connect(string name:"hierarchy-changed", CB/*:signal_hierarchy_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"hierarchy-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::key-press-event signal is emitted when a key is pressed.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_KEY_PRESS_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventKey which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventKey* event, void* user_data=null) signal_key_press_event;
   ulong signal_connect(string name:"key-press-event", CB/*:signal_key_press_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"key-press-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::key-release-event signal is emitted when a key is pressed.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_KEY_RELEASE_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventKey which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventKey* event, void* user_data=null) signal_key_release_event;
   ulong signal_connect(string name:"key-release-event", CB/*:signal_key_release_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"key-release-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Gets emitted if keyboard navigation fails. 
   // See gtk_widget_keynav_failed() for details.
   // if the emitting widget should try to handle the keyboard
   // navigation attempt in its parent container(s).
   // RETURNS: %TRUE if stopping keyboard navigation is fine, %FALSE
   // <direction>: the direction of movement
   extern (C) alias static c_int function (Widget* this_, DirectionType* direction, void* user_data=null) signal_keynav_failed;
   ulong signal_connect(string name:"keynav-failed", CB/*:signal_keynav_failed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"keynav-failed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::leave-notify-event will be emitted when the pointer leaves
   // the @widget's window.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_LEAVE_NOTIFY_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventCrossing which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventCrossing* event, void* user_data=null) signal_leave_notify_event;
   ulong signal_connect(string name:"leave-notify-event", CB/*:signal_leave_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"leave-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_map;
   ulong signal_connect(string name:"map", CB/*:signal_map*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"map",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::map-event signal will be emitted when the @widget's window is
   // mapped. A window is mapped when it becomes visible on the screen.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
   // automatically for all new windows.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventAny which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventAny* event, void* user_data=null) signal_map_event;
   ulong signal_connect(string name:"map-event", CB/*:signal_map_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"map-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Widget* this_, c_int object, void* user_data=null) signal_mnemonic_activate;
   ulong signal_connect(string name:"mnemonic-activate", CB/*:signal_mnemonic_activate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"mnemonic-activate",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::motion-notify-event signal is emitted when the pointer moves 
   // over the widget's #GdkWindow.
   // To receive this signal, the #GdkWindow associated to the widget 
   // needs to enable the #GDK_POINTER_MOTION_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventMotion which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventMotion* event, void* user_data=null) signal_motion_notify_event;
   ulong signal_connect(string name:"motion-notify-event", CB/*:signal_motion_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"motion-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, DirectionType* object, void* user_data=null) signal_move_focus;
   ulong signal_connect(string name:"move-focus", CB/*:signal_move_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"move-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::no-expose-event will be emitted when the @widget's window is 
   // drawn as a copy of another #GdkDrawable (with gdk_draw_drawable() or
   // gdk_window_copy_area()) which was completely unobscured. If the source
   // window was partially obscured #GdkEventExpose events will be generated
   // for those areas.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventNoExpose which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventNoExpose* event, void* user_data=null) signal_no_expose_event;
   ulong signal_connect(string name:"no-expose-event", CB/*:signal_no_expose_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"no-expose-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::parent-set signal is emitted when a new parent 
   // has been set on a widget.
   // <old_parent>: the previous parent, or %NULL if the widget just got its initial parent.
   extern (C) alias static void function (Widget* this_, Widget* old_parent=null, void* user_data=null) signal_parent_set;
   ulong signal_connect(string name:"parent-set", CB/*:signal_parent_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"parent-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // This signal gets emitted whenever a widget should pop up a context 
   // menu. This usually happens through the standard key binding mechanism; 
   // by pressing a certain key while a widget is focused, the user can cause 
   // the widget to pop up a menu.  For example, the #GtkEntry widget creates 
   // a menu with clipboard commands. See <xref linkend="checklist-popup-menu"/> 
   // for an example of how to use this signal.
   // RETURNS: %TRUE if a menu was activated
   extern (C) alias static c_int function (Widget* this_, void* user_data=null) signal_popup_menu;
   ulong signal_connect(string name:"popup-menu", CB/*:signal_popup_menu*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"popup-menu",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::property-notify-event signal will be emitted when a property on
   // the @widget's window has been changed or deleted.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_PROPERTY_CHANGE_MASK mask.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventProperty which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventProperty* event, void* user_data=null) signal_property_notify_event;
   ulong signal_connect(string name:"property-notify-event", CB/*:signal_property_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"property-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // To receive this signal the #GdkWindow associated to the widget needs
   // to enable the #GDK_PROXIMITY_IN_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventProximity which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventProximity* event, void* user_data=null) signal_proximity_in_event;
   ulong signal_connect(string name:"proximity-in-event", CB/*:signal_proximity_in_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"proximity-in-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // To receive this signal the #GdkWindow associated to the widget needs
   // to enable the #GDK_PROXIMITY_OUT_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventProximity which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventProximity* event, void* user_data=null) signal_proximity_out_event;
   ulong signal_connect(string name:"proximity-out-event", CB/*:signal_proximity_out_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"proximity-out-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // Emitted when #GtkWidget:has-tooltip is %TRUE and the #GtkSettings:gtk-tooltip-timeout 
   // has expired with the cursor hovering "above" @widget; or emitted when @widget got 
   // focus in keyboard mode.
   // Using the given coordinates, the signal handler should determine
   // whether a tooltip should be shown for @widget. If this is the case
   // %TRUE should be returned, %FALSE otherwise.  Note that if
   // should not be used.
   // The signal handler is free to manipulate @tooltip with the therefore
   // destined function calls.
   // RETURNS: %TRUE if @tooltip should be shown right now, %FALSE otherwise.
   // <x>: the x coordinate of the cursor position where the request has been emitted, relative to @widget->window
   // <y>: the y coordinate of the cursor position where the request has been emitted, relative to @widget->window
   // <keyboard_mode>: %TRUE if the tooltip was trigged using the keyboard
   // <tooltip>: a #GtkTooltip
   extern (C) alias static c_int function (Widget* this_, int x, int y, c_int keyboard_mode, Tooltip* tooltip, void* user_data=null) signal_query_tooltip;
   ulong signal_connect(string name:"query-tooltip", CB/*:signal_query_tooltip*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"query-tooltip",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_realize;
   ulong signal_connect(string name:"realize", CB/*:signal_realize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"realize",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::screen-changed signal gets emitted when the
   // screen of a widget has changed.
   // <previous_screen>: the previous screen, or %NULL if the widget was not associated with a screen before
   extern (C) alias static void function (Widget* this_, Gdk2.Screen* previous_screen=null, void* user_data=null) signal_screen_changed;
   ulong signal_connect(string name:"screen-changed", CB/*:signal_screen_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"screen-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::scroll-event signal is emitted when a button in the 4 to 7
   // range is pressed. Wheel mice are usually configured to generate 
   // button press events for buttons 4 and 5 when the wheel is turned.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_BUTTON_PRESS_MASK mask.
   // This signal will be sent to the grab widget if there is one.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventScroll which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventScroll* event, void* user_data=null) signal_scroll_event;
   ulong signal_connect(string name:"scroll-event", CB/*:signal_scroll_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"scroll-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::selection-clear-event signal will be emitted when the
   // the @widget's window has lost ownership of a selection.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventSelection which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventSelection* event, void* user_data=null) signal_selection_clear_event;
   ulong signal_connect(string name:"selection-clear-event", CB/*:signal_selection_clear_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-clear-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, SelectionData* object, c_uint p0, c_uint p1, void* user_data=null) signal_selection_get;
   ulong signal_connect(string name:"selection-get", CB/*:signal_selection_get*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-get",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // RETURNS: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
   // <returns>: %TRUE to stop other handlers from being invoked for the event. %FALSE to propagate the event further.
   extern (C) alias static c_int function (Widget* this_, Gdk2.Event* returns, void* user_data=null) signal_selection_notify_event;
   ulong signal_connect(string name:"selection-notify-event", CB/*:signal_selection_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, SelectionData* object, c_uint p0, void* user_data=null) signal_selection_received;
   ulong signal_connect(string name:"selection-received", CB/*:signal_selection_received*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-received",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::selection-request-event signal will be emitted when
   // another client requests ownership of the selection owned by
   // the @widget's window.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventSelection which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventSelection* event, void* user_data=null) signal_selection_request_event;
   ulong signal_connect(string name:"selection-request-event", CB/*:signal_selection_request_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"selection-request-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_show;
   ulong signal_connect(string name:"show", CB/*:signal_show*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"show",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Widget* this_, WidgetHelpType* object, void* user_data=null) signal_show_help;
   ulong signal_connect(string name:"show-help", CB/*:signal_show_help*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"show-help",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, Gdk2.Rectangle* object, void* user_data=null) signal_size_allocate;
   ulong signal_connect(string name:"size-allocate", CB/*:signal_size_allocate*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"size-allocate",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, Requisition* object, void* user_data=null) signal_size_request;
   ulong signal_connect(string name:"size-request", CB/*:signal_size_request*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"size-request",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::state-changed signal is emitted when the widget state changes.
   // See gtk_widget_get_state().
   // <state>: the previous state
   extern (C) alias static void function (Widget* this_, StateType* state, void* user_data=null) signal_state_changed;
   ulong signal_connect(string name:"state-changed", CB/*:signal_state_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"state-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::style-set signal is emitted when a new style has been set 
   // on a widget. Note that style-modifying functions like 
   // gtk_widget_modify_base() also cause this signal to be emitted.
   // <previous_style>: the previous style, or %NULL if the widget just got its initial style
   extern (C) alias static void function (Widget* this_, Style* previous_style=null, void* user_data=null) signal_style_set;
   ulong signal_connect(string name:"style-set", CB/*:signal_style_set*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"style-set",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_unmap;
   ulong signal_connect(string name:"unmap", CB/*:signal_unmap*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unmap",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::unmap-event signal will be emitted when the @widget's window is
   // unmapped. A window is unmapped when it becomes invisible on the screen.
   // To receive this signal, the #GdkWindow associated to the widget needs
   // to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
   // automatically for all new windows.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventAny which triggered this signal
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventAny* event, void* user_data=null) signal_unmap_event;
   ulong signal_connect(string name:"unmap-event", CB/*:signal_unmap_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unmap-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Widget* this_, void* user_data=null) signal_unrealize;
   ulong signal_connect(string name:"unrealize", CB/*:signal_unrealize*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"unrealize",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::visibility-notify-event will be emitted when the @widget's window
   // is obscured or unobscured.
   // To receive this signal the #GdkWindow associated to the widget needs
   // to enable the #GDK_VISIBILITY_NOTIFY_MASK mask.
   // %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the event.
   // <event>: the #GdkEventVisibility which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventVisibility* event, void* user_data=null) signal_visibility_notify_event;
   ulong signal_connect(string name:"visibility-notify-event", CB/*:signal_visibility_notify_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"visibility-notify-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::window-state-event will be emitted when the state of the 
   // toplevel window associated to the @widget changes.
   // To receive this signal the #GdkWindow associated to the widget 
   // needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable 
   // this mask automatically for all new windows.
   // event. %FALSE to propagate the event further.
   // RETURNS: %TRUE to stop other handlers from being invoked for the
   // <event>: the #GdkEventWindowState which triggered this signal.
   extern (C) alias static c_int function (Widget* this_, Gdk2.EventWindowState* event, void* user_data=null) signal_window_state_event;
   ulong signal_connect(string name:"window-state-event", CB/*:signal_window_state_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"window-state-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct WidgetAuxInfo {
   int x, y, width, height;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "x_set", 1,
   uint, "y_set", 1,
    uint, "__dummy32A", 30));
}


// <structfield>activate_signal</structfield>
// The signal to emit when a widget of this class is activated,
// gtk_widget_activate() handles the emission. Implementation of this
// signal is optional.
// <structfield>set_scroll_adjustment_signal</structfield>
// This signal is emitted  when a widget of this class is added
// to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
// handles the emission.
// Implementation of this signal is optional.
struct WidgetClass {
   ObjectClass parent_class;
   uint activate_signal, set_scroll_adjustments_signal;
   extern (C) void function (Widget* widget, uint n_pspecs, GObject2.ParamSpec** pspecs) dispatch_child_properties_changed;
   extern (C) void function (Widget* widget) show;
   extern (C) void function (Widget* widget) show_all;
   extern (C) void function (Widget* widget) hide;
   extern (C) void function (Widget* widget) hide_all;
   extern (C) void function (Widget* widget) map;
   extern (C) void function (Widget* widget) unmap;
   extern (C) void function (Widget* widget) realize;
   extern (C) void function (Widget* widget) unrealize;
   // <requisition>: a #GtkRequisition to be filled in
   extern (C) void function (Widget* widget, Requisition* requisition) size_request;
   // <allocation>: position and size to be allocated to @widget
   extern (C) void function (Widget* widget, Allocation* allocation) size_allocate;
   extern (C) void function (Widget* widget, StateType previous_state) state_changed;
   extern (C) void function (Widget* widget, Widget* previous_parent) parent_set;
   extern (C) void function (Widget* widget, Widget* previous_toplevel) hierarchy_changed;
   extern (C) void function (Widget* widget, Style* previous_style) style_set;
   extern (C) void function (Widget* widget, TextDirection previous_direction) direction_changed;
   extern (C) void function (Widget* widget, int was_grabbed) grab_notify;
   extern (C) void function (Widget* widget, GObject2.ParamSpec* pspec) child_notify;

   // RETURNS: %TRUE if the signal has been handled
   // <group_cycling>: %TRUE if there are other widgets with the same mnemonic
   extern (C) int function (Widget* widget, int group_cycling) mnemonic_activate;
   extern (C) void function (Widget* widget) grab_focus;
   extern (C) int function (Widget* widget, DirectionType direction) focus;

   // RETURNS: return from the event signal emission (%TRUE if
   // <event>: a #GdkEvent
   extern (C) int function (Widget* widget, Gdk2.Event* event) event;
   extern (C) int function (Widget* widget, Gdk2.EventButton* event) button_press_event;
   extern (C) int function (Widget* widget, Gdk2.EventButton* event) button_release_event;
   extern (C) int function (Widget* widget, Gdk2.EventScroll* event) scroll_event;
   extern (C) int function (Widget* widget, Gdk2.EventMotion* event) motion_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventAny* event) delete_event;
   extern (C) int function (Widget* widget, Gdk2.EventAny* event) destroy_event;
   extern (C) int function (Widget* widget, Gdk2.EventExpose* event) expose_event;
   extern (C) int function (Widget* widget, Gdk2.EventKey* event) key_press_event;
   extern (C) int function (Widget* widget, Gdk2.EventKey* event) key_release_event;
   extern (C) int function (Widget* widget, Gdk2.EventCrossing* event) enter_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventCrossing* event) leave_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventConfigure* event) configure_event;
   extern (C) int function (Widget* widget, Gdk2.EventFocus* event) focus_in_event;
   extern (C) int function (Widget* widget, Gdk2.EventFocus* event) focus_out_event;
   extern (C) int function (Widget* widget, Gdk2.EventAny* event) map_event;
   extern (C) int function (Widget* widget, Gdk2.EventAny* event) unmap_event;
   extern (C) int function (Widget* widget, Gdk2.EventProperty* event) property_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventSelection* event) selection_clear_event;
   extern (C) int function (Widget* widget, Gdk2.EventSelection* event) selection_request_event;
   extern (C) int function (Widget* widget, Gdk2.EventSelection* event) selection_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventProximity* event) proximity_in_event;
   extern (C) int function (Widget* widget, Gdk2.EventProximity* event) proximity_out_event;
   extern (C) int function (Widget* widget, Gdk2.EventVisibility* event) visibility_notify_event;
   extern (C) int function (Widget* widget, Gdk2.EventClient* event) client_event;
   extern (C) int function (Widget* widget, Gdk2.EventAny* event) no_expose_event;
   extern (C) int function (Widget* widget, Gdk2.EventWindowState* event) window_state_event;
   extern (C) void function (Widget* widget, SelectionData* selection_data, uint info, uint time_) selection_get;
   extern (C) void function (Widget* widget, SelectionData* selection_data, uint time_) selection_received;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context) drag_begin;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context) drag_end;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context, SelectionData* selection_data, uint info, uint time_) drag_data_get;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context) drag_data_delete;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context, uint time_) drag_leave;
   extern (C) int function (Widget* widget, Gdk2.DragContext* context, int x, int y, uint time_) drag_motion;
   extern (C) int function (Widget* widget, Gdk2.DragContext* context, int x, int y, uint time_) drag_drop;
   extern (C) void function (Widget* widget, Gdk2.DragContext* context, int x, int y, SelectionData* selection_data, uint info, uint time_) drag_data_received;
   extern (C) int function (Widget* widget) popup_menu;
   extern (C) int function (Widget* widget, WidgetHelpType help_type) show_help;
   // RETURNS: the #AtkObject associated with @widget
   extern (C) Atk.Object* function (Widget* widget) get_accessible;
   extern (C) void function (Widget* widget, Gdk2.Screen* previous_screen) screen_changed;

   // RETURNS: %TRUE if the accelerator can be activated.
   // <signal_id>: the ID of a signal installed on @widget
   extern (C) int function (Widget* widget, uint signal_id) can_activate_accel;
   extern (C) int function (Widget* widget, Gdk2.EventGrabBroken* event) grab_broken_event;
   extern (C) void function (Widget* widget) composited_changed;
   extern (C) int function (Widget* widget, int x, int y, int keyboard_tooltip, Tooltip* tooltip) query_tooltip;
   extern (C) void function () _gtk_reserved5;
   extern (C) void function () _gtk_reserved6;
   extern (C) void function () _gtk_reserved7;


   // Finds a style property of a widget class by name.
   // RETURNS: the #GParamSpec of the style property or %NULL if @class has no style property with that name.
   // <property_name>: the name of the style property to find
   GObject2.ParamSpec* find_style_property(char* property_name) {
      return gtk_widget_class_find_style_property(&this, property_name);
   }

   // Installs a style property on a widget class. The parser for the
   // style property is determined by the value type of @pspec.
   // <pspec>: the #GParamSpec for the property
   void install_style_property(GObject2.ParamSpec* pspec) {
      gtk_widget_class_install_style_property(&this, pspec);
   }

   // Unintrospectable method: install_style_property_parser() / gtk_widget_class_install_style_property_parser()
   // Installs a style property on a widget class.
   // <pspec>: the #GParamSpec for the style property
   // <parser>: the parser for the style property
   void install_style_property_parser(GObject2.ParamSpec* pspec, RcPropertyParser parser) {
      gtk_widget_class_install_style_property_parser(&this, pspec, parser);
   }

   // Returns all style properties of a widget class.
   // RETURNS: an newly allocated array of #GParamSpec*. The array must be freed with g_free().
   // <n_properties>: location to return the number of style properties found
   GObject2.ParamSpec** /*new container*/ list_style_properties(/*out*/ uint* n_properties) {
      return gtk_widget_class_list_style_properties(&this, n_properties);
   }
}

// Tells about certain properties of the widget.
enum WidgetFlags {
   TOPLEVEL = 16,
   NO_WINDOW = 32,
   REALIZED = 64,
   MAPPED = 128,
   VISIBLE = 256,
   SENSITIVE = 512,
   PARENT_SENSITIVE = 1024,
   CAN_FOCUS = 2048,
   HAS_FOCUS = 4096,
   CAN_DEFAULT = 8192,
   HAS_DEFAULT = 16384,
   HAS_GRAB = 32768,
   RC_STYLE = 65536,
   COMPOSITE_CHILD = 131072,
   NO_REPARENT = 262144,
   APP_PAINTABLE = 524288,
   RECEIVES_DEFAULT = 1048576,
   DOUBLE_BUFFERED = 2097152,
   NO_SHOW_ALL = 4194304
}
enum WidgetHelpType {
   TOOLTIP = 0,
   WHATS_THIS = 1
}
struct WidgetShapeInfo {
   short offset_x, offset_y;
   Gdk2.Bitmap* shape_mask;
}

struct Window /* : Bin */ {
   alias bin this;
   alias bin super_;
   Bin bin;
   char* title, wmclass_name, wmclass_class, wm_role;
   Widget* focus_widget, default_widget;
   Window* transient_parent;
   WindowGeometryInfo* geometry_info;
   Gdk2.Window* frame;
   WindowGroup* group;
   ushort configure_request_count;
    static import std.bitmanip; mixin(std.bitmanip.bitfields!(
   uint, "allow_shrink", 1,
   uint, "allow_grow", 1,
   uint, "configure_notify_received", 1,
   uint, "need_default_position", 1,
   uint, "need_default_size", 1,
   uint, "position", 3,
   uint, "type", 4,
   uint, "has_user_ref_count", 1,
   uint, "has_focus", 1,
   uint, "modal", 1,
   uint, "destroy_with_parent", 1,
   uint, "has_frame", 1,
   uint, "iconify_initially", 1,
   uint, "stick_initially", 1,
   uint, "maximize_initially", 1,
   uint, "decorated", 1,
   uint, "type_hint", 3,
   uint, "gravity", 5,
   uint, "is_active", 1,
   uint, "has_toplevel_focus", 1,
    uint, "__dummy32A", 1));
   uint frame_left, frame_top, frame_right, frame_bottom, keys_changed_handler;
   Gdk2.ModifierType mnemonic_modifier;
   Gdk2.Screen* screen;


   // Creates a new #GtkWindow, which is a toplevel window that can
   // contain other widgets. Nearly always, the type of the window should
   // be #GTK_WINDOW_TOPLEVEL. If you're implementing something like a
   // popup menu from scratch (which is a bad idea, just use #GtkMenu),
   // you might use #GTK_WINDOW_POPUP. #GTK_WINDOW_POPUP is not for
   // dialogs, though in some other toolkits dialogs are called "popups".
   // In GTK+, #GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip.
   // On X11, popup windows are not controlled by the <link
   // linkend="gtk-X11-arch">window manager</link>.
   // If you simply want an undecorated window (no window borders), use
   // gtk_window_set_decorated(), don't use #GTK_WINDOW_POPUP.
   // RETURNS: a new #GtkWindow.
   // <type>: type of window
   static Window* new_(WindowType type) {
      return gtk_window_new(type);
   }

   // Gets the value set by gtk_window_set_default_icon_list().
   // The list is a copy and should be freed with g_list_free(),
   // but the pixbufs in the list have not had their reference count
   // incremented.
   // RETURNS: copy of default icon list
   static GLib2.List* /*new container*/ get_default_icon_list() {
      return gtk_window_get_default_icon_list();
   }

   // Returns the fallback icon name for windows that has been set
   // with gtk_window_set_default_icon_name(). The returned
   // string is owned by GTK+ and should not be modified. It
   // is only valid until the next call to
   // gtk_window_set_default_icon_name().
   // RETURNS: the fallback icon name for windows
   static char* get_default_icon_name() {
      return gtk_window_get_default_icon_name();
   }

   // Returns a list of all existing toplevel windows. The widgets
   // in the list are not individually referenced. If you want
   // to iterate through the list and perform actions involving
   // callbacks that might destroy the widgets, you <emphasis>must</emphasis> call
   // <literal>g_list_foreach (result, (GFunc)g_object_ref, NULL)</literal> first, and
   // then unref all the widgets afterwards.
   // RETURNS: list of toplevel widgets
   static GLib2.List* /*new container*/ list_toplevels() {
      return gtk_window_list_toplevels();
   }

   // By default, after showing the first #GtkWindow, GTK+ calls 
   // gdk_notify_startup_complete().  Call this function to disable 
   // the automatic startup notification. You might do this if your 
   // first window is a splash screen, and you want to delay notification 
   // until after your real main window has been shown, for example.
   // In that example, you would disable startup notification
   // temporarily, show your splash screen, then re-enable it so that
   // showing the main window would automatically result in notification.
   // <setting>: %TRUE to automatically do startup notification
   static void set_auto_startup_notification(int setting) {
      gtk_window_set_auto_startup_notification(setting);
   }

   // Sets an icon to be used as fallback for windows that haven't
   // had gtk_window_set_icon() called on them from a pixbuf.
   // <icon>: the icon
   static void set_default_icon(GdkPixbuf2.Pixbuf* icon) {
      gtk_window_set_default_icon(icon);
   }

   // Sets an icon to be used as fallback for windows that haven't
   // had gtk_window_set_icon_list() called on them from a file
   // on disk. Warns on failure if @err is %NULL.
   // RETURNS: %TRUE if setting the icon succeeded.
   // <filename>: location of icon file
   static int set_default_icon_from_file(char* filename, GLib2.Error** error=null) {
      return gtk_window_set_default_icon_from_file(filename, error);
   }

   // Sets an icon list to be used as fallback for windows that haven't
   // had gtk_window_set_icon_list() called on them to set up a
   // window-specific icon list. This function allows you to set up the
   // icon for all windows in your app at once.
   // See gtk_window_set_icon_list() for more details.
   // <list>: a list of #GdkPixbuf
   static void set_default_icon_list(GLib2.List* list) {
      gtk_window_set_default_icon_list(list);
   }

   // Sets an icon to be used as fallback for windows that haven't
   // had gtk_window_set_icon_list() called on them from a named
   // themed icon, see gtk_window_set_icon_name().
   // <name>: the name of the themed icon
   static void set_default_icon_name(char* name) {
      gtk_window_set_default_icon_name(name);
   }

   // Activates the default widget for the window, unless the current 
   // focused widget has been configured to receive the default action 
   // (see gtk_widget_set_receives_default()), in which case the
   // focused widget is activated.
   // RETURNS: %TRUE if a widget got activated.
   int activate_default() {
      return gtk_window_activate_default(&this);
   }

   // Activates the current focused widget within the window.
   // RETURNS: %TRUE if a widget got activated.
   int activate_focus() {
      return gtk_window_activate_focus(&this);
   }

   // Activates mnemonics and accelerators for this #GtkWindow. This is normally
   // called by the default ::key_press_event handler for toplevel windows,
   // however in some cases it may be useful to call this directly when
   // overriding the standard key handling for a toplevel window.
   // RETURNS: %TRUE if a mnemonic or accelerator was found and activated.
   // <event>: a #GdkEventKey
   int activate_key(Gdk2.EventKey* event) {
      return gtk_window_activate_key(&this, event);
   }

   // Associate @accel_group with @window, such that calling
   // gtk_accel_groups_activate() on @window will activate accelerators
   // in @accel_group.
   // <accel_group>: a #GtkAccelGroup
   void add_accel_group(AccelGroup* accel_group) {
      gtk_window_add_accel_group(&this, accel_group);
   }
   void add_embedded_xid(Gdk2.NativeWindow xid) {
      gtk_window_add_embedded_xid(&this, xid);
   }

   // Adds a mnemonic to this window.
   // <keyval>: the mnemonic
   // <target>: the widget that gets activated by the mnemonic
   void add_mnemonic(uint keyval, Widget* target) {
      gtk_window_add_mnemonic(&this, keyval, target);
   }

   // Starts moving a window. This function is used if an application has
   // window movement grips. When GDK can support it, the window movement
   // will be done using the standard mechanism for the <link
   // linkend="gtk-X11-arch">window manager</link> or windowing
   // system. Otherwise, GDK will try to emulate window movement,
   // potentially not all that well, depending on the windowing system.
   // <button>: mouse button that initiated the drag
   // <root_x>: X position where the user clicked to initiate the drag, in root window coordinates
   // <root_y>: Y position where the user clicked to initiate the drag
   // <timestamp>: timestamp from the click event that initiated the drag
   void begin_move_drag(int button, int root_x, int root_y, uint timestamp) {
      gtk_window_begin_move_drag(&this, button, root_x, root_y, timestamp);
   }

   // Starts resizing a window. This function is used if an application
   // has window resizing controls. When GDK can support it, the resize
   // will be done using the standard mechanism for the <link
   // linkend="gtk-X11-arch">window manager</link> or windowing
   // system. Otherwise, GDK will try to emulate window resizing,
   // potentially not all that well, depending on the windowing system.
   // <edge>: position of the resize control
   // <button>: mouse button that initiated the drag
   // <root_x>: X position where the user clicked to initiate the drag, in root window coordinates
   // <root_y>: Y position where the user clicked to initiate the drag
   // <timestamp>: timestamp from the click event that initiated the drag
   void begin_resize_drag(Gdk2.WindowEdge edge, int button, int root_x, int root_y, uint timestamp) {
      gtk_window_begin_resize_drag(&this, edge, button, root_x, root_y, timestamp);
   }

   // Asks to deiconify (i.e. unminimize) the specified @window. Note
   // that you shouldn't assume the window is definitely deiconified
   // afterward, because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could iconify it
   // again before your code which assumes deiconification gets to run.
   // You can track iconification via the "window-state-event" signal
   // on #GtkWidget.
   void deiconify() {
      gtk_window_deiconify(&this);
   }

   // Asks to place @window in the fullscreen state. Note that you
   // shouldn't assume the window is definitely full screen afterward,
   // because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could unfullscreen it
   // again, and not all window managers honor requests to fullscreen
   // windows. But normally the window will end up fullscreen. Just
   // don't write code that crashes if not.
   // You can track the fullscreen state via the "window-state-event" signal
   // on #GtkWidget.
   void fullscreen() {
      gtk_window_fullscreen(&this);
   }

   // Gets the value set by gtk_window_set_accept_focus().
   // RETURNS: %TRUE if window should receive the input focus
   int get_accept_focus() {
      return gtk_window_get_accept_focus(&this);
   }

   // Returns whether the window has been set to have decorations
   // such as a title bar via gtk_window_set_decorated().
   // RETURNS: %TRUE if the window has been set to have decorations
   int get_decorated() {
      return gtk_window_get_decorated(&this);
   }

   // Gets the default size of the window. A value of -1 for the width or
   // height indicates that a default size has not been explicitly set
   // for that dimension, so the "natural" size of the window will be
   // used.
   // <width>: location to store the default width, or %NULL
   // <height>: location to store the default height, or %NULL
   void get_default_size(int* width=null, int* height=null) {
      gtk_window_get_default_size(&this, width, height);
   }

   // Returns the default widget for @window. See gtk_window_set_default()
   // for more details.
   // RETURNS: the default widget, or %NULL if there is none.
   Widget* get_default_widget() {
      return gtk_window_get_default_widget(&this);
   }

   // Returns whether the window has been set to have a close button
   // via gtk_window_set_deletable().
   // RETURNS: %TRUE if the window has been set to have a close button
   int get_deletable() {
      return gtk_window_get_deletable(&this);
   }

   // Returns whether the window will be destroyed with its transient parent. See
   // gtk_window_set_destroy_with_parent ().
   // RETURNS: %TRUE if the window will be destroyed with its transient parent.
   int get_destroy_with_parent() {
      return gtk_window_get_destroy_with_parent(&this);
   }

   // Retrieves the current focused widget within the window.
   // Note that this is the widget that would have the focus
   // if the toplevel window focused; if the toplevel window
   // is not focused then  <literal>gtk_widget_has_focus (widget)</literal> will
   // not be %TRUE for the widget.
   // RETURNS: the currently focused widget, or %NULL if there is none.
   Widget* get_focus() {
      return gtk_window_get_focus(&this);
   }

   // Gets the value set by gtk_window_set_focus_on_map().
   // mapped.
   // RETURNS: %TRUE if window should receive the input focus when
   int get_focus_on_map() {
      return gtk_window_get_focus_on_map(&this);
   }

   // (Note: this is a special-purpose function intended for the
   // framebuffer port; see gtk_window_set_has_frame(). It will not
   // return the size of the window border drawn by the <link
   // linkend="gtk-X11-arch">window manager</link>, which is the normal
   // case when using a windowing system.  See
   // gdk_window_get_frame_extents() to get the standard window border
   // extents.)
   // Retrieves the dimensions of the frame window for this toplevel.
   // See gtk_window_set_has_frame(), gtk_window_set_frame_dimensions().
   // <left>: location to store the width of the frame at the left, or %NULL
   // <top>: location to store the height of the frame at the top, or %NULL
   // <right>: location to store the width of the frame at the returns, or %NULL
   // <bottom>: location to store the height of the frame at the bottom, or %NULL
   void get_frame_dimensions(/*out*/ int* left=null, /*out*/ int* top=null, /*out*/ int* right=null, /*out*/ int* bottom=null) {
      gtk_window_get_frame_dimensions(&this, left, top, right, bottom);
   }

   // Gets the value set by gtk_window_set_gravity().
   // RETURNS: window gravity
   Gdk2.Gravity get_gravity() {
      return gtk_window_get_gravity(&this);
   }

   // Returns the group for @window or the default group, if
   // window group.
   // RETURNS: the #GtkWindowGroup for a window or the default group
   WindowGroup* get_group() {
      return gtk_window_get_group(&this);
   }

   // Accessor for whether the window has a frame window exterior to
   // via gtk_window_set_has_frame().
   // RETURNS: %TRUE if a frame has been added to the window
   int get_has_frame() {
      return gtk_window_get_has_frame(&this);
   }

   // Gets the value set by gtk_window_set_icon() (or if you've
   // called gtk_window_set_icon_list(), gets the first icon in
   // the icon list).
   // RETURNS: icon for window
   GdkPixbuf2.Pixbuf* get_icon() {
      return gtk_window_get_icon(&this);
   }

   // Retrieves the list of icons set by gtk_window_set_icon_list().
   // The list is copied, but the reference count on each
   // member won't be incremented.
   // RETURNS: copy of window's icon list
   GLib2.List* /*new container*/ get_icon_list() {
      return gtk_window_get_icon_list(&this);
   }

   // Returns the name of the themed icon for the window,
   // see gtk_window_set_icon_name().
   // no themed icon
   // RETURNS: the icon name or %NULL if the window has
   char* get_icon_name() {
      return gtk_window_get_icon_name(&this);
   }

   // Returns the mnemonic modifier for this window. See
   // gtk_window_set_mnemonic_modifier().
   // mnemonics on this window.
   // RETURNS: the modifier mask used to activate
   Gdk2.ModifierType get_mnemonic_modifier() {
      return gtk_window_get_mnemonic_modifier(&this);
   }
   int get_mnemonics_visible() {
      return gtk_window_get_mnemonics_visible(&this);
   }

   // Returns whether the window is modal. See gtk_window_set_modal().
   // establishes a grab when shown
   // RETURNS: %TRUE if the window is set to be modal and
   int get_modal() {
      return gtk_window_get_modal(&this);
   }

   // Fetches the requested opacity for this window. See
   // gtk_window_set_opacity().
   // RETURNS: the requested opacity for this window.
   double get_opacity() {
      return gtk_window_get_opacity(&this);
   }

   // This function returns the position you need to pass to
   // gtk_window_move() to keep @window in its current position.  This
   // means that the meaning of the returned value varies with window
   // gravity. See gtk_window_move() for more details.
   // If you haven't changed the window gravity, its gravity will be
   // #GDK_GRAVITY_NORTH_WEST. This means that gtk_window_get_position()
   // gets the position of the top-left corner of the window manager
   // frame for the window. gtk_window_move() sets the position of this
   // same top-left corner.
   // gtk_window_get_position() is not 100% reliable because the X Window System
   // does not specify a way to obtain the geometry of the
   // decorations placed on a window by the window manager.
   // Thus GTK+ is using a "best guess" that works with most
   // window managers.
   // Moreover, nearly all window managers are historically broken with
   // respect to their handling of window gravity. So moving a window to
   // its current position as returned by gtk_window_get_position() tends
   // to result in moving the window slightly. Window managers are
   // slowly getting better over time.
   // If a window has gravity #GDK_GRAVITY_STATIC the window manager
   // frame is not relevant, and thus gtk_window_get_position() will
   // always produce accurate results. However you can't use static
   // gravity to do things like place a window in a corner of the screen,
   // because static gravity ignores the window manager decorations.
   // If you are saving and restoring your application's window
   // positions, you should know that it's impossible for applications to
   // do this without getting it somewhat wrong because applications do
   // not have sufficient knowledge of window manager state. The Correct
   // Mechanism is to support the session management protocol (see the
   // "GnomeClient" object in the GNOME libraries for example) and allow
   // the window manager to save your window sizes and positions.
   // <root_x>: return location for X coordinate of gravity-determined reference point
   // <root_y>: return location for Y coordinate of gravity-determined reference point
   void get_position(/*out*/ int* root_x=null, /*out*/ int* root_y=null) {
      gtk_window_get_position(&this, root_x, root_y);
   }

   // Gets the value set by gtk_window_set_resizable().
   // RETURNS: %TRUE if the user can resize the window
   int get_resizable() {
      return gtk_window_get_resizable(&this);
   }

   // Returns the role of the window. See gtk_window_set_role() for
   // further explanation.
   // returned is owned by the widget and must not be modified
   // or freed.
   // RETURNS: the role of the window if set, or %NULL. The
   char* get_role() {
      return gtk_window_get_role(&this);
   }

   // Returns the #GdkScreen associated with @window.
   // RETURNS: a #GdkScreen.
   Gdk2.Screen* get_screen() {
      return gtk_window_get_screen(&this);
   }

   // Obtains the current size of @window. If @window is not onscreen,
   // it returns the size GTK+ will suggest to the <link
   // linkend="gtk-X11-arch">window manager</link> for the initial window
   // size (but this is not reliably the same as the size the window
   // manager will actually select). The size obtained by
   // gtk_window_get_size() is the last size received in a
   // #GdkEventConfigure, that is, GTK+ uses its locally-stored size,
   // rather than querying the X server for the size. As a result, if you
   // call gtk_window_resize() then immediately call
   // gtk_window_get_size(), the size won't have taken effect yet. After
   // the window manager processes the resize request, GTK+ receives
   // notification that the size has changed via a configure event, and
   // the size of the window gets updated.
   // because the size of the window may change between the time that you
   // get the size and the time that you perform some action assuming
   // that size is the current size. To avoid race conditions, connect to
   // "configure-event" on the window and adjust your size-dependent
   // state to match the size delivered in the #GdkEventConfigure.
   // size of the window manager decorations (aka the window frame or
   // border). Those are not drawn by GTK+ and GTK+ has no reliable
   // method of determining their size.
   // the window onscreen, there may be a better way. The preferred
   // way is to simply set the window's semantic type with
   // gtk_window_set_type_hint(), which allows the window manager to
   // e.g. center dialogs. Also, if you set the transient parent of
   // dialogs with gtk_window_set_transient_for() window managers
   // will often center the dialog over its parent window. It's
   // much preferred to let the window manager handle these
   // things rather than doing it yourself, because all apps will
   // behave consistently and according to user prefs if the window
   // manager handles it. Also, the window manager can take the size
   // of the window decorations/border into account, while your
   // application cannot.
   // In any case, if you insist on application-specified window
   // positioning, there's <emphasis>still</emphasis> a better way than
   // doing it yourself - gtk_window_set_position() will frequently
   // handle the details for you.
   // <width>: return location for width, or %NULL
   // <height>: return location for height, or %NULL
   void get_size(/*out*/ int* width=null, /*out*/ int* height=null) {
      gtk_window_get_size(&this, width, height);
   }

   // Gets the value set by gtk_window_set_skip_pager_hint().
   // RETURNS: %TRUE if window shouldn't be in pager
   int get_skip_pager_hint() {
      return gtk_window_get_skip_pager_hint(&this);
   }

   // Gets the value set by gtk_window_set_skip_taskbar_hint()
   // RETURNS: %TRUE if window shouldn't be in taskbar
   int get_skip_taskbar_hint() {
      return gtk_window_get_skip_taskbar_hint(&this);
   }

   // Retrieves the title of the window. See gtk_window_set_title().
   // been set explicitely. The returned string is owned by the widget
   // and must not be modified or freed.
   // RETURNS: the title of the window, or %NULL if none has
   char* get_title() {
      return gtk_window_get_title(&this);
   }

   // Fetches the transient parent for this window. See
   // gtk_window_set_transient_for().
   // if no transient parent has been set.
   // RETURNS: the transient parent for this window, or %NULL
   Window* get_transient_for() {
      return gtk_window_get_transient_for(&this);
   }

   // Gets the type hint for this window. See gtk_window_set_type_hint().
   // RETURNS: the type hint for @window.
   Gdk2.WindowTypeHint get_type_hint() {
      return gtk_window_get_type_hint(&this);
   }

   // Gets the value set by gtk_window_set_urgency_hint()
   // RETURNS: %TRUE if window is urgent
   int get_urgency_hint() {
      return gtk_window_get_urgency_hint(&this);
   }

   // Gets the type of the window. See #GtkWindowType.
   // RETURNS: the type of the window
   WindowType get_window_type() {
      return gtk_window_get_window_type(&this);
   }

   // Returns whether @window has an explicit window group.
   // Since 2.22
   // RETURNS: %TRUE if @window has an explicit window group.
   int has_group() {
      return gtk_window_has_group(&this);
   }

   // Returns whether the input focus is within this GtkWindow.
   // For real toplevel windows, this is identical to gtk_window_is_active(),
   // but for embedded windows, like #GtkPlug, the results will differ.
   // RETURNS: %TRUE if the input focus is within this GtkWindow
   int has_toplevel_focus() {
      return gtk_window_has_toplevel_focus(&this);
   }

   // Asks to iconify (i.e. minimize) the specified @window. Note that
   // you shouldn't assume the window is definitely iconified afterward,
   // because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could deiconify it
   // again, or there may not be a window manager in which case
   // iconification isn't possible, etc. But normally the window will end
   // up iconified. Just don't write code that crashes if not.
   // It's permitted to call this function before showing a window,
   // in which case the window will be iconified before it ever appears
   // onscreen.
   // You can track iconification via the "window-state-event" signal
   // on #GtkWidget.
   void iconify() {
      gtk_window_iconify(&this);
   }

   // Returns whether the window is part of the current active toplevel.
   // (That is, the toplevel window receiving keystrokes.)
   // The return value is %TRUE if the window is active toplevel
   // itself, but also if it is, say, a #GtkPlug embedded in the active toplevel.
   // You might use this function if you wanted to draw a widget
   // differently in an active window from a widget in an inactive window.
   // See gtk_window_has_toplevel_focus()
   // RETURNS: %TRUE if the window part of the current active window.
   int is_active() {
      return gtk_window_is_active(&this);
   }

   // Asks to maximize @window, so that it becomes full-screen. Note that
   // you shouldn't assume the window is definitely maximized afterward,
   // because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could unmaximize it
   // again, and not all window managers support maximization. But
   // normally the window will end up maximized. Just don't write code
   // that crashes if not.
   // It's permitted to call this function before showing a window,
   // in which case the window will be maximized when it appears onscreen
   // initially.
   // You can track maximization via the "window-state-event" signal
   // on #GtkWidget.
   void maximize() {
      gtk_window_maximize(&this);
   }

   // Activates the targets associated with the mnemonic.
   // RETURNS: %TRUE if the activation is done.
   // <keyval>: the mnemonic
   // <modifier>: the modifiers
   int mnemonic_activate(uint keyval, Gdk2.ModifierType modifier) {
      return gtk_window_mnemonic_activate(&this, keyval, modifier);
   }

   // Asks the <link linkend="gtk-X11-arch">window manager</link> to move
   // this; most window managers ignore requests for initial window
   // positions (instead using a user-defined placement algorithm) and
   // honor requests after the window has already been shown.
   // reference point for the window. The gravity determines two things:
   // first, the location of the reference point in root window
   // coordinates; and second, which point on the window is positioned at
   // the reference point.
   // By default the gravity is #GDK_GRAVITY_NORTH_WEST, so the reference
   // point is simply the @x, @y supplied to gtk_window_move(). The
   // top-left corner of the window decorations (aka window frame or
   // border) will be placed at @x, @y.  Therefore, to position a window
   // at the top left of the screen, you want to use the default gravity
   // (which is #GDK_GRAVITY_NORTH_WEST) and move the window to 0,0.
   // To position a window at the bottom right corner of the screen, you
   // would set #GDK_GRAVITY_SOUTH_EAST, which means that the reference
   // point is at @x + the window width and @y + the window height, and
   // the bottom-right corner of the window border will be placed at that
   // reference point. So, to place a window in the bottom right corner
   // you would first set gravity to south east, then write:
   // <literal>gtk_window_move (window, gdk_screen_width () - window_width,
   // gdk_screen_height () - window_height)</literal> (note that this
   // example does not take multi-head scenarios into account).
   // The Extended Window Manager Hints specification at <ulink 
   // url="http://www.freedesktop.org/Standards/wm-spec">
   // http://www.freedesktop.org/Standards/wm-spec</ulink> has a 
   // nice table of gravities in the "implementation notes" section.
   // The gtk_window_get_position() documentation may also be relevant.
   // <x>: X coordinate to move window to
   // <y>: Y coordinate to move window to
   void move(int x, int y) {
      gtk_window_move(&this, x, y);
   }

   // Parses a standard X Window System geometry string - see the
   // manual page for X (type 'man X') for details on this.
   // gtk_window_parse_geometry() does work on all GTK+ ports
   // including Win32 but is primarily intended for an X environment.
   // If either a size or a position can be extracted from the
   // geometry string, gtk_window_parse_geometry() returns %TRUE
   // and calls gtk_window_set_default_size() and/or gtk_window_move()
   // to resize/move the window.
   // If gtk_window_parse_geometry() returns %TRUE, it will also
   // set the #GDK_HINT_USER_POS and/or #GDK_HINT_USER_SIZE hints
   // indicating to the window manager that the size/position of
   // the window was user-specified. This causes most window
   // managers to honor the geometry.
   // Note that for gtk_window_parse_geometry() to work as expected, it has
   // to be called when the window has its "final" size, i.e. after calling
   // gtk_widget_show_all() on the contents and gtk_window_set_geometry_hints()
   // on the window.
   // |[
   // #include <gtk/gtk.h>
   // static void
   // fill_with_content (GtkWidget *vbox)
   // {
   // /&ast; fill with content... &ast;/
   // }
   // int
   // main (int argc, char *argv[])
   // {
   // GtkWidget *window, *vbox;
   // GdkGeometry size_hints = {
   // 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
   // };
   // gtk_init (&argc, &argv);
   // window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   // vbox = gtk_vbox_new (FALSE, 0);
   // gtk_container_add (GTK_CONTAINER (window), vbox);
   // fill_with_content (vbox);
   // gtk_widget_show_all (vbox);
   // gtk_window_set_geometry_hints (GTK_WINDOW (window),
   // window,
   // &size_hints,
   // GDK_HINT_MIN_SIZE | 
   // GDK_HINT_BASE_SIZE | 
   // GDK_HINT_RESIZE_INC);
   // if (argc &gt; 1)
   // {
   // if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
   // fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
   // }
   // gtk_widget_show_all (window);
   // gtk_main ();
   // return 0;
   // }
   // ]|
   // RETURNS: %TRUE if string was parsed successfully
   // <geometry>: geometry string
   int parse_geometry(char* geometry) {
      return gtk_window_parse_geometry(&this, geometry);
   }

   // Presents a window to the user. This may mean raising the window
   // in the stacking order, deiconifying it, moving it to the current
   // desktop, and/or giving it the keyboard focus, possibly dependent
   // on the user's platform, window manager, and preferences.
   // If @window is hidden, this function calls gtk_widget_show()
   // as well.
   // This function should be used when the user tries to open a window
   // that's already open. Say for example the preferences dialog is
   // currently open, and the user chooses Preferences from the menu
   // a second time; use gtk_window_present() to move the already-open dialog
   // where the user can see it.
   // If you are calling this function in response to a user interaction,
   // it is preferable to use gtk_window_present_with_time().
   void present() {
      gtk_window_present(&this);
   }

   // Presents a window to the user in response to a user interaction.
   // If you need to present a window without a timestamp, use 
   // gtk_window_present(). See gtk_window_present() for details.
   // <timestamp>: the timestamp of the user interaction (typically a button or key press event) which triggered this call
   void present_with_time(uint timestamp) {
      gtk_window_present_with_time(&this, timestamp);
   }

   // Propagate a key press or release event to the focus widget and
   // up the focus container chain until a widget handles @event.
   // This is normally called by the default ::key_press_event and
   // ::key_release_event handlers for toplevel windows,
   // however in some cases it may be useful to call this directly when
   // overriding the standard key handling for a toplevel window.
   // RETURNS: %TRUE if a widget in the focus chain handled the event.
   // <event>: a #GdkEventKey
   int propagate_key_event(Gdk2.EventKey* event) {
      return gtk_window_propagate_key_event(&this, event);
   }

   // Reverses the effects of gtk_window_add_accel_group().
   // <accel_group>: a #GtkAccelGroup
   void remove_accel_group(AccelGroup* accel_group) {
      gtk_window_remove_accel_group(&this, accel_group);
   }
   void remove_embedded_xid(Gdk2.NativeWindow xid) {
      gtk_window_remove_embedded_xid(&this, xid);
   }

   // Removes a mnemonic from this window.
   // <keyval>: the mnemonic
   // <target>: the widget that gets activated by the mnemonic
   void remove_mnemonic(uint keyval, Widget* target) {
      gtk_window_remove_mnemonic(&this, keyval, target);
   }

   // Hides @window, then reshows it, resetting the
   // default size and position of the window. Used
   // by GUI builders only.
   void reshow_with_initial_size() {
      gtk_window_reshow_with_initial_size(&this);
   }

   // Resizes the window as if the user had done so, obeying geometry
   // constraints. The default geometry constraint is that windows may
   // not be smaller than their size request; to override this
   // constraint, call gtk_widget_set_size_request() to set the window's
   // request to a smaller value.
   // If gtk_window_resize() is called before showing a window for the
   // first time, it overrides any default size set with
   // gtk_window_set_default_size().
   // Windows may not be resized smaller than 1 by 1 pixels.
   // <width>: width in pixels to resize the window to
   // <height>: height in pixels to resize the window to
   void resize(int width, int height) {
      gtk_window_resize(&this, width, height);
   }

   // Windows may set a hint asking the desktop environment not to receive
   // the input focus. This function sets this hint.
   // <setting>: %TRUE to let this window receive input focus
   void set_accept_focus(int setting) {
      gtk_window_set_accept_focus(&this, setting);
   }

   // By default, windows are decorated with a title bar, resize
   // controls, etc.  Some <link linkend="gtk-X11-arch">window
   // managers</link> allow GTK+ to disable these decorations, creating a
   // borderless window. If you set the decorated property to %FALSE
   // using this function, GTK+ will do its best to convince the window
   // manager not to decorate the window. Depending on the system, this
   // function may not have any effect when called on a window that is
   // already visible, so you should call it before calling gtk_window_show().
   // On Windows, this function always works, since there's no window manager
   // policy involved.
   // <setting>: %TRUE to decorate the window
   void set_decorated(int setting) {
      gtk_window_set_decorated(&this, setting);
   }

   // The default widget is the widget that's activated when the user
   // presses Enter in a dialog (for example). This function sets or
   // unsets the default widget for a #GtkWindow about. When setting
   // (rather than unsetting) the default widget it's generally easier to
   // call gtk_widget_grab_focus() on the widget. Before making a widget
   // the default widget, you must set the #GTK_CAN_DEFAULT flag on the
   // widget you'd like to make the default using GTK_WIDGET_SET_FLAGS().
   // <default_widget>: widget to be the default, or %NULL to unset the default widget for the toplevel.
   void set_default(Widget* default_widget=null) {
      gtk_window_set_default(&this, default_widget);
   }

   // Sets the default size of a window. If the window's "natural" size
   // (its size request) is larger than the default, the default will be
   // ignored. More generally, if the default size does not obey the
   // geometry hints for the window (gtk_window_set_geometry_hints() can
   // be used to set these explicitly), the default size will be clamped
   // to the nearest permitted size.
   // Unlike gtk_widget_set_size_request(), which sets a size request for
   // a widget and thus would keep users from shrinking the window, this
   // function only sets the initial size, just as if the user had
   // resized the window themselves. Users can still shrink the window
   // again as they normally would. Setting a default size of -1 means to
   // use the "natural" default size (the size request of the window).
   // For more control over a window's initial size and how resizing works,
   // investigate gtk_window_set_geometry_hints().
   // For some uses, gtk_window_resize() is a more appropriate function.
   // gtk_window_resize() changes the current size of the window, rather
   // than the size to be used on initial display. gtk_window_resize() always
   // affects the window itself, not the geometry widget.
   // The default size of a window only affects the first time a window is
   // shown; if a window is hidden and re-shown, it will remember the size
   // it had prior to hiding, rather than using the default size.
   // Windows can't actually be 0x0 in size, they must be at least 1x1, but
   // passing 0 for @width and @height is OK, resulting in a 1x1 default size.
   // <width>: width in pixels, or -1 to unset the default width
   // <height>: height in pixels, or -1 to unset the default height
   void set_default_size(int width, int height) {
      gtk_window_set_default_size(&this, width, height);
   }

   // By default, windows have a close button in the window frame. Some 
   // <link linkend="gtk-X11-arch">window managers</link> allow GTK+ to 
   // disable this button. If you set the deletable property to %FALSE
   // using this function, GTK+ will do its best to convince the window
   // manager not to show a close button. Depending on the system, this
   // function may not have any effect when called on a window that is
   // already visible, so you should call it before calling gtk_window_show().
   // On Windows, this function always works, since there's no window manager
   // policy involved.
   // <setting>: %TRUE to decorate the window as deletable
   void set_deletable(int setting) {
      gtk_window_set_deletable(&this, setting);
   }

   // If @setting is %TRUE, then destroying the transient parent of @window
   // will also destroy @window itself. This is useful for dialogs that
   // shouldn't persist beyond the lifetime of the main window they're
   // associated with, for example.
   // <setting>: whether to destroy @window with its transient parent
   void set_destroy_with_parent(int setting) {
      gtk_window_set_destroy_with_parent(&this, setting);
   }

   // If @focus is not the current focus widget, and is focusable, sets
   // it as the focus widget for the window. If @focus is %NULL, unsets
   // the focus widget for this window. To set the focus to a particular
   // widget in the toplevel, it is usually more convenient to use
   // gtk_widget_grab_focus() instead of this function.
   // <focus>: widget to be the new focus widget, or %NULL to unset any focus widget for the toplevel window.
   void set_focus(Widget* focus=null) {
      gtk_window_set_focus(&this, focus);
   }

   // Windows may set a hint asking the desktop environment not to receive
   // the input focus when the window is mapped.  This function sets this
   // hint.
   // <setting>: %TRUE to let this window receive input focus on map
   void set_focus_on_map(int setting) {
      gtk_window_set_focus_on_map(&this, setting);
   }

   // (Note: this is a special-purpose function intended for the framebuffer
   // port; see gtk_window_set_has_frame(). It will have no effect on the
   // window border drawn by the window manager, which is the normal
   // case when using the X Window system.)
   // For windows with frames (see gtk_window_set_has_frame()) this function
   // can be used to change the size of the frame border.
   // <left>: The width of the left border
   // <top>: The height of the top border
   // <right>: The width of the right border
   // <bottom>: The height of the bottom border
   void set_frame_dimensions(int left, int top, int right, int bottom) {
      gtk_window_set_frame_dimensions(&this, left, top, right, bottom);
   }

   // This function sets up hints about how a window can be resized by
   // the user.  You can set a minimum and maximum size; allowed resize
   // increments (e.g. for xterm, you can only resize by the size of a
   // character); aspect ratios; and more. See the #GdkGeometry struct.
   // <geometry_widget>: widget the geometry hints will be applied to
   // <geometry>: struct containing geometry information
   // <geom_mask>: mask indicating which struct fields should be paid attention to
   void set_geometry_hints(Widget* geometry_widget, Gdk2.Geometry* geometry, Gdk2.WindowHints geom_mask) {
      gtk_window_set_geometry_hints(&this, geometry_widget, geometry, geom_mask);
   }

   // Window gravity defines the meaning of coordinates passed to
   // gtk_window_move(). See gtk_window_move() and #GdkGravity for
   // more details.
   // The default window gravity is #GDK_GRAVITY_NORTH_WEST which will
   // typically "do what you mean."
   // <gravity>: window gravity
   void set_gravity(Gdk2.Gravity gravity) {
      gtk_window_set_gravity(&this, gravity);
   }

   // (Note: this is a special-purpose function for the framebuffer port,
   // that causes GTK+ to draw its own window border. For most applications,
   // you want gtk_window_set_decorated() instead, which tells the window
   // manager whether to draw the window border.)
   // If this function is called on a window with setting of %TRUE, before
   // it is realized or showed, it will have a "frame" window around
   // frame_event you can receive all events targeted at the frame.
   // This function is used by the linux-fb port to implement managed
   // windows, but it could conceivably be used by X-programs that
   // want to do their own window decorations.
   // <setting>: a boolean
   void set_has_frame(int setting) {
      gtk_window_set_has_frame(&this, setting);
   }

   // Sets up the icon representing a #GtkWindow. This icon is used when
   // the window is minimized (also known as iconified).  Some window
   // managers or desktop environments may also place it in the window
   // frame, or display it in other contexts.
   // The icon should be provided in whatever size it was naturally
   // drawn; that is, don't scale the image before passing it to
   // GTK+. Scaling is postponed until the last minute, when the desired
   // final size is known, to allow best quality.
   // If you have your icon hand-drawn in multiple sizes, use
   // gtk_window_set_icon_list(). Then the best size will be used.
   // This function is equivalent to calling gtk_window_set_icon_list()
   // with a 1-element list.
   // See also gtk_window_set_default_icon_list() to set the icon
   // for all windows in your application in one go.
   // <icon>: icon image, or %NULL
   void set_icon(GdkPixbuf2.Pixbuf* icon=null) {
      gtk_window_set_icon(&this, icon);
   }

   // Sets the icon for @window.  
   // Warns on failure if @err is %NULL.
   // This function is equivalent to calling gtk_window_set_icon()
   // with a pixbuf created by loading the image from @filename.
   // RETURNS: %TRUE if setting the icon succeeded.
   // <filename>: location of icon file
   int set_icon_from_file(char* filename, GLib2.Error** error=null) {
      return gtk_window_set_icon_from_file(&this, filename, error);
   }

   // Sets up the icon representing a #GtkWindow. The icon is used when
   // the window is minimized (also known as iconified).  Some window
   // managers or desktop environments may also place it in the window
   // frame, or display it in other contexts.
   // gtk_window_set_icon_list() allows you to pass in the same icon in
   // several hand-drawn sizes. The list should contain the natural sizes
   // your icon is available in; that is, don't scale the image before
   // passing it to GTK+. Scaling is postponed until the last minute,
   // when the desired final size is known, to allow best quality.
   // By passing several sizes, you may improve the final image quality
   // of the icon, by reducing or eliminating automatic image scaling.
   // larger images (64x64, 128x128) if you have them.
   // See also gtk_window_set_default_icon_list() to set the icon
   // for all windows in your application in one go.
   // Note that transient windows (those who have been set transient for another
   // window using gtk_window_set_transient_for()) will inherit their
   // icon from their transient parent. So there's no need to explicitly
   // set the icon on transient windows.
   // <list>: list of #GdkPixbuf
   void set_icon_list(GLib2.List* list) {
      gtk_window_set_icon_list(&this, list);
   }

   // Sets the icon for the window from a named themed icon. See
   // the docs for #GtkIconTheme for more details.
   // Note that this has nothing to do with the WM_ICON_NAME 
   // property which is mentioned in the ICCCM.
   // <name>: the name of the themed icon
   void set_icon_name(char* name=null) {
      gtk_window_set_icon_name(&this, name);
   }

   // Asks to keep @window above, so that it stays on top. Note that
   // you shouldn't assume the window is definitely above afterward,
   // because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could not keep it above,
   // and not all window managers support keeping windows above. But
   // normally the window will end kept above. Just don't write code
   // that crashes if not.
   // It's permitted to call this function before showing a window,
   // in which case the window will be kept above when it appears onscreen
   // initially.
   // You can track the above state via the "window-state-event" signal
   // on #GtkWidget.
   // Note that, according to the <ulink 
   // url="http://www.freedesktop.org/Standards/wm-spec">Extended Window 
   // Manager Hints</ulink> specification, the above state is mainly meant 
   // for user preferences and should not be used by applications e.g. for 
   // drawing attention to their dialogs.
   // <setting>: whether to keep @window above other windows
   void set_keep_above(int setting) {
      gtk_window_set_keep_above(&this, setting);
   }

   // Asks to keep @window below, so that it stays in bottom. Note that
   // you shouldn't assume the window is definitely below afterward,
   // because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could not keep it below,
   // and not all window managers support putting windows below. But
   // normally the window will be kept below. Just don't write code
   // that crashes if not.
   // It's permitted to call this function before showing a window,
   // in which case the window will be kept below when it appears onscreen
   // initially.
   // You can track the below state via the "window-state-event" signal
   // on #GtkWidget.
   // Note that, according to the <ulink 
   // url="http://www.freedesktop.org/Standards/wm-spec">Extended Window 
   // Manager Hints</ulink> specification, the above state is mainly meant 
   // for user preferences and should not be used by applications e.g. for 
   // drawing attention to their dialogs.
   // <setting>: whether to keep @window below other windows
   void set_keep_below(int setting) {
      gtk_window_set_keep_below(&this, setting);
   }

   // Sets the mnemonic modifier for this window.
   // <modifier>: the modifier mask used to activate mnemonics on this window.
   void set_mnemonic_modifier(Gdk2.ModifierType modifier) {
      gtk_window_set_mnemonic_modifier(&this, modifier);
   }

   // Sets the #GtkWindow:mnemonics-visible property.
   // <setting>: the new value
   void set_mnemonics_visible(int setting) {
      gtk_window_set_mnemonics_visible(&this, setting);
   }

   // Sets a window modal or non-modal. Modal windows prevent interaction
   // with other windows in the same application. To keep modal dialogs
   // on top of main application windows, use
   // gtk_window_set_transient_for() to make the dialog transient for the
   // parent; most <link linkend="gtk-X11-arch">window managers</link>
   // will then disallow lowering the dialog below the parent.
   // <modal>: whether the window is modal
   void set_modal(int modal) {
      gtk_window_set_modal(&this, modal);
   }

   // Request the windowing system to make @window partially transparent,
   // with opacity 0 being fully transparent and 1 fully opaque. (Values
   // of the opacity parameter are clamped to the [0,1] range.) On X11
   // this has any effect only on X screens with a compositing manager
   // running. See gtk_widget_is_composited(). On Windows it should work
   // always.
   // Note that setting a window's opacity after the window has been
   // shown causes it to flicker once on Windows.
   // <opacity>: desired opacity, between 0 and 1
   void set_opacity(double opacity) {
      gtk_window_set_opacity(&this, opacity);
   }
   void set_policy(int allow_shrink, int allow_grow, int auto_shrink) {
      gtk_window_set_policy(&this, allow_shrink, allow_grow, auto_shrink);
   }

   // Sets a position constraint for this window. If the old or new
   // constraint is %GTK_WIN_POS_CENTER_ALWAYS, this will also cause
   // the window to be repositioned to satisfy the new constraint.
   // <position>: a position constraint.
   void set_position(WindowPosition position) {
      gtk_window_set_position(&this, position);
   }

   // Sets whether the user can resize a window. Windows are user resizable
   // by default.
   // <resizable>: %TRUE if the user can resize this window
   void set_resizable(int resizable) {
      gtk_window_set_resizable(&this, resizable);
   }

   // This function is only useful on X11, not with other GTK+ targets.
   // In combination with the window title, the window role allows a
   // <link linkend="gtk-X11-arch">window manager</link> to identify "the
   // same" window when an application is restarted. So for example you
   // might set the "toolbox" role on your app's toolbox window, so that
   // when the user restarts their session, the window manager can put
   // the toolbox back in the same place.
   // If a window already has a unique title, you don't need to set the
   // role, since the WM can use the title to identify the window when
   // restoring the session.
   // <role>: unique identifier for the window to be used when restoring a session
   void set_role(char* role) {
      gtk_window_set_role(&this, role);
   }

   // Sets the #GdkScreen where the @window is displayed; if
   // the window is already mapped, it will be unmapped, and
   // then remapped on the new screen.
   // <screen>: a #GdkScreen.
   void set_screen(Gdk2.Screen* screen) {
      gtk_window_set_screen(&this, screen);
   }

   // Windows may set a hint asking the desktop environment not to display
   // the window in the pager. This function sets this hint.
   // (A "pager" is any desktop navigation tool such as a workspace
   // switcher that displays a thumbnail representation of the windows
   // on the screen.)
   // <setting>: %TRUE to keep this window from appearing in the pager
   void set_skip_pager_hint(int setting) {
      gtk_window_set_skip_pager_hint(&this, setting);
   }

   // Windows may set a hint asking the desktop environment not to display
   // the window in the task bar. This function sets this hint.
   // <setting>: %TRUE to keep this window from appearing in the task bar
   void set_skip_taskbar_hint(int setting) {
      gtk_window_set_skip_taskbar_hint(&this, setting);
   }

   // Startup notification identifiers are used by desktop environment to 
   // track application startup, to provide user feedback and other 
   // features. This function changes the corresponding property on the
   // underlying GdkWindow. Normally, startup identifier is managed 
   // automatically and you should only use this function in special cases
   // like transferring focus from other processes. You should use this
   // function before calling gtk_window_present() or any equivalent
   // function generating a window map event.
   // This function is only useful on X11, not with other GTK+ targets.
   // <startup_id>: a string with startup-notification identifier
   void set_startup_id(char* startup_id) {
      gtk_window_set_startup_id(&this, startup_id);
   }

   // Sets the title of the #GtkWindow. The title of a window will be
   // displayed in its title bar; on the X Window System, the title bar
   // is rendered by the <link linkend="gtk-X11-arch">window
   // manager</link>, so exactly how the title appears to users may vary
   // according to a user's exact configuration. The title should help a
   // user distinguish this window from other windows they may have
   // open. A good title might include the application name and current
   // document filename, for example.
   // <title>: title of the window
   void set_title(char* title) {
      gtk_window_set_title(&this, title);
   }

   // Dialog windows should be set transient for the main application
   // window they were spawned from. This allows <link
   // linkend="gtk-X11-arch">window managers</link> to e.g. keep the
   // dialog on top of the main window, or center the dialog over the
   // main window. gtk_dialog_new_with_buttons() and other convenience
   // functions in GTK+ will sometimes call
   // gtk_window_set_transient_for() on your behalf.
   // Passing %NULL for @parent unsets the current transient window.
   // On Windows, this function puts the child window on top of the parent,
   // much as the window manager would have done on X.
   // <parent>: parent window, or %NULL
   void set_transient_for(Window* parent=null) {
      gtk_window_set_transient_for(&this, parent);
   }

   // By setting the type hint for the window, you allow the window
   // manager to decorate and handle the window in a way which is
   // suitable to the function of the window in your application.
   // This function should be called before the window becomes visible.
   // gtk_dialog_new_with_buttons() and other convenience functions in GTK+
   // will sometimes call gtk_window_set_type_hint() on your behalf.
   // <hint>: the window type
   void set_type_hint(Gdk2.WindowTypeHint hint) {
      gtk_window_set_type_hint(&this, hint);
   }

   // Windows may set a hint asking the desktop environment to draw
   // the users attention to the window. This function sets this hint.
   // <setting>: %TRUE to mark this window as urgent
   void set_urgency_hint(int setting) {
      gtk_window_set_urgency_hint(&this, setting);
   }

   // Don't use this function. It sets the X Window System "class" and
   // "name" hints for a window.  According to the ICCCM, you should
   // always set these to the same value for all windows in an
   // application, and GTK+ sets them to that value by default, so calling
   // this function is sort of pointless. However, you may want to call
   // gtk_window_set_role() on each window in your application, for the
   // benefit of the session manager. Setting the role allows the window
   // manager to restore window positions when loading a saved session.
   // <wmclass_name>: window name hint
   // <wmclass_class>: window class hint
   void set_wmclass(char* wmclass_name, char* wmclass_class) {
      gtk_window_set_wmclass(&this, wmclass_name, wmclass_class);
   }

   // Asks to stick @window, which means that it will appear on all user
   // desktops. Note that you shouldn't assume the window is definitely
   // stuck afterward, because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could unstick it
   // again, and some window managers do not support sticking
   // windows. But normally the window will end up stuck. Just don't
   // write code that crashes if not.
   // It's permitted to call this function before showing a window.
   // You can track stickiness via the "window-state-event" signal
   // on #GtkWidget.
   void stick() {
      gtk_window_stick(&this);
   }

   // Asks to toggle off the fullscreen state for @window. Note that you
   // shouldn't assume the window is definitely not full screen
   // afterward, because other entities (e.g. the user or <link
   // linkend="gtk-X11-arch">window manager</link>) could fullscreen it
   // again, and not all window managers honor requests to unfullscreen
   // windows. But normally the window will end up restored to its normal
   // state. Just don't write code that crashes if not.
   // You can track the fullscreen state via the "window-state-event" signal
   // on #GtkWidget.
   void unfullscreen() {
      gtk_window_unfullscreen(&this);
   }

   // Asks to unmaximize @window. Note that you shouldn't assume the
   // window is definitely unmaximized afterward, because other entities
   // (e.g. the user or <link linkend="gtk-X11-arch">window
   // manager</link>) could maximize it again, and not all window
   // managers honor requests to unmaximize. But normally the window will
   // end up unmaximized. Just don't write code that crashes if not.
   // You can track maximization via the "window-state-event" signal
   // on #GtkWidget.
   void unmaximize() {
      gtk_window_unmaximize(&this);
   }

   // Asks to unstick @window, which means that it will appear on only
   // one of the user's desktops. Note that you shouldn't assume the
   // window is definitely unstuck afterward, because other entities
   // (e.g. the user or <link linkend="gtk-X11-arch">window
   // manager</link>) could stick it again. But normally the window will
   // end up stuck. Just don't write code that crashes if not.
   // You can track stickiness via the "window-state-event" signal
   // on #GtkWidget.
   void unstick() {
      gtk_window_unstick(&this);
   }

   // The ::activate-default signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user activates the default widget
   // of @window.
   extern (C) alias static void function (Window* this_, void* user_data=null) signal_activate_default;

   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-default", CB/*:signal_activate_default*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-default",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::activate-focus signal is a
   // <link linkend="keybinding-signals">keybinding signal</link>
   // which gets emitted when the user activates the currently
   // focused widget of @window.
   extern (C) alias static void function (Window* this_, void* user_data=null) signal_activate_focus;
   ulong signal_connect(string name:"activate-focus", CB/*:signal_activate_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"activate-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static c_int function (Window* this_, Gdk2.Event* object, void* user_data=null) signal_frame_event;
   ulong signal_connect(string name:"frame-event", CB/*:signal_frame_event*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"frame-event",
      cast(GObject2.Callback)cb, data, null, cf);
   }

   // The ::keys-changed signal gets emitted when the set of accelerators
   // or mnemonics that are associated with @window changes.
   extern (C) alias static void function (Window* this_, void* user_data=null) signal_keys_changed;
   ulong signal_connect(string name:"keys-changed", CB/*:signal_keys_changed*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"keys-changed",
      cast(GObject2.Callback)cb, data, null, cf);
   }
   extern (C) alias static void function (Window* this_, Widget* object, void* user_data=null) signal_set_focus;
   ulong signal_connect(string name:"set-focus", CB/*:signal_set_focus*/)(CB cb, void* data=null, ConnectFlags cf=cast(ConnectFlags)0) {
      return signal_connect_data(&this, cast(char*)"set-focus",
      cast(GObject2.Callback)cb, data, null, cf);
   }
}

struct WindowClass {
   BinClass parent_class;
   // <focus>: widget to be the new focus widget, or %NULL to unset any focus widget for the toplevel window.
   extern (C) void function (Window* window, Widget* focus=null) set_focus;
   extern (C) int function (Window* window, Gdk2.Event* event) frame_event;
   extern (C) void function (Window* window) activate_focus;
   extern (C) void function (Window* window) activate_default;
   extern (C) void function (Window* window, DirectionType direction) move_focus;
   extern (C) void function (Window* window) keys_changed;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

struct WindowGeometryInfo {
}

struct WindowGroup /* : GObject.Object */ {
   alias parent_instance this;
   alias parent_instance super_;
   alias parent_instance object;
   GObject2.Object parent_instance;
   GLib2.SList* grabs;


   // Creates a new #GtkWindowGroup object. Grabs added with
   // gtk_grab_add() only affect windows within the same #GtkWindowGroup.
   // RETURNS: a new #GtkWindowGroup.
   static WindowGroup* /*new*/ new_() {
      return gtk_window_group_new();
   }

   // Adds a window to a #GtkWindowGroup.
   // <window>: the #GtkWindow to add
   void add_window(Window* window) {
      gtk_window_group_add_window(&this, window);
   }
   // Unintrospectable method: get_current_grab() / gtk_window_group_get_current_grab()
   Widget* get_current_grab() {
      return gtk_window_group_get_current_grab(&this);
   }

   // Returns a list of the #GtkWindows that belong to @window_group.
   // windows inside the group.
   // RETURNS: A newly-allocated list of
   GLib2.List* /*new container*/ list_windows() {
      return gtk_window_group_list_windows(&this);
   }

   // Removes a window from a #GtkWindowGroup.
   // <window>: the #GtkWindow to remove
   void remove_window(Window* window) {
      gtk_window_group_remove_window(&this, window);
   }
}

struct WindowGroupClass {
   GObject2.ObjectClass parent_class;
   extern (C) void function () _gtk_reserved1;
   extern (C) void function () _gtk_reserved2;
   extern (C) void function () _gtk_reserved3;
   extern (C) void function () _gtk_reserved4;
}

extern (C) alias void function (Window* window, uint keyval, Gdk2.ModifierType modifiers, int is_mnemonic, void* data) WindowKeysForeachFunc;

enum WindowPosition {
   NONE = 0,
   CENTER = 1,
   MOUSE = 2,
   CENTER_ALWAYS = 3,
   CENTER_ON_PARENT = 4
}
enum WindowType {
   TOPLEVEL = 0,
   POPUP = 1
}
enum WrapMode {
   NONE = 0,
   CHAR = 1,
   WORD = 2,
   WORD_CHAR = 3
}

// Finds the first accelerator in any #GtkAccelGroup attached
// to @object that matches @accel_key and @accel_mods, and
// activates that accelerator.
// RETURNS: %TRUE if an accelerator was activated and handled this keypress
// <object>: the #GObject, usually a #GtkWindow, on which to activate the accelerator.
// <accel_key>: accelerator keyval from a key event
// <accel_mods>: keyboard state mask from a key event
static int accel_groups_activate(GObject2.Object* object, uint accel_key, Gdk2.ModifierType accel_mods) {
   return gtk_accel_groups_activate(object, accel_key, accel_mods);
}


// Gets a list of all accel groups which are attached to @object.
// RETURNS: a list of all accel groups which are attached to @object
// <object>: a #GObject, usually a #GtkWindow
static GLib2.SList* accel_groups_from_object(GObject2.Object* object) {
   return gtk_accel_groups_from_object(object);
}


// Gets the value set by gtk_accelerator_set_default_mod_mask().
// RETURNS: the default accelerator modifier mask
static uint accelerator_get_default_mod_mask() {
   return gtk_accelerator_get_default_mod_mask();
}


// Converts an accelerator keyval and modifier mask into a string 
// which can be used to represent the accelerator to the user.
// RETURNS: a newly-allocated string representing the accelerator.
// <accelerator_key>: accelerator keyval
// <accelerator_mods>: accelerator modifier mask
static char* /*new*/ accelerator_get_label(uint accelerator_key, Gdk2.ModifierType accelerator_mods) {
   return gtk_accelerator_get_label(accelerator_key, accelerator_mods);
}


// Converts an accelerator keyval and modifier mask
// into a string parseable by gtk_accelerator_parse().
// For example, if you pass in #GDK_q and #GDK_CONTROL_MASK,
// this function returns "&lt;Control&gt;q". 
// If you need to display accelerators in the user interface,
// see gtk_accelerator_get_label().
// RETURNS: a newly-allocated accelerator name
// <accelerator_key>: accelerator keyval
// <accelerator_mods>: accelerator modifier mask
static char* /*new*/ accelerator_name(uint accelerator_key, Gdk2.ModifierType accelerator_mods) {
   return gtk_accelerator_name(accelerator_key, accelerator_mods);
}


// Parses a string representing an accelerator. The
// format looks like "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1" or
// "&lt;Release&gt;z" (the last one is for key release).
// The parser is fairly liberal and allows lower or upper case,
// and also abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;".
// Key names are parsed using gdk_keyval_from_name(). For character keys the
// name is not the symbol, but the lowercase name, e.g. one would use
// "&lt;Ctrl&gt;minus" instead of "&lt;Ctrl&gt;-".
// If the parse fails, @accelerator_key and @accelerator_mods will
// be set to 0 (zero).
// <accelerator>: string representing an accelerator
// <accelerator_key>: return location for accelerator keyval
// <accelerator_mods>: return location for accelerator modifier mask
static void accelerator_parse(char* accelerator, /*out*/ uint* accelerator_key=null, /*out*/ Gdk2.ModifierType* accelerator_mods=null) {
   gtk_accelerator_parse(accelerator, accelerator_key, accelerator_mods);
}


// Sets the modifiers that will be considered significant for keyboard
// accelerators. The default mod mask is #GDK_CONTROL_MASK |
// #GDK_SHIFT_MASK | #GDK_MOD1_MASK | #GDK_SUPER_MASK | 
// #GDK_HYPER_MASK | #GDK_META_MASK, that is, Control, Shift, Alt, 
// Super, Hyper and Meta. Other modifiers will by default be ignored 
// by #GtkAccelGroup.
// You must include at least the three modifiers Control, Shift
// and Alt in any value you pass to this function.
// The default mod mask should be changed on application startup,
// before using any accelerator groups.
// <default_mod_mask>: accelerator modifier mask
static void accelerator_set_default_mod_mask(Gdk2.ModifierType default_mod_mask) {
   gtk_accelerator_set_default_mod_mask(default_mod_mask);
}


// Determines whether a given keyval and modifier mask constitute
// a valid keyboard accelerator. For example, the #GDK_a keyval
// plus #GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator.
// But, you can't, for instance, use the #GDK_Control_L keyval
// as an accelerator.
// RETURNS: %TRUE if the accelerator is valid
// <keyval>: a GDK keyval
// <modifiers>: modifier mask
static int accelerator_valid(uint keyval, Gdk2.ModifierType modifiers) {
   return gtk_accelerator_valid(keyval, modifiers);
}


// Returns %TRUE if dialogs are expected to use an alternative
// button order on the screen @screen. See
// gtk_dialog_set_alternative_button_order() for more details
// about alternative button order. 
// If you need to use this function, you should probably connect
// to the ::notify:gtk-alternative-button-order signal on the
// #GtkSettings object associated to @screen, in order to be 
// notified if the button order setting changes.
// RETURNS: Whether the alternative button order should be used
// <screen>: a #GdkScreen, or %NULL to use the default screen
static int alternative_dialog_button_order(Gdk2.Screen* screen=null) {
   return gtk_alternative_dialog_button_order(screen);
}


// Unintrospectable function: binding_entry_add_signal() / gtk_binding_entry_add_signal()
// Override or install a new key binding for @keyval with @modifiers on
// emitted on the target widget, with @n_args @Varargs used as
// arguments.
// <binding_set>: a #GtkBindingSet to install an entry for
// <keyval>: key value of binding to install
// <modifiers>: key modifier of binding to install
// <signal_name>: signal to execute upon activation
// <n_args>: number of arguments to @signal_name
alias gtk_binding_entry_add_signal binding_entry_add_signal; // Variadic


// Override or install a new key binding for @keyval with @modifiers on
// <binding_set>: a #GtkBindingSet to add a signal to
// <keyval>: key value
// <modifiers>: key modifier
// <signal_name>: signal name to be bound
// <binding_args>: list of #GtkBindingArg signal arguments
static void binding_entry_add_signall(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers, char* signal_name, GLib2.SList* binding_args) {
   gtk_binding_entry_add_signall(binding_set, keyval, modifiers, signal_name, binding_args);
}


// Clears a binding entry.
// <binding_set>: binding set to clear an entry of
// <keyval>: key value of binding to clear
// <modifiers>: key modifier of binding to clear
static void binding_entry_clear(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers) {
   gtk_binding_entry_clear(binding_set, keyval, modifiers);
}


// Remove a binding previously installed via
// gtk_binding_entry_add_signal() on @binding_set.
// <binding_set>: a #GtkBindingSet to remove an entry of
// <keyval>: key value of binding to remove
// <modifiers>: key modifier of binding to remove
static void binding_entry_remove(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers) {
   gtk_binding_entry_remove(binding_set, keyval, modifiers);
}


// Install a binding on @binding_set which causes key lookups
// to be aborted, to prevent bindings from lower priority sets
// to be activated.
// <binding_set>: a #GtkBindingSet to skip an entry of
// <keyval>: key value of binding to skip
// <modifiers>: key modifier of binding to skip
static void binding_entry_skip(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers) {
   gtk_binding_entry_skip(binding_set, keyval, modifiers);
}


// Parse a binding entry from a gtkrc file.
// RETURNS: expected token upon errors, %G_TOKEN_NONE on success.
// <scanner>: GtkRC scanner
static uint binding_parse_binding(GLib2.Scanner* scanner) {
   return gtk_binding_parse_binding(scanner);
}


// Unintrospectable function: binding_set_by_class() / gtk_binding_set_by_class()
// This function returns the binding set named after the type name of
// the passed in class structure. New binding sets are created on
// demand by this function.
// RETURNS: the binding set corresponding to @object_class
// <object_class>: a valid #GtkObject class
static BindingSet* binding_set_by_class(void* object_class) {
   return gtk_binding_set_by_class(object_class);
}


// Find a binding set by its globally unique name. The @set_name can
// either be a name used for gtk_binding_set_new() or the type name of
// a class used in gtk_binding_set_by_class().
// RETURNS: %NULL or the specified binding set
// <set_name>: unique binding set name
static BindingSet* binding_set_find(char* set_name) {
   return gtk_binding_set_find(set_name);
}


// Unintrospectable function: binding_set_new() / gtk_binding_set_new()
// GTK+ maintains a global list of binding sets. Each binding set has
// a unique name which needs to be specified upon creation.
// RETURNS: new binding set
// <set_name>: unique name of this binding set
static BindingSet* binding_set_new(char* set_name) {
   return gtk_binding_set_new(set_name);
}


// Find a key binding matching @keyval and @modifiers and activate the
// binding on @object.
// RETURNS: %TRUE if a binding was found and activated
// <object>: object to activate when binding found
// <keyval>: key value of the binding
// <modifiers>: key modifier of the binding
static int bindings_activate(Object* object, uint keyval, Gdk2.ModifierType modifiers) {
   return gtk_bindings_activate(object, keyval, modifiers);
}


// Looks up key bindings for @object to find one matching
// RETURNS: %TRUE if a matching key binding was found
// <object>: a #GtkObject (generally must be a widget)
// <event>: a #GdkEventKey
static int bindings_activate_event(Object* object, Gdk2.EventKey* event) {
   return gtk_bindings_activate_event(object, event);
}

static GLib2.Quark builder_error_quark() {
   return gtk_builder_error_quark();
}


// Checks that the GTK+ library in use is compatible with the
// given version. Generally you would pass in the constants
// #GTK_MAJOR_VERSION, #GTK_MINOR_VERSION, #GTK_MICRO_VERSION
// as the three arguments to this function; that produces
// a check that the library in use is compatible with
// the version of GTK+ the application or module was compiled
// against.
// of the running library is newer than the version
// the running library must be binary compatible with the
// version @required_major.required_minor.@required_micro
// (same major version.)
// This function is primarily for GTK+ modules; the module
// can call this function to check that it wasn't loaded
// into an incompatible version of GTK+. However, such a
// a check isn't completely reliable, since the module may be
// linked against an old version of GTK+ and calling the
// old version of gtk_check_version(), but still get loaded
// into an application using a newer version of GTK+.
// given version, or a string describing the version mismatch.
// The returned string is owned by GTK+ and should not be modified
// or freed.
// RETURNS: %NULL if the GTK+ library is compatible with the
// <required_major>: the required major version.
// <required_minor>: the required minor version.
// <required_micro>: the required micro version.
static char* check_version(uint required_major, uint required_minor, uint required_micro) {
   return gtk_check_version(required_major, required_minor, required_micro);
}

static Type ctree_node_get_type() {
   return gtk_ctree_node_get_type();
}


// Prevents gtk_init(), gtk_init_check(), gtk_init_with_args() and
// gtk_parse_args() from automatically
// calling <literal>setlocale (LC_ALL, "")</literal>. You would
// want to use this function if you wanted to set the locale for
// your program to something other than the user's locale, or if
// you wanted to set different values for different locale categories.
// Most programs should not need to call this function.
static void disable_setlocale() {
   gtk_disable_setlocale();
}


// Initiates a drag on the source side. The function
// only needs to be used when the application is
// starting drags itself, and is not needed when
// gtk_drag_source_set() is used.
// The @event is used to retrieve the timestamp that will be used internally to
// grab the pointer.  If @event is #NULL, then GDK_CURRENT_TIME will be used.
// However, you should try to pass a real event in all cases, since that can be
// used by GTK+ to get information about the start position of the drag, for
// example if the @event is a GDK_MOTION_NOTIFY.
// Generally there are three cases when you want to start a drag by hand by calling
// this function:
// 1. During a button-press-event handler, if you want to start a drag immediately
// when the user presses the mouse button.  Pass the @event that you have in your
// button-press-event handler.
// 2. During a motion-notify-event handler, if you want to start a drag when the mouse
// moves past a certain threshold distance after a button-press.  Pass the @event that you
// have in your motion-notify-event handler.
// 3. During a timeout handler, if you want to start a drag after the mouse
// button is held down for some time.  Try to save the last event that you got
// from the mouse, using gdk_event_copy(), and pass it to this function
// (remember to free the event with gdk_event_free() when you are done).  If you
// can really not pass a real event, pass #NULL instead.
// RETURNS: the context for this drag.
// <widget>: the source widget.
// <targets>: The targets (data formats) in which the source can provide the data.
// <actions>: A bitmask of the allowed drag actions for this drag.
// <button>: The button the user clicked to start the drag.
// <event>: The event that triggered the start of the drag.
static Gdk2.DragContext* drag_begin(Widget* widget, TargetList* targets, Gdk2.DragAction actions, int button, Gdk2.Event* event) {
   return gtk_drag_begin(widget, targets, actions, button, event);
}


// Checks to see if a mouse drag starting at (@start_x, @start_y) and ending
// at (@current_x, @current_y) has passed the GTK+ drag threshold, and thus
// should trigger the beginning of a drag-and-drop operation.
// RETURNS: %TRUE if the drag threshold has been passed.
// <widget>: a #GtkWidget
// <start_x>: X coordinate of start of drag
// <start_y>: Y coordinate of start of drag
// <current_x>: current X coordinate
// <current_y>: current Y coordinate
static int drag_check_threshold(Widget* widget, int start_x, int start_y, int current_x, int current_y) {
   return gtk_drag_check_threshold(widget, start_x, start_y, current_x, current_y);
}


// Add the image targets supported by #GtkSelection to
// the target list of the drag destination. The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_image_targets() and
// gtk_drag_dest_set_target_list().
// <widget>: a #GtkWidget that's a drag destination
static void drag_dest_add_image_targets(Widget* widget) {
   gtk_drag_dest_add_image_targets(widget);
}


// Add the text targets supported by #GtkSelection to
// the target list of the drag destination. The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_text_targets() and
// gtk_drag_dest_set_target_list().
// <widget>: a #GtkWidget that's a drag destination
static void drag_dest_add_text_targets(Widget* widget) {
   gtk_drag_dest_add_text_targets(widget);
}


// Add the URI targets supported by #GtkSelection to
// the target list of the drag destination. The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_uri_targets() and
// gtk_drag_dest_set_target_list().
// <widget>: a #GtkWidget that's a drag destination
static void drag_dest_add_uri_targets(Widget* widget) {
   gtk_drag_dest_add_uri_targets(widget);
}


// and the dest can accept, or %GDK_NONE
// RETURNS: first target that the source offers
// <widget>: drag destination widget
// <context>: drag context
// <target_list>: list of droppable targets, or %NULL to use gtk_drag_dest_get_target_list (@widget). Looks for a match between the supported targets of @context and the returning %GDK_NONE. @dest_target_list should usually be the return value from gtk_drag_dest_get_target_list(), but some widgets may have different valid targets for different parts of the widget; in that case, they will have to implement a drag_motion handler that passes the correct target list to this function.
static Gdk2.Atom drag_dest_find_target(Widget* widget, Gdk2.DragContext* context, TargetList* target_list=null) {
   return gtk_drag_dest_find_target(widget, context, target_list);
}


// Returns the list of targets this widget can accept from
// drag-and-drop.
// RETURNS: the #GtkTargetList, or %NULL if none
// <widget>: a #GtkWidget
static TargetList* drag_dest_get_target_list(Widget* widget) {
   return gtk_drag_dest_get_target_list(widget);
}


// Returns whether the widget has been configured to always
// emit ::drag-motion signals.
// RETURNS: %TRUE if the widget always emits ::drag-motion events
// <widget>: a #GtkWidget that's a drag destination
static int drag_dest_get_track_motion(Widget* widget) {
   return gtk_drag_dest_get_track_motion(widget);
}


// Sets a widget as a potential drop destination, and adds default behaviors.
// The default behaviors listed in @flags have an effect similar
// to installing default handlers for the widget's drag-and-drop signals
// (#GtkWidget:drag-motion, #GtkWidget:drag-drop, ...). They all exist
// for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
// sufficient to connect to the widget's #GtkWidget::drag-data-received
// signal to get primitive, but consistent drag-and-drop support.
// Things become more complicated when you try to preview the dragged data,
// as described in the documentation for #GtkWidget:drag-motion. The default
// behaviors described by @flags make some assumptions, that can conflict
// with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
// invokations of gdk_drag_status() in the context of #GtkWidget:drag-motion,
// and invokations of gtk_drag_finish() in #GtkWidget:drag-data-received.
// Especially the later is dramatic, when your own #GtkWidget:drag-motion
// handler calls gtk_drag_get_data() to inspect the dragged data.
// There's no way to set a default action here, you can use the
// #GtkWidget:drag-motion callback for that. Here's an example which selects
// the action to use depending on whether the control key is pressed or not:
// |[
// static void
// drag_motion (GtkWidget *widget,
// GdkDragContext *context,
// gint x,
// gint y,
// guint time)
// {
// GdkModifierType mask;
// gdk_window_get_pointer (gtk_widget_get_window (widget),
// NULL, NULL, &mask);
// if (mask & GDK_CONTROL_MASK)
// gdk_drag_status (context, GDK_ACTION_COPY, time);
// else
// gdk_drag_status (context, GDK_ACTION_MOVE, time);
// }
// ]|
// <widget>: a #GtkWidget
// <flags>: which types of default drag behavior to use
// <targets>: a pointer to an array of #GtkTargetEntry<!-- -->s indicating the drop types that this @widget will accept, or %NULL. Later you can access the list with gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
// <n_targets>: the number of entries in @targets
// <actions>: a bitmask of possible actions for a drop onto this @widget.
static void drag_dest_set(Widget* widget, DestDefaults flags, TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
   gtk_drag_dest_set(widget, flags, targets, n_targets, actions);
}

static void drag_dest_set_proxy(Widget* widget, Gdk2.Window* proxy_window, Gdk2.DragProtocol protocol, int use_coordinates) {
   gtk_drag_dest_set_proxy(widget, proxy_window, protocol, use_coordinates);
}


// Sets the target types that this widget can accept from drag-and-drop.
// The widget must first be made into a drag destination with
// gtk_drag_dest_set().
// <widget>: a #GtkWidget that's a drag destination
// <target_list>: list of droppable targets, or %NULL for none
static void drag_dest_set_target_list(Widget* widget, TargetList* target_list=null) {
   gtk_drag_dest_set_target_list(widget, target_list);
}


// Tells the widget to emit ::drag-motion and ::drag-leave
// events regardless of the targets and the %GTK_DEST_DEFAULT_MOTION
// flag. 
// This may be used when a widget wants to do generic
// actions regardless of the targets that the source offers.
// <widget>: a #GtkWidget that's a drag destination
// <track_motion>: whether to accept all targets
static void drag_dest_set_track_motion(Widget* widget, int track_motion) {
   gtk_drag_dest_set_track_motion(widget, track_motion);
}

static void drag_dest_unset(Widget* widget) {
   gtk_drag_dest_unset(widget);
}

static void drag_finish(Gdk2.DragContext* context, int success, int del, uint time_) {
   gtk_drag_finish(context, success, del, time_);
}

static void drag_get_data(Widget* widget, Gdk2.DragContext* context, Gdk2.Atom target, uint time_) {
   gtk_drag_get_data(widget, context, target, time_);
}


// Determines the source widget for a drag.
// within a single application, a pointer to the source widget.
// Otherwise, %NULL.
// RETURNS: if the drag is occurring
// <context>: a (destination side) drag context
static Widget* drag_get_source_widget(Gdk2.DragContext* context) {
   return gtk_drag_get_source_widget(context);
}

static void drag_highlight(Widget* widget) {
   gtk_drag_highlight(widget);
}


// Changes the default drag icon. GTK+ retains references for the
// arguments, and will release them when they are no longer needed.
// changing the stock pixbuf for #GTK_STOCK_DND instead.
// <colormap>: the colormap of the icon
// <pixmap>: the image data for the icon
// <mask>: the transparency mask for an image, or %NULL
// <hot_x>: The X offset within @widget of the hotspot.
// <hot_y>: The Y offset within @widget of the hotspot.
static void drag_set_default_icon(Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask, int hot_x, int hot_y) {
   gtk_drag_set_default_icon(colormap, pixmap, mask, hot_x, hot_y);
}


// Sets the icon for a particular drag to the default
// icon.
// <context>: the context for a drag. (This must be called
static void drag_set_icon_default(Gdk2.DragContext* context) {
   gtk_drag_set_icon_default(context);
}


// Sets the icon for a given drag from a named themed icon. See
// the docs for #GtkIconTheme for more details. Note that the
// size of the icon depends on the icon theme (the icon is
// loaded at the symbolic size #GTK_ICON_SIZE_DND), thus
// <context>: the context for a drag. (This must be called with a context for the source side of a drag)
// <icon_name>: name of icon to use
// <hot_x>: the X offset of the hotspot within the icon
// <hot_y>: the Y offset of the hotspot within the icon
static void drag_set_icon_name(Gdk2.DragContext* context, char* icon_name, int hot_x, int hot_y) {
   gtk_drag_set_icon_name(context, icon_name, hot_x, hot_y);
}


// Sets @pixbuf as the icon for a given drag.
// <context>: the context for a drag. (This must be called with a  context for the source side of a drag)
// <pixbuf>: the #GdkPixbuf to use as the drag icon.
// <hot_x>: the X offset within @widget of the hotspot.
// <hot_y>: the Y offset within @widget of the hotspot.
static void drag_set_icon_pixbuf(Gdk2.DragContext* context, GdkPixbuf2.Pixbuf* pixbuf, int hot_x, int hot_y) {
   gtk_drag_set_icon_pixbuf(context, pixbuf, hot_x, hot_y);
}


// Sets @pixmap as the icon for a given drag. GTK+ retains
// references for the arguments, and will release them when
// they are no longer needed. In general, gtk_drag_set_icon_pixbuf()
// will be more convenient to use.
// <context>: the context for a drag. (This must be called with a  context for the source side of a drag)
// <colormap>: the colormap of the icon
// <pixmap>: the image data for the icon
// <mask>: the transparency mask for the icon or %NULL for none.
// <hot_x>: the X offset within @pixmap of the hotspot.
// <hot_y>: the Y offset within @pixmap of the hotspot.
static void drag_set_icon_pixmap(Gdk2.DragContext* context, Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask, int hot_x, int hot_y) {
   gtk_drag_set_icon_pixmap(context, colormap, pixmap, mask, hot_x, hot_y);
}


// Sets the icon for a given drag from a stock ID.
// <context>: the context for a drag. (This must be called with a  context for the source side of a drag)
// <stock_id>: the ID of the stock icon to use for the drag.
// <hot_x>: the X offset within the icon of the hotspot.
// <hot_y>: the Y offset within the icon of the hotspot.
static void drag_set_icon_stock(Gdk2.DragContext* context, char* stock_id, int hot_x, int hot_y) {
   gtk_drag_set_icon_stock(context, stock_id, hot_x, hot_y);
}


// Changes the icon for a widget to a given widget. GTK+
// will not destroy the icon, so if you don't want
// it to persist, you should connect to the "drag-end" 
// signal and destroy it yourself.
// <context>: the context for a drag. (This must be called
// <widget>: a toplevel window to use as an icon.
// <hot_x>: the X offset within @widget of the hotspot.
// <hot_y>: the Y offset within @widget of the hotspot.
static void drag_set_icon_widget(Gdk2.DragContext* context, Widget* widget, int hot_x, int hot_y) {
   gtk_drag_set_icon_widget(context, widget, hot_x, hot_y);
}


// Add the writable image targets supported by #GtkSelection to
// the target list of the drag source. The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_image_targets() and
// gtk_drag_source_set_target_list().
// <widget>: a #GtkWidget that's is a drag source
static void drag_source_add_image_targets(Widget* widget) {
   gtk_drag_source_add_image_targets(widget);
}


// Add the text targets supported by #GtkSelection to
// the target list of the drag source.  The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_text_targets() and
// gtk_drag_source_set_target_list().
// <widget>: a #GtkWidget that's is a drag source
static void drag_source_add_text_targets(Widget* widget) {
   gtk_drag_source_add_text_targets(widget);
}


// Add the URI targets supported by #GtkSelection to
// the target list of the drag source.  The targets
// are added with @info = 0. If you need another value, 
// use gtk_target_list_add_uri_targets() and
// gtk_drag_source_set_target_list().
// <widget>: a #GtkWidget that's is a drag source
static void drag_source_add_uri_targets(Widget* widget) {
   gtk_drag_source_add_uri_targets(widget);
}


// Gets the list of targets this widget can provide for
// drag-and-drop.
// RETURNS: the #GtkTargetList, or %NULL if none
// <widget>: a #GtkWidget
static TargetList* drag_source_get_target_list(Widget* widget) {
   return gtk_drag_source_get_target_list(widget);
}


// Sets up a widget so that GTK+ will start a drag operation when the user
// clicks and drags on the widget. The widget must have a window.
// <widget>: a #GtkWidget
// <start_button_mask>: the bitmask of buttons that can start the drag
// <targets>: the table of targets that the drag will support, may be %NULL
// <n_targets>: the number of items in @targets
// <actions>: the bitmask of possible actions for a drag from this widget
static void drag_source_set(Widget* widget, Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions) {
   gtk_drag_source_set(widget, start_button_mask, targets, n_targets, actions);
}


// Sets the icon that will be used for drags from a particular widget
// from a pixmap/mask. GTK+ retains references for the arguments, and
// will release them when they are no longer needed.
// Use gtk_drag_source_set_icon_pixbuf() instead.
// <widget>: a #GtkWidget
// <colormap>: the colormap of the icon
// <pixmap>: the image data for the icon
// <mask>: the transparency mask for an image.
static void drag_source_set_icon(Widget* widget, Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null) {
   gtk_drag_source_set_icon(widget, colormap, pixmap, mask);
}


// Sets the icon that will be used for drags from a particular source
// to a themed icon. See the docs for #GtkIconTheme for more details.
// <widget>: a #GtkWidget
// <icon_name>: name of icon to use
static void drag_source_set_icon_name(Widget* widget, char* icon_name) {
   gtk_drag_source_set_icon_name(widget, icon_name);
}


// Sets the icon that will be used for drags from a particular widget
// from a #GdkPixbuf. GTK+ retains a reference for @pixbuf and will 
// release it when it is no longer needed.
// <widget>: a #GtkWidget
// <pixbuf>: the #GdkPixbuf for the drag icon
static void drag_source_set_icon_pixbuf(Widget* widget, GdkPixbuf2.Pixbuf* pixbuf) {
   gtk_drag_source_set_icon_pixbuf(widget, pixbuf);
}


// Sets the icon that will be used for drags from a particular source
// to a stock icon.
// <widget>: a #GtkWidget
// <stock_id>: the ID of the stock icon to use
static void drag_source_set_icon_stock(Widget* widget, char* stock_id) {
   gtk_drag_source_set_icon_stock(widget, stock_id);
}


// Changes the target types that this widget offers for drag-and-drop.
// The widget must first be made into a drag source with
// gtk_drag_source_set().
// <widget>: a #GtkWidget that's a drag source
// <target_list>: list of draggable targets, or %NULL for none
static void drag_source_set_target_list(Widget* widget, TargetList* target_list=null) {
   gtk_drag_source_set_target_list(widget, target_list);
}

static void drag_source_unset(Widget* widget) {
   gtk_drag_source_unset(widget);
}

static void drag_unhighlight(Widget* widget) {
   gtk_drag_unhighlight(widget);
}


// Draws an arrow in the given rectangle on @window using the given 
// parameters. @arrow_type determines the direction of the arrow.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <arrow_type>: the type of arrow to draw
// <fill>: %TRUE if the arrow tip should be filled
// <x>: x origin of the rectangle to draw the arrow in
// <y>: y origin of the rectangle to draw the arrow in
// <width>: width of the rectangle to draw the arrow in
// <height>: height of the rectangle to draw the arrow in
static void draw_arrow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, ArrowType arrow_type, int fill, int x, int y, int width, int height) {
   gtk_draw_arrow(style, window, state_type, shadow_type, arrow_type, fill, x, y, width, height);
}


// Draws a box on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the box
// <y>: y origin of the box
// <width>: the width of the box
// <height>: the height of the box
static void draw_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_box(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a box in @window using the given style and state and shadow type, 
// leaving a gap in one side.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
// <gap_side>: side in which to leave the gap
// <gap_x>: starting position of the gap
// <gap_width>: width of the gap
static void draw_box_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) {
   gtk_draw_box_gap(style, window, state_type, shadow_type, x, y, width, height, gap_side, gap_x, gap_width);
}


// Draws a check button indicator in the given rectangle on @window with 
// the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the rectangle to draw the check in
// <y>: y origin of the rectangle to draw the check in
// <width>: the width of the rectangle to draw the check in
// <height>: the height of the rectangle to draw the check in
static void draw_check(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_check(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a diamond in the given rectangle on @window using the given
// parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the rectangle to draw the diamond in
// <y>: y origin of the rectangle to draw the diamond in
// <width>: width of the rectangle to draw the diamond in
// <height>: height of the rectangle to draw the diamond in
static void draw_diamond(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_diamond(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws an expander as used in #GtkTreeView.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <x>: the x position to draw the expander at
// <y>: the y position to draw the expander at
// <expander_style>: the style to draw the expander in
static void draw_expander(Style* style, Gdk2.Window* window, StateType state_type, int x, int y, ExpanderStyle expander_style) {
   gtk_draw_expander(style, window, state_type, x, y, expander_style);
}


// Draws an extension, i.e. a notebook tab.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <x>: x origin of the extension
// <y>: y origin of the extension
// <width>: width of the extension
// <height>: width of the extension
// <gap_side>: the side on to which the extension is attached
static void draw_extension(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side) {
   gtk_draw_extension(style, window, state_type, shadow_type, x, y, width, height, gap_side);
}


// Draws a flat box on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the box
// <y>: y origin of the box
// <width>: the width of the box
// <height>: the height of the box
static void draw_flat_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_flat_box(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a focus indicator around the given rectangle on @window using the
// given style.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <x>: the x origin of the rectangle around which to draw a focus indicator
// <y>: the y origin of the rectangle around which to draw a focus indicator
// <width>: the width of the rectangle around which to draw a focus indicator
// <height>: the height of the rectangle around which to draw a focus indicator
static void draw_focus(Style* style, Gdk2.Window* window, int x, int y, int width, int height) {
   gtk_draw_focus(style, window, x, y, width, height);
}


// Draws a handle as used in #GtkHandleBox and #GtkPaned.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <x>: x origin of the handle
// <y>: y origin of the handle
// <width>: with of the handle
// <height>: height of the handle
// <orientation>: the orientation of the handle
static void draw_handle(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, Orientation orientation) {
   gtk_draw_handle(style, window, state_type, shadow_type, x, y, width, height, orientation);
}


// Draws a horizontal line from (@x1, @y) to (@x2, @y) in @window
// using the given style and state.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <x1>: the starting x coordinate
// <x2>: the ending x coordinate
// <y>: the y coordinate
static void draw_hline(Style* style, Gdk2.Window* window, StateType state_type, int x1, int x2, int y) {
   gtk_draw_hline(style, window, state_type, x1, x2, y);
}


// Draws a text caret on @drawable at @location. This is not a style function
// but merely a convenience function for drawing the standard cursor shape.
// <widget>: a #GtkWidget
// <drawable>: a #GdkDrawable
// <area>: rectangle to which the output is clipped, or %NULL if the output should not be clipped
// <location>: location where to draw the cursor (@location->width is ignored)
// <is_primary>: if the cursor should be the primary cursor color.
// <direction>: whether the cursor is left-to-right or right-to-left. Should never be #GTK_TEXT_DIR_NONE
// <draw_arrow>: %TRUE to draw a directional arrow on the cursor. Should be %FALSE unless the cursor is split.
static void draw_insertion_cursor(Widget* widget, Gdk2.Drawable* drawable, Gdk2.Rectangle* area, Gdk2.Rectangle* location, int is_primary, TextDirection direction, int draw_arrow) {
   gtk_draw_insertion_cursor(widget, drawable, area, location, is_primary, direction, draw_arrow);
}


// Draws a layout on @window using the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <use_text>: whether to use the text or foreground graphics context of @style
// <x>: x origin
// <y>: y origin
// <layout>: the layout to draw
static void draw_layout(Style* style, Gdk2.Window* window, StateType state_type, int use_text, int x, int y, Pango.Layout* layout) {
   gtk_draw_layout(style, window, state_type, use_text, x, y, layout);
}


// Draws a radio button indicator in the given rectangle on @window with 
// the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the rectangle to draw the option in
// <y>: y origin of the rectangle to draw the option in
// <width>: the width of the rectangle to draw the option in
// <height>: the height of the rectangle to draw the option in
static void draw_option(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_option(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a polygon on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <points>: an array of #GdkPoint<!-- -->s
// <npoints>: length of @points
// <fill>: %TRUE if the polygon should be filled
static void draw_polygon(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Point* points, int npoints, int fill) {
   gtk_draw_polygon(style, window, state_type, shadow_type, points, npoints, fill);
}


// Draws a resize grip in the given rectangle on @window using the given
// parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <edge>: the edge in which to draw the resize grip
// <x>: the x origin of the rectangle in which to draw the resize grip
// <y>: the y origin of the rectangle in which to draw the resize grip
// <width>: the width of the rectangle in which to draw the resize grip
// <height>: the height of the rectangle in which to draw the resize grip
static void draw_resize_grip(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.WindowEdge edge, int x, int y, int width, int height) {
   gtk_draw_resize_grip(style, window, state_type, edge, x, y, width, height);
}


// Draws a shadow around the given rectangle in @window 
// using the given style and state and shadow type.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
static void draw_shadow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_shadow(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a shadow around the given rectangle in @window 
// using the given style and state and shadow type, leaving a 
// gap in one side.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
// <gap_side>: side in which to leave the gap
// <gap_x>: starting position of the gap
// <gap_width>: width of the gap
static void draw_shadow_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) {
   gtk_draw_shadow_gap(style, window, state_type, shadow_type, x, y, width, height, gap_side, gap_x, gap_width);
}


// Draws a slider in the given rectangle on @window using the
// given style and orientation.
// <style>: a #GtkStyle
// <state_type>: a state
// <shadow_type>: a shadow
// <x>: the x origin of the rectangle in which to draw a slider
// <y>: the y origin of the rectangle in which to draw a slider
// <width>: the width of the rectangle in which to draw a slider
// <height>: the height of the rectangle in which to draw a slider
// <orientation>: the orientation to be used
static void draw_slider(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, Orientation orientation) {
   gtk_draw_slider(style, window, state_type, shadow_type, x, y, width, height, orientation);
}


// Draws a text string on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <x>: x origin
// <y>: y origin
// <string>: the string to draw
static void draw_string(Style* style, Gdk2.Window* window, StateType state_type, int x, int y, char* string_) {
   gtk_draw_string(style, window, state_type, x, y, string_);
}


// Draws an option menu tab (i.e. the up and down pointing arrows)
// in the given rectangle on @window using the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <x>: x origin of the rectangle to draw the tab in
// <y>: y origin of the rectangle to draw the tab in
// <width>: the width of the rectangle to draw the tab in
// <height>: the height of the rectangle to draw the tab in
static void draw_tab(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height) {
   gtk_draw_tab(style, window, state_type, shadow_type, x, y, width, height);
}


// Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @window
// using the given style and state.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <y1_>: the starting y coordinate
// <y2_>: the ending y coordinate
// <x>: the x coordinate
static void draw_vline(Style* style, Gdk2.Window* window, StateType state_type, int y1_, int y2_, int x) {
   gtk_draw_vline(style, window, state_type, y1_, y2_, x);
}

static int events_pending() {
   return gtk_events_pending();
}

static void exit(int error_code) {
   gtk_exit(error_code);
}

static int false_() {
   return gtk_false();
}


// Registers an error quark for #GtkFileChooser if necessary.
// RETURNS: The error quark used for #GtkFileChooser errors.
static GLib2.Quark file_chooser_error_quark() {
   return gtk_file_chooser_error_quark();
}

// Unintrospectable function: gc_get() / gtk_gc_get()
static Gdk2.GC* gc_get(int depth, Gdk2.Colormap* colormap, Gdk2.GCValues* values, Gdk2.GCValuesMask values_mask) {
   return gtk_gc_get(depth, colormap, values, values_mask);
}

static void gc_release(Gdk2.GC* gc) {
   gtk_gc_release(gc);
}


// Obtains a copy of the event currently being processed by GTK+.  For
// example, if you get a "clicked" signal from #GtkButton, the current
// event will be the #GdkEventButton that triggered the "clicked"
// signal. The returned event must be freed with gdk_event_free().
// If there is no current event, the function returns %NULL.
// current event.
// RETURNS: a copy of the current event, or %NULL if no
static Gdk2.Event* /*new*/ get_current_event() {
   return gtk_get_current_event();
}


// If there is a current event and it has a state field, place
// that state field in @state and return %TRUE, otherwise return
// %FALSE.
// RETURNS: %TRUE if there was a current event and it had a state field
// <state>: a location to store the state of the current event
static int get_current_event_state(/*out*/ Gdk2.ModifierType* state) {
   return gtk_get_current_event_state(state);
}


// If there is a current event and it has a timestamp, return that
// timestamp, otherwise return %GDK_CURRENT_TIME.
// RETURNS: the timestamp from the current event, or %GDK_CURRENT_TIME.
static uint get_current_event_time() {
   return gtk_get_current_event_time();
}


// Returns the #PangoLanguage for the default language currently in
// effect. (Note that this can change over the life of an
// application.)  The default language is derived from the current
// locale. It determines, for example, whether GTK+ uses the
// right-to-left or left-to-right text direction.
// This function is equivalent to pango_language_get_default().  See
// that function for details.
// freed
// RETURNS: the default language as a #PangoLanguage, must not be
static Pango.Language* /*new*/ get_default_language() {
   return gtk_get_default_language();
}


// If @event is %NULL or the event was not associated with any widget,
// returns %NULL, otherwise returns the widget that received the event
// originally.
// received @event, or %NULL
// RETURNS: the widget that originally
// <event>: a #GdkEvent
static Widget* get_event_widget(Gdk2.Event* event) {
   return gtk_get_event_widget(event);
}


// Unintrospectable function: get_option_group() / gtk_get_option_group()
// Returns a #GOptionGroup for the commandline arguments recognized
// by GTK+ and GDK. You should add this group to your #GOptionContext 
// with g_option_context_add_group(), if you are using 
// g_option_context_parse() to parse your commandline arguments.
// by GTK+
// RETURNS: a #GOptionGroup for the commandline arguments recognized
// <open_default_display>: whether to open the default display when parsing the commandline arguments
static GLib2.OptionGroup* get_option_group(int open_default_display) {
   return gtk_get_option_group(open_default_display);
}

static void grab_add(Widget* widget) {
   gtk_grab_add(widget);
}


// Queries the current grab of the default window group.
// has the grab or %NULL if no grab is active
// RETURNS: The widget which currently
static Widget* grab_get_current() {
   return gtk_grab_get_current();
}

static void grab_remove(Widget* widget) {
   gtk_grab_remove(widget);
}


// Looks up the icon size associated with @name.
// RETURNS: the icon size
// <name>: the name to look up.
static int icon_size_from_name(char* name) {
   return gtk_icon_size_from_name(name);
}


// Gets the canonical name of the given icon size. The returned string
// is statically allocated and should not be freed.
// RETURNS: the name of the given icon size.
// <size>: a #GtkIconSize.
static char* icon_size_get_name(int size) {
   return gtk_icon_size_get_name(size);
}


// Obtains the pixel size of a semantic icon size, possibly
// modified by user preferences for the default #GtkSettings.
// (See gtk_icon_size_lookup_for_settings().)
// Normally @size would be
// #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc.  This function
// isn't normally needed, gtk_widget_render_icon() is the usual
// way to get an icon for rendering, then just look at the size of
// the rendered pixbuf. The rendered pixbuf may not even correspond to
// the width/height returned by gtk_icon_size_lookup(), because themes
// are free to render the pixbuf however they like, including changing
// the usual size.
// RETURNS: %TRUE if @size was a valid size
// <size>: an icon size
// <width>: location to store icon width
// <height>: location to store icon height
static int icon_size_lookup(int size, /*out*/ int* width, /*out*/ int* height) {
   return gtk_icon_size_lookup(size, width, height);
}


// Obtains the pixel size of a semantic icon size, possibly
// modified by user preferences for a particular
// #GtkSettings. Normally @size would be
// #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc.  This function
// isn't normally needed, gtk_widget_render_icon() is the usual
// way to get an icon for rendering, then just look at the size of
// the rendered pixbuf. The rendered pixbuf may not even correspond to
// the width/height returned by gtk_icon_size_lookup(), because themes
// are free to render the pixbuf however they like, including changing
// the usual size.
// RETURNS: %TRUE if @size was a valid size
// <settings>: a #GtkSettings object, used to determine which set of user preferences to used.
// <size>: an icon size
// <width>: location to store icon width
// <height>: location to store icon height
static int icon_size_lookup_for_settings(Settings* settings, int size, /*out*/ int* width, /*out*/ int* height) {
   return gtk_icon_size_lookup_for_settings(settings, size, width, height);
}


// Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU,
// etc. Returns the integer value for the size.
// RETURNS: integer value representing the size
// <name>: name of the icon size
// <width>: the icon width
// <height>: the icon height
static int icon_size_register(char* name, int width, int height) {
   return gtk_icon_size_register(name, width, height);
}


// Registers @alias as another name for @target.
// So calling gtk_icon_size_from_name() with @alias as argument
// will return @target.
// <alias>: an alias for @target
// <target>: an existing icon size
static void icon_size_register_alias(char* alias_, int target) {
   gtk_icon_size_register_alias(alias_, target);
}

static GLib2.Quark icon_theme_error_quark() {
   return gtk_icon_theme_error_quark();
}

static Type identifier_get_type() {
   return gtk_identifier_get_type();
}

// Unintrospectable function: idle_add() / gtk_idle_add()
static uint idle_add(Function function_, void* data) {
   return gtk_idle_add(function_, data);
}

// Unintrospectable function: idle_add_full() / gtk_idle_add_full()
static uint idle_add_full(int priority, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy) {
   return gtk_idle_add_full(priority, function_, marshal, data, destroy);
}

// Unintrospectable function: idle_add_priority() / gtk_idle_add_priority()
static uint idle_add_priority(int priority, Function function_, void* data) {
   return gtk_idle_add_priority(priority, function_, data);
}

static void idle_remove(uint idle_handler_id) {
   gtk_idle_remove(idle_handler_id);
}

static void idle_remove_by_data(void* data) {
   gtk_idle_remove_by_data(data);
}


// Call this function before using any other GTK+ functions in your GUI
// applications.  It will initialize everything needed to operate the
// toolkit and parses some standard command line options.
// never see those standard arguments.
// Note that there are some alternative ways to initialize GTK+:
// if you are calling gtk_parse_args(), gtk_init_check(),
// gtk_init_with_args() or g_option_context_parse() with
// the option group returned by gtk_get_option_group(),
// you <emphasis>don't</emphasis> have to call gtk_init().
// <note><para>
// This function will terminate your program if it was unable to
// initialize the windowing system for some reason. If you want
// your program to fall back to a textual interface you want to
// call gtk_init_check() instead.
// </para></note>
// <note><para>
// Since 2.18, GTK+ calls <literal>signal (SIGPIPE, SIG_IGN)</literal>
// during initialization, to ignore SIGPIPE signals, since these are
// almost never wanted in graphical applications. If you do need to
// handle SIGPIPE for some reason, reset the handler after gtk_init(),
// but notice that other libraries (e.g. libdbus or gvfs) might do
// similar things.
// </para></note>
// <argc>: Address of the <parameter>argc</parameter> parameter of your main() function. Changed if any arguments were handled
// <argv>: Address of the <parameter>argv</parameter> parameter of main(). Any options understood by GTK+ are stripped before return.
static void init(/*inout*/ int* argc, /*inout*/ char*** argv=null) {
   gtk_init(argc, argv);
}

// Unintrospectable function: init_add() / gtk_init_add()
static void init_add(Function function_, void* data) {
   gtk_init_add(function_, data);
}


// This function does the same work as gtk_init() with only
// initialized. Instead it returns %FALSE on failure.
// This way the application can fall back to some other means of communication 
// with the user - for example a curses or command line interface.
// %FALSE otherwise.
// RETURNS: %TRUE if the GUI has been successfully initialized,
// <argc>: Address of the <parameter>argc</parameter> parameter of your main() function. Changed if any arguments were handled.
// <argv>: Address of the <parameter>argv</parameter> parameter of main(). Any parameters understood by gtk_init() are stripped before return.
static int init_check(/*inout*/ int* argc, /*inout*/ char*** argv=null) {
   return gtk_init_check(argc, argv);
}


// This function does the same work as gtk_init_check(). 
// Additionally, it allows you to add your own commandline options, 
// and it automatically generates nicely formatted 
// <option>--help</option> output. Note that your program will
// be terminated after writing out the help output.
// %FALSE otherwise.
// RETURNS: %TRUE if the GUI has been successfully initialized,
// <argc>: a pointer to the number of command line arguments.
// <argv>: a pointer to the array of command line arguments.
// <parameter_string>: a string which is displayed in the first line of <option>--help</option> output, after <literal><replaceable>programname</replaceable> [OPTION...]</literal>
// <entries>: a %NULL-terminated array of #GOptionEntry<!-- -->s describing the options of your program
// <translation_domain>: a translation domain to use for translating the <option>--help</option> output for the options in @entries with gettext(), or %NULL
static int init_with_args(/*inout*/ int* argc, /*inout*/ char*** argv, char* parameter_string, GLib2.OptionEntry* entries, char* translation_domain, GLib2.Error** error=null) {
   return gtk_init_with_args(argc, argv, parameter_string, entries, translation_domain, error);
}

// Unintrospectable function: input_add_full() / gtk_input_add_full()
static uint input_add_full(int source, Gdk2.InputCondition condition, Gdk2.InputFunction function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy) {
   return gtk_input_add_full(source, condition, function_, marshal, data, destroy);
}

static void input_remove(uint input_handler_id) {
   gtk_input_remove(input_handler_id);
}

// Unintrospectable function: key_snooper_install() / gtk_key_snooper_install()
static uint key_snooper_install(KeySnoopFunc snooper, void* func_data) {
   return gtk_key_snooper_install(snooper, func_data);
}

static void key_snooper_remove(uint snooper_handler_id) {
   gtk_key_snooper_remove(snooper_handler_id);
}

static void main_() {
   gtk_main();
}

static void main_do_event(Gdk2.Event* event) {
   gtk_main_do_event(event);
}

static int main_iteration() {
   return gtk_main_iteration();
}

static int main_iteration_do(int blocking) {
   return gtk_main_iteration_do(blocking);
}

static uint main_level() {
   return gtk_main_level();
}

static void main_quit() {
   gtk_main_quit();
}

static void marshal_BOOLEAN__POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_BOOLEAN__POINTER_INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__POINTER_INT_INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_BOOLEAN__POINTER_INT_INT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_BOOLEAN__POINTER_POINTER_INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_BOOLEAN__POINTER_STRING_STRING_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_BOOLEAN__VOID(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_BOOLEAN__VOID(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_ENUM__ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_ENUM__ENUM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_INT__POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_INT__POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_INT__POINTER_CHAR_CHAR(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_INT__POINTER_CHAR_CHAR(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__ENUM_FLOAT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__ENUM_FLOAT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__ENUM_FLOAT_BOOLEAN(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__INT_INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__INT_INT_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__INT_INT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_POINTER_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_POINTER_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_POINTER_UINT_UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_STRING_STRING(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_STRING_STRING(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_UINT_ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_UINT_ENUM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__POINTER_UINT_UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__STRING_INT_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__STRING_INT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__UINT_POINTER_UINT_UINT_ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

static void marshal_VOID__UINT_STRING(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data) {
   gtk_marshal_VOID__UINT_STRING(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


// Draws an arrow in the given rectangle on @window using the given 
// parameters. @arrow_type determines the direction of the arrow.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <arrow_type>: the type of arrow to draw
// <fill>: %TRUE if the arrow tip should be filled
// <x>: x origin of the rectangle to draw the arrow in
// <y>: y origin of the rectangle to draw the arrow in
// <width>: width of the rectangle to draw the arrow in
// <height>: height of the rectangle to draw the arrow in
static void paint_arrow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, ArrowType arrow_type, int fill, int x, int y, int width, int height) {
   gtk_paint_arrow(style, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
}


// Draws a box on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the box
// <y>: y origin of the box
// <width>: the width of the box
// <height>: the height of the box
static void paint_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_box(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a box in @window using the given style and state and shadow type, 
// leaving a gap in one side.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
// <gap_side>: side in which to leave the gap
// <gap_x>: starting position of the gap
// <gap_width>: width of the gap
static void paint_box_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) {
   gtk_paint_box_gap(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
}


// Draws a check button indicator in the given rectangle on @window with 
// the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle to draw the check in
// <y>: y origin of the rectangle to draw the check in
// <width>: the width of the rectangle to draw the check in
// <height>: the height of the rectangle to draw the check in
static void paint_check(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_check(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a diamond in the given rectangle on @window using the given
// parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle to draw the diamond in
// <y>: y origin of the rectangle to draw the diamond in
// <width>: width of the rectangle to draw the diamond in
// <height>: height of the rectangle to draw the diamond in
static void paint_diamond(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_diamond(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws an expander as used in #GtkTreeView. @x and @y specify the
// center the expander. The size of the expander is determined by the
// "expander-size" style property of @widget.  (If widget is not
// specified or doesn't have an "expander-size" property, an
// unspecified default size will be used, since the caller doesn't
// have sufficient information to position the expander, this is
// likely not useful.) The expander is expander_size pixels tall
// in the collapsed position and expander_size pixels wide in the
// expanded position.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: the x position to draw the expander at
// <y>: the y position to draw the expander at
// <expander_style>: the style to draw the expander in; determines whether the expander is collapsed, expanded, or in an intermediate state.
static void paint_expander(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, ExpanderStyle expander_style) {
   gtk_paint_expander(style, window, state_type, area, widget, detail, x, y, expander_style);
}


// Draws an extension, i.e. a notebook tab.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the extension
// <y>: y origin of the extension
// <width>: width of the extension
// <height>: width of the extension
// <gap_side>: the side on to which the extension is attached
static void paint_extension(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side) {
   gtk_paint_extension(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
}


// Draws a flat box on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the box
// <y>: y origin of the box
// <width>: the width of the box
// <height>: the height of the box
static void paint_flat_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_flat_box(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a focus indicator around the given rectangle on @window using the
// given style.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: the x origin of the rectangle around which to draw a focus indicator
// <y>: the y origin of the rectangle around which to draw a focus indicator
// <width>: the width of the rectangle around which to draw a focus indicator
// <height>: the height of the rectangle around which to draw a focus indicator
static void paint_focus(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_focus(style, window, state_type, area, widget, detail, x, y, width, height);
}


// Draws a handle as used in #GtkHandleBox and #GtkPaned.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the handle
// <y>: y origin of the handle
// <width>: with of the handle
// <height>: height of the handle
// <orientation>: the orientation of the handle
static void paint_handle(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation) {
   gtk_paint_handle(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
}


// Draws a horizontal line from (@x1, @y) to (@x2, @y) in @window
// using the given style and state.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: rectangle to which the output is clipped, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x1>: the starting x coordinate
// <x2>: the ending x coordinate
// <y>: the y coordinate
static void paint_hline(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x1, int x2, int y) {
   gtk_paint_hline(style, window, state_type, area, widget, detail, x1, x2, y);
}


// Draws a layout on @window using the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <use_text>: whether to use the text or foreground graphics context of @style
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin
// <y>: y origin
// <layout>: the layout to draw
static void paint_layout(Style* style, Gdk2.Window* window, StateType state_type, int use_text, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, Pango.Layout* layout) {
   gtk_paint_layout(style, window, state_type, use_text, area, widget, detail, x, y, layout);
}


// Draws a radio button indicator in the given rectangle on @window with 
// the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle to draw the option in
// <y>: y origin of the rectangle to draw the option in
// <width>: the width of the rectangle to draw the option in
// <height>: the height of the rectangle to draw the option in
static void paint_option(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_option(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a polygon on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <points>: an array of #GdkPoint<!-- -->s
// <n_points>: length of @points
// <fill>: %TRUE if the polygon should be filled
static void paint_polygon(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.Point* points, int n_points, int fill) {
   gtk_paint_polygon(style, window, state_type, shadow_type, area, widget, detail, points, n_points, fill);
}


// Draws a resize grip in the given rectangle on @window using the given
// parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <edge>: the edge in which to draw the resize grip
// <x>: the x origin of the rectangle in which to draw the resize grip
// <y>: the y origin of the rectangle in which to draw the resize grip
// <width>: the width of the rectangle in which to draw the resize grip
// <height>: the height of the rectangle in which to draw the resize grip
static void paint_resize_grip(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.WindowEdge edge, int x, int y, int width, int height) {
   gtk_paint_resize_grip(style, window, state_type, area, widget, detail, edge, x, y, width, height);
}


// Draws a shadow around the given rectangle in @window 
// using the given style and state and shadow type.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
static void paint_shadow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_shadow(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a shadow around the given rectangle in @window 
// using the given style and state and shadow type, leaving a 
// gap in one side.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle
// <y>: y origin of the rectangle
// <width>: width of the rectangle
// <height>: width of the rectangle
// <gap_side>: side in which to leave the gap
// <gap_x>: starting position of the gap
// <gap_width>: width of the gap
static void paint_shadow_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) {
   gtk_paint_shadow_gap(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
}


// Draws a slider in the given rectangle on @window using the
// given style and orientation.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: a shadow
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: the x origin of the rectangle in which to draw a slider
// <y>: the y origin of the rectangle in which to draw a slider
// <width>: the width of the rectangle in which to draw a slider
// <height>: the height of the rectangle in which to draw a slider
// <orientation>: the orientation to be used
static void paint_slider(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation) {
   gtk_paint_slider(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
}


// Draws a spinner on @window using the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget (may be %NULL)
// <detail>: a style detail (may be %NULL)
// <step>: the nth step, a value between 0 and #GtkSpinner:num-steps
// <x>: the x origin of the rectangle in which to draw the spinner
// <y>: the y origin of the rectangle in which to draw the spinner
// <width>: the width of the rectangle in which to draw the spinner
// <height>: the height of the rectangle in which to draw the spinner
static void paint_spinner(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, uint step, int x, int y, int width, int height) {
   gtk_paint_spinner(style, window, state_type, area, widget, detail, step, x, y, width, height);
}


// Draws a text string on @window with the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin
// <y>: y origin
// <string>: the string to draw
static void paint_string(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, char* string_) {
   gtk_paint_string(style, window, state_type, area, widget, detail, x, y, string_);
}


// Draws an option menu tab (i.e. the up and down pointing arrows)
// in the given rectangle on @window using the given parameters.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <shadow_type>: the type of shadow to draw
// <area>: clip rectangle, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <x>: x origin of the rectangle to draw the tab in
// <y>: y origin of the rectangle to draw the tab in
// <width>: the width of the rectangle to draw the tab in
// <height>: the height of the rectangle to draw the tab in
static void paint_tab(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height) {
   gtk_paint_tab(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}


// Draws a vertical line from (@x, @y1_) to (@x, @y2_) in @window
// using the given style and state.
// <style>: a #GtkStyle
// <window>: a #GdkWindow
// <state_type>: a state
// <area>: rectangle to which the output is clipped, or %NULL if the output should not be clipped
// <widget>: the widget
// <detail>: a style detail
// <y1_>: the starting y coordinate
// <y2_>: the ending y coordinate
// <x>: the x coordinate
static void paint_vline(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int y1_, int y2_, int x) {
   gtk_paint_vline(style, window, state_type, area, widget, detail, y1_, y2_, x);
}


// Returns the name of the default paper size, which 
// depends on the current locale.  
// is owned by GTK+ and should not be modified.
// RETURNS: the name of the default paper size. The string
static char* paper_size_get_default() {
   return gtk_paper_size_get_default();
}


// Creates a list of known paper sizes.
// allocated #GtkPaperSize objects
// RETURNS: a newly allocated list of newly
// <include_custom>: whether to include custom paper sizes as defined in the page setup dialog
static GLib2.List* /*new*/ paper_size_get_paper_sizes(int include_custom) {
   return gtk_paper_size_get_paper_sizes(include_custom);
}


// Parses command line arguments, and initializes global
// attributes of GTK+, but does not actually open a connection
// to a display. (See gdk_display_open(), gdk_get_display_arg_name())
// Any arguments used by GTK+ or GDK are removed from the array and
// There is no need to call this function explicitely if you are using
// gtk_init(), or gtk_init_check().
// RETURNS: %TRUE if initialization succeeded, otherwise %FALSE.
// <argc>: a pointer to the number of command line arguments
// <argv>: a pointer to the array of command line arguments
static int parse_args(/*inout*/ int* argc, /*inout*/ char*** argv) {
   return gtk_parse_args(argc, argv);
}


// Registers an error quark for #GtkPrintOperation if necessary.
// RETURNS: The error quark used for #GtkPrintOperation errors.
static GLib2.Quark print_error_quark() {
   return gtk_print_error_quark();
}


// Runs a page setup dialog, letting the user modify the values from
// is identical to the passed in @page_setup, otherwise it contains the 
// modifications done in the dialog.
// Note that this function may use a recursive mainloop to show the page
// setup dialog. See gtk_print_run_page_setup_dialog_async() if this is 
// a problem.
// RETURNS: a new #GtkPageSetup
// <parent>: transient parent
// <page_setup>: an existing #GtkPageSetup
// <settings>: a #GtkPrintSettings
static PageSetup* /*new*/ print_run_page_setup_dialog(Window* parent, PageSetup* page_setup, PrintSettings* settings) {
   return gtk_print_run_page_setup_dialog(parent, page_setup, settings);
}


// Unintrospectable function: print_run_page_setup_dialog_async() / gtk_print_run_page_setup_dialog_async()
// Runs a page setup dialog, letting the user modify the values from @page_setup. 
// In contrast to gtk_print_run_page_setup_dialog(), this function  returns after 
// showing the page setup dialog on platforms that support this, and calls @done_cb 
// from a signal handler for the ::response signal of the dialog.
// <parent>: transient parent, or %NULL
// <page_setup>: an existing #GtkPageSetup, or %NULL
// <settings>: a #GtkPrintSettings
// <done_cb>: a function to call when the user saves the modified page setup
// <data>: user data to pass to @done_cb
static void print_run_page_setup_dialog_async(Window* parent, PageSetup* page_setup, PrintSettings* settings, PageSetupDoneFunc done_cb, void* data) {
   gtk_print_run_page_setup_dialog_async(parent, page_setup, settings, done_cb, data);
}


// Sends an event to a widget, propagating the event to parent widgets
// if the event remains unhandled. Events received by GTK+ from GDK
// normally begin in gtk_main_do_event(). Depending on the type of
// event, existence of modal dialogs, grabs, etc., the event may be
// propagated; if so, this function is used. gtk_propagate_event()
// calls gtk_widget_event() on each widget it decides to send the
// event to.  So gtk_widget_event() is the lowest-level function; it
// simply emits the "event" and possibly an event-specific signal on a
// widget.  gtk_propagate_event() is a bit higher-level, and
// gtk_main_do_event() is the highest level.
// All that said, you most likely don't want to use any of these
// functions; synthesizing events is rarely needed. Consider asking on
// the mailing list for better ways to achieve your goals. For
// example, use gdk_window_invalidate_rect() or
// gtk_widget_queue_draw() instead of making up expose events.
// <widget>: a #GtkWidget
// <event>: an event
static void propagate_event(Widget* widget, Gdk2.Event* event) {
   gtk_propagate_event(widget, event);
}

// Unintrospectable function: quit_add() / gtk_quit_add()
static uint quit_add(uint main_level, Function function_, void* data) {
   return gtk_quit_add(main_level, function_, data);
}

static void quit_add_destroy(uint main_level, Object* object) {
   gtk_quit_add_destroy(main_level, object);
}

// Unintrospectable function: quit_add_full() / gtk_quit_add_full()
static uint quit_add_full(uint main_level, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy) {
   return gtk_quit_add_full(main_level, function_, marshal, data, destroy);
}

static void quit_remove(uint quit_handler_id) {
   gtk_quit_remove(quit_handler_id);
}

static void quit_remove_by_data(void* data) {
   gtk_quit_remove_by_data(data);
}

static void rc_add_class_style(RcStyle* rc_style, char* pattern) {
   gtk_rc_add_class_style(rc_style, pattern);
}


// Adds a file to the list of files to be parsed at the
// end of gtk_init().
// <filename>: the pathname to the file. If @filename is not absolute, it is searched in the current directory.
static void rc_add_default_file(char* filename) {
   gtk_rc_add_default_file(filename);
}

static void rc_add_widget_class_style(RcStyle* rc_style, char* pattern) {
   gtk_rc_add_widget_class_style(rc_style, pattern);
}

static void rc_add_widget_name_style(RcStyle* rc_style, char* pattern) {
   gtk_rc_add_widget_name_style(rc_style, pattern);
}


// Searches for a theme engine in the GTK+ search path. This function
// is not useful for applications and should not be used.
// otherwise %NULL.
// RETURNS: The filename, if found (must be freed with g_free()),
// <module_file>: name of a theme engine
static char* /*new*/ rc_find_module_in_path(char* module_file) {
   return gtk_rc_find_module_in_path(module_file);
}


// Looks up a file in pixmap path for the specified #GtkSettings.
// If the file is not found, it outputs a warning message using
// g_warning() and returns %NULL.
// RETURNS: the filename.
// <settings>: a #GtkSettings
// <scanner>: Scanner used to get line number information for the warning message, or %NULL
// <pixmap_file>: name of the pixmap file to locate.
static char* /*new*/ rc_find_pixmap_in_path(Settings* settings, GLib2.Scanner* scanner, char* pixmap_file) {
   return gtk_rc_find_pixmap_in_path(settings, scanner, pixmap_file);
}


// Retrieves the current list of RC files that will be parsed
// at the end of gtk_init().
// A %NULL-terminated array of filenames.
// This memory is owned by GTK+ and must not be freed by the application.
// If you want to store this information, you should make a copy.
static char** rc_get_default_files() {
   return gtk_rc_get_default_files();
}


// Obtains the path to the IM modules file. See the documentation
// of the <link linkend="im-module-file"><envar>GTK_IM_MODULE_FILE</envar></link>
// environment variable for more details.
// RETURNS: a newly-allocated string containing the name of the file listing the IM modules available for loading
static char* /*new*/ rc_get_im_module_file() {
   return gtk_rc_get_im_module_file();
}


// Obtains the path in which to look for IM modules. See the documentation
// of the <link linkend="im-module-path"><envar>GTK_PATH</envar></link>
// environment variable for more details about looking up modules. This
// function is useful solely for utilities supplied with GTK+ and should
// not be used by applications under normal circumstances.
// RETURNS: a newly-allocated string containing the path in which to look for IM modules.
static char* /*new*/ rc_get_im_module_path() {
   return gtk_rc_get_im_module_path();
}


// Returns a directory in which GTK+ looks for theme engines.
// For full information about the search for theme engines,
// see the docs for <envar>GTK_PATH</envar> in
// <xref linkend="gtk-running"/>.
// RETURNS: the directory. (Must be freed with g_free())
static char* /*new*/ rc_get_module_dir() {
   return gtk_rc_get_module_dir();
}


// Finds all matching RC styles for a given widget,
// composites them together, and then creates a 
// #GtkStyle representing the composite appearance.
// (GTK+ actually keeps a cache of previously 
// created styles, so a new style may not be
// created.)
// to the returned style, so if you want to save this
// style around, you should add a reference yourself.
// RETURNS: the resulting style. No refcount is added
// <widget>: a #GtkWidget
static Style* rc_get_style(Widget* widget) {
   return gtk_rc_get_style(widget);
}


// Creates up a #GtkStyle from styles defined in a RC file by providing
// the raw components used in matching. This function may be useful
// when creating pseudo-widgets that should be themed like widgets but
// don't actually have corresponding GTK+ widgets. An example of this
// would be items inside a GNOME canvas widget.
// The action of gtk_rc_get_style() is similar to:
// |[
// gtk_widget_path (widget, NULL, &path, NULL);
// gtk_widget_class_path (widget, NULL, &class_path, NULL);
// gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), 
// path, class_path,
// G_OBJECT_TYPE (widget));
// ]|
// supplied paths, or %NULL if nothing matching was specified and the
// default style should be used. The returned value is owned by GTK+
// as part of an internal cache, so you must call g_object_ref() on
// the returned value if you want to keep a reference to it.
// RETURNS: A style created by matching with the
// <settings>: a #GtkSettings object
// <widget_path>: the widget path to use when looking up the style, or %NULL if no matching against the widget path should be done
// <class_path>: the class path to use when looking up the style, or %NULL if no matching against the class path should be done.
// <type>: a type that will be used along with parent types of this type when matching against class styles, or #G_TYPE_NONE
static Style* rc_get_style_by_paths(Settings* settings, char* widget_path, char* class_path, Type type) {
   return gtk_rc_get_style_by_paths(settings, widget_path, class_path, type);
}

static char* /*new*/ rc_get_theme_dir() {
   return gtk_rc_get_theme_dir();
}

static void rc_parse(char* filename) {
   gtk_rc_parse(filename);
}


// Parses a color in the <link linkend="color=format">format</link> expected
// in a RC file. 
// Note that theme engines should use gtk_rc_parse_color_full() in 
// order to support symbolic colors.
// that was expected but not found
// RETURNS: %G_TOKEN_NONE if parsing succeeded, otherwise the token
// <scanner>: a #GScanner
// <color>: a pointer to a #GdkColor structure in which to store the result
static uint rc_parse_color(GLib2.Scanner* scanner, /*out*/ Gdk2.Color* color) {
   return gtk_rc_parse_color(scanner, color);
}


// Parses a color in the <link linkend="color=format">format</link> expected
// in a RC file. If @style is not %NULL, it will be consulted to resolve
// references to symbolic colors.
// that was expected but not found
// RETURNS: %G_TOKEN_NONE if parsing succeeded, otherwise the token
// <scanner>: a #GScanner
// <style>: a #GtkRcStyle, or %NULL
// <color>: a pointer to a #GdkColor structure in which to store the result
static uint rc_parse_color_full(GLib2.Scanner* scanner, RcStyle* style, /*out*/ Gdk2.Color* color) {
   return gtk_rc_parse_color_full(scanner, style, color);
}

static uint rc_parse_priority(GLib2.Scanner* scanner, PathPriorityType* priority) {
   return gtk_rc_parse_priority(scanner, priority);
}

static uint rc_parse_state(GLib2.Scanner* scanner, StateType* state) {
   return gtk_rc_parse_state(scanner, state);
}

static void rc_parse_string(char* rc_string) {
   gtk_rc_parse_string(rc_string);
}


// A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
// or gtk_widget_class_install_style_property_parser() which parses
// borders in the form 
// <literal>"{ left, right, top, bottom }"</literal> for integers 
// %left, %right, %top and %bottom.
// has been set to the resulting #GtkBorder.
// RETURNS: %TRUE if @gstring could be parsed and @property_value
// <pspec>: a #GParamSpec
// <gstring>: the #GString to be parsed
// <property_value>: a #GValue which must hold boxed values.
static int rc_property_parse_border(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value) {
   return gtk_rc_property_parse_border(pspec, gstring, property_value);
}


// A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
// or gtk_widget_class_install_style_property_parser() which parses a
// color given either by its name or in the form 
// <literal>{ red, green, blue }</literal> where %red, %green and
// %blue are integers between 0 and 65535 or floating-point numbers
// between 0 and 1.
// has been set to the resulting #GdkColor.
// RETURNS: %TRUE if @gstring could be parsed and @property_value
// <pspec>: a #GParamSpec
// <gstring>: the #GString to be parsed
// <property_value>: a #GValue which must hold #GdkColor values.
static int rc_property_parse_color(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value) {
   return gtk_rc_property_parse_color(pspec, gstring, property_value);
}


// A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
// or gtk_widget_class_install_style_property_parser() which parses a single
// enumeration value.
// The enumeration value can be specified by its name, its nickname or
// its numeric value. For consistency with flags parsing, the value
// may be surrounded by parentheses.
// has been set to the resulting #GEnumValue.
// RETURNS: %TRUE if @gstring could be parsed and @property_value
// <pspec>: a #GParamSpec
// <gstring>: the #GString to be parsed
// <property_value>: a #GValue which must hold enum values.
static int rc_property_parse_enum(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value) {
   return gtk_rc_property_parse_enum(pspec, gstring, property_value);
}


// A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
// or gtk_widget_class_install_style_property_parser() which parses flags. 
// Flags can be specified by their name, their nickname or
// numerically. Multiple flags can be specified in the form 
// <literal>"( flag1 | flag2 | ... )"</literal>.
// has been set to the resulting flags value.
// RETURNS: %TRUE if @gstring could be parsed and @property_value
// <pspec>: a #GParamSpec
// <gstring>: the #GString to be parsed
// <property_value>: a #GValue which must hold flags values.
static int rc_property_parse_flags(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value) {
   return gtk_rc_property_parse_flags(pspec, gstring, property_value);
}


// A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
// or gtk_widget_class_install_style_property_parser() which parses a
// requisition in the form 
// <literal>"{ width, height }"</literal> for integers %width and %height.
// has been set to the resulting #GtkRequisition.
// RETURNS: %TRUE if @gstring could be parsed and @property_value
// <pspec>: a #GParamSpec
// <gstring>: the #GString to be parsed
// <property_value>: a #GValue which must hold boxed values.
static int rc_property_parse_requisition(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value) {
   return gtk_rc_property_parse_requisition(pspec, gstring, property_value);
}


// If the modification time on any previously read file for the
// default #GtkSettings has changed, discard all style information
// and then reread all previously read RC files.
// RETURNS: %TRUE if the files were reread.
static int rc_reparse_all() {
   return gtk_rc_reparse_all();
}


// If the modification time on any previously read file
// for the given #GtkSettings has changed, discard all style information
// and then reread all previously read RC files.
// RETURNS: %TRUE if the files were reread.
// <settings>: a #GtkSettings
// <force_load>: load whether or not anything changed
static int rc_reparse_all_for_settings(Settings* settings, int force_load) {
   return gtk_rc_reparse_all_for_settings(settings, force_load);
}


// This function recomputes the styles for all widgets that use a
// particular #GtkSettings object. (There is one #GtkSettings object
// per #GdkScreen, see gtk_settings_get_for_screen()); It is useful
// when some global parameter has changed that affects the appearance
// of all widgets, because when a widget gets a new style, it will
// both redraw and recompute any cached information about its
// appearance. As an example, it is used when the default font size
// set by the operating system changes. Note that this function
// doesn't affect widgets that have a style set explicitely on them
// with gtk_widget_set_style().
// <settings>: a #GtkSettings
static void rc_reset_styles(Settings* settings) {
   gtk_rc_reset_styles(settings);
}

// Unintrospectable function: rc_scanner_new() / gtk_rc_scanner_new()
static GLib2.Scanner* rc_scanner_new() {
   return gtk_rc_scanner_new();
}


// Sets the list of files that GTK+ will read at the
// end of gtk_init().
// <filenames>: A %NULL-terminated list of filenames.
static void rc_set_default_files(char** filenames) {
   gtk_rc_set_default_files(filenames);
}

static GLib2.Quark recent_chooser_error_quark() {
   return gtk_recent_chooser_error_quark();
}

static GLib2.Quark recent_manager_error_quark() {
   return gtk_recent_manager_error_quark();
}


// Converts a color from RGB space to HSV.
// Input values must be in the [0.0, 1.0] range;
// output values will be in the same range.
// <r>: Red
// <g>: Green
// <b>: Blue
// <h>: Return value for the hue component
// <s>: Return value for the saturation component
// <v>: Return value for the value component
static void rgb_to_hsv(double r, double g, double b, /*out*/ double* h, /*out*/ double* s, /*out*/ double* v) {
   gtk_rgb_to_hsv(r, g, b, h, s, v);
}


// Appends a specified target to the list of supported targets for a 
// given widget and selection.
// <widget>: a #GtkTarget
// <selection>: the selection
// <target>: target to add.
// <info>: A unsigned integer which will be passed back to the application.
static void selection_add_target(Widget* widget, Gdk2.Atom selection, Gdk2.Atom target, uint info) {
   gtk_selection_add_target(widget, selection, target, info);
}


// Prepends a table of targets to the list of supported targets
// for a given widget and selection.
// <widget>: a #GtkWidget
// <selection>: the selection
// <targets>: a table of targets to add
// <ntargets>: number of entries in @targets
static void selection_add_targets(Widget* widget, Gdk2.Atom selection, TargetEntry* targets, uint ntargets) {
   gtk_selection_add_targets(widget, selection, targets, ntargets);
}


// The default handler for the #GtkWidget::selection-clear-event
// signal. 
// your selection-clear-event handler. Calling this function
// from any other context is illegal.
// RETURNS: %TRUE if the event was handled, otherwise false
// <widget>: a #GtkWidget
// <event>: the event
static int selection_clear(Widget* widget, Gdk2.EventSelection* event) {
   return gtk_selection_clear(widget, event);
}


// Remove all targets registered for the given selection for the
// widget.
// <widget>: a #GtkWidget
// <selection>: an atom representing a selection
static void selection_clear_targets(Widget* widget, Gdk2.Atom selection) {
   gtk_selection_clear_targets(widget, selection);
}


// Requests the contents of a selection. When received, 
// a "selection-received" signal will be generated.
// request. (e.g., there was already a request in process for
// this widget).
// RETURNS: %TRUE if requested succeeded. %FALSE if we could not process
// <widget>: The widget which acts as requestor
// <selection>: Which selection to get
// <target>: Form of information desired (e.g., STRING)
// <time_>: Time of request (usually of triggering event)
static int selection_convert(Widget* widget, Gdk2.Atom selection, Gdk2.Atom target, uint time_) {
   return gtk_selection_convert(widget, selection, target, time_);
}


// Claims ownership of a given selection for a particular widget,
// or, if @widget is %NULL, release ownership of the selection.
// RETURNS: %TRUE if the operation succeeded
// <widget>: a #GtkWidget, or %NULL.
// <selection>: an interned atom representing the selection to claim
// <time_>: timestamp with which to claim the selection
static int selection_owner_set(Widget* widget, Gdk2.Atom selection, uint time_) {
   return gtk_selection_owner_set(widget, selection, time_);
}


// Claim ownership of a given selection for a particular widget, or,
// if @widget is %NULL, release ownership of the selection.
// RETURNS: TRUE if the operation succeeded
// <display>: the #Gdkdisplay where the selection is set
// <widget>: new selection owner (a #GdkWidget), or %NULL.
// <selection>: an interned atom representing the selection to claim.
// <time_>: timestamp with which to claim the selection
static int selection_owner_set_for_display(Gdk2.Display* display, Widget* widget, Gdk2.Atom selection, uint time_) {
   return gtk_selection_owner_set_for_display(display, widget, selection, time_);
}


// Removes all handlers and unsets ownership of all 
// selections for a widget. Called when widget is being
// destroyed. This function will not generally be
// called by applications.
// <widget>: a #GtkWidget
static void selection_remove_all(Widget* widget) {
   gtk_selection_remove_all(widget);
}


// Initializes internationalization support for GTK+. gtk_init()
// automatically does this, so there is typically no point
// in calling this function.
// If you are calling this function because you changed the locale
// after GTK+ is was initialized, then calling this function
// may help a bit. (Note, however, that changing the locale
// after GTK+ is initialized may produce inconsistent results and
// is not really supported.)
// In detail - sets the current locale according to the
// program environment. This is the same as calling the C library function
// <literal>setlocale (LC_ALL, "")</literal> but also takes care of the 
// locale specific setup of the windowing system used by GDK.
// form lang_COUNTRY, where lang is an ISO-639 language code, and
// COUNTRY is an ISO-3166 country code. On Unix, this form matches the
// result of the setlocale(); it is also used on other machines, such as 
// Windows, where the C library returns a different result. The string is 
// owned by GTK+ and should not be modified or freed.
// RETURNS: a string corresponding to the locale set, typically in the
static char* /*new*/ set_locale() {
   return gtk_set_locale();
}


// Unintrospectable function: show_about_dialog() / gtk_show_about_dialog()
// This is a convenience function for showing an application's about box.
// The constructed dialog is associated with the parent window and
// reused for future invocations of this function.
// <parent>: transient parent, or %NULL for none
// <first_property_name>: the name of the first property
alias gtk_show_about_dialog show_about_dialog; // Variadic


// This is a convenience function for launching the default application
// to show the uri. The uri must be of a form understood by GIO (i.e. you
// need to install gvfs to get support for uri schemes such as http://
// or ftp://, as only local files are handled by GIO itself).
// Typical examples are
// <simplelist>
// <member><filename>file:///home/gnome/pict.jpg</filename></member>
// <member><filename>http://www.gnome.org</filename></member>
// <member><filename>mailto:me&commat;gnome.org</filename></member>
// </simplelist>
// Ideally the timestamp is taken from the event triggering
// the gtk_show_uri() call. If timestamp is not known you can take
// %GDK_CURRENT_TIME.
// This function can be used as a replacement for gnome_vfs_url_show()
// and gnome_url_show().
// RETURNS: %TRUE on success, %FALSE on error.
// <screen>: screen to show the uri on or %NULL for the default screen
// <uri>: the uri to show
// <timestamp>: a timestamp to prevent focus stealing.
static int show_uri(Gdk2.Screen* screen, char* uri, uint timestamp, GLib2.Error** error=null) {
   return gtk_show_uri(screen, uri, timestamp, error);
}

// Unintrospectable function: signal_compat_matched() / gtk_signal_compat_matched()
static void signal_compat_matched(Object* object, GObject2.Callback func, void* data, GObject2.SignalMatchType match, uint action) {
   gtk_signal_compat_matched(object, func, data, match, action);
}

// Unintrospectable function: signal_connect_full() / gtk_signal_connect_full()
static c_ulong signal_connect_full(Object* object, char* name, GObject2.Callback func, CallbackMarshal unsupported, void* data, GLib2.DestroyNotify destroy_func, int object_signal, int after) {
   return gtk_signal_connect_full(object, name, func, unsupported, data, destroy_func, object_signal, after);
}

// Unintrospectable function: signal_connect_object_while_alive() / gtk_signal_connect_object_while_alive()
static void signal_connect_object_while_alive(Object* object, char* name, GObject2.Callback func, Object* alive_object) {
   gtk_signal_connect_object_while_alive(object, name, func, alive_object);
}

// Unintrospectable function: signal_connect_while_alive() / gtk_signal_connect_while_alive()
static void signal_connect_while_alive(Object* object, char* name, GObject2.Callback func, void* func_data, Object* alive_object) {
   gtk_signal_connect_while_alive(object, name, func, func_data, alive_object);
}

// Unintrospectable function: signal_emit() / gtk_signal_emit()
alias gtk_signal_emit signal_emit; // Variadic

// Unintrospectable function: signal_emit_by_name() / gtk_signal_emit_by_name()
alias gtk_signal_emit_by_name signal_emit_by_name; // Variadic

static void signal_emit_stop_by_name(Object* object, char* name) {
   gtk_signal_emit_stop_by_name(object, name);
}

static void signal_emitv(Object* object, uint signal_id, Arg* args) {
   gtk_signal_emitv(object, signal_id, args);
}

static void signal_emitv_by_name(Object* object, char* name, Arg* args) {
   gtk_signal_emitv_by_name(object, name, args);
}

// Unintrospectable function: signal_new() / gtk_signal_new()
alias gtk_signal_new signal_new; // Variadic

static uint signal_newv(char* name, SignalRunType signal_flags, Type object_type, uint function_offset, GObject2.SignalCMarshaller marshaller, Type return_val, uint n_args, Type* args) {
   return gtk_signal_newv(name, signal_flags, object_type, function_offset, marshaller, return_val, n_args, args);
}


// Registers each of the stock items in @items. If an item already
// exists with the same stock ID as one of the @items, the old item
// gets replaced. The stock items are copied, so GTK+ does not hold
// any pointer into @items and @items can be freed. Use
// gtk_stock_add_static() if @items is persistent and GTK+ need not
// copy the array.
// <items>: a #GtkStockItem or array of items
// <n_items>: number of #GtkStockItem in @items
static void stock_add(StockItem* items, uint n_items) {
   gtk_stock_add(items, n_items);
}


// Same as gtk_stock_add(), but doesn't copy @items, so
// <items>: a #GtkStockItem or array of #GtkStockItem
// <n_items>: number of items
static void stock_add_static(StockItem* items, uint n_items) {
   gtk_stock_add_static(items, n_items);
}


// Retrieves a list of all known stock IDs added to a #GtkIconFactory
// or registered with gtk_stock_add(). The list must be freed with g_slist_free(),
// and each string in the list must be freed with g_free().
// RETURNS: a list of known stock IDs
static GLib2.SList* /*new*/ stock_list_ids() {
   return gtk_stock_list_ids();
}


// Fills @item with the registered values for @stock_id, returning %TRUE
// if @stock_id was known.
// RETURNS: %TRUE if @item was initialized
// <stock_id>: a stock item name
// <item>: stock item to initialize with values
static int stock_lookup(char* stock_id, /*out*/ StockItem* item) {
   return gtk_stock_lookup(stock_id, item);
}


// Sets a function to be used for translating the @label of 
// a stock item.
// If no function is registered for a translation domain,
// g_dgettext() is used.
// The function is used for all stock items whose
// to use strings different from the actual gettext translation domain
// of your application for this, as long as your #GtkTranslateFunc uses
// the correct domain when calling dgettext(). This can be useful, e.g.
// when dealing with message contexts:
// |[
// GtkStockItem items[] = { 
// { MY_ITEM1, NC_("odd items", "Item 1"), 0, 0, "odd-item-domain" },
// { MY_ITEM2, NC_("even items", "Item 2"), 0, 0, "even-item-domain" },
// };
// gchar *
// my_translate_func (const gchar *msgid,
// gpointer     data)
// {
// gchar *msgctxt = data;
// return (gchar*)g_dpgettext2 (GETTEXT_PACKAGE, msgctxt, msgid);
// }
// /&ast; ... &ast;/
// gtk_stock_add (items, G_N_ELEMENTS (items));
// gtk_stock_set_translate_func ("odd-item-domain", my_translate_func, "odd items"); 
// gtk_stock_set_translate_func ("even-item-domain", my_translate_func, "even items"); 
// ]|
// <domain>: the translation domain for which @func shall be used
// <func>: a #GtkTranslateFunc
// <data>: data to pass to @func
// <notify>: a #GDestroyNotify that is called when @data is no longer needed
static void stock_set_translate_func(char* domain, TranslateFunc func, void* data, GLib2.DestroyNotify notify) {
   gtk_stock_set_translate_func(domain, func, data, notify);
}


// This function frees a target table as returned by
// gtk_target_table_new_from_list()
// <targets>: a #GtkTargetEntry array
// <n_targets>: the number of entries in the array
static void target_table_free(TargetEntry* targets, int n_targets) {
   gtk_target_table_free(targets, n_targets);
}


// This function creates an #GtkTargetEntry array that contains the
// same targets as the passed %list. The returned table is newly
// allocated and should be freed using gtk_target_table_free() when no
// longer needed.
// RETURNS: the new table.
// <list>: a #GtkTargetList
// <n_targets>: return location for the number ot targets in the table
static TargetEntry* /*new*/ target_table_new_from_list(TargetList* list, /*out*/ int* n_targets) {
   return gtk_target_table_new_from_list(list, n_targets);
}


// Determines if any of the targets in @targets can be used to
// provide a #GdkPixbuf.
// otherwise %FALSE.
// RETURNS: %TRUE if @targets include a suitable target for images,
// <targets>: an array of #GdkAtom<!-- -->s
// <n_targets>: the length of @targets
// <writable>: whether to accept only targets for which GTK+ knows how to convert a pixbuf into the format
static int targets_include_image(Gdk2.Atom* targets, int n_targets, int writable) {
   return gtk_targets_include_image(targets, n_targets, writable);
}


// Determines if any of the targets in @targets can be used to
// provide rich text.
// otherwise %FALSE.
// RETURNS: %TRUE if @targets include a suitable target for rich text,
// <targets>: an array of #GdkAtom<!-- -->s
// <n_targets>: the length of @targets
// <buffer>: a #GtkTextBuffer
static int targets_include_rich_text(Gdk2.Atom* targets, int n_targets, TextBuffer* buffer) {
   return gtk_targets_include_rich_text(targets, n_targets, buffer);
}


// Determines if any of the targets in @targets can be used to
// provide text.
// otherwise %FALSE.
// RETURNS: %TRUE if @targets include a suitable target for text,
// <targets>: an array of #GdkAtom<!-- -->s
// <n_targets>: the length of @targets
static int targets_include_text(Gdk2.Atom* targets, int n_targets) {
   return gtk_targets_include_text(targets, n_targets);
}


// Determines if any of the targets in @targets can be used to
// provide an uri list.
// otherwise %FALSE.
// RETURNS: %TRUE if @targets include a suitable target for uri lists,
// <targets>: an array of #GdkAtom<!-- -->s
// <n_targets>: the length of @targets
static int targets_include_uri(Gdk2.Atom* targets, int n_targets) {
   return gtk_targets_include_uri(targets, n_targets);
}


// Create a simple window with window title @window_title and
// text contents @dialog_text.
// The window will quit any running gtk_main()-loop when destroyed, and it
// will automatically be destroyed upon test function teardown.
// RETURNS: a widget pointer to the newly created GtkWindow.
// <window_title>: Title of the window to be displayed.
// <dialog_text>: Text inside the window to be displayed.
static Widget* test_create_simple_window(char* window_title, char* dialog_text) {
   return gtk_test_create_simple_window(window_title, dialog_text);
}


// Unintrospectable function: test_create_widget() / gtk_test_create_widget()
// This function wraps g_object_new() for widget types.
// It'll automatically show all created non window widgets, also
// g_object_ref_sink() them (to keep them alive across a running test)
// and set them up for destruction during the next test teardown phase.
// RETURNS: a newly created widget.
// <widget_type>: a valid widget type.
// <first_property_name>: Name of first property to set or %NULL
alias gtk_test_create_widget test_create_widget; // Variadic


// Unintrospectable function: test_display_button_window() / gtk_test_display_button_window()
// Create a window with window title @window_title, text contents @dialog_text,
// and a number of buttons, according to the paired argument list given
// as @... parameters.
// Each button is created with a @label and a ::clicked signal handler that
// incremrents the integer stored in @nump.
// The window will be automatically shown with gtk_widget_show_now() after
// creation, so when this function returns it has already been mapped,
// resized and positioned on screen.
// The window will quit any running gtk_main()-loop when destroyed, and it
// will automatically be destroyed upon test function teardown.
// RETURNS: a widget pointer to the newly created GtkWindow.
// <window_title>: Title of the window to be displayed.
// <dialog_text>: Text inside the window to be displayed.
alias gtk_test_display_button_window test_display_button_window; // Variadic


// This function will search @widget and all its descendants for a GtkLabel
// widget with a text string matching @label_pattern.
// The @label_pattern may contain asterisks '*' and question marks '?' as
// placeholders, g_pattern_match() is used for the matching.
// Note that locales other than "C" tend to alter (translate" label strings,
// so this function is genrally only useful in test programs with
// predetermined locales, see gtk_test_init() for more details.
// RETURNS: a GtkLabel widget if any is found.
// <widget>: Valid label or container widget.
// <label_pattern>: Shell-glob pattern to match a label string.
static Widget* test_find_label(Widget* widget, char* label_pattern) {
   return gtk_test_find_label(widget, label_pattern);
}


// This function will search siblings of @base_widget and siblings of its
// ancestors for all widgets matching @widget_type.
// Of the matching widgets, the one that is geometrically closest to
// The general purpose of this function is to find the most likely "action"
// widget, relative to another labeling widget. Such as finding a
// button or text entry widget, given it's corresponding label widget.
// RETURNS: a widget of type @widget_type if any is found.
// <base_widget>: Valid widget, part of a widget hierarchy
// <widget_type>: Type of a aearched for sibling widget
static Widget* test_find_sibling(Widget* base_widget, Type widget_type) {
   return gtk_test_find_sibling(base_widget, widget_type);
}


// This function will search the descendants of @widget for a widget
// of type @widget_type that has a label matching @label_pattern next
// to it. This is most useful for automated GUI testing, e.g. to find
// the "OK" button in a dialog and synthesize clicks on it.
// However see gtk_test_find_label(), gtk_test_find_sibling() and
// gtk_test_widget_click() for possible caveats involving the search of
// such widgets and synthesizing widget events.
// RETURNS: a valid widget if any is found or %NULL.
// <widget>: Container widget, usually a GtkWindow.
// <label_pattern>: Shell-glob pattern to match a label string.
// <widget_type>: Type of a aearched for label sibling widget.
static Widget* test_find_widget(Widget* widget, char* label_pattern, Type widget_type) {
   return gtk_test_find_widget(widget, label_pattern, widget_type);
}


// Unintrospectable function: test_init() / gtk_test_init()
// This function is used to initialize a GTK+ test program.
// It will in turn call g_test_init() and gtk_init() to properly
// initialize the testing framework and graphical toolkit. It'll 
// also set the program's locale to "C" and prevent loading of rc 
// files and Gtk+ modules. This is done to make tets program
// environments as deterministic as possible.
// Like gtk_init() and g_test_init(), any known arguments will be
// processed and stripped from @argc and @argv.
// <argcp>: Address of the <parameter>argc</parameter> parameter of the main() function. Changed if any arguments were handled.
// <argvp>: Address of the <parameter>argv</parameter> parameter of main(). Any parameters understood by g_test_init() or gtk_init() are stripped before return.
alias gtk_test_init test_init; // Variadic


// Return the type ids that have been registered after
// calling gtk_test_register_all_types().
// RETURNS: 0-terminated array of type ids
// <n_types>: location to store number of types
static Type* test_list_all_types(/*out*/ uint* n_types) {
   return gtk_test_list_all_types(n_types);
}


// Force registration of all core Gtk+ and Gdk object types.
// This allowes to refer to any of those object types via
// g_type_from_name() after calling this function.
static void test_register_all_types() {
   gtk_test_register_all_types();
}


// Retrive the literal adjustment value for GtkRange based
// widgets and spin buttons. Note that the value returned by
// this function is anything between the lower and upper bounds
// of the adjustment belonging to @widget, and is not a percentage
// as passed in to gtk_test_slider_set_perc().
// RETURNS: adjustment->value for an adjustment belonging to @widget.
// <widget>: valid widget pointer.
static double test_slider_get_value(Widget* widget) {
   return gtk_test_slider_get_value(widget);
}


// This function will adjust the slider position of all GtkRange
// based widgets, such as scrollbars or scales, it'll also adjust
// spin buttons. The adjustment value of these widgets is set to
// a value between the lower and upper limits, according to the
// <widget>: valid widget pointer.
// <percentage>: value between 0 and 100.
static void test_slider_set_perc(Widget* widget, double percentage) {
   gtk_test_slider_set_perc(widget, percentage);
}


// This function will generate a @button click in the upwards or downwards
// spin button arrow areas, usually leading to an increase or decrease of
// spin button's value.
// RETURNS: wether all actions neccessary for the button click simulation were carried out successfully.
// <spinner>: valid GtkSpinButton widget.
// <button>: Number of the pointer button for the event, usually 1, 2 or 3.
// <upwards>: %TRUE for upwards arrow click, %FALSE for downwards arrow click.
static int test_spin_button_click(SpinButton* spinner, uint button, int upwards) {
   return gtk_test_spin_button_click(spinner, button, upwards);
}


// Retrive the text string of @widget if it is a GtkLabel,
// GtkEditable (entry and text widgets) or GtkTextView.
// RETURNS: new 0-terminated C string, needs to be released with g_free().
// <widget>: valid widget pointer.
static char* /*new*/ test_text_get(Widget* widget) {
   return gtk_test_text_get(widget);
}


// Set the text string of @widget to @string if it is a GtkLabel,
// GtkEditable (entry and text widgets) or GtkTextView.
// <widget>: valid widget pointer.
// <string>: a 0-terminated C string
static void test_text_set(Widget* widget, char* string_) {
   gtk_test_text_set(widget, string_);
}


// This function will generate a @button click (button press and button
// release event) in the middle of the first GdkWindow found that belongs
// to @widget.
// For %GTK_NO_WINDOW widgets like GtkButton, this will often be an
// input-only event window. For other widgets, this is usually widget->window.
// Certain caveats should be considered when using this function, in
// particular because the mouse pointer is warped to the button click
// location, see gdk_test_simulate_button() for details.
// RETURNS: wether all actions neccessary for the button click simulation were carried out successfully.
// <widget>: Widget to generate a button click on.
// <button>: Number of the pointer button for the event, usually 1, 2 or 3.
// <modifiers>: Keyboard modifiers the event is setup with.
static int test_widget_click(Widget* widget, uint button, Gdk2.ModifierType modifiers) {
   return gtk_test_widget_click(widget, button, modifiers);
}


// This function will generate keyboard press and release events in
// the middle of the first GdkWindow found that belongs to @widget.
// For %GTK_NO_WINDOW widgets like GtkButton, this will often be an
// input-only event window. For other widgets, this is usually widget->window.
// Certain caveats should be considered when using this function, in
// particular because the mouse pointer is warped to the key press
// location, see gdk_test_simulate_key() for details.
// RETURNS: wether all actions neccessary for the key event simulation were carried out successfully.
// <widget>: Widget to generate a key press and release on.
// <keyval>: A Gdk keyboard value.
// <modifiers>: Keyboard modifiers the event is setup with.
static int test_widget_send_key(Widget* widget, uint keyval, Gdk2.ModifierType modifiers) {
   return gtk_test_widget_send_key(widget, keyval, modifiers);
}

static void text_anchored_child_set_layout(Widget* child, TextLayout* layout) {
   gtk_text_anchored_child_set_layout(child, layout);
}

// Unintrospectable function: timeout_add() / gtk_timeout_add()
static uint timeout_add(uint interval, Function function_, void* data) {
   return gtk_timeout_add(interval, function_, data);
}

// Unintrospectable function: timeout_add_full() / gtk_timeout_add_full()
static uint timeout_add_full(uint interval, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy) {
   return gtk_timeout_add_full(interval, function_, marshal, data, destroy);
}

static void timeout_remove(uint timeout_handler_id) {
   gtk_timeout_remove(timeout_handler_id);
}

// Unintrospectable function: tooltips_data_get() / gtk_tooltips_data_get()
static TooltipsData* tooltips_data_get(Widget* widget) {
   return gtk_tooltips_data_get(widget);
}


// Obtains a @tree_model and @path from selection data of target type
// %GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler.
// This function can only be used if @selection_data originates from the same
// process that's calling this function, because a pointer to the tree model
// is being passed around. If you aren't in the same process, then you'll
// get memory corruption. In the #GtkTreeDragDest drag_data_received handler,
// you can assume that selection data of type %GTK_TREE_MODEL_ROW is
// in from the current process. The returned path must be freed with
// gtk_tree_path_free().
// is otherwise valid
// RETURNS: %TRUE if @selection_data had target type %GTK_TREE_MODEL_ROW and
// <selection_data>: a #GtkSelectionData
// <tree_model>: a #GtkTreeModel
// <path>: row in @tree_model
static int tree_get_row_drag_data(SelectionData* selection_data, /*out*/ TreeModel** tree_model, /*out*/ TreePath** path) {
   return gtk_tree_get_row_drag_data(selection_data, tree_model, path);
}


// Lets a set of row reference created by gtk_tree_row_reference_new_proxy()
// know that the model emitted the "row_deleted" signal.
// <proxy>: A #GObject
// <path>: The path position that was deleted
static void tree_row_reference_deleted(GObject2.Object* proxy, TreePath* path) {
   gtk_tree_row_reference_deleted(proxy, path);
}


// Lets a set of row reference created by gtk_tree_row_reference_new_proxy()
// know that the model emitted the "row_inserted" signal.
// <proxy>: A #GObject
// <path>: The row position that was inserted
static void tree_row_reference_inserted(GObject2.Object* proxy, TreePath* path) {
   gtk_tree_row_reference_inserted(proxy, path);
}


// Lets a set of row reference created by gtk_tree_row_reference_new_proxy()
// know that the model emitted the "rows_reordered" signal.
// <proxy>: A #GObject
// <path>: The parent path of the reordered signal
// <iter>: The iter pointing to the parent of the reordered
// <new_order>: The new order of rows
static void tree_row_reference_reordered(GObject2.Object* proxy, TreePath* path, TreeIter* iter, int* new_order) {
   gtk_tree_row_reference_reordered(proxy, path, iter, new_order);
}


// Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used
// in a drag_data_get handler.
// RETURNS: %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row
// <selection_data>: some #GtkSelectionData
// <tree_model>: a #GtkTreeModel
// <path>: a row in @tree_model
static int tree_set_row_drag_data(SelectionData* selection_data, TreeModel* tree_model, TreePath* path) {
   return gtk_tree_set_row_drag_data(selection_data, tree_model, path);
}

static int true_() {
   return gtk_true();
}


// Unintrospectable function: type_class() / gtk_type_class()
// Returns a pointer pointing to the class of @type or %NULL if there
// was any trouble identifying @type.  Initializes the class if
// necessary.
// RETURNS: pointer to the class.
// <type>: a #GtkType.
static void* type_class(Type type) {
   return gtk_type_class(type);
}

// Unintrospectable function: type_enum_find_value() / gtk_type_enum_find_value()
static EnumValue* type_enum_find_value(Type enum_type, char* value_name) {
   return gtk_type_enum_find_value(enum_type, value_name);
}

// Unintrospectable function: type_enum_get_values() / gtk_type_enum_get_values()
static EnumValue* type_enum_get_values(Type enum_type) {
   return gtk_type_enum_get_values(enum_type);
}

// Unintrospectable function: type_flags_find_value() / gtk_type_flags_find_value()
static FlagValue* type_flags_find_value(Type flags_type, char* value_name) {
   return gtk_type_flags_find_value(flags_type, value_name);
}

// Unintrospectable function: type_flags_get_values() / gtk_type_flags_get_values()
static FlagValue* type_flags_get_values(Type flags_type) {
   return gtk_type_flags_get_values(flags_type);
}

static void type_init(GObject2.TypeDebugFlags debug_flags) {
   gtk_type_init(debug_flags);
}

// Unintrospectable function: type_new() / gtk_type_new()
static void* type_new(Type type) {
   return gtk_type_new(type);
}

static Type type_unique(Type parent_type, TypeInfo* gtkinfo) {
   return gtk_type_unique(parent_type, gtkinfo);
}


//  --- mixin/Gtk2__MODULE.d --->

void _dumpObj(T)(T o, bool deep=0) {
   import std.stdio;
   auto ts = o.tupleof;
   write(typeid(o), " {");
   
   static if (is(typeof(*T)==union)) {
      write(*o, "}\n");
      return;
   }
   else
      writeln();
   
   foreach (i, t; ts) {
      write(" (", typeid(t), ") ", t);
      if (deep)
         static if (is(typeof(*t)))
            if (ts[i])
               write(" {", *ts[i], "}");
      write(i!=ts.length-1 ? "\n" : "\n}\n");
   }
}


// An overload of gtk.init() that works with D strings.
// Unlike the original, it does not need to modify the inputs.
// Returns a new string array (that can be assigned to the argv
// array in the caller).

string[] init(string argv[]) {
   int argc = argv.length;
   auto c_argv = argvToC(argv);
   init(&argc, &c_argv);
   return argvFromC(argc, c_argv);
}


// <--- mixin/Gtk2__MODULE.d ---

// C prototypes:

extern (C) {
AboutDialog* gtk_about_dialog_new();
AboutDialogActivateLinkFunc gtk_about_dialog_set_email_hook(AboutDialogActivateLinkFunc func, void* data, GLib2.DestroyNotify destroy);
AboutDialogActivateLinkFunc gtk_about_dialog_set_url_hook(AboutDialogActivateLinkFunc func, void* data, GLib2.DestroyNotify destroy);
char** gtk_about_dialog_get_artists(AboutDialog* this_);
char** gtk_about_dialog_get_authors(AboutDialog* this_);
char* gtk_about_dialog_get_comments(AboutDialog* this_);
char* gtk_about_dialog_get_copyright(AboutDialog* this_);
char** gtk_about_dialog_get_documenters(AboutDialog* this_);
char* gtk_about_dialog_get_license(AboutDialog* this_);
GdkPixbuf2.Pixbuf* gtk_about_dialog_get_logo(AboutDialog* this_);
char* gtk_about_dialog_get_logo_icon_name(AboutDialog* this_);
char* gtk_about_dialog_get_name(AboutDialog* this_);
char* gtk_about_dialog_get_program_name(AboutDialog* this_);
char* gtk_about_dialog_get_translator_credits(AboutDialog* this_);
char* gtk_about_dialog_get_version(AboutDialog* this_);
char* gtk_about_dialog_get_website(AboutDialog* this_);
char* gtk_about_dialog_get_website_label(AboutDialog* this_);
int gtk_about_dialog_get_wrap_license(AboutDialog* this_);
void gtk_about_dialog_set_artists(AboutDialog* this_, char** artists);
void gtk_about_dialog_set_authors(AboutDialog* this_, char** authors);
void gtk_about_dialog_set_comments(AboutDialog* this_, char* comments=null);
void gtk_about_dialog_set_copyright(AboutDialog* this_, char* copyright);
void gtk_about_dialog_set_documenters(AboutDialog* this_, char** documenters);
void gtk_about_dialog_set_license(AboutDialog* this_, char* license=null);
void gtk_about_dialog_set_logo(AboutDialog* this_, GdkPixbuf2.Pixbuf* logo=null);
void gtk_about_dialog_set_logo_icon_name(AboutDialog* this_, char* icon_name=null);
void gtk_about_dialog_set_name(AboutDialog* this_, char* name=null);
void gtk_about_dialog_set_program_name(AboutDialog* this_, char* name);
void gtk_about_dialog_set_translator_credits(AboutDialog* this_, char* translator_credits=null);
void gtk_about_dialog_set_version(AboutDialog* this_, char* version_=null);
void gtk_about_dialog_set_website(AboutDialog* this_, char* website=null);
void gtk_about_dialog_set_website_label(AboutDialog* this_, char* website_label);
void gtk_about_dialog_set_wrap_license(AboutDialog* this_, int wrap_license);
AccelGroup* /*new*/ gtk_accel_group_new();
AccelGroup* gtk_accel_group_from_accel_closure(GObject2.Closure* closure);
int gtk_accel_group_activate(AccelGroup* this_, GLib2.Quark accel_quark, GObject2.Object* acceleratable, uint accel_key, Gdk2.ModifierType accel_mods);
void gtk_accel_group_connect(AccelGroup* this_, uint accel_key, Gdk2.ModifierType accel_mods, AccelFlags accel_flags, GObject2.Closure* closure);
void gtk_accel_group_connect_by_path(AccelGroup* this_, char* accel_path, GObject2.Closure* closure);
int gtk_accel_group_disconnect(AccelGroup* this_, GObject2.Closure* closure=null);
int gtk_accel_group_disconnect_key(AccelGroup* this_, uint accel_key, Gdk2.ModifierType accel_mods);
AccelKey* gtk_accel_group_find(AccelGroup* this_, AccelGroupFindFunc find_func, void* data);
int gtk_accel_group_get_is_locked(AccelGroup* this_);
Gdk2.ModifierType gtk_accel_group_get_modifier_mask(AccelGroup* this_);
void gtk_accel_group_lock(AccelGroup* this_);
AccelGroupEntry* gtk_accel_group_query(AccelGroup* this_, uint accel_key, Gdk2.ModifierType accel_mods, uint* n_entries=null);
void gtk_accel_group_unlock(AccelGroup* this_);
AccelLabel* gtk_accel_label_new(char* string_);
Widget* gtk_accel_label_get_accel_widget(AccelLabel* this_);
uint gtk_accel_label_get_accel_width(AccelLabel* this_);
int gtk_accel_label_refetch(AccelLabel* this_);
void gtk_accel_label_set_accel_closure(AccelLabel* this_, GObject2.Closure* accel_closure);
void gtk_accel_label_set_accel_widget(AccelLabel* this_, Widget* accel_widget);
void gtk_accel_map_add_entry(char* accel_path, uint accel_key, Gdk2.ModifierType accel_mods);
void gtk_accel_map_add_filter(char* filter_pattern);
int gtk_accel_map_change_entry(char* accel_path, uint accel_key, Gdk2.ModifierType accel_mods, int replace);
void gtk_accel_map_foreach(void* data, AccelMapForeach foreach_func);
void gtk_accel_map_foreach_unfiltered(void* data, AccelMapForeach foreach_func);
AccelMap* gtk_accel_map_get();
void gtk_accel_map_load(char* file_name);
void gtk_accel_map_load_fd(int fd);
void gtk_accel_map_load_scanner(GLib2.Scanner* scanner);
void gtk_accel_map_lock_path(char* accel_path);
int gtk_accel_map_lookup_entry(char* accel_path, AccelKey* key);
void gtk_accel_map_save(char* file_name);
void gtk_accel_map_save_fd(int fd);
void gtk_accel_map_unlock_path(char* accel_path);
void gtk_accessible_connect_widget_destroyed(Accessible* this_);
Widget* gtk_accessible_get_widget(Accessible* this_);
void gtk_accessible_set_widget(Accessible* this_, Widget* widget);
Action* /*new*/ gtk_action_new(char* name, char* label, char* tooltip, char* stock_id);
void gtk_action_activate(Action* this_);
void gtk_action_block_activate(Action* this_);
void gtk_action_block_activate_from(Action* this_, Widget* proxy);
void gtk_action_connect_accelerator(Action* this_);
void gtk_action_connect_proxy(Action* this_, Widget* proxy);
Widget* gtk_action_create_icon(Action* this_, int icon_size);
Widget* gtk_action_create_menu(Action* this_);
Widget* gtk_action_create_menu_item(Action* this_);
Widget* gtk_action_create_tool_item(Action* this_);
void gtk_action_disconnect_accelerator(Action* this_);
void gtk_action_disconnect_proxy(Action* this_, Widget* proxy);
GObject2.Closure* gtk_action_get_accel_closure(Action* this_);
char* gtk_action_get_accel_path(Action* this_);
int gtk_action_get_always_show_image(Action* this_);
Gio2.Icon* gtk_action_get_gicon(Action* this_);
char* gtk_action_get_icon_name(Action* this_);
int gtk_action_get_is_important(Action* this_);
char* gtk_action_get_label(Action* this_);
char* gtk_action_get_name(Action* this_);
GLib2.SList* gtk_action_get_proxies(Action* this_);
int gtk_action_get_sensitive(Action* this_);
char* gtk_action_get_short_label(Action* this_);
char* gtk_action_get_stock_id(Action* this_);
char* gtk_action_get_tooltip(Action* this_);
int gtk_action_get_visible(Action* this_);
int gtk_action_get_visible_horizontal(Action* this_);
int gtk_action_get_visible_vertical(Action* this_);
int gtk_action_is_sensitive(Action* this_);
int gtk_action_is_visible(Action* this_);
void gtk_action_set_accel_group(Action* this_, AccelGroup* accel_group=null);
void gtk_action_set_accel_path(Action* this_, char* accel_path);
void gtk_action_set_always_show_image(Action* this_, int always_show);
void gtk_action_set_gicon(Action* this_, Gio2.Icon* icon);
void gtk_action_set_icon_name(Action* this_, char* icon_name);
void gtk_action_set_is_important(Action* this_, int is_important);
void gtk_action_set_label(Action* this_, char* label);
void gtk_action_set_sensitive(Action* this_, int sensitive);
void gtk_action_set_short_label(Action* this_, char* short_label);
void gtk_action_set_stock_id(Action* this_, char* stock_id);
void gtk_action_set_tooltip(Action* this_, char* tooltip);
void gtk_action_set_visible(Action* this_, int visible);
void gtk_action_set_visible_horizontal(Action* this_, int visible_horizontal);
void gtk_action_set_visible_vertical(Action* this_, int visible_vertical);
void gtk_action_unblock_activate(Action* this_);
void gtk_action_unblock_activate_from(Action* this_, Widget* proxy);
ActionGroup* /*new*/ gtk_action_group_new(char* name);
void gtk_action_group_add_action(ActionGroup* this_, Action* action);
void gtk_action_group_add_action_with_accel(ActionGroup* this_, Action* action, char* accelerator=null);
void gtk_action_group_add_actions(ActionGroup* this_, ActionEntry* entries, uint n_entries, void* user_data);
void gtk_action_group_add_actions_full(ActionGroup* this_, ActionEntry* entries, uint n_entries, void* user_data, GLib2.DestroyNotify destroy);
void gtk_action_group_add_radio_actions(ActionGroup* this_, RadioActionEntry* entries, uint n_entries, int value, GObject2.Callback on_change, void* user_data);
void gtk_action_group_add_radio_actions_full(ActionGroup* this_, RadioActionEntry* entries, uint n_entries, int value, GObject2.Callback on_change, void* user_data, GLib2.DestroyNotify destroy);
void gtk_action_group_add_toggle_actions(ActionGroup* this_, ToggleActionEntry* entries, uint n_entries, void* user_data);
void gtk_action_group_add_toggle_actions_full(ActionGroup* this_, ToggleActionEntry* entries, uint n_entries, void* user_data, GLib2.DestroyNotify destroy);
Action* gtk_action_group_get_action(ActionGroup* this_, char* action_name);
char* gtk_action_group_get_name(ActionGroup* this_);
int gtk_action_group_get_sensitive(ActionGroup* this_);
int gtk_action_group_get_visible(ActionGroup* this_);
GLib2.List* /*new container*/ gtk_action_group_list_actions(ActionGroup* this_);
void gtk_action_group_remove_action(ActionGroup* this_, Action* action);
void gtk_action_group_set_sensitive(ActionGroup* this_, int sensitive);
void gtk_action_group_set_translate_func(ActionGroup* this_, TranslateFunc func, void* data, GLib2.DestroyNotify notify);
void gtk_action_group_set_translation_domain(ActionGroup* this_, char* domain);
void gtk_action_group_set_visible(ActionGroup* this_, int visible);
char* gtk_action_group_translate_string(ActionGroup* this_, char* string_);
void gtk_activatable_do_set_related_action(Activatable* this_, Action* action);
Action* gtk_activatable_get_related_action(Activatable* this_);
int gtk_activatable_get_use_action_appearance(Activatable* this_);
void gtk_activatable_set_related_action(Activatable* this_, Action* action);
void gtk_activatable_set_use_action_appearance(Activatable* this_, int use_appearance);
void gtk_activatable_sync_action_properties(Activatable* this_, Action* action=null);
Adjustment* gtk_adjustment_new(double value, double lower, double upper, double step_increment, double page_increment, double page_size);
void gtk_adjustment_changed(Adjustment* this_);
void gtk_adjustment_clamp_page(Adjustment* this_, double lower, double upper);
void gtk_adjustment_configure(Adjustment* this_, double value, double lower, double upper, double step_increment, double page_increment, double page_size);
double gtk_adjustment_get_lower(Adjustment* this_);
double gtk_adjustment_get_page_increment(Adjustment* this_);
double gtk_adjustment_get_page_size(Adjustment* this_);
double gtk_adjustment_get_step_increment(Adjustment* this_);
double gtk_adjustment_get_upper(Adjustment* this_);
double gtk_adjustment_get_value(Adjustment* this_);
void gtk_adjustment_set_lower(Adjustment* this_, double lower);
void gtk_adjustment_set_page_increment(Adjustment* this_, double page_increment);
void gtk_adjustment_set_page_size(Adjustment* this_, double page_size);
void gtk_adjustment_set_step_increment(Adjustment* this_, double step_increment);
void gtk_adjustment_set_upper(Adjustment* this_, double upper);
void gtk_adjustment_set_value(Adjustment* this_, double value);
void gtk_adjustment_value_changed(Adjustment* this_);
Alignment* gtk_alignment_new(float xalign, float yalign, float xscale, float yscale);
void gtk_alignment_get_padding(Alignment* this_, /*out*/ uint* padding_top=null, /*out*/ uint* padding_bottom=null, /*out*/ uint* padding_left=null, /*out*/ uint* padding_right=null);
void gtk_alignment_set(Alignment* this_, float xalign, float yalign, float xscale, float yscale);
void gtk_alignment_set_padding(Alignment* this_, uint padding_top, uint padding_bottom, uint padding_left, uint padding_right);
Arrow* gtk_arrow_new(ArrowType arrow_type, ShadowType shadow_type);
void gtk_arrow_set(Arrow* this_, ArrowType arrow_type, ShadowType shadow_type);
AspectFrame* gtk_aspect_frame_new(char* label, float xalign, float yalign, float ratio, int obey_child);
void gtk_aspect_frame_set(AspectFrame* this_, float xalign, float yalign, float ratio, int obey_child);
Assistant* gtk_assistant_new();
void gtk_assistant_add_action_widget(Assistant* this_, Widget* child);
int gtk_assistant_append_page(Assistant* this_, Widget* page);
void gtk_assistant_commit(Assistant* this_);
int gtk_assistant_get_current_page(Assistant* this_);
int gtk_assistant_get_n_pages(Assistant* this_);
Widget* gtk_assistant_get_nth_page(Assistant* this_, int page_num);
int gtk_assistant_get_page_complete(Assistant* this_, Widget* page);
GdkPixbuf2.Pixbuf* gtk_assistant_get_page_header_image(Assistant* this_, Widget* page);
GdkPixbuf2.Pixbuf* gtk_assistant_get_page_side_image(Assistant* this_, Widget* page);
char* gtk_assistant_get_page_title(Assistant* this_, Widget* page);
AssistantPageType gtk_assistant_get_page_type(Assistant* this_, Widget* page);
int gtk_assistant_insert_page(Assistant* this_, Widget* page, int position);
int gtk_assistant_prepend_page(Assistant* this_, Widget* page);
void gtk_assistant_remove_action_widget(Assistant* this_, Widget* child);
void gtk_assistant_set_current_page(Assistant* this_, int page_num);
void gtk_assistant_set_forward_page_func(Assistant* this_, AssistantPageFunc page_func, void* data, GLib2.DestroyNotify destroy);
void gtk_assistant_set_page_complete(Assistant* this_, Widget* page, int complete);
void gtk_assistant_set_page_header_image(Assistant* this_, Widget* page, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_assistant_set_page_side_image(Assistant* this_, Widget* page, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_assistant_set_page_title(Assistant* this_, Widget* page, char* title);
void gtk_assistant_set_page_type(Assistant* this_, Widget* page, AssistantPageType type);
void gtk_assistant_update_buttons_state(Assistant* this_);
Widget* gtk_bin_get_child(Bin* this_);
int gtk_binding_set_activate(BindingSet* this_, uint keyval, Gdk2.ModifierType modifiers, Object* object);
void gtk_binding_set_add_path(BindingSet* this_, PathType path_type, char* path_pattern, PathPriorityType priority);
Border* /*new*/ gtk_border_new();
Border* /*new*/ gtk_border_copy(Border* this_);
void gtk_border_free(Border* this_);
int gtk_box_get_homogeneous(Box* this_);
int gtk_box_get_spacing(Box* this_);
void gtk_box_pack_end(Box* this_, Widget* child, int expand, int fill, uint padding);
void gtk_box_pack_end_defaults(Box* this_, Widget* widget);
void gtk_box_pack_start(Box* this_, Widget* child, int expand, int fill, uint padding);
void gtk_box_pack_start_defaults(Box* this_, Widget* widget);
void gtk_box_query_child_packing(Box* this_, Widget* child, int* expand, int* fill, uint* padding, PackType* pack_type);
void gtk_box_reorder_child(Box* this_, Widget* child, int position);
void gtk_box_set_child_packing(Box* this_, Widget* child, int expand, int fill, uint padding, PackType pack_type);
void gtk_box_set_homogeneous(Box* this_, int homogeneous);
void gtk_box_set_spacing(Box* this_, int spacing);
void gtk_buildable_add_child(Buildable* this_, Builder* builder, GObject2.Object* child, char* type=null);
GObject2.Object* /*new*/ gtk_buildable_construct_child(Buildable* this_, Builder* builder, char* name);
void gtk_buildable_custom_finished(Buildable* this_, Builder* builder, GObject2.Object* child, char* tagname, void* data);
void gtk_buildable_custom_tag_end(Buildable* this_, Builder* builder, GObject2.Object* child, char* tagname, void* data);
int gtk_buildable_custom_tag_start(Buildable* this_, Builder* builder, GObject2.Object* child, char* tagname, /*out*/ GLib2.MarkupParser* parser, /*out*/ void** data);
GObject2.Object* gtk_buildable_get_internal_child(Buildable* this_, Builder* builder, char* childname);
char* gtk_buildable_get_name(Buildable* this_);
void gtk_buildable_parser_finished(Buildable* this_, Builder* builder);
void gtk_buildable_set_buildable_property(Buildable* this_, Builder* builder, char* name, GObject2.Value* value);
void gtk_buildable_set_name(Buildable* this_, char* name);
Builder* /*new*/ gtk_builder_new();
uint gtk_builder_add_from_file(Builder* this_, char* filename, GLib2.Error** error);
uint gtk_builder_add_from_string(Builder* this_, char* buffer, size_t length, GLib2.Error** error);
uint gtk_builder_add_objects_from_file(Builder* this_, char* filename, char** object_ids, GLib2.Error** error);
uint gtk_builder_add_objects_from_string(Builder* this_, char* buffer, size_t length, char** object_ids, GLib2.Error** error);
void gtk_builder_connect_signals(Builder* this_, void* user_data);
void gtk_builder_connect_signals_full(Builder* this_, BuilderConnectFunc func, void* user_data);
GObject2.Object* gtk_builder_get_object(Builder* this_, char* name);
GLib2.SList* /*new container*/ gtk_builder_get_objects(Builder* this_);
char* gtk_builder_get_translation_domain(Builder* this_);
Type gtk_builder_get_type_from_name(Builder* this_, char* type_name);
void gtk_builder_set_translation_domain(Builder* this_, char* domain=null);
int gtk_builder_value_from_string(Builder* this_, GObject2.ParamSpec* pspec, char* string_, /*out*/ GObject2.Value* value, GLib2.Error** error);
int gtk_builder_value_from_string_type(Builder* this_, Type type, char* string_, /*out*/ GObject2.Value* value, GLib2.Error** error);
Button* gtk_button_new();
Button* gtk_button_new_from_stock(char* stock_id);
Button* gtk_button_new_with_label(char* label);
Button* gtk_button_new_with_mnemonic(char* label);
void gtk_button_clicked(Button* this_);
void gtk_button_enter(Button* this_);
void gtk_button_get_alignment(Button* this_, /*out*/ float* xalign, /*out*/ float* yalign);
Gdk2.Window* gtk_button_get_event_window(Button* this_);
int gtk_button_get_focus_on_click(Button* this_);
Widget* gtk_button_get_image(Button* this_);
PositionType gtk_button_get_image_position(Button* this_);
char* gtk_button_get_label(Button* this_);
ReliefStyle gtk_button_get_relief(Button* this_);
int gtk_button_get_use_stock(Button* this_);
int gtk_button_get_use_underline(Button* this_);
void gtk_button_leave(Button* this_);
void gtk_button_pressed(Button* this_);
void gtk_button_released(Button* this_);
void gtk_button_set_alignment(Button* this_, float xalign, float yalign);
void gtk_button_set_focus_on_click(Button* this_, int focus_on_click);
void gtk_button_set_image(Button* this_, Widget* image);
void gtk_button_set_image_position(Button* this_, PositionType position);
void gtk_button_set_label(Button* this_, char* label);
void gtk_button_set_relief(Button* this_, ReliefStyle newstyle);
void gtk_button_set_use_stock(Button* this_, int use_stock);
void gtk_button_set_use_underline(Button* this_, int use_underline);
void gtk_button_box_get_child_ipadding(ButtonBox* this_, int* ipad_x, int* ipad_y);
int gtk_button_box_get_child_secondary(ButtonBox* this_, Widget* child);
void gtk_button_box_get_child_size(ButtonBox* this_, int* min_width, int* min_height);
ButtonBoxStyle gtk_button_box_get_layout(ButtonBox* this_);
void gtk_button_box_set_child_ipadding(ButtonBox* this_, int ipad_x, int ipad_y);
void gtk_button_box_set_child_secondary(ButtonBox* this_, Widget* child, int is_secondary);
void gtk_button_box_set_child_size(ButtonBox* this_, int min_width, int min_height);
void gtk_button_box_set_layout(ButtonBox* this_, ButtonBoxStyle layout_style);
CList* gtk_clist_new(int columns);
CList* gtk_clist_new_with_titles(int columns, char* titles);
int gtk_clist_append(CList* this_, char* text);
void gtk_clist_clear(CList* this_);
void gtk_clist_column_title_active(CList* this_, int column);
void gtk_clist_column_title_passive(CList* this_, int column);
void gtk_clist_column_titles_active(CList* this_);
void gtk_clist_column_titles_hide(CList* this_);
void gtk_clist_column_titles_passive(CList* this_);
void gtk_clist_column_titles_show(CList* this_);
int gtk_clist_columns_autosize(CList* this_);
int gtk_clist_find_row_from_data(CList* this_, void* data);
void gtk_clist_freeze(CList* this_);
Style* gtk_clist_get_cell_style(CList* this_, int row, int column);
CellType gtk_clist_get_cell_type(CList* this_, int row, int column);
char* /*new*/ gtk_clist_get_column_title(CList* this_, int column);
Widget* gtk_clist_get_column_widget(CList* this_, int column);
Adjustment* gtk_clist_get_hadjustment(CList* this_);
int gtk_clist_get_pixmap(CList* this_, int row, int column, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask);
int gtk_clist_get_pixtext(CList* this_, int row, int column, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask);
void* gtk_clist_get_row_data(CList* this_, int row);
Style* gtk_clist_get_row_style(CList* this_, int row);
int gtk_clist_get_selectable(CList* this_, int row);
int gtk_clist_get_selection_info(CList* this_, int x, int y, int* row, int* column);
int gtk_clist_get_text(CList* this_, int row, int column, char** text);
Adjustment* gtk_clist_get_vadjustment(CList* this_);
int gtk_clist_insert(CList* this_, int row, char* text);
void gtk_clist_moveto(CList* this_, int row, int column, float row_align, float col_align);
int gtk_clist_optimal_column_width(CList* this_, int column);
int gtk_clist_prepend(CList* this_, char* text);
void gtk_clist_remove(CList* this_, int row);
Visibility gtk_clist_row_is_visible(CList* this_, int row);
void gtk_clist_row_move(CList* this_, int source_row, int dest_row);
void gtk_clist_select_all(CList* this_);
void gtk_clist_select_row(CList* this_, int row, int column);
void gtk_clist_set_auto_sort(CList* this_, int auto_sort);
void gtk_clist_set_background(CList* this_, int row, Gdk2.Color* color);
void gtk_clist_set_button_actions(CList* this_, uint button, ubyte button_actions);
void gtk_clist_set_cell_style(CList* this_, int row, int column, Style* style);
void gtk_clist_set_column_auto_resize(CList* this_, int column, int auto_resize);
void gtk_clist_set_column_justification(CList* this_, int column, Justification justification);
void gtk_clist_set_column_max_width(CList* this_, int column, int max_width);
void gtk_clist_set_column_min_width(CList* this_, int column, int min_width);
void gtk_clist_set_column_resizeable(CList* this_, int column, int resizeable);
void gtk_clist_set_column_title(CList* this_, int column, char* title);
void gtk_clist_set_column_visibility(CList* this_, int column, int visible);
void gtk_clist_set_column_widget(CList* this_, int column, Widget* widget);
void gtk_clist_set_column_width(CList* this_, int column, int width);
void gtk_clist_set_compare_func(CList* this_, CListCompareFunc cmp_func);
void gtk_clist_set_foreground(CList* this_, int row, Gdk2.Color* color);
void gtk_clist_set_hadjustment(CList* this_, Adjustment* adjustment);
void gtk_clist_set_pixmap(CList* this_, int row, int column, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null);
void gtk_clist_set_pixtext(CList* this_, int row, int column, char* text, ubyte spacing, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask);
void gtk_clist_set_reorderable(CList* this_, int reorderable);
void gtk_clist_set_row_data(CList* this_, int row, void* data);
void gtk_clist_set_row_data_full(CList* this_, int row, void* data, GLib2.DestroyNotify destroy);
void gtk_clist_set_row_height(CList* this_, uint height);
void gtk_clist_set_row_style(CList* this_, int row, Style* style);
void gtk_clist_set_selectable(CList* this_, int row, int selectable);
void gtk_clist_set_selection_mode(CList* this_, SelectionMode mode);
void gtk_clist_set_shadow_type(CList* this_, ShadowType type);
void gtk_clist_set_shift(CList* this_, int row, int column, int vertical, int horizontal);
void gtk_clist_set_sort_column(CList* this_, int column);
void gtk_clist_set_sort_type(CList* this_, SortType sort_type);
void gtk_clist_set_text(CList* this_, int row, int column, char* text);
void gtk_clist_set_use_drag_icons(CList* this_, int use_icons);
void gtk_clist_set_vadjustment(CList* this_, Adjustment* adjustment);
void gtk_clist_sort(CList* this_);
void gtk_clist_swap_rows(CList* this_, int row1, int row2);
void gtk_clist_thaw(CList* this_);
void gtk_clist_undo_selection(CList* this_);
void gtk_clist_unselect_all(CList* this_);
void gtk_clist_unselect_row(CList* this_, int row, int column);
CTree* gtk_ctree_new(int columns, int tree_column);
CTree* gtk_ctree_new_with_titles(int columns, int tree_column, char* titles);
void gtk_ctree_collapse(CTree* this_, CTreeNode* node);
void gtk_ctree_collapse_recursive(CTree* this_, CTreeNode* node);
void gtk_ctree_collapse_to_depth(CTree* this_, CTreeNode* node, int depth);
void gtk_ctree_expand(CTree* this_, CTreeNode* node);
void gtk_ctree_expand_recursive(CTree* this_, CTreeNode* node);
void gtk_ctree_expand_to_depth(CTree* this_, CTreeNode* node, int depth);
GLib2.Node* gtk_ctree_export_to_gnode(CTree* this_, GLib2.Node* parent, GLib2.Node* sibling, CTreeNode* node, CTreeGNodeFunc func, void* data);
int gtk_ctree_find(CTree* this_, CTreeNode* node, CTreeNode* child);
GLib2.List* gtk_ctree_find_all_by_row_data(CTree* this_, CTreeNode* node, void* data);
GLib2.List* gtk_ctree_find_all_by_row_data_custom(CTree* this_, CTreeNode* node, void* data, GLib2.CompareFunc func);
CTreeNode* gtk_ctree_find_by_row_data(CTree* this_, CTreeNode* node, void* data);
CTreeNode* gtk_ctree_find_by_row_data_custom(CTree* this_, CTreeNode* node, void* data, GLib2.CompareFunc func);
CTreeNode* gtk_ctree_find_node_ptr(CTree* this_, CTreeRow* ctree_row);
int gtk_ctree_get_node_info(CTree* this_, CTreeNode* node, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap_closed, Gdk2.Bitmap** mask_closed, Gdk2.Pixmap** pixmap_opened, Gdk2.Bitmap** mask_opened, int* is_leaf, int* expanded);
CTreeNode* gtk_ctree_insert_gnode(CTree* this_, CTreeNode* parent, CTreeNode* sibling, GLib2.Node* gnode, CTreeGNodeFunc func, void* data);
CTreeNode* gtk_ctree_insert_node(CTree* this_, CTreeNode* parent, CTreeNode* sibling, char* text, ubyte spacing, Gdk2.Pixmap* pixmap_closed, Gdk2.Bitmap* mask_closed, Gdk2.Pixmap* pixmap_opened, Gdk2.Bitmap* mask_opened, int is_leaf, int expanded);
int gtk_ctree_is_ancestor(CTree* this_, CTreeNode* node, CTreeNode* child);
int gtk_ctree_is_hot_spot(CTree* this_, int x, int y);
int gtk_ctree_is_viewable(CTree* this_, CTreeNode* node);
CTreeNode* gtk_ctree_last(CTree* this_, CTreeNode* node);
void gtk_ctree_move(CTree* this_, CTreeNode* node, CTreeNode* new_parent=null, CTreeNode* new_sibling=null);
Style* gtk_ctree_node_get_cell_style(CTree* this_, CTreeNode* node, int column);
CellType gtk_ctree_node_get_cell_type(CTree* this_, CTreeNode* node, int column);
int gtk_ctree_node_get_pixmap(CTree* this_, CTreeNode* node, int column, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask);
int gtk_ctree_node_get_pixtext(CTree* this_, CTreeNode* node, int column, char** text, ubyte* spacing, Gdk2.Pixmap** pixmap, Gdk2.Bitmap** mask);
void* gtk_ctree_node_get_row_data(CTree* this_, CTreeNode* node);
Style* gtk_ctree_node_get_row_style(CTree* this_, CTreeNode* node);
int gtk_ctree_node_get_selectable(CTree* this_, CTreeNode* node);
int gtk_ctree_node_get_text(CTree* this_, CTreeNode* node, int column, char** text);
Visibility gtk_ctree_node_is_visible(CTree* this_, CTreeNode* node);
void gtk_ctree_node_moveto(CTree* this_, CTreeNode* node, int column, float row_align, float col_align);
CTreeNode* gtk_ctree_node_nth(CTree* this_, uint row);
void gtk_ctree_node_set_background(CTree* this_, CTreeNode* node, Gdk2.Color* color);
void gtk_ctree_node_set_cell_style(CTree* this_, CTreeNode* node, int column, Style* style);
void gtk_ctree_node_set_foreground(CTree* this_, CTreeNode* node, Gdk2.Color* color);
void gtk_ctree_node_set_pixmap(CTree* this_, CTreeNode* node, int column, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null);
void gtk_ctree_node_set_pixtext(CTree* this_, CTreeNode* node, int column, char* text, ubyte spacing, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null);
void gtk_ctree_node_set_row_data(CTree* this_, CTreeNode* node, void* data);
void gtk_ctree_node_set_row_data_full(CTree* this_, CTreeNode* node, void* data, GLib2.DestroyNotify destroy);
void gtk_ctree_node_set_row_style(CTree* this_, CTreeNode* node, Style* style);
void gtk_ctree_node_set_selectable(CTree* this_, CTreeNode* node, int selectable);
void gtk_ctree_node_set_shift(CTree* this_, CTreeNode* node, int column, int vertical, int horizontal);
void gtk_ctree_node_set_text(CTree* this_, CTreeNode* node, int column, char* text);
void gtk_ctree_post_recursive(CTree* this_, CTreeNode* node, CTreeFunc func, void* data);
void gtk_ctree_post_recursive_to_depth(CTree* this_, CTreeNode* node, int depth, CTreeFunc func, void* data);
void gtk_ctree_pre_recursive(CTree* this_, CTreeNode* node, CTreeFunc func, void* data);
void gtk_ctree_pre_recursive_to_depth(CTree* this_, CTreeNode* node, int depth, CTreeFunc func, void* data);
void gtk_ctree_real_select_recursive(CTree* this_, CTreeNode* node, int state);
void gtk_ctree_remove_node(CTree* this_, CTreeNode* node);
void gtk_ctree_select(CTree* this_, CTreeNode* node);
void gtk_ctree_select_recursive(CTree* this_, CTreeNode* node);
void gtk_ctree_set_drag_compare_func(CTree* this_, CTreeCompareDragFunc cmp_func);
void gtk_ctree_set_expander_style(CTree* this_, CTreeExpanderStyle expander_style);
void gtk_ctree_set_indent(CTree* this_, int indent);
void gtk_ctree_set_line_style(CTree* this_, CTreeLineStyle line_style);
void gtk_ctree_set_node_info(CTree* this_, CTreeNode* node, char* text, ubyte spacing, Gdk2.Pixmap* pixmap_closed, Gdk2.Bitmap* mask_closed, Gdk2.Pixmap* pixmap_opened, Gdk2.Bitmap* mask_opened, int is_leaf, int expanded);
void gtk_ctree_set_show_stub(CTree* this_, int show_stub);
void gtk_ctree_set_spacing(CTree* this_, int spacing);
void gtk_ctree_sort_node(CTree* this_, CTreeNode* node);
void gtk_ctree_sort_recursive(CTree* this_, CTreeNode* node);
void gtk_ctree_toggle_expansion(CTree* this_, CTreeNode* node);
void gtk_ctree_toggle_expansion_recursive(CTree* this_, CTreeNode* node);
void gtk_ctree_unselect(CTree* this_, CTreeNode* node);
void gtk_ctree_unselect_recursive(CTree* this_, CTreeNode* node);
Calendar* gtk_calendar_new();
void gtk_calendar_clear_marks(Calendar* this_);
void gtk_calendar_display_options(Calendar* this_, CalendarDisplayOptions flags);
void gtk_calendar_freeze(Calendar* this_);
void gtk_calendar_get_date(Calendar* this_, /*out*/ uint* year=null, /*out*/ uint* month=null, /*out*/ uint* day=null);
int gtk_calendar_get_detail_height_rows(Calendar* this_);
int gtk_calendar_get_detail_width_chars(Calendar* this_);
CalendarDisplayOptions gtk_calendar_get_display_options(Calendar* this_);
int gtk_calendar_mark_day(Calendar* this_, uint day);
void gtk_calendar_select_day(Calendar* this_, uint day);
int gtk_calendar_select_month(Calendar* this_, uint month, uint year);
void gtk_calendar_set_detail_func(Calendar* this_, CalendarDetailFunc func, void* data, GLib2.DestroyNotify destroy);
void gtk_calendar_set_detail_height_rows(Calendar* this_, int rows);
void gtk_calendar_set_detail_width_chars(Calendar* this_, int chars);
void gtk_calendar_set_display_options(Calendar* this_, CalendarDisplayOptions flags);
void gtk_calendar_thaw(Calendar* this_);
int gtk_calendar_unmark_day(Calendar* this_, uint day);
void gtk_cell_editable_editing_done(CellEditable* this_);
void gtk_cell_editable_remove_widget(CellEditable* this_);
void gtk_cell_editable_start_editing(CellEditable* this_, Gdk2.Event* event=null);
void gtk_cell_layout_add_attribute(CellLayout* this_, CellRenderer* cell, char* attribute, int column);
void gtk_cell_layout_clear(CellLayout* this_);
void gtk_cell_layout_clear_attributes(CellLayout* this_, CellRenderer* cell);
GLib2.List* /*new container*/ gtk_cell_layout_get_cells(CellLayout* this_);
void gtk_cell_layout_pack_end(CellLayout* this_, CellRenderer* cell, int expand);
void gtk_cell_layout_pack_start(CellLayout* this_, CellRenderer* cell, int expand);
void gtk_cell_layout_reorder(CellLayout* this_, CellRenderer* cell, int position);
void gtk_cell_layout_set_attributes(CellLayout* this_, CellRenderer* cell, ...);
void gtk_cell_layout_set_cell_data_func(CellLayout* this_, CellRenderer* cell, CellLayoutDataFunc func, void* func_data, GLib2.DestroyNotify destroy);
int gtk_cell_renderer_activate(CellRenderer* this_, Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags);
void gtk_cell_renderer_editing_canceled(CellRenderer* this_);
void gtk_cell_renderer_get_alignment(CellRenderer* this_, /*out*/ float* xalign=null, /*out*/ float* yalign=null);
void gtk_cell_renderer_get_fixed_size(CellRenderer* this_, /*out*/ int* width=null, /*out*/ int* height=null);
void gtk_cell_renderer_get_padding(CellRenderer* this_, /*out*/ int* xpad=null, /*out*/ int* ypad=null);
int gtk_cell_renderer_get_sensitive(CellRenderer* this_);
void gtk_cell_renderer_get_size(CellRenderer* this_, Widget* widget, Gdk2.Rectangle* cell_area=null, /*out*/ int* x_offset=null, /*out*/ int* y_offset=null, /*out*/ int* width=null, /*out*/ int* height=null);
int gtk_cell_renderer_get_visible(CellRenderer* this_);
void gtk_cell_renderer_render(CellRenderer* this_, Gdk2.Window* window, Widget* widget, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, Gdk2.Rectangle* expose_area, CellRendererState flags);
void gtk_cell_renderer_set_alignment(CellRenderer* this_, float xalign, float yalign);
void gtk_cell_renderer_set_fixed_size(CellRenderer* this_, int width, int height);
void gtk_cell_renderer_set_padding(CellRenderer* this_, int xpad, int ypad);
void gtk_cell_renderer_set_sensitive(CellRenderer* this_, int sensitive);
void gtk_cell_renderer_set_visible(CellRenderer* this_, int visible);
CellEditable* gtk_cell_renderer_start_editing(CellRenderer* this_, Gdk2.Event* event, Widget* widget, char* path, Gdk2.Rectangle* background_area, Gdk2.Rectangle* cell_area, CellRendererState flags);
void gtk_cell_renderer_stop_editing(CellRenderer* this_, int canceled);
CellRendererAccel* gtk_cell_renderer_accel_new();
CellRendererCombo* gtk_cell_renderer_combo_new();
CellRendererPixbuf* gtk_cell_renderer_pixbuf_new();
CellRendererProgress* gtk_cell_renderer_progress_new();
CellRendererSpin* gtk_cell_renderer_spin_new();
CellRendererSpinner* gtk_cell_renderer_spinner_new();
CellRendererText* gtk_cell_renderer_text_new();
void gtk_cell_renderer_text_set_fixed_height_from_font(CellRendererText* this_, int number_of_rows);
CellRendererToggle* gtk_cell_renderer_toggle_new();
int gtk_cell_renderer_toggle_get_activatable(CellRendererToggle* this_);
int gtk_cell_renderer_toggle_get_active(CellRendererToggle* this_);
int gtk_cell_renderer_toggle_get_radio(CellRendererToggle* this_);
void gtk_cell_renderer_toggle_set_activatable(CellRendererToggle* this_, int setting);
void gtk_cell_renderer_toggle_set_active(CellRendererToggle* this_, int setting);
void gtk_cell_renderer_toggle_set_radio(CellRendererToggle* this_, int radio);
CellView* gtk_cell_view_new();
CellView* gtk_cell_view_new_with_markup(char* markup);
CellView* gtk_cell_view_new_with_pixbuf(GdkPixbuf2.Pixbuf* pixbuf);
CellView* gtk_cell_view_new_with_text(char* text);
GLib2.List* gtk_cell_view_get_cell_renderers(CellView* this_);
TreePath* /*new*/ gtk_cell_view_get_displayed_row(CellView* this_);
TreeModel* gtk_cell_view_get_model(CellView* this_);
int gtk_cell_view_get_size_of_row(CellView* this_, TreePath* path, /*out*/ Requisition* requisition);
void gtk_cell_view_set_background_color(CellView* this_, Gdk2.Color* color);
void gtk_cell_view_set_displayed_row(CellView* this_, TreePath* path=null);
void gtk_cell_view_set_model(CellView* this_, TreeModel* model=null);
CheckButton* gtk_check_button_new();
CheckButton* gtk_check_button_new_with_label(char* label);
CheckButton* gtk_check_button_new_with_mnemonic(char* label);
CheckMenuItem* gtk_check_menu_item_new();
CheckMenuItem* gtk_check_menu_item_new_with_label(char* label);
CheckMenuItem* gtk_check_menu_item_new_with_mnemonic(char* label);
int gtk_check_menu_item_get_active(CheckMenuItem* this_);
int gtk_check_menu_item_get_draw_as_radio(CheckMenuItem* this_);
int gtk_check_menu_item_get_inconsistent(CheckMenuItem* this_);
void gtk_check_menu_item_set_active(CheckMenuItem* this_, int is_active);
void gtk_check_menu_item_set_draw_as_radio(CheckMenuItem* this_, int draw_as_radio);
void gtk_check_menu_item_set_inconsistent(CheckMenuItem* this_, int setting);
void gtk_check_menu_item_set_show_toggle(CheckMenuItem* this_, int always);
void gtk_check_menu_item_toggled(CheckMenuItem* this_);
Clipboard* gtk_clipboard_get(Gdk2.Atom selection);
Clipboard* gtk_clipboard_get_for_display(Gdk2.Display* display, Gdk2.Atom selection);
void gtk_clipboard_clear(Clipboard* this_);
Gdk2.Display* gtk_clipboard_get_display(Clipboard* this_);
GObject2.Object* gtk_clipboard_get_owner(Clipboard* this_);
void gtk_clipboard_request_contents(Clipboard* this_, Gdk2.Atom target, ClipboardReceivedFunc callback, void* user_data);
void gtk_clipboard_request_image(Clipboard* this_, ClipboardImageReceivedFunc callback, void* user_data);
void gtk_clipboard_request_rich_text(Clipboard* this_, TextBuffer* buffer, ClipboardRichTextReceivedFunc callback, void* user_data);
void gtk_clipboard_request_targets(Clipboard* this_, ClipboardTargetsReceivedFunc callback, void* user_data);
void gtk_clipboard_request_text(Clipboard* this_, ClipboardTextReceivedFunc callback, void* user_data);
void gtk_clipboard_request_uris(Clipboard* this_, ClipboardURIReceivedFunc callback, void* user_data);
void gtk_clipboard_set_can_store(Clipboard* this_, TargetEntry* targets, int n_targets);
void gtk_clipboard_set_image(Clipboard* this_, GdkPixbuf2.Pixbuf* pixbuf);
void gtk_clipboard_set_text(Clipboard* this_, char* text, int len);
int gtk_clipboard_set_with_data(Clipboard* this_, TargetEntry* targets, uint n_targets, ClipboardGetFunc get_func, ClipboardClearFunc clear_func, void* user_data);
int gtk_clipboard_set_with_owner(Clipboard* this_, TargetEntry* targets, uint n_targets, ClipboardGetFunc get_func, ClipboardClearFunc clear_func, GObject2.Object* owner);
void gtk_clipboard_store(Clipboard* this_);
SelectionData* /*new*/ gtk_clipboard_wait_for_contents(Clipboard* this_, Gdk2.Atom target);
GdkPixbuf2.Pixbuf* /*new*/ gtk_clipboard_wait_for_image(Clipboard* this_);
ubyte* /*new*/ gtk_clipboard_wait_for_rich_text(Clipboard* this_, TextBuffer* buffer, Gdk2.Atom* format, /*out*/ size_t* length);
int gtk_clipboard_wait_for_targets(Clipboard* this_, /*out*/ Gdk2.Atom** targets, /*out*/ int* n_targets);
char* /*new*/ gtk_clipboard_wait_for_text(Clipboard* this_);
char** /*new*/ gtk_clipboard_wait_for_uris(Clipboard* this_);
int gtk_clipboard_wait_is_image_available(Clipboard* this_);
int gtk_clipboard_wait_is_rich_text_available(Clipboard* this_, TextBuffer* buffer);
int gtk_clipboard_wait_is_target_available(Clipboard* this_, Gdk2.Atom target);
int gtk_clipboard_wait_is_text_available(Clipboard* this_);
int gtk_clipboard_wait_is_uris_available(Clipboard* this_);
ColorButton* gtk_color_button_new();
ColorButton* gtk_color_button_new_with_color(Gdk2.Color* color);
ushort gtk_color_button_get_alpha(ColorButton* this_);
void gtk_color_button_get_color(ColorButton* this_, Gdk2.Color* color);
char* gtk_color_button_get_title(ColorButton* this_);
int gtk_color_button_get_use_alpha(ColorButton* this_);
void gtk_color_button_set_alpha(ColorButton* this_, ushort alpha);
void gtk_color_button_set_color(ColorButton* this_, Gdk2.Color* color);
void gtk_color_button_set_title(ColorButton* this_, char* title);
void gtk_color_button_set_use_alpha(ColorButton* this_, int use_alpha);
ColorSelection* gtk_color_selection_new();
int gtk_color_selection_palette_from_string(char* str, /*out*/ Gdk2.Color** colors, /*out*/ int* n_colors);
char* /*new*/ gtk_color_selection_palette_to_string(Gdk2.Color* colors, int n_colors);
ColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook(ColorSelectionChangePaletteFunc func);
ColorSelectionChangePaletteWithScreenFunc gtk_color_selection_set_change_palette_with_screen_hook(ColorSelectionChangePaletteWithScreenFunc func);
void gtk_color_selection_get_color(ColorSelection* this_, double* color);
ushort gtk_color_selection_get_current_alpha(ColorSelection* this_);
void gtk_color_selection_get_current_color(ColorSelection* this_, /*out*/ Gdk2.Color* color);
int gtk_color_selection_get_has_opacity_control(ColorSelection* this_);
int gtk_color_selection_get_has_palette(ColorSelection* this_);
ushort gtk_color_selection_get_previous_alpha(ColorSelection* this_);
void gtk_color_selection_get_previous_color(ColorSelection* this_, /*out*/ Gdk2.Color* color);
int gtk_color_selection_is_adjusting(ColorSelection* this_);
void gtk_color_selection_set_color(ColorSelection* this_, double* color);
void gtk_color_selection_set_current_alpha(ColorSelection* this_, ushort alpha);
void gtk_color_selection_set_current_color(ColorSelection* this_, Gdk2.Color* color);
void gtk_color_selection_set_has_opacity_control(ColorSelection* this_, int has_opacity);
void gtk_color_selection_set_has_palette(ColorSelection* this_, int has_palette);
void gtk_color_selection_set_previous_alpha(ColorSelection* this_, ushort alpha);
void gtk_color_selection_set_previous_color(ColorSelection* this_, Gdk2.Color* color);
void gtk_color_selection_set_update_policy(ColorSelection* this_, UpdateType policy);
ColorSelectionDialog* gtk_color_selection_dialog_new(char* title);
Widget* gtk_color_selection_dialog_get_color_selection(ColorSelectionDialog* this_);
Combo* gtk_combo_new();
void gtk_combo_disable_activate(Combo* this_);
void gtk_combo_set_case_sensitive(Combo* this_, int val);
void gtk_combo_set_item_string(Combo* this_, Item* item, char* item_value);
void gtk_combo_set_popdown_strings(Combo* this_, GLib2.List* strings);
void gtk_combo_set_use_arrows(Combo* this_, int val);
void gtk_combo_set_use_arrows_always(Combo* this_, int val);
void gtk_combo_set_value_in_list(Combo* this_, int val, int ok_if_empty);
ComboBox* gtk_combo_box_new();
ComboBox* gtk_combo_box_new_text();
ComboBox* gtk_combo_box_new_with_entry();
ComboBox* gtk_combo_box_new_with_model(TreeModel* model);
ComboBox* gtk_combo_box_new_with_model_and_entry(TreeModel* model);
void gtk_combo_box_append_text(ComboBox* this_, char* text);
int gtk_combo_box_get_active(ComboBox* this_);
int gtk_combo_box_get_active_iter(ComboBox* this_, /*out*/ TreeIter* iter);
char* /*new*/ gtk_combo_box_get_active_text(ComboBox* this_);
int gtk_combo_box_get_add_tearoffs(ComboBox* this_);
SensitivityType gtk_combo_box_get_button_sensitivity(ComboBox* this_);
int gtk_combo_box_get_column_span_column(ComboBox* this_);
int gtk_combo_box_get_entry_text_column(ComboBox* this_);
int gtk_combo_box_get_focus_on_click(ComboBox* this_);
int gtk_combo_box_get_has_entry(ComboBox* this_);
TreeModel* gtk_combo_box_get_model(ComboBox* this_);
Atk.Object* gtk_combo_box_get_popup_accessible(ComboBox* this_);
TreeViewRowSeparatorFunc gtk_combo_box_get_row_separator_func(ComboBox* this_);
int gtk_combo_box_get_row_span_column(ComboBox* this_);
char* gtk_combo_box_get_title(ComboBox* this_);
int gtk_combo_box_get_wrap_width(ComboBox* this_);
void gtk_combo_box_insert_text(ComboBox* this_, int position, char* text);
void gtk_combo_box_popdown(ComboBox* this_);
void gtk_combo_box_popup(ComboBox* this_);
void gtk_combo_box_prepend_text(ComboBox* this_, char* text);
void gtk_combo_box_remove_text(ComboBox* this_, int position);
void gtk_combo_box_set_active(ComboBox* this_, int index_);
void gtk_combo_box_set_active_iter(ComboBox* this_, TreeIter* iter=null);
void gtk_combo_box_set_add_tearoffs(ComboBox* this_, int add_tearoffs);
void gtk_combo_box_set_button_sensitivity(ComboBox* this_, SensitivityType sensitivity);
void gtk_combo_box_set_column_span_column(ComboBox* this_, int column_span);
void gtk_combo_box_set_entry_text_column(ComboBox* this_, int text_column);
void gtk_combo_box_set_focus_on_click(ComboBox* this_, int focus_on_click);
void gtk_combo_box_set_model(ComboBox* this_, TreeModel* model=null);
void gtk_combo_box_set_row_separator_func(ComboBox* this_, TreeViewRowSeparatorFunc func, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_combo_box_set_row_span_column(ComboBox* this_, int row_span);
void gtk_combo_box_set_title(ComboBox* this_, char* title);
void gtk_combo_box_set_wrap_width(ComboBox* this_, int width);
ComboBoxEntry* gtk_combo_box_entry_new();
ComboBoxEntry* gtk_combo_box_entry_new_text();
ComboBoxEntry* gtk_combo_box_entry_new_with_model(TreeModel* model, int text_column);
int gtk_combo_box_entry_get_text_column(ComboBoxEntry* this_);
void gtk_combo_box_entry_set_text_column(ComboBoxEntry* this_, int text_column);
ComboBoxText* gtk_combo_box_text_new();
ComboBoxText* gtk_combo_box_text_new_with_entry();
void gtk_combo_box_text_append_text(ComboBoxText* this_, char* text);
char* /*new*/ gtk_combo_box_text_get_active_text(ComboBoxText* this_);
void gtk_combo_box_text_insert_text(ComboBoxText* this_, int position, char* text);
void gtk_combo_box_text_prepend_text(ComboBoxText* this_, char* text);
void gtk_combo_box_text_remove(ComboBoxText* this_, int position);
void gtk_container_add(Container* this_, Widget* widget);
void gtk_container_add_with_properties(Container* this_, Widget* widget, char* first_prop_name, ...);
void gtk_container_check_resize(Container* this_);
void gtk_container_child_get(Container* this_, Widget* child, char* first_prop_name, ...);
void gtk_container_child_get_property(Container* this_, Widget* child, char* property_name, GObject2.Value* value);
void gtk_container_child_get_valist(Container* this_, Widget* child, char* first_property_name, va_list var_args);
void gtk_container_child_set(Container* this_, Widget* child, char* first_prop_name, ...);
void gtk_container_child_set_property(Container* this_, Widget* child, char* property_name, GObject2.Value* value);
void gtk_container_child_set_valist(Container* this_, Widget* child, char* first_property_name, va_list var_args);
Type gtk_container_child_type(Container* this_);
void gtk_container_forall(Container* this_, Callback callback, void* callback_data);
void gtk_container_foreach(Container* this_, Callback callback, void* callback_data);
void gtk_container_foreach_full(Container* this_, Callback callback, CallbackMarshal marshal, void* callback_data, GLib2.DestroyNotify notify);
uint gtk_container_get_border_width(Container* this_);
GLib2.List* /*new container*/ gtk_container_get_children(Container* this_);
int gtk_container_get_focus_chain(Container* this_, /*out*/ GLib2.List** focusable_widgets);
Widget* gtk_container_get_focus_child(Container* this_);
Adjustment* gtk_container_get_focus_hadjustment(Container* this_);
Adjustment* gtk_container_get_focus_vadjustment(Container* this_);
ResizeMode gtk_container_get_resize_mode(Container* this_);
void gtk_container_propagate_expose(Container* this_, Widget* child, Gdk2.EventExpose* event);
void gtk_container_remove(Container* this_, Widget* widget);
void gtk_container_resize_children(Container* this_);
void gtk_container_set_border_width(Container* this_, uint border_width);
void gtk_container_set_focus_chain(Container* this_, GLib2.List* focusable_widgets);
void gtk_container_set_focus_child(Container* this_, Widget* child=null);
void gtk_container_set_focus_hadjustment(Container* this_, Adjustment* adjustment);
void gtk_container_set_focus_vadjustment(Container* this_, Adjustment* adjustment);
void gtk_container_set_reallocate_redraws(Container* this_, int needs_redraws);
void gtk_container_set_resize_mode(Container* this_, ResizeMode resize_mode);
void gtk_container_unset_focus_chain(Container* this_);
GObject2.ParamSpec* gtk_container_class_find_child_property(ContainerClass* this_, char* property_name);
void gtk_container_class_install_child_property(ContainerClass* this_, uint property_id, GObject2.ParamSpec* pspec);
GObject2.ParamSpec** /*new container*/ gtk_container_class_list_child_properties(ContainerClass* this_, /*out*/ uint* n_properties);
Curve* gtk_curve_new();
void gtk_curve_get_vector(Curve* this_, int veclen, float vector);
void gtk_curve_reset(Curve* this_);
void gtk_curve_set_curve_type(Curve* this_, CurveType type);
void gtk_curve_set_gamma(Curve* this_, float gamma_);
void gtk_curve_set_range(Curve* this_, float min_x, float max_x, float min_y, float max_y);
void gtk_curve_set_vector(Curve* this_, int veclen, float vector);
Dialog* gtk_dialog_new();
Dialog* gtk_dialog_new_with_buttons(char* title, Window* parent, DialogFlags flags, char* first_button_text=null, ...);
void gtk_dialog_add_action_widget(Dialog* this_, Widget* child, int response_id);
Widget* gtk_dialog_add_button(Dialog* this_, char* button_text, int response_id);
void gtk_dialog_add_buttons(Dialog* this_, char* first_button_text, ...);
Widget* gtk_dialog_get_action_area(Dialog* this_);
Widget* gtk_dialog_get_content_area(Dialog* this_);
int gtk_dialog_get_has_separator(Dialog* this_);
int gtk_dialog_get_response_for_widget(Dialog* this_, Widget* widget);
Widget* gtk_dialog_get_widget_for_response(Dialog* this_, int response_id);
void gtk_dialog_response(Dialog* this_, int response_id);
int gtk_dialog_run(Dialog* this_);
void gtk_dialog_set_alternative_button_order(Dialog* this_, int first_response_id, ...);
void gtk_dialog_set_alternative_button_order_from_array(Dialog* this_, int n_params, int* new_order);
void gtk_dialog_set_default_response(Dialog* this_, int response_id);
void gtk_dialog_set_has_separator(Dialog* this_, int setting);
void gtk_dialog_set_response_sensitive(Dialog* this_, int response_id, int setting);
DrawingArea* gtk_drawing_area_new();
void gtk_drawing_area_size(DrawingArea* this_, int width, int height);
void gtk_editable_copy_clipboard(Editable* this_);
void gtk_editable_cut_clipboard(Editable* this_);
void gtk_editable_delete_selection(Editable* this_);
void gtk_editable_delete_text(Editable* this_, int start_pos, int end_pos);
char* /*new*/ gtk_editable_get_chars(Editable* this_, int start_pos, int end_pos);
int gtk_editable_get_editable(Editable* this_);
int gtk_editable_get_position(Editable* this_);
int gtk_editable_get_selection_bounds(Editable* this_, /*out*/ int* start_pos=null, /*out*/ int* end_pos=null);
void gtk_editable_insert_text(Editable* this_, char* new_text, int new_text_length, /*inout*/ int* position);
void gtk_editable_paste_clipboard(Editable* this_);
void gtk_editable_select_region(Editable* this_, int start_pos, int end_pos);
void gtk_editable_set_editable(Editable* this_, int is_editable);
void gtk_editable_set_position(Editable* this_, int position);
Entry* gtk_entry_new();
Entry* gtk_entry_new_with_buffer(EntryBuffer* buffer);
Entry* gtk_entry_new_with_max_length(int max);
void gtk_entry_append_text(Entry* this_, char* text);
int gtk_entry_get_activates_default(Entry* this_);
float gtk_entry_get_alignment(Entry* this_);
EntryBuffer* gtk_entry_get_buffer(Entry* this_);
EntryCompletion* gtk_entry_get_completion(Entry* this_);
int gtk_entry_get_current_icon_drag_source(Entry* this_);
Adjustment* gtk_entry_get_cursor_hadjustment(Entry* this_);
int gtk_entry_get_has_frame(Entry* this_);
int gtk_entry_get_icon_activatable(Entry* this_, EntryIconPosition icon_pos);
int gtk_entry_get_icon_at_pos(Entry* this_, int x, int y);
Gio2.Icon* gtk_entry_get_icon_gicon(Entry* this_, EntryIconPosition icon_pos);
char* gtk_entry_get_icon_name(Entry* this_, EntryIconPosition icon_pos);
GdkPixbuf2.Pixbuf* gtk_entry_get_icon_pixbuf(Entry* this_, EntryIconPosition icon_pos);
int gtk_entry_get_icon_sensitive(Entry* this_, EntryIconPosition icon_pos);
char* gtk_entry_get_icon_stock(Entry* this_, EntryIconPosition icon_pos);
ImageType gtk_entry_get_icon_storage_type(Entry* this_, EntryIconPosition icon_pos);
char* /*new*/ gtk_entry_get_icon_tooltip_markup(Entry* this_, EntryIconPosition icon_pos);
char* /*new*/ gtk_entry_get_icon_tooltip_text(Entry* this_, EntryIconPosition icon_pos);
Gdk2.Window* gtk_entry_get_icon_window(Entry* this_, EntryIconPosition icon_pos);
Border* gtk_entry_get_inner_border(Entry* this_);
dchar gtk_entry_get_invisible_char(Entry* this_);
Pango.Layout* gtk_entry_get_layout(Entry* this_);
void gtk_entry_get_layout_offsets(Entry* this_, /*out*/ int* x=null, /*out*/ int* y=null);
int gtk_entry_get_max_length(Entry* this_);
int gtk_entry_get_overwrite_mode(Entry* this_);
double gtk_entry_get_progress_fraction(Entry* this_);
double gtk_entry_get_progress_pulse_step(Entry* this_);
char* gtk_entry_get_text(Entry* this_);
ushort gtk_entry_get_text_length(Entry* this_);
Gdk2.Window* gtk_entry_get_text_window(Entry* this_);
int gtk_entry_get_visibility(Entry* this_);
int gtk_entry_get_width_chars(Entry* this_);
int gtk_entry_im_context_filter_keypress(Entry* this_, Gdk2.EventKey* event);
int gtk_entry_layout_index_to_text_index(Entry* this_, int layout_index);
void gtk_entry_prepend_text(Entry* this_, char* text);
void gtk_entry_progress_pulse(Entry* this_);
void gtk_entry_reset_im_context(Entry* this_);
void gtk_entry_select_region(Entry* this_, int start, int end);
void gtk_entry_set_activates_default(Entry* this_, int setting);
void gtk_entry_set_alignment(Entry* this_, float xalign);
void gtk_entry_set_buffer(Entry* this_, EntryBuffer* buffer);
void gtk_entry_set_completion(Entry* this_, EntryCompletion* completion=null);
void gtk_entry_set_cursor_hadjustment(Entry* this_, Adjustment* adjustment);
void gtk_entry_set_editable(Entry* this_, int editable);
void gtk_entry_set_has_frame(Entry* this_, int setting);
void gtk_entry_set_icon_activatable(Entry* this_, EntryIconPosition icon_pos, int activatable);
void gtk_entry_set_icon_drag_source(Entry* this_, EntryIconPosition icon_pos, TargetList* target_list, Gdk2.DragAction actions);
void gtk_entry_set_icon_from_gicon(Entry* this_, EntryIconPosition icon_pos, Gio2.Icon* icon=null);
void gtk_entry_set_icon_from_icon_name(Entry* this_, EntryIconPosition icon_pos, char* icon_name=null);
void gtk_entry_set_icon_from_pixbuf(Entry* this_, EntryIconPosition icon_pos, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_entry_set_icon_from_stock(Entry* this_, EntryIconPosition icon_pos, char* stock_id=null);
void gtk_entry_set_icon_sensitive(Entry* this_, EntryIconPosition icon_pos, int sensitive);
void gtk_entry_set_icon_tooltip_markup(Entry* this_, EntryIconPosition icon_pos, char* tooltip=null);
void gtk_entry_set_icon_tooltip_text(Entry* this_, EntryIconPosition icon_pos, char* tooltip=null);
void gtk_entry_set_inner_border(Entry* this_, Border* border=null);
void gtk_entry_set_invisible_char(Entry* this_, dchar ch);
void gtk_entry_set_max_length(Entry* this_, int max);
void gtk_entry_set_overwrite_mode(Entry* this_, int overwrite);
void gtk_entry_set_position(Entry* this_, int position);
void gtk_entry_set_progress_fraction(Entry* this_, double fraction);
void gtk_entry_set_progress_pulse_step(Entry* this_, double fraction);
void gtk_entry_set_text(Entry* this_, char* text);
void gtk_entry_set_visibility(Entry* this_, int visible);
void gtk_entry_set_width_chars(Entry* this_, int n_chars);
int gtk_entry_text_index_to_layout_index(Entry* this_, int text_index);
void gtk_entry_unset_invisible_char(Entry* this_);
EntryBuffer* /*new*/ gtk_entry_buffer_new(char* initial_chars, int n_initial_chars);
uint gtk_entry_buffer_delete_text(EntryBuffer* this_, uint position, int n_chars);
void gtk_entry_buffer_emit_deleted_text(EntryBuffer* this_, uint position, uint n_chars);
void gtk_entry_buffer_emit_inserted_text(EntryBuffer* this_, uint position, char* chars, uint n_chars);
size_t gtk_entry_buffer_get_bytes(EntryBuffer* this_);
uint gtk_entry_buffer_get_length(EntryBuffer* this_);
int gtk_entry_buffer_get_max_length(EntryBuffer* this_);
char* gtk_entry_buffer_get_text(EntryBuffer* this_);
uint gtk_entry_buffer_insert_text(EntryBuffer* this_, uint position, char* chars, int n_chars);
void gtk_entry_buffer_set_max_length(EntryBuffer* this_, int max_length);
void gtk_entry_buffer_set_text(EntryBuffer* this_, char* chars, int n_chars);
EntryCompletion* /*new*/ gtk_entry_completion_new();
void gtk_entry_completion_complete(EntryCompletion* this_);
void gtk_entry_completion_delete_action(EntryCompletion* this_, int index_);
char* gtk_entry_completion_get_completion_prefix(EntryCompletion* this_);
Widget* gtk_entry_completion_get_entry(EntryCompletion* this_);
int gtk_entry_completion_get_inline_completion(EntryCompletion* this_);
int gtk_entry_completion_get_inline_selection(EntryCompletion* this_);
int gtk_entry_completion_get_minimum_key_length(EntryCompletion* this_);
TreeModel* gtk_entry_completion_get_model(EntryCompletion* this_);
int gtk_entry_completion_get_popup_completion(EntryCompletion* this_);
int gtk_entry_completion_get_popup_set_width(EntryCompletion* this_);
int gtk_entry_completion_get_popup_single_match(EntryCompletion* this_);
int gtk_entry_completion_get_text_column(EntryCompletion* this_);
void gtk_entry_completion_insert_action_markup(EntryCompletion* this_, int index_, char* markup);
void gtk_entry_completion_insert_action_text(EntryCompletion* this_, int index_, char* text);
void gtk_entry_completion_insert_prefix(EntryCompletion* this_);
void gtk_entry_completion_set_inline_completion(EntryCompletion* this_, int inline_completion);
void gtk_entry_completion_set_inline_selection(EntryCompletion* this_, int inline_selection);
void gtk_entry_completion_set_match_func(EntryCompletion* this_, EntryCompletionMatchFunc func, void* func_data, GLib2.DestroyNotify func_notify);
void gtk_entry_completion_set_minimum_key_length(EntryCompletion* this_, int length);
void gtk_entry_completion_set_model(EntryCompletion* this_, TreeModel* model=null);
void gtk_entry_completion_set_popup_completion(EntryCompletion* this_, int popup_completion);
void gtk_entry_completion_set_popup_set_width(EntryCompletion* this_, int popup_set_width);
void gtk_entry_completion_set_popup_single_match(EntryCompletion* this_, int popup_single_match);
void gtk_entry_completion_set_text_column(EntryCompletion* this_, int column);
EventBox* gtk_event_box_new();
int gtk_event_box_get_above_child(EventBox* this_);
int gtk_event_box_get_visible_window(EventBox* this_);
void gtk_event_box_set_above_child(EventBox* this_, int above_child);
void gtk_event_box_set_visible_window(EventBox* this_, int visible_window);
Expander* gtk_expander_new(char* label);
Expander* gtk_expander_new_with_mnemonic(char* label=null);
int gtk_expander_get_expanded(Expander* this_);
char* gtk_expander_get_label(Expander* this_);
int gtk_expander_get_label_fill(Expander* this_);
Widget* gtk_expander_get_label_widget(Expander* this_);
int gtk_expander_get_spacing(Expander* this_);
int gtk_expander_get_use_markup(Expander* this_);
int gtk_expander_get_use_underline(Expander* this_);
void gtk_expander_set_expanded(Expander* this_, int expanded);
void gtk_expander_set_label(Expander* this_, char* label=null);
void gtk_expander_set_label_fill(Expander* this_, int label_fill);
void gtk_expander_set_label_widget(Expander* this_, Widget* label_widget=null);
void gtk_expander_set_spacing(Expander* this_, int spacing);
void gtk_expander_set_use_markup(Expander* this_, int use_markup);
void gtk_expander_set_use_underline(Expander* this_, int use_underline);
void gtk_file_chooser_add_filter(FileChooser* this_, FileFilter* filter);
int gtk_file_chooser_add_shortcut_folder(FileChooser* this_, char* folder, GLib2.Error** error);
int gtk_file_chooser_add_shortcut_folder_uri(FileChooser* this_, char* uri, GLib2.Error** error);
FileChooserAction gtk_file_chooser_get_action(FileChooser* this_);
int gtk_file_chooser_get_create_folders(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_current_folder(FileChooser* this_);
Gio2.File* /*new*/ gtk_file_chooser_get_current_folder_file(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_current_folder_uri(FileChooser* this_);
int gtk_file_chooser_get_do_overwrite_confirmation(FileChooser* this_);
Widget* gtk_file_chooser_get_extra_widget(FileChooser* this_);
Gio2.File* /*new*/ gtk_file_chooser_get_file(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_filename(FileChooser* this_);
GLib2.SList* /*new*/ gtk_file_chooser_get_filenames(FileChooser* this_);
GLib2.SList* /*new*/ gtk_file_chooser_get_files(FileChooser* this_);
FileFilter* gtk_file_chooser_get_filter(FileChooser* this_);
int gtk_file_chooser_get_local_only(FileChooser* this_);
Gio2.File* /*new*/ gtk_file_chooser_get_preview_file(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_preview_filename(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_preview_uri(FileChooser* this_);
Widget* gtk_file_chooser_get_preview_widget(FileChooser* this_);
int gtk_file_chooser_get_preview_widget_active(FileChooser* this_);
int gtk_file_chooser_get_select_multiple(FileChooser* this_);
int gtk_file_chooser_get_show_hidden(FileChooser* this_);
char* /*new*/ gtk_file_chooser_get_uri(FileChooser* this_);
GLib2.SList* /*new*/ gtk_file_chooser_get_uris(FileChooser* this_);
int gtk_file_chooser_get_use_preview_label(FileChooser* this_);
GLib2.SList* /*new container*/ gtk_file_chooser_list_filters(FileChooser* this_);
GLib2.SList* /*new*/ gtk_file_chooser_list_shortcut_folder_uris(FileChooser* this_);
GLib2.SList* /*new*/ gtk_file_chooser_list_shortcut_folders(FileChooser* this_);
void gtk_file_chooser_remove_filter(FileChooser* this_, FileFilter* filter);
int gtk_file_chooser_remove_shortcut_folder(FileChooser* this_, char* folder, GLib2.Error** error);
int gtk_file_chooser_remove_shortcut_folder_uri(FileChooser* this_, char* uri, GLib2.Error** error);
void gtk_file_chooser_select_all(FileChooser* this_);
int gtk_file_chooser_select_file(FileChooser* this_, Gio2.File* file, GLib2.Error** error);
int gtk_file_chooser_select_filename(FileChooser* this_, char* filename);
int gtk_file_chooser_select_uri(FileChooser* this_, char* uri);
void gtk_file_chooser_set_action(FileChooser* this_, FileChooserAction action);
void gtk_file_chooser_set_create_folders(FileChooser* this_, int create_folders);
int gtk_file_chooser_set_current_folder(FileChooser* this_, char* filename);
int gtk_file_chooser_set_current_folder_file(FileChooser* this_, Gio2.File* file, GLib2.Error** error);
int gtk_file_chooser_set_current_folder_uri(FileChooser* this_, char* uri);
void gtk_file_chooser_set_current_name(FileChooser* this_, char* name);
void gtk_file_chooser_set_do_overwrite_confirmation(FileChooser* this_, int do_overwrite_confirmation);
void gtk_file_chooser_set_extra_widget(FileChooser* this_, Widget* extra_widget);
int gtk_file_chooser_set_file(FileChooser* this_, Gio2.File* file, GLib2.Error** error);
int gtk_file_chooser_set_filename(FileChooser* this_, char* filename);
void gtk_file_chooser_set_filter(FileChooser* this_, FileFilter* filter);
void gtk_file_chooser_set_local_only(FileChooser* this_, int local_only);
void gtk_file_chooser_set_preview_widget(FileChooser* this_, Widget* preview_widget);
void gtk_file_chooser_set_preview_widget_active(FileChooser* this_, int active);
void gtk_file_chooser_set_select_multiple(FileChooser* this_, int select_multiple);
void gtk_file_chooser_set_show_hidden(FileChooser* this_, int show_hidden);
int gtk_file_chooser_set_uri(FileChooser* this_, char* uri);
void gtk_file_chooser_set_use_preview_label(FileChooser* this_, int use_label);
void gtk_file_chooser_unselect_all(FileChooser* this_);
void gtk_file_chooser_unselect_file(FileChooser* this_, Gio2.File* file);
void gtk_file_chooser_unselect_filename(FileChooser* this_, char* filename);
void gtk_file_chooser_unselect_uri(FileChooser* this_, char* uri);
FileChooserButton* gtk_file_chooser_button_new(char* title, FileChooserAction action);
FileChooserButton* gtk_file_chooser_button_new_with_backend(char* title, FileChooserAction action, char* backend);
FileChooserButton* gtk_file_chooser_button_new_with_dialog(Widget* dialog);
int gtk_file_chooser_button_get_focus_on_click(FileChooserButton* this_);
char* gtk_file_chooser_button_get_title(FileChooserButton* this_);
int gtk_file_chooser_button_get_width_chars(FileChooserButton* this_);
void gtk_file_chooser_button_set_focus_on_click(FileChooserButton* this_, int focus_on_click);
void gtk_file_chooser_button_set_title(FileChooserButton* this_, char* title);
void gtk_file_chooser_button_set_width_chars(FileChooserButton* this_, int n_chars);
FileChooserDialog* gtk_file_chooser_dialog_new(char* title, Window* parent, FileChooserAction action, char* first_button_text=null, ...);
FileChooserDialog* gtk_file_chooser_dialog_new_with_backend(char* title, Window* parent, FileChooserAction action, char* backend, char* first_button_text=null, ...);
FileChooserWidget* gtk_file_chooser_widget_new(FileChooserAction action);
FileChooserWidget* gtk_file_chooser_widget_new_with_backend(FileChooserAction action, char* backend);
FileFilter* gtk_file_filter_new();
void gtk_file_filter_add_custom(FileFilter* this_, FileFilterFlags needed, FileFilterFunc func, void* data, GLib2.DestroyNotify notify);
void gtk_file_filter_add_mime_type(FileFilter* this_, char* mime_type);
void gtk_file_filter_add_pattern(FileFilter* this_, char* pattern);
void gtk_file_filter_add_pixbuf_formats(FileFilter* this_);
int gtk_file_filter_filter(FileFilter* this_, FileFilterInfo* filter_info);
char* gtk_file_filter_get_name(FileFilter* this_);
FileFilterFlags gtk_file_filter_get_needed(FileFilter* this_);
void gtk_file_filter_set_name(FileFilter* this_, char* name=null);
FileSelection* gtk_file_selection_new(char* title);
void gtk_file_selection_complete(FileSelection* this_, char* pattern);
char* gtk_file_selection_get_filename(FileSelection* this_);
int gtk_file_selection_get_select_multiple(FileSelection* this_);
char** gtk_file_selection_get_selections(FileSelection* this_);
void gtk_file_selection_hide_fileop_buttons(FileSelection* this_);
void gtk_file_selection_set_filename(FileSelection* this_, char* filename);
void gtk_file_selection_set_select_multiple(FileSelection* this_, int select_multiple);
void gtk_file_selection_show_fileop_buttons(FileSelection* this_);
Fixed* gtk_fixed_new();
int gtk_fixed_get_has_window(Fixed* this_);
void gtk_fixed_move(Fixed* this_, Widget* widget, int x, int y);
void gtk_fixed_put(Fixed* this_, Widget* widget, int x, int y);
void gtk_fixed_set_has_window(Fixed* this_, int has_window);
FontButton* gtk_font_button_new();
FontButton* gtk_font_button_new_with_font(char* fontname);
char* gtk_font_button_get_font_name(FontButton* this_);
int gtk_font_button_get_show_size(FontButton* this_);
int gtk_font_button_get_show_style(FontButton* this_);
char* gtk_font_button_get_title(FontButton* this_);
int gtk_font_button_get_use_font(FontButton* this_);
int gtk_font_button_get_use_size(FontButton* this_);
int gtk_font_button_set_font_name(FontButton* this_, char* fontname);
void gtk_font_button_set_show_size(FontButton* this_, int show_size);
void gtk_font_button_set_show_style(FontButton* this_, int show_style);
void gtk_font_button_set_title(FontButton* this_, char* title);
void gtk_font_button_set_use_font(FontButton* this_, int use_font);
void gtk_font_button_set_use_size(FontButton* this_, int use_size);
FontSelection* gtk_font_selection_new();
Pango.FontFace* gtk_font_selection_get_face(FontSelection* this_);
Widget* gtk_font_selection_get_face_list(FontSelection* this_);
Pango.FontFamily* gtk_font_selection_get_family(FontSelection* this_);
Widget* gtk_font_selection_get_family_list(FontSelection* this_);
Gdk2.Font* /*new*/ gtk_font_selection_get_font(FontSelection* this_);
char* /*new*/ gtk_font_selection_get_font_name(FontSelection* this_);
Widget* gtk_font_selection_get_preview_entry(FontSelection* this_);
char* gtk_font_selection_get_preview_text(FontSelection* this_);
int gtk_font_selection_get_size(FontSelection* this_);
Widget* gtk_font_selection_get_size_entry(FontSelection* this_);
Widget* gtk_font_selection_get_size_list(FontSelection* this_);
int gtk_font_selection_set_font_name(FontSelection* this_, char* fontname);
void gtk_font_selection_set_preview_text(FontSelection* this_, char* text);
FontSelectionDialog* gtk_font_selection_dialog_new(char* title);
Widget* gtk_font_selection_dialog_get_apply_button(FontSelectionDialog* this_);
Widget* gtk_font_selection_dialog_get_cancel_button(FontSelectionDialog* this_);
Gdk2.Font* /*new*/ gtk_font_selection_dialog_get_font(FontSelectionDialog* this_);
char* /*new*/ gtk_font_selection_dialog_get_font_name(FontSelectionDialog* this_);
Widget* gtk_font_selection_dialog_get_font_selection(FontSelectionDialog* this_);
Widget* gtk_font_selection_dialog_get_ok_button(FontSelectionDialog* this_);
char* gtk_font_selection_dialog_get_preview_text(FontSelectionDialog* this_);
int gtk_font_selection_dialog_set_font_name(FontSelectionDialog* this_, char* fontname);
void gtk_font_selection_dialog_set_preview_text(FontSelectionDialog* this_, char* text);
Frame* gtk_frame_new(char* label);
char* gtk_frame_get_label(Frame* this_);
void gtk_frame_get_label_align(Frame* this_, /*out*/ float* xalign=null, /*out*/ float* yalign=null);
Widget* gtk_frame_get_label_widget(Frame* this_);
ShadowType gtk_frame_get_shadow_type(Frame* this_);
void gtk_frame_set_label(Frame* this_, char* label=null);
void gtk_frame_set_label_align(Frame* this_, float xalign, float yalign);
void gtk_frame_set_label_widget(Frame* this_, Widget* label_widget);
void gtk_frame_set_shadow_type(Frame* this_, ShadowType type);
GammaCurve* gtk_gamma_curve_new();
HBox* gtk_hbox_new(int homogeneous, int spacing);
HButtonBox* gtk_hbutton_box_new();
ButtonBoxStyle gtk_hbutton_box_get_layout_default();
int gtk_hbutton_box_get_spacing_default();
void gtk_hbutton_box_set_layout_default(ButtonBoxStyle layout);
void gtk_hbutton_box_set_spacing_default(int spacing);
HPaned* gtk_hpaned_new();
HRuler* gtk_hruler_new();
HSV* gtk_hsv_new();
void gtk_hsv_to_rgb(double h, double s, double v, /*out*/ double* r, /*out*/ double* g, /*out*/ double* b);
void gtk_hsv_get_color(HSV* this_, /*out*/ double* h, /*out*/ double* s, /*out*/ double* v);
void gtk_hsv_get_metrics(HSV* this_, /*out*/ int* size, /*out*/ int* ring_width);
int gtk_hsv_is_adjusting(HSV* this_);
void gtk_hsv_set_color(HSV* this_, double h, double s, double v);
void gtk_hsv_set_metrics(HSV* this_, int size, int ring_width);
HScale* gtk_hscale_new(Adjustment* adjustment);
HScale* gtk_hscale_new_with_range(double min, double max, double step);
HScrollbar* gtk_hscrollbar_new(Adjustment* adjustment=null);
HSeparator* gtk_hseparator_new();
HandleBox* gtk_handle_box_new();
int gtk_handle_box_get_child_detached(HandleBox* this_);
PositionType gtk_handle_box_get_handle_position(HandleBox* this_);
ShadowType gtk_handle_box_get_shadow_type(HandleBox* this_);
PositionType gtk_handle_box_get_snap_edge(HandleBox* this_);
void gtk_handle_box_set_handle_position(HandleBox* this_, PositionType position);
void gtk_handle_box_set_shadow_type(HandleBox* this_, ShadowType type);
void gtk_handle_box_set_snap_edge(HandleBox* this_, PositionType edge);
int gtk_im_context_delete_surrounding(IMContext* this_, int offset, int n_chars);
int gtk_im_context_filter_keypress(IMContext* this_, Gdk2.EventKey* event);
void gtk_im_context_focus_in(IMContext* this_);
void gtk_im_context_focus_out(IMContext* this_);
void gtk_im_context_get_preedit_string(IMContext* this_, /*out*/ char** str, /*out*/ Pango.AttrList** attrs, /*out*/ int* cursor_pos);
int gtk_im_context_get_surrounding(IMContext* this_, /*out*/ char** text, int* cursor_index);
void gtk_im_context_reset(IMContext* this_);
void gtk_im_context_set_client_window(IMContext* this_, Gdk2.Window* window=null);
void gtk_im_context_set_cursor_location(IMContext* this_, Gdk2.Rectangle* area);
void gtk_im_context_set_surrounding(IMContext* this_, char* text, int len, int cursor_index);
void gtk_im_context_set_use_preedit(IMContext* this_, int use_preedit);
IMContextSimple* /*new*/ gtk_im_context_simple_new();
void gtk_im_context_simple_add_table(IMContextSimple* this_, ushort* data, int max_seq_len, int n_seqs);
IMMulticontext* /*new*/ gtk_im_multicontext_new();
void gtk_im_multicontext_append_menuitems(IMMulticontext* this_, MenuShell* menushell);
char* gtk_im_multicontext_get_context_id(IMMulticontext* this_);
void gtk_im_multicontext_set_context_id(IMMulticontext* this_, char* context_id);
IconFactory* /*new*/ gtk_icon_factory_new();
IconSet* gtk_icon_factory_lookup_default(char* stock_id);
void gtk_icon_factory_add(IconFactory* this_, char* stock_id, IconSet* icon_set);
void gtk_icon_factory_add_default(IconFactory* this_);
IconSet* gtk_icon_factory_lookup(IconFactory* this_, char* stock_id);
void gtk_icon_factory_remove_default(IconFactory* this_);
IconInfo* /*new*/ gtk_icon_info_new_for_pixbuf(IconTheme* icon_theme, GdkPixbuf2.Pixbuf* pixbuf);
IconInfo* /*new*/ gtk_icon_info_copy(IconInfo* this_);
void gtk_icon_info_free(IconInfo* this_);
int gtk_icon_info_get_attach_points(IconInfo* this_, Gdk2.Point** points=null, int* n_points=null);
int gtk_icon_info_get_base_size(IconInfo* this_);
GdkPixbuf2.Pixbuf* gtk_icon_info_get_builtin_pixbuf(IconInfo* this_);
char* gtk_icon_info_get_display_name(IconInfo* this_);
int gtk_icon_info_get_embedded_rect(IconInfo* this_, /*out*/ Gdk2.Rectangle* rectangle);
char* gtk_icon_info_get_filename(IconInfo* this_);
GdkPixbuf2.Pixbuf* /*new*/ gtk_icon_info_load_icon(IconInfo* this_, GLib2.Error** error);
void gtk_icon_info_set_raw_coordinates(IconInfo* this_, int raw_coordinates);
IconSet* /*new*/ gtk_icon_set_new();
IconSet* /*new*/ gtk_icon_set_new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf);
void gtk_icon_set_add_source(IconSet* this_, IconSource* source);
IconSet* /*new*/ gtk_icon_set_copy(IconSet* this_);
void gtk_icon_set_get_sizes(IconSet* this_, /*out*/ /*POINTER*/ int* sizes, /*out*/ int* n_sizes);
IconSet* /*new*/ gtk_icon_set_ref(IconSet* this_);
GdkPixbuf2.Pixbuf* /*new*/ gtk_icon_set_render_icon(IconSet* this_, Style* style, TextDirection direction, StateType state, int size, Widget* widget=null, char* detail=null);
void gtk_icon_set_unref(IconSet* this_);
IconSource* /*new*/ gtk_icon_source_new();
IconSource* /*new*/ gtk_icon_source_copy(IconSource* this_);
void gtk_icon_source_free(IconSource* this_);
TextDirection gtk_icon_source_get_direction(IconSource* this_);
int gtk_icon_source_get_direction_wildcarded(IconSource* this_);
char* gtk_icon_source_get_filename(IconSource* this_);
char* gtk_icon_source_get_icon_name(IconSource* this_);
GdkPixbuf2.Pixbuf* gtk_icon_source_get_pixbuf(IconSource* this_);
int gtk_icon_source_get_size(IconSource* this_);
int gtk_icon_source_get_size_wildcarded(IconSource* this_);
StateType gtk_icon_source_get_state(IconSource* this_);
int gtk_icon_source_get_state_wildcarded(IconSource* this_);
void gtk_icon_source_set_direction(IconSource* this_, TextDirection direction);
void gtk_icon_source_set_direction_wildcarded(IconSource* this_, int setting);
void gtk_icon_source_set_filename(IconSource* this_, char* filename);
void gtk_icon_source_set_icon_name(IconSource* this_, char* icon_name=null);
void gtk_icon_source_set_pixbuf(IconSource* this_, GdkPixbuf2.Pixbuf* pixbuf);
void gtk_icon_source_set_size(IconSource* this_, int size);
void gtk_icon_source_set_size_wildcarded(IconSource* this_, int setting);
void gtk_icon_source_set_state(IconSource* this_, StateType state);
void gtk_icon_source_set_state_wildcarded(IconSource* this_, int setting);
IconTheme* /*new*/ gtk_icon_theme_new();
void gtk_icon_theme_add_builtin_icon(char* icon_name, int size, GdkPixbuf2.Pixbuf* pixbuf);
IconTheme* gtk_icon_theme_get_default();
IconTheme* gtk_icon_theme_get_for_screen(Gdk2.Screen* screen);
void gtk_icon_theme_append_search_path(IconTheme* this_, char* path);
IconInfo* /*new*/ gtk_icon_theme_choose_icon(IconTheme* this_, char* icon_names, int size, IconLookupFlags flags);
char* /*new*/ gtk_icon_theme_get_example_icon_name(IconTheme* this_);
int* gtk_icon_theme_get_icon_sizes(IconTheme* this_, char* icon_name);
void gtk_icon_theme_get_search_path(IconTheme* this_, char** path, int* n_elements);
int gtk_icon_theme_has_icon(IconTheme* this_, char* icon_name);
GLib2.List* /*new*/ gtk_icon_theme_list_contexts(IconTheme* this_);
GLib2.List* /*new*/ gtk_icon_theme_list_icons(IconTheme* this_, char* context);
GdkPixbuf2.Pixbuf* /*new*/ gtk_icon_theme_load_icon(IconTheme* this_, char* icon_name, int size, IconLookupFlags flags, GLib2.Error** error);
IconInfo* /*new*/ gtk_icon_theme_lookup_by_gicon(IconTheme* this_, Gio2.Icon* icon, int size, IconLookupFlags flags);
IconInfo* /*new*/ gtk_icon_theme_lookup_icon(IconTheme* this_, char* icon_name, int size, IconLookupFlags flags);
void gtk_icon_theme_prepend_search_path(IconTheme* this_, char* path);
int gtk_icon_theme_rescan_if_needed(IconTheme* this_);
void gtk_icon_theme_set_custom_theme(IconTheme* this_, char* theme_name);
void gtk_icon_theme_set_screen(IconTheme* this_, Gdk2.Screen* screen);
void gtk_icon_theme_set_search_path(IconTheme* this_, char* path, int n_elements);
IconView* gtk_icon_view_new();
IconView* gtk_icon_view_new_with_model(TreeModel* model);
void gtk_icon_view_convert_widget_to_bin_window_coords(IconView* this_, int wx, int wy, /*out*/ int* bx, /*out*/ int* by);
Gdk2.Pixmap* /*new*/ gtk_icon_view_create_drag_icon(IconView* this_, TreePath* path);
void gtk_icon_view_enable_model_drag_dest(IconView* this_, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
void gtk_icon_view_enable_model_drag_source(IconView* this_, Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
int gtk_icon_view_get_column_spacing(IconView* this_);
int gtk_icon_view_get_columns(IconView* this_);
int gtk_icon_view_get_cursor(IconView* this_, TreePath** path=null, CellRenderer** cell=null);
int gtk_icon_view_get_dest_item_at_pos(IconView* this_, int drag_x, int drag_y, TreePath** path=null, IconViewDropPosition* pos=null);
void gtk_icon_view_get_drag_dest_item(IconView* this_, TreePath** path=null, IconViewDropPosition* pos=null);
int gtk_icon_view_get_item_at_pos(IconView* this_, int x, int y, TreePath** path, CellRenderer** cell);
int gtk_icon_view_get_item_column(IconView* this_, TreePath* path);
Orientation gtk_icon_view_get_item_orientation(IconView* this_);
int gtk_icon_view_get_item_padding(IconView* this_);
int gtk_icon_view_get_item_row(IconView* this_, TreePath* path);
int gtk_icon_view_get_item_width(IconView* this_);
int gtk_icon_view_get_margin(IconView* this_);
int gtk_icon_view_get_markup_column(IconView* this_);
TreeModel* gtk_icon_view_get_model(IconView* this_);
Orientation gtk_icon_view_get_orientation(IconView* this_);
TreePath* /*new*/ gtk_icon_view_get_path_at_pos(IconView* this_, int x, int y);
int gtk_icon_view_get_pixbuf_column(IconView* this_);
int gtk_icon_view_get_reorderable(IconView* this_);
int gtk_icon_view_get_row_spacing(IconView* this_);
GLib2.List* /*new*/ gtk_icon_view_get_selected_items(IconView* this_);
SelectionMode gtk_icon_view_get_selection_mode(IconView* this_);
int gtk_icon_view_get_spacing(IconView* this_);
int gtk_icon_view_get_text_column(IconView* this_);
int gtk_icon_view_get_tooltip_column(IconView* this_);
int gtk_icon_view_get_tooltip_context(IconView* this_, /*inout*/ int* x, /*inout*/ int* y, int keyboard_tip, /*out*/ TreeModel** model=null, /*out*/ TreePath** path=null, /*out*/ TreeIter* iter=null);
int gtk_icon_view_get_visible_range(IconView* this_, TreePath** start_path=null, TreePath** end_path=null);
void gtk_icon_view_item_activated(IconView* this_, TreePath* path);
int gtk_icon_view_path_is_selected(IconView* this_, TreePath* path);
void gtk_icon_view_scroll_to_path(IconView* this_, TreePath* path, int use_align, float row_align, float col_align);
void gtk_icon_view_select_all(IconView* this_);
void gtk_icon_view_select_path(IconView* this_, TreePath* path);
void gtk_icon_view_selected_foreach(IconView* this_, IconViewForeachFunc func, void* data);
void gtk_icon_view_set_column_spacing(IconView* this_, int column_spacing);
void gtk_icon_view_set_columns(IconView* this_, int columns);
void gtk_icon_view_set_cursor(IconView* this_, TreePath* path, CellRenderer* cell, int start_editing);
void gtk_icon_view_set_drag_dest_item(IconView* this_, TreePath* path, IconViewDropPosition pos);
void gtk_icon_view_set_item_orientation(IconView* this_, Orientation orientation);
void gtk_icon_view_set_item_padding(IconView* this_, int item_padding);
void gtk_icon_view_set_item_width(IconView* this_, int item_width);
void gtk_icon_view_set_margin(IconView* this_, int margin);
void gtk_icon_view_set_markup_column(IconView* this_, int column);
void gtk_icon_view_set_model(IconView* this_, TreeModel* model=null);
void gtk_icon_view_set_orientation(IconView* this_, Orientation orientation);
void gtk_icon_view_set_pixbuf_column(IconView* this_, int column);
void gtk_icon_view_set_reorderable(IconView* this_, int reorderable);
void gtk_icon_view_set_row_spacing(IconView* this_, int row_spacing);
void gtk_icon_view_set_selection_mode(IconView* this_, SelectionMode mode);
void gtk_icon_view_set_spacing(IconView* this_, int spacing);
void gtk_icon_view_set_text_column(IconView* this_, int column);
void gtk_icon_view_set_tooltip_cell(IconView* this_, Tooltip* tooltip, TreePath* path, CellRenderer* cell=null);
void gtk_icon_view_set_tooltip_column(IconView* this_, int column);
void gtk_icon_view_set_tooltip_item(IconView* this_, Tooltip* tooltip, TreePath* path);
void gtk_icon_view_unselect_all(IconView* this_);
void gtk_icon_view_unselect_path(IconView* this_, TreePath* path);
void gtk_icon_view_unset_model_drag_dest(IconView* this_);
void gtk_icon_view_unset_model_drag_source(IconView* this_);
Image* gtk_image_new();
Image* gtk_image_new_from_animation(GdkPixbuf2.PixbufAnimation* animation);
Image* gtk_image_new_from_file(char* filename);
Image* gtk_image_new_from_gicon(Gio2.Icon* icon, int size);
Image* gtk_image_new_from_icon_name(char* icon_name, int size);
Image* gtk_image_new_from_icon_set(IconSet* icon_set, int size);
Image* gtk_image_new_from_image(Gdk2.Image* image=null, Gdk2.Bitmap* mask=null);
Image* gtk_image_new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf=null);
Image* gtk_image_new_from_pixmap(Gdk2.Pixmap* pixmap=null, Gdk2.Bitmap* mask=null);
Image* gtk_image_new_from_stock(char* stock_id, int size);
void gtk_image_clear(Image* this_);
void gtk_image_get(Image* this_, Gdk2.Image** val, Gdk2.Bitmap** mask);
GdkPixbuf2.PixbufAnimation* gtk_image_get_animation(Image* this_);
void gtk_image_get_gicon(Image* this_, /*out*/ Gio2.Icon** gicon=null, /*out*/ /*POINTER*/ int* size=null);
void gtk_image_get_icon_name(Image* this_, /*out*/ char** icon_name=null, /*out*/ /*POINTER*/ int* size=null);
void gtk_image_get_icon_set(Image* this_, /*out*/ IconSet** icon_set=null, /*out*/ /*POINTER*/ int* size=null);
void gtk_image_get_image(Image* this_, /*out*/ Gdk2.Image** gdk_image=null, /*out*/ Gdk2.Bitmap** mask=null);
GdkPixbuf2.Pixbuf* gtk_image_get_pixbuf(Image* this_);
int gtk_image_get_pixel_size(Image* this_);
void gtk_image_get_pixmap(Image* this_, /*out*/ Gdk2.Pixmap** pixmap=null, /*out*/ Gdk2.Bitmap** mask=null);
void gtk_image_get_stock(Image* this_, /*out*/ char** stock_id=null, /*out*/ /*POINTER*/ int* size=null);
ImageType gtk_image_get_storage_type(Image* this_);
void gtk_image_set(Image* this_, Gdk2.Image* val, Gdk2.Bitmap* mask);
void gtk_image_set_from_animation(Image* this_, GdkPixbuf2.PixbufAnimation* animation);
void gtk_image_set_from_file(Image* this_, char* filename=null);
void gtk_image_set_from_gicon(Image* this_, Gio2.Icon* icon, int size);
void gtk_image_set_from_icon_name(Image* this_, char* icon_name, int size);
void gtk_image_set_from_icon_set(Image* this_, IconSet* icon_set, int size);
void gtk_image_set_from_image(Image* this_, Gdk2.Image* gdk_image=null, Gdk2.Bitmap* mask=null);
void gtk_image_set_from_pixbuf(Image* this_, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_image_set_from_pixmap(Image* this_, Gdk2.Pixmap* pixmap=null, Gdk2.Bitmap* mask=null);
void gtk_image_set_from_stock(Image* this_, char* stock_id, int size);
void gtk_image_set_pixel_size(Image* this_, int pixel_size);
ImageMenuItem* gtk_image_menu_item_new();
ImageMenuItem* gtk_image_menu_item_new_from_stock(char* stock_id, AccelGroup* accel_group=null);
ImageMenuItem* gtk_image_menu_item_new_with_label(char* label);
ImageMenuItem* gtk_image_menu_item_new_with_mnemonic(char* label);
int gtk_image_menu_item_get_always_show_image(ImageMenuItem* this_);
Widget* gtk_image_menu_item_get_image(ImageMenuItem* this_);
int gtk_image_menu_item_get_use_stock(ImageMenuItem* this_);
void gtk_image_menu_item_set_accel_group(ImageMenuItem* this_, AccelGroup* accel_group);
void gtk_image_menu_item_set_always_show_image(ImageMenuItem* this_, int always_show);
void gtk_image_menu_item_set_image(ImageMenuItem* this_, Widget* image=null);
void gtk_image_menu_item_set_use_stock(ImageMenuItem* this_, int use_stock);
InfoBar* gtk_info_bar_new();
InfoBar* gtk_info_bar_new_with_buttons(char* first_button_text=null, ...);
void gtk_info_bar_add_action_widget(InfoBar* this_, Widget* child, int response_id);
Widget* gtk_info_bar_add_button(InfoBar* this_, char* button_text, int response_id);
void gtk_info_bar_add_buttons(InfoBar* this_, char* first_button_text, ...);
Widget* gtk_info_bar_get_action_area(InfoBar* this_);
Widget* gtk_info_bar_get_content_area(InfoBar* this_);
MessageType gtk_info_bar_get_message_type(InfoBar* this_);
void gtk_info_bar_response(InfoBar* this_, int response_id);
void gtk_info_bar_set_default_response(InfoBar* this_, int response_id);
void gtk_info_bar_set_message_type(InfoBar* this_, MessageType message_type);
void gtk_info_bar_set_response_sensitive(InfoBar* this_, int response_id, int setting);
InputDialog* gtk_input_dialog_new();
Invisible* gtk_invisible_new();
Invisible* gtk_invisible_new_for_screen(Gdk2.Screen* screen);
Gdk2.Screen* gtk_invisible_get_screen(Invisible* this_);
void gtk_invisible_set_screen(Invisible* this_, Gdk2.Screen* screen);
void gtk_item_factories_path_delete(char* ifactory_path, char* path);
void gtk_item_deselect(Item* this_);
void gtk_item_select(Item* this_);
void gtk_item_toggle(Item* this_);
ItemFactory* gtk_item_factory_new(Type container_type, char* path, AccelGroup* accel_group=null);
void gtk_item_factory_add_foreign(Widget* accel_widget, char* full_path, AccelGroup* accel_group, uint keyval, Gdk2.ModifierType modifiers);
void gtk_item_factory_create_menu_entries(uint n_entries, MenuEntry* entries);
ItemFactory* gtk_item_factory_from_path(char* path);
ItemFactory* gtk_item_factory_from_widget(Widget* widget);
char* gtk_item_factory_path_from_widget(Widget* widget);
void* gtk_item_factory_popup_data_from_widget(Widget* widget);
void gtk_item_factory_construct(ItemFactory* this_, Type container_type, char* path, AccelGroup* accel_group);
void gtk_item_factory_create_item(ItemFactory* this_, ItemFactoryEntry* entry, void* callback_data, uint callback_type);
void gtk_item_factory_create_items(ItemFactory* this_, uint n_entries, ItemFactoryEntry* entries, void* callback_data);
void gtk_item_factory_create_items_ac(ItemFactory* this_, uint n_entries, ItemFactoryEntry* entries, void* callback_data, uint callback_type);
void gtk_item_factory_delete_entries(ItemFactory* this_, uint n_entries, ItemFactoryEntry* entries);
void gtk_item_factory_delete_entry(ItemFactory* this_, ItemFactoryEntry* entry);
void gtk_item_factory_delete_item(ItemFactory* this_, char* path);
Widget* gtk_item_factory_get_item(ItemFactory* this_, char* path);
Widget* gtk_item_factory_get_item_by_action(ItemFactory* this_, uint action);
Widget* gtk_item_factory_get_widget(ItemFactory* this_, char* path);
Widget* gtk_item_factory_get_widget_by_action(ItemFactory* this_, uint action);
void gtk_item_factory_popup(ItemFactory* this_, uint x, uint y, uint mouse_button, uint time_);
void* gtk_item_factory_popup_data(ItemFactory* this_);
void gtk_item_factory_popup_with_data(ItemFactory* this_, void* popup_data, GLib2.DestroyNotify destroy, uint x, uint y, uint mouse_button, uint time_);
void gtk_item_factory_set_translate_func(ItemFactory* this_, TranslateFunc func, void* data, GLib2.DestroyNotify notify);
Label* gtk_label_new(char* str);
Label* gtk_label_new_with_mnemonic(char* str);
void gtk_label_get(Label* this_, char** str);
double gtk_label_get_angle(Label* this_);
Pango.AttrList* gtk_label_get_attributes(Label* this_);
char* gtk_label_get_current_uri(Label* this_);
Pango.EllipsizeMode gtk_label_get_ellipsize(Label* this_);
Justification gtk_label_get_justify(Label* this_);
char* gtk_label_get_label(Label* this_);
Pango.Layout* gtk_label_get_layout(Label* this_);
void gtk_label_get_layout_offsets(Label* this_, /*out*/ int* x=null, /*out*/ int* y=null);
int gtk_label_get_line_wrap(Label* this_);
Pango.WrapMode gtk_label_get_line_wrap_mode(Label* this_);
int gtk_label_get_max_width_chars(Label* this_);
uint gtk_label_get_mnemonic_keyval(Label* this_);
Widget* gtk_label_get_mnemonic_widget(Label* this_);
int gtk_label_get_selectable(Label* this_);
int gtk_label_get_selection_bounds(Label* this_, /*out*/ int* start, /*out*/ int* end);
int gtk_label_get_single_line_mode(Label* this_);
char* gtk_label_get_text(Label* this_);
int gtk_label_get_track_visited_links(Label* this_);
int gtk_label_get_use_markup(Label* this_);
int gtk_label_get_use_underline(Label* this_);
int gtk_label_get_width_chars(Label* this_);
uint gtk_label_parse_uline(Label* this_, char* string_);
void gtk_label_select_region(Label* this_, int start_offset, int end_offset);
void gtk_label_set_angle(Label* this_, double angle);
void gtk_label_set_attributes(Label* this_, Pango.AttrList* attrs);
void gtk_label_set_ellipsize(Label* this_, Pango.EllipsizeMode mode);
void gtk_label_set_justify(Label* this_, Justification jtype);
void gtk_label_set_label(Label* this_, char* str);
void gtk_label_set_line_wrap(Label* this_, int wrap);
void gtk_label_set_line_wrap_mode(Label* this_, Pango.WrapMode wrap_mode);
void gtk_label_set_markup(Label* this_, char* str);
void gtk_label_set_markup_with_mnemonic(Label* this_, char* str);
void gtk_label_set_max_width_chars(Label* this_, int n_chars);
void gtk_label_set_mnemonic_widget(Label* this_, Widget* widget=null);
void gtk_label_set_pattern(Label* this_, char* pattern);
void gtk_label_set_selectable(Label* this_, int setting);
void gtk_label_set_single_line_mode(Label* this_, int single_line_mode);
void gtk_label_set_text(Label* this_, char* str);
void gtk_label_set_text_with_mnemonic(Label* this_, char* str);
void gtk_label_set_track_visited_links(Label* this_, int track_links);
void gtk_label_set_use_markup(Label* this_, int setting);
void gtk_label_set_use_underline(Label* this_, int setting);
void gtk_label_set_width_chars(Label* this_, int n_chars);
Layout* gtk_layout_new(Adjustment* hadjustment=null, Adjustment* vadjustment=null);
void gtk_layout_freeze(Layout* this_);
Gdk2.Window* gtk_layout_get_bin_window(Layout* this_);
Adjustment* gtk_layout_get_hadjustment(Layout* this_);
void gtk_layout_get_size(Layout* this_, /*out*/ uint* width=null, /*out*/ uint* height=null);
Adjustment* gtk_layout_get_vadjustment(Layout* this_);
void gtk_layout_move(Layout* this_, Widget* child_widget, int x, int y);
void gtk_layout_put(Layout* this_, Widget* child_widget, int x, int y);
void gtk_layout_set_hadjustment(Layout* this_, Adjustment* adjustment=null);
void gtk_layout_set_size(Layout* this_, uint width, uint height);
void gtk_layout_set_vadjustment(Layout* this_, Adjustment* adjustment=null);
void gtk_layout_thaw(Layout* this_);
LinkButton* gtk_link_button_new(char* uri);
LinkButton* gtk_link_button_new_with_label(char* uri, char* label=null);
LinkButtonUriFunc gtk_link_button_set_uri_hook(LinkButtonUriFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null);
char* gtk_link_button_get_uri(LinkButton* this_);
int gtk_link_button_get_visited(LinkButton* this_);
void gtk_link_button_set_uri(LinkButton* this_, char* uri);
void gtk_link_button_set_visited(LinkButton* this_, int visited);
List* gtk_list_new();
void gtk_list_append_items(List* this_, GLib2.List* items);
int gtk_list_child_position(List* this_, Widget* child);
void gtk_list_clear_items(List* this_, int start, int end);
void gtk_list_end_drag_selection(List* this_);
void gtk_list_end_selection(List* this_);
void gtk_list_extend_selection(List* this_, ScrollType scroll_type, float position, int auto_start_selection);
void gtk_list_insert_items(List* this_, GLib2.List* items, int position);
void gtk_list_prepend_items(List* this_, GLib2.List* items);
void gtk_list_remove_items(List* this_, GLib2.List* items);
void gtk_list_remove_items_no_unref(List* this_, GLib2.List* items);
void gtk_list_scroll_horizontal(List* this_, ScrollType scroll_type, float position);
void gtk_list_scroll_vertical(List* this_, ScrollType scroll_type, float position);
void gtk_list_select_all(List* this_);
void gtk_list_select_child(List* this_, Widget* child);
void gtk_list_select_item(List* this_, int item);
void gtk_list_set_selection_mode(List* this_, SelectionMode mode);
void gtk_list_start_selection(List* this_);
void gtk_list_toggle_add_mode(List* this_);
void gtk_list_toggle_focus_row(List* this_);
void gtk_list_toggle_row(List* this_, Widget* item);
void gtk_list_undo_selection(List* this_);
void gtk_list_unselect_all(List* this_);
void gtk_list_unselect_child(List* this_, Widget* child);
void gtk_list_unselect_item(List* this_, int item);
ListItem* gtk_list_item_new();
ListItem* gtk_list_item_new_with_label(char* label);
void gtk_list_item_deselect(ListItem* this_);
void gtk_list_item_select(ListItem* this_);
ListStore* /*new*/ gtk_list_store_new(int n_columns, ...);
ListStore* gtk_list_store_newv(int n_columns, Type* types);
void gtk_list_store_append(ListStore* this_, /*out*/ TreeIter* iter);
void gtk_list_store_clear(ListStore* this_);
void gtk_list_store_insert(ListStore* this_, /*out*/ TreeIter* iter, int position);
void gtk_list_store_insert_after(ListStore* this_, /*out*/ TreeIter* iter, TreeIter* sibling=null);
void gtk_list_store_insert_before(ListStore* this_, /*out*/ TreeIter* iter, TreeIter* sibling=null);
void gtk_list_store_insert_with_values(ListStore* this_, /*out*/ TreeIter* iter, int position, ...);
void gtk_list_store_insert_with_valuesv(ListStore* this_, /*out*/ TreeIter* iter, int position, int* columns, GObject2.Value* values, int n_values);
int gtk_list_store_iter_is_valid(ListStore* this_, TreeIter* iter);
void gtk_list_store_move_after(ListStore* this_, TreeIter* iter, TreeIter* position=null);
void gtk_list_store_move_before(ListStore* this_, TreeIter* iter, TreeIter* position=null);
void gtk_list_store_prepend(ListStore* this_, /*out*/ TreeIter* iter);
int gtk_list_store_remove(ListStore* this_, TreeIter* iter);
void gtk_list_store_reorder(ListStore* this_, int* new_order);
void gtk_list_store_set(ListStore* this_, TreeIter* iter, ...);
void gtk_list_store_set_column_types(ListStore* this_, int n_columns, Type* types);
void gtk_list_store_set_valist(ListStore* this_, TreeIter* iter, va_list var_args);
void gtk_list_store_set_value(ListStore* this_, TreeIter* iter, int column, GObject2.Value* value);
void gtk_list_store_set_valuesv(ListStore* this_, TreeIter* iter, int* columns, GObject2.Value* values, int n_values);
void gtk_list_store_swap(ListStore* this_, TreeIter* a, TreeIter* b);
Menu* gtk_menu_new();
GLib2.List* gtk_menu_get_for_attach_widget(Widget* widget);
void gtk_menu_attach(Menu* this_, Widget* child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach);
void gtk_menu_attach_to_widget(Menu* this_, Widget* attach_widget, MenuDetachFunc detacher);
void gtk_menu_detach(Menu* this_);
AccelGroup* gtk_menu_get_accel_group(Menu* this_);
char* gtk_menu_get_accel_path(Menu* this_);
Widget* gtk_menu_get_active(Menu* this_);
Widget* gtk_menu_get_attach_widget(Menu* this_);
int gtk_menu_get_monitor(Menu* this_);
int gtk_menu_get_reserve_toggle_size(Menu* this_);
int gtk_menu_get_tearoff_state(Menu* this_);
char* gtk_menu_get_title(Menu* this_);
void gtk_menu_popdown(Menu* this_);
void gtk_menu_popup(Menu* this_, Widget* parent_menu_shell, Widget* parent_menu_item, MenuPositionFunc func, void* data, uint button, uint activate_time);
void gtk_menu_reorder_child(Menu* this_, Widget* child, int position);
void gtk_menu_reposition(Menu* this_);
void gtk_menu_set_accel_group(Menu* this_, AccelGroup* accel_group=null);
void gtk_menu_set_accel_path(Menu* this_, char* accel_path=null);
void gtk_menu_set_active(Menu* this_, uint index_);
void gtk_menu_set_monitor(Menu* this_, int monitor_num);
void gtk_menu_set_reserve_toggle_size(Menu* this_, int reserve_toggle_size);
void gtk_menu_set_screen(Menu* this_, Gdk2.Screen* screen=null);
void gtk_menu_set_tearoff_state(Menu* this_, int torn_off);
void gtk_menu_set_title(Menu* this_, char* title);
MenuBar* gtk_menu_bar_new();
PackDirection gtk_menu_bar_get_child_pack_direction(MenuBar* this_);
PackDirection gtk_menu_bar_get_pack_direction(MenuBar* this_);
void gtk_menu_bar_set_child_pack_direction(MenuBar* this_, PackDirection child_pack_dir);
void gtk_menu_bar_set_pack_direction(MenuBar* this_, PackDirection pack_dir);
MenuItem* gtk_menu_item_new();
MenuItem* gtk_menu_item_new_with_label(char* label);
MenuItem* gtk_menu_item_new_with_mnemonic(char* label);
void gtk_menu_item_activate(MenuItem* this_);
void gtk_menu_item_deselect(MenuItem* this_);
char* gtk_menu_item_get_accel_path(MenuItem* this_);
char* gtk_menu_item_get_label(MenuItem* this_);
int gtk_menu_item_get_right_justified(MenuItem* this_);
Widget* gtk_menu_item_get_submenu(MenuItem* this_);
int gtk_menu_item_get_use_underline(MenuItem* this_);
void gtk_menu_item_remove_submenu(MenuItem* this_);
void gtk_menu_item_select(MenuItem* this_);
void gtk_menu_item_set_accel_path(MenuItem* this_, char* accel_path=null);
void gtk_menu_item_set_label(MenuItem* this_, char* label);
void gtk_menu_item_set_right_justified(MenuItem* this_, int right_justified);
void gtk_menu_item_set_submenu(MenuItem* this_, Widget* submenu=null);
void gtk_menu_item_set_use_underline(MenuItem* this_, int setting);
void gtk_menu_item_toggle_size_allocate(MenuItem* this_, int allocation);
void gtk_menu_item_toggle_size_request(MenuItem* this_, int* requisition);
void gtk_menu_shell_activate_item(MenuShell* this_, Widget* menu_item, int force_deactivate);
void gtk_menu_shell_append(MenuShell* this_, Widget* child);
void gtk_menu_shell_cancel(MenuShell* this_);
void gtk_menu_shell_deactivate(MenuShell* this_);
void gtk_menu_shell_deselect(MenuShell* this_);
int gtk_menu_shell_get_take_focus(MenuShell* this_);
void gtk_menu_shell_insert(MenuShell* this_, Widget* child, int position);
void gtk_menu_shell_prepend(MenuShell* this_, Widget* child);
void gtk_menu_shell_select_first(MenuShell* this_, int search_sensitive);
void gtk_menu_shell_select_item(MenuShell* this_, Widget* menu_item);
void gtk_menu_shell_set_take_focus(MenuShell* this_, int take_focus);
MenuToolButton* gtk_menu_tool_button_new(Widget* icon_widget=null, char* label=null);
MenuToolButton* gtk_menu_tool_button_new_from_stock(char* stock_id);
Widget* gtk_menu_tool_button_get_menu(MenuToolButton* this_);
void gtk_menu_tool_button_set_arrow_tooltip(MenuToolButton* this_, Tooltips* tooltips, char* tip_text=null, char* tip_private=null);
void gtk_menu_tool_button_set_arrow_tooltip_markup(MenuToolButton* this_, char* markup);
void gtk_menu_tool_button_set_arrow_tooltip_text(MenuToolButton* this_, char* text);
void gtk_menu_tool_button_set_menu(MenuToolButton* this_, Widget* menu);
MessageDialog* gtk_message_dialog_new(Window* parent, DialogFlags flags, MessageType type, ButtonsType buttons, char* message_format=null, ...);
MessageDialog* gtk_message_dialog_new_with_markup(Window* parent, DialogFlags flags, MessageType type, ButtonsType buttons, char* message_format=null, ...);
void gtk_message_dialog_format_secondary_markup(MessageDialog* this_, char* message_format, ...);
void gtk_message_dialog_format_secondary_text(MessageDialog* this_, char* message_format=null, ...);
Widget* gtk_message_dialog_get_image(MessageDialog* this_);
Widget* gtk_message_dialog_get_message_area(MessageDialog* this_);
void gtk_message_dialog_set_image(MessageDialog* this_, Widget* image);
void gtk_message_dialog_set_markup(MessageDialog* this_, char* str);
void gtk_misc_get_alignment(Misc* this_, /*out*/ float* xalign=null, /*out*/ float* yalign=null);
void gtk_misc_get_padding(Misc* this_, /*out*/ int* xpad=null, /*out*/ int* ypad=null);
void gtk_misc_set_alignment(Misc* this_, float xalign, float yalign);
void gtk_misc_set_padding(Misc* this_, int xpad, int ypad);
MountOperation* /*new*/ gtk_mount_operation_new(Window* parent=null);
Window* gtk_mount_operation_get_parent(MountOperation* this_);
Gdk2.Screen* gtk_mount_operation_get_screen(MountOperation* this_);
int gtk_mount_operation_is_showing(MountOperation* this_);
void gtk_mount_operation_set_parent(MountOperation* this_, Window* parent=null);
void gtk_mount_operation_set_screen(MountOperation* this_, Gdk2.Screen* screen);
Notebook* gtk_notebook_new();
void gtk_notebook_set_window_creation_hook(NotebookWindowCreationFunc func, void* data, GLib2.DestroyNotify destroy=null);
int gtk_notebook_append_page(Notebook* this_, Widget* child, Widget* tab_label=null);
int gtk_notebook_append_page_menu(Notebook* this_, Widget* child, Widget* tab_label=null, Widget* menu_label=null);
Widget* gtk_notebook_get_action_widget(Notebook* this_, PackType pack_type);
int gtk_notebook_get_current_page(Notebook* this_);
void* gtk_notebook_get_group(Notebook* this_);
int gtk_notebook_get_group_id(Notebook* this_);
char* gtk_notebook_get_group_name(Notebook* this_);
Widget* gtk_notebook_get_menu_label(Notebook* this_, Widget* child);
char* gtk_notebook_get_menu_label_text(Notebook* this_, Widget* child);
int gtk_notebook_get_n_pages(Notebook* this_);
Widget* gtk_notebook_get_nth_page(Notebook* this_, int page_num);
int gtk_notebook_get_scrollable(Notebook* this_);
int gtk_notebook_get_show_border(Notebook* this_);
int gtk_notebook_get_show_tabs(Notebook* this_);
int gtk_notebook_get_tab_detachable(Notebook* this_, Widget* child);
ushort gtk_notebook_get_tab_hborder(Notebook* this_);
Widget* gtk_notebook_get_tab_label(Notebook* this_, Widget* child);
char* gtk_notebook_get_tab_label_text(Notebook* this_, Widget* child);
PositionType gtk_notebook_get_tab_pos(Notebook* this_);
int gtk_notebook_get_tab_reorderable(Notebook* this_, Widget* child);
ushort gtk_notebook_get_tab_vborder(Notebook* this_);
int gtk_notebook_insert_page(Notebook* this_, Widget* child, Widget* tab_label, int position);
int gtk_notebook_insert_page_menu(Notebook* this_, Widget* child, Widget* tab_label, Widget* menu_label, int position);
void gtk_notebook_next_page(Notebook* this_);
int gtk_notebook_page_num(Notebook* this_, Widget* child);
void gtk_notebook_popup_disable(Notebook* this_);
void gtk_notebook_popup_enable(Notebook* this_);
int gtk_notebook_prepend_page(Notebook* this_, Widget* child, Widget* tab_label=null);
int gtk_notebook_prepend_page_menu(Notebook* this_, Widget* child, Widget* tab_label=null, Widget* menu_label=null);
void gtk_notebook_prev_page(Notebook* this_);
void gtk_notebook_query_tab_label_packing(Notebook* this_, Widget* child, int* expand, int* fill, PackType* pack_type);
void gtk_notebook_remove_page(Notebook* this_, int page_num);
void gtk_notebook_reorder_child(Notebook* this_, Widget* child, int position);
void gtk_notebook_set_action_widget(Notebook* this_, Widget* widget, PackType pack_type);
void gtk_notebook_set_current_page(Notebook* this_, int page_num);
void gtk_notebook_set_group(Notebook* this_, void* group=null);
void gtk_notebook_set_group_id(Notebook* this_, int group_id);
void gtk_notebook_set_group_name(Notebook* this_, char* group_name);
void gtk_notebook_set_homogeneous_tabs(Notebook* this_, int homogeneous);
void gtk_notebook_set_menu_label(Notebook* this_, Widget* child, Widget* menu_label=null);
void gtk_notebook_set_menu_label_text(Notebook* this_, Widget* child, char* menu_text);
void gtk_notebook_set_scrollable(Notebook* this_, int scrollable);
void gtk_notebook_set_show_border(Notebook* this_, int show_border);
void gtk_notebook_set_show_tabs(Notebook* this_, int show_tabs);
void gtk_notebook_set_tab_border(Notebook* this_, uint border_width);
void gtk_notebook_set_tab_detachable(Notebook* this_, Widget* child, int detachable);
void gtk_notebook_set_tab_hborder(Notebook* this_, uint tab_hborder);
void gtk_notebook_set_tab_label(Notebook* this_, Widget* child, Widget* tab_label=null);
void gtk_notebook_set_tab_label_packing(Notebook* this_, Widget* child, int expand, int fill, PackType pack_type);
void gtk_notebook_set_tab_label_text(Notebook* this_, Widget* child, char* tab_text);
void gtk_notebook_set_tab_pos(Notebook* this_, PositionType pos);
void gtk_notebook_set_tab_reorderable(Notebook* this_, Widget* child, int reorderable);
void gtk_notebook_set_tab_vborder(Notebook* this_, uint tab_vborder);
Object* gtk_object_new(Type type, char* first_property_name, ...);
void gtk_object_add_arg_type(char* arg_name, Type arg_type, uint arg_flags, uint arg_id);
void gtk_object_destroy(Object* this_);
void gtk_object_get(Object* this_, char* first_property_name, ...);
void* gtk_object_get_data(Object* this_, char* key);
void* gtk_object_get_data_by_id(Object* this_, GLib2.Quark data_id);
void* gtk_object_get_user_data(Object* this_);
Object* gtk_object_ref(Object* this_);
void gtk_object_remove_data(Object* this_, char* key);
void gtk_object_remove_data_by_id(Object* this_, GLib2.Quark data_id);
void gtk_object_remove_no_notify(Object* this_, char* key);
void gtk_object_remove_no_notify_by_id(Object* this_, GLib2.Quark key_id);
void gtk_object_set(Object* this_, char* first_property_name, ...);
void gtk_object_set_data(Object* this_, char* key, void* data);
void gtk_object_set_data_by_id(Object* this_, GLib2.Quark data_id, void* data);
void gtk_object_set_data_by_id_full(Object* this_, GLib2.Quark data_id, void* data, GLib2.DestroyNotify destroy);
void gtk_object_set_data_full(Object* this_, char* key, void* data, GLib2.DestroyNotify destroy);
void gtk_object_set_user_data(Object* this_, void* data);
void gtk_object_sink(Object* this_);
void gtk_object_unref(Object* this_);
void gtk_object_weakref(Object* this_, GLib2.DestroyNotify notify, void* data);
void gtk_object_weakunref(Object* this_, GLib2.DestroyNotify notify, void* data);
OffscreenWindow* gtk_offscreen_window_new();
GdkPixbuf2.Pixbuf* /*new*/ gtk_offscreen_window_get_pixbuf(OffscreenWindow* this_);
Gdk2.Pixmap* gtk_offscreen_window_get_pixmap(OffscreenWindow* this_);
void gtk_old_editable_changed(OldEditable* this_);
void gtk_old_editable_claim_selection(OldEditable* this_, int claim, uint time_);
OptionMenu* gtk_option_menu_new();
int gtk_option_menu_get_history(OptionMenu* this_);
Widget* gtk_option_menu_get_menu(OptionMenu* this_);
void gtk_option_menu_remove_menu(OptionMenu* this_);
void gtk_option_menu_set_history(OptionMenu* this_, uint index_);
void gtk_option_menu_set_menu(OptionMenu* this_, Widget* menu);
Orientation gtk_orientable_get_orientation(Orientable* this_);
void gtk_orientable_set_orientation(Orientable* this_, Orientation orientation);
PageSetup* /*new*/ gtk_page_setup_new();
PageSetup* /*new*/ gtk_page_setup_new_from_file(char* file_name, GLib2.Error** error);
PageSetup* /*new*/ gtk_page_setup_new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error);
PageSetup* /*new*/ gtk_page_setup_copy(PageSetup* this_);
double gtk_page_setup_get_bottom_margin(PageSetup* this_, Unit unit);
double gtk_page_setup_get_left_margin(PageSetup* this_, Unit unit);
PageOrientation gtk_page_setup_get_orientation(PageSetup* this_);
double gtk_page_setup_get_page_height(PageSetup* this_, Unit unit);
double gtk_page_setup_get_page_width(PageSetup* this_, Unit unit);
double gtk_page_setup_get_paper_height(PageSetup* this_, Unit unit);
PaperSize* /*new*/ gtk_page_setup_get_paper_size(PageSetup* this_);
double gtk_page_setup_get_paper_width(PageSetup* this_, Unit unit);
double gtk_page_setup_get_right_margin(PageSetup* this_, Unit unit);
double gtk_page_setup_get_top_margin(PageSetup* this_, Unit unit);
int gtk_page_setup_load_file(PageSetup* this_, char* file_name, GLib2.Error** error);
int gtk_page_setup_load_key_file(PageSetup* this_, GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error);
void gtk_page_setup_set_bottom_margin(PageSetup* this_, double margin, Unit unit);
void gtk_page_setup_set_left_margin(PageSetup* this_, double margin, Unit unit);
void gtk_page_setup_set_orientation(PageSetup* this_, PageOrientation orientation);
void gtk_page_setup_set_paper_size(PageSetup* this_, PaperSize* size);
void gtk_page_setup_set_paper_size_and_default_margins(PageSetup* this_, PaperSize* size);
void gtk_page_setup_set_right_margin(PageSetup* this_, double margin, Unit unit);
void gtk_page_setup_set_top_margin(PageSetup* this_, double margin, Unit unit);
int gtk_page_setup_to_file(PageSetup* this_, char* file_name, GLib2.Error** error);
void gtk_page_setup_to_key_file(PageSetup* this_, GLib2.KeyFile* key_file, char* group_name);
void gtk_paned_add1(Paned* this_, Widget* child);
void gtk_paned_add2(Paned* this_, Widget* child);
void gtk_paned_compute_position(Paned* this_, int allocation, int child1_req, int child2_req);
Widget* gtk_paned_get_child1(Paned* this_);
Widget* gtk_paned_get_child2(Paned* this_);
Gdk2.Window* gtk_paned_get_handle_window(Paned* this_);
int gtk_paned_get_position(Paned* this_);
void gtk_paned_pack1(Paned* this_, Widget* child, int resize, int shrink);
void gtk_paned_pack2(Paned* this_, Widget* child, int resize, int shrink);
void gtk_paned_set_position(Paned* this_, int position);
PaperSize* /*new*/ gtk_paper_size_new(char* name=null);
PaperSize* /*new*/ gtk_paper_size_new_custom(char* name, char* display_name, double width, double height, Unit unit);
PaperSize* /*new*/ gtk_paper_size_new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error);
PaperSize* /*new*/ gtk_paper_size_new_from_ppd(char* ppd_name, char* ppd_display_name, double width, double height);
PaperSize* /*new*/ gtk_paper_size_copy(PaperSize* this_);
void gtk_paper_size_free(PaperSize* this_);
double gtk_paper_size_get_default_bottom_margin(PaperSize* this_, Unit unit);
double gtk_paper_size_get_default_left_margin(PaperSize* this_, Unit unit);
double gtk_paper_size_get_default_right_margin(PaperSize* this_, Unit unit);
double gtk_paper_size_get_default_top_margin(PaperSize* this_, Unit unit);
char* gtk_paper_size_get_display_name(PaperSize* this_);
double gtk_paper_size_get_height(PaperSize* this_, Unit unit);
char* gtk_paper_size_get_name(PaperSize* this_);
char* gtk_paper_size_get_ppd_name(PaperSize* this_);
double gtk_paper_size_get_width(PaperSize* this_, Unit unit);
int gtk_paper_size_is_custom(PaperSize* this_);
int gtk_paper_size_is_equal(PaperSize* this_, PaperSize* size2);
void gtk_paper_size_set_size(PaperSize* this_, double width, double height, Unit unit);
void gtk_paper_size_to_key_file(PaperSize* this_, GLib2.KeyFile* key_file, char* group_name);
Pixmap* gtk_pixmap_new(Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null);
void gtk_pixmap_get(Pixmap* this_, Gdk2.Pixmap** val, Gdk2.Bitmap** mask);
void gtk_pixmap_set(Pixmap* this_, Gdk2.Pixmap* val, Gdk2.Bitmap* mask);
void gtk_pixmap_set_build_insensitive(Pixmap* this_, int build);
Plug* gtk_plug_new(Gdk2.NativeWindow socket_id);
Plug* gtk_plug_new_for_display(Gdk2.Display* display, Gdk2.NativeWindow socket_id);
void gtk_plug_construct(Plug* this_, Gdk2.NativeWindow socket_id);
void gtk_plug_construct_for_display(Plug* this_, Gdk2.Display* display, Gdk2.NativeWindow socket_id);
int gtk_plug_get_embedded(Plug* this_);
Gdk2.NativeWindow gtk_plug_get_id(Plug* this_);
Gdk2.Window* gtk_plug_get_socket_window(Plug* this_);
Preview* gtk_preview_new(PreviewType type);
Gdk2.Colormap* gtk_preview_get_cmap();
PreviewInfo* gtk_preview_get_info();
Gdk2.Visual* gtk_preview_get_visual();
void gtk_preview_reset();
void gtk_preview_set_color_cube(uint nred_shades, uint ngreen_shades, uint nblue_shades, uint ngray_shades);
void gtk_preview_set_gamma(double gamma_);
void gtk_preview_set_install_cmap(int install_cmap);
void gtk_preview_set_reserved(int nreserved);
void gtk_preview_uninit();
void gtk_preview_draw_row(Preview* this_, ubyte* data, int x, int y, int w);
void gtk_preview_put(Preview* this_, Gdk2.Window* window, Gdk2.GC* gc, int srcx, int srcy, int destx, int desty, int width, int height);
void gtk_preview_set_dither(Preview* this_, Gdk2.RgbDither dither);
void gtk_preview_set_expand(Preview* this_, int expand);
void gtk_preview_size(Preview* this_, int width, int height);
Pango.Context* /*new*/ gtk_print_context_create_pango_context(PrintContext* this_);
Pango.Layout* /*new*/ gtk_print_context_create_pango_layout(PrintContext* this_);
cairo.Context* gtk_print_context_get_cairo_context(PrintContext* this_);
double gtk_print_context_get_dpi_x(PrintContext* this_);
double gtk_print_context_get_dpi_y(PrintContext* this_);
int gtk_print_context_get_hard_margins(PrintContext* this_, /*out*/ double* top, /*out*/ double* bottom, /*out*/ double* left, /*out*/ double* right);
double gtk_print_context_get_height(PrintContext* this_);
PageSetup* gtk_print_context_get_page_setup(PrintContext* this_);
Pango.FontMap* gtk_print_context_get_pango_fontmap(PrintContext* this_);
double gtk_print_context_get_width(PrintContext* this_);
void gtk_print_context_set_cairo_context(PrintContext* this_, cairo.Context* cr, double dpi_x, double dpi_y);
PrintOperation* /*new*/ gtk_print_operation_new();
void gtk_print_operation_cancel(PrintOperation* this_);
void gtk_print_operation_draw_page_finish(PrintOperation* this_);
PageSetup* gtk_print_operation_get_default_page_setup(PrintOperation* this_);
int gtk_print_operation_get_embed_page_setup(PrintOperation* this_);
void gtk_print_operation_get_error(PrintOperation* this_, GLib2.Error** error);
int gtk_print_operation_get_has_selection(PrintOperation* this_);
int gtk_print_operation_get_n_pages_to_print(PrintOperation* this_);
PrintSettings* gtk_print_operation_get_print_settings(PrintOperation* this_);
PrintStatus gtk_print_operation_get_status(PrintOperation* this_);
char* gtk_print_operation_get_status_string(PrintOperation* this_);
int gtk_print_operation_get_support_selection(PrintOperation* this_);
int gtk_print_operation_is_finished(PrintOperation* this_);
PrintOperationResult gtk_print_operation_run(PrintOperation* this_, PrintOperationAction action, Window* parent, GLib2.Error** error);
void gtk_print_operation_set_allow_async(PrintOperation* this_, int allow_async);
void gtk_print_operation_set_current_page(PrintOperation* this_, int current_page);
void gtk_print_operation_set_custom_tab_label(PrintOperation* this_, char* label=null);
void gtk_print_operation_set_default_page_setup(PrintOperation* this_, PageSetup* default_page_setup=null);
void gtk_print_operation_set_defer_drawing(PrintOperation* this_);
void gtk_print_operation_set_embed_page_setup(PrintOperation* this_, int embed);
void gtk_print_operation_set_export_filename(PrintOperation* this_, char* filename);
void gtk_print_operation_set_has_selection(PrintOperation* this_, int has_selection);
void gtk_print_operation_set_job_name(PrintOperation* this_, char* job_name);
void gtk_print_operation_set_n_pages(PrintOperation* this_, int n_pages);
void gtk_print_operation_set_print_settings(PrintOperation* this_, PrintSettings* print_settings=null);
void gtk_print_operation_set_show_progress(PrintOperation* this_, int show_progress);
void gtk_print_operation_set_support_selection(PrintOperation* this_, int support_selection);
void gtk_print_operation_set_track_print_status(PrintOperation* this_, int track_status);
void gtk_print_operation_set_unit(PrintOperation* this_, Unit unit);
void gtk_print_operation_set_use_full_page(PrintOperation* this_, int full_page);
void gtk_print_operation_preview_end_preview(PrintOperationPreview* this_);
int gtk_print_operation_preview_is_selected(PrintOperationPreview* this_, int page_nr);
void gtk_print_operation_preview_render_page(PrintOperationPreview* this_, int page_nr);
PrintSettings* /*new*/ gtk_print_settings_new();
PrintSettings* /*new*/ gtk_print_settings_new_from_file(char* file_name, GLib2.Error** error);
PrintSettings* /*new*/ gtk_print_settings_new_from_key_file(GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error);
PrintSettings* /*new*/ gtk_print_settings_copy(PrintSettings* this_);
void gtk_print_settings_foreach(PrintSettings* this_, PrintSettingsFunc func, void* user_data);
char* gtk_print_settings_get(PrintSettings* this_, char* key);
int gtk_print_settings_get_bool(PrintSettings* this_, char* key);
int gtk_print_settings_get_collate(PrintSettings* this_);
char* gtk_print_settings_get_default_source(PrintSettings* this_);
char* gtk_print_settings_get_dither(PrintSettings* this_);
double gtk_print_settings_get_double(PrintSettings* this_, char* key);
double gtk_print_settings_get_double_with_default(PrintSettings* this_, char* key, double def);
PrintDuplex gtk_print_settings_get_duplex(PrintSettings* this_);
char* gtk_print_settings_get_finishings(PrintSettings* this_);
int gtk_print_settings_get_int(PrintSettings* this_, char* key);
int gtk_print_settings_get_int_with_default(PrintSettings* this_, char* key, int def);
double gtk_print_settings_get_length(PrintSettings* this_, char* key, Unit unit);
char* gtk_print_settings_get_media_type(PrintSettings* this_);
int gtk_print_settings_get_n_copies(PrintSettings* this_);
int gtk_print_settings_get_number_up(PrintSettings* this_);
NumberUpLayout gtk_print_settings_get_number_up_layout(PrintSettings* this_);
PageOrientation gtk_print_settings_get_orientation(PrintSettings* this_);
char* gtk_print_settings_get_output_bin(PrintSettings* this_);
PageRange* /*new*/ gtk_print_settings_get_page_ranges(PrintSettings* this_, /*out*/ int* num_ranges);
PageSet gtk_print_settings_get_page_set(PrintSettings* this_);
double gtk_print_settings_get_paper_height(PrintSettings* this_, Unit unit);
PaperSize* /*new*/ gtk_print_settings_get_paper_size(PrintSettings* this_);
double gtk_print_settings_get_paper_width(PrintSettings* this_, Unit unit);
PrintPages gtk_print_settings_get_print_pages(PrintSettings* this_);
char* gtk_print_settings_get_printer(PrintSettings* this_);
double gtk_print_settings_get_printer_lpi(PrintSettings* this_);
PrintQuality gtk_print_settings_get_quality(PrintSettings* this_);
int gtk_print_settings_get_resolution(PrintSettings* this_);
int gtk_print_settings_get_resolution_x(PrintSettings* this_);
int gtk_print_settings_get_resolution_y(PrintSettings* this_);
int gtk_print_settings_get_reverse(PrintSettings* this_);
double gtk_print_settings_get_scale(PrintSettings* this_);
int gtk_print_settings_get_use_color(PrintSettings* this_);
int gtk_print_settings_has_key(PrintSettings* this_, char* key);
int gtk_print_settings_load_file(PrintSettings* this_, char* file_name, GLib2.Error** error);
int gtk_print_settings_load_key_file(PrintSettings* this_, GLib2.KeyFile* key_file, char* group_name, GLib2.Error** error);
void gtk_print_settings_set(PrintSettings* this_, char* key, char* value=null);
void gtk_print_settings_set_bool(PrintSettings* this_, char* key, int value);
void gtk_print_settings_set_collate(PrintSettings* this_, int collate);
void gtk_print_settings_set_default_source(PrintSettings* this_, char* default_source);
void gtk_print_settings_set_dither(PrintSettings* this_, char* dither);
void gtk_print_settings_set_double(PrintSettings* this_, char* key, double value);
void gtk_print_settings_set_duplex(PrintSettings* this_, PrintDuplex duplex);
void gtk_print_settings_set_finishings(PrintSettings* this_, char* finishings);
void gtk_print_settings_set_int(PrintSettings* this_, char* key, int value);
void gtk_print_settings_set_length(PrintSettings* this_, char* key, double value, Unit unit);
void gtk_print_settings_set_media_type(PrintSettings* this_, char* media_type);
void gtk_print_settings_set_n_copies(PrintSettings* this_, int num_copies);
void gtk_print_settings_set_number_up(PrintSettings* this_, int number_up);
void gtk_print_settings_set_number_up_layout(PrintSettings* this_, NumberUpLayout number_up_layout);
void gtk_print_settings_set_orientation(PrintSettings* this_, PageOrientation orientation);
void gtk_print_settings_set_output_bin(PrintSettings* this_, char* output_bin);
void gtk_print_settings_set_page_ranges(PrintSettings* this_, PageRange* page_ranges, int num_ranges);
void gtk_print_settings_set_page_set(PrintSettings* this_, PageSet page_set);
void gtk_print_settings_set_paper_height(PrintSettings* this_, double height, Unit unit);
void gtk_print_settings_set_paper_size(PrintSettings* this_, PaperSize* paper_size);
void gtk_print_settings_set_paper_width(PrintSettings* this_, double width, Unit unit);
void gtk_print_settings_set_print_pages(PrintSettings* this_, PrintPages pages);
void gtk_print_settings_set_printer(PrintSettings* this_, char* printer);
void gtk_print_settings_set_printer_lpi(PrintSettings* this_, double lpi);
void gtk_print_settings_set_quality(PrintSettings* this_, PrintQuality quality);
void gtk_print_settings_set_resolution(PrintSettings* this_, int resolution);
void gtk_print_settings_set_resolution_xy(PrintSettings* this_, int resolution_x, int resolution_y);
void gtk_print_settings_set_reverse(PrintSettings* this_, int reverse);
void gtk_print_settings_set_scale(PrintSettings* this_, double scale);
void gtk_print_settings_set_use_color(PrintSettings* this_, int use_color);
int gtk_print_settings_to_file(PrintSettings* this_, char* file_name, GLib2.Error** error);
void gtk_print_settings_to_key_file(PrintSettings* this_, GLib2.KeyFile* key_file, char* group_name);
void gtk_print_settings_unset(PrintSettings* this_, char* key);
void gtk_progress_configure(Progress* this_, double value, double min, double max);
double gtk_progress_get_current_percentage(Progress* this_);
char* /*new*/ gtk_progress_get_current_text(Progress* this_);
double gtk_progress_get_percentage_from_value(Progress* this_, double value);
char* /*new*/ gtk_progress_get_text_from_value(Progress* this_, double value);
double gtk_progress_get_value(Progress* this_);
void gtk_progress_set_activity_mode(Progress* this_, int activity_mode);
void gtk_progress_set_adjustment(Progress* this_, Adjustment* adjustment);
void gtk_progress_set_format_string(Progress* this_, char* format);
void gtk_progress_set_percentage(Progress* this_, double percentage);
void gtk_progress_set_show_text(Progress* this_, int show_text);
void gtk_progress_set_text_alignment(Progress* this_, float x_align, float y_align);
void gtk_progress_set_value(Progress* this_, double value);
ProgressBar* gtk_progress_bar_new();
ProgressBar* gtk_progress_bar_new_with_adjustment(Adjustment* adjustment=null);
Pango.EllipsizeMode gtk_progress_bar_get_ellipsize(ProgressBar* this_);
double gtk_progress_bar_get_fraction(ProgressBar* this_);
ProgressBarOrientation gtk_progress_bar_get_orientation(ProgressBar* this_);
double gtk_progress_bar_get_pulse_step(ProgressBar* this_);
char* gtk_progress_bar_get_text(ProgressBar* this_);
void gtk_progress_bar_pulse(ProgressBar* this_);
void gtk_progress_bar_set_activity_blocks(ProgressBar* this_, uint blocks);
void gtk_progress_bar_set_activity_step(ProgressBar* this_, uint step);
void gtk_progress_bar_set_bar_style(ProgressBar* this_, ProgressBarStyle style);
void gtk_progress_bar_set_discrete_blocks(ProgressBar* this_, uint blocks);
void gtk_progress_bar_set_ellipsize(ProgressBar* this_, Pango.EllipsizeMode mode);
void gtk_progress_bar_set_fraction(ProgressBar* this_, double fraction);
void gtk_progress_bar_set_orientation(ProgressBar* this_, ProgressBarOrientation orientation);
void gtk_progress_bar_set_pulse_step(ProgressBar* this_, double fraction);
void gtk_progress_bar_set_text(ProgressBar* this_, char* text=null);
void gtk_progress_bar_update(ProgressBar* this_, double percentage);
RadioAction* /*new*/ gtk_radio_action_new(char* name, char* label, char* tooltip, char* stock_id, int value);
int gtk_radio_action_get_current_value(RadioAction* this_);
GLib2.SList* gtk_radio_action_get_group(RadioAction* this_);
void gtk_radio_action_set_current_value(RadioAction* this_, int current_value);
void gtk_radio_action_set_group(RadioAction* this_, GLib2.SList* group);
RadioButton* gtk_radio_button_new(GLib2.SList* group=null);
RadioButton* gtk_radio_button_new_with_label(GLib2.SList* group, char* label);
RadioButton* gtk_radio_button_new_with_label_from_widget(RadioButton* radio_group_member, char* label);
RadioButton* gtk_radio_button_new_with_mnemonic(GLib2.SList* group, char* label);
RadioButton* gtk_radio_button_new_with_mnemonic_from_widget(RadioButton* radio_group_member, char* label);
GLib2.SList* gtk_radio_button_get_group(RadioButton* this_);
Widget* gtk_radio_button_new_from_widget(RadioButton* this_);
void gtk_radio_button_set_group(RadioButton* this_, GLib2.SList* group);
RadioMenuItem* gtk_radio_menu_item_new(GLib2.SList* group);
RadioMenuItem* gtk_radio_menu_item_new_with_label(GLib2.SList* group, char* label);
RadioMenuItem* gtk_radio_menu_item_new_with_mnemonic(GLib2.SList* group, char* label);
GLib2.SList* gtk_radio_menu_item_get_group(RadioMenuItem* this_);
Widget* gtk_radio_menu_item_new_from_widget(RadioMenuItem* this_);
Widget* gtk_radio_menu_item_new_with_label_from_widget(RadioMenuItem* this_, char* label);
Widget* gtk_radio_menu_item_new_with_mnemonic_from_widget(RadioMenuItem* this_, char* label);
void gtk_radio_menu_item_set_group(RadioMenuItem* this_, GLib2.SList* group);
RadioToolButton* gtk_radio_tool_button_new(GLib2.SList* group=null);
RadioToolButton* gtk_radio_tool_button_new_from_stock(GLib2.SList* group, char* stock_id);
GLib2.SList* gtk_radio_tool_button_get_group(RadioToolButton* this_);
ToolItem* gtk_radio_tool_button_new_from_widget(RadioToolButton* this_);
ToolItem* gtk_radio_tool_button_new_with_stock_from_widget(RadioToolButton* this_, char* stock_id);
void gtk_radio_tool_button_set_group(RadioToolButton* this_, GLib2.SList* group);
Adjustment* gtk_range_get_adjustment(Range* this_);
double gtk_range_get_fill_level(Range* this_);
int gtk_range_get_flippable(Range* this_);
int gtk_range_get_inverted(Range* this_);
SensitivityType gtk_range_get_lower_stepper_sensitivity(Range* this_);
int gtk_range_get_min_slider_size(Range* this_);
void gtk_range_get_range_rect(Range* this_, /*out*/ Gdk2.Rectangle* range_rect);
int gtk_range_get_restrict_to_fill_level(Range* this_);
int gtk_range_get_round_digits(Range* this_);
int gtk_range_get_show_fill_level(Range* this_);
void gtk_range_get_slider_range(Range* this_, /*out*/ int* slider_start=null, /*out*/ int* slider_end=null);
int gtk_range_get_slider_size_fixed(Range* this_);
UpdateType gtk_range_get_update_policy(Range* this_);
SensitivityType gtk_range_get_upper_stepper_sensitivity(Range* this_);
double gtk_range_get_value(Range* this_);
void gtk_range_set_adjustment(Range* this_, Adjustment* adjustment);
void gtk_range_set_fill_level(Range* this_, double fill_level);
void gtk_range_set_flippable(Range* this_, int flippable);
void gtk_range_set_increments(Range* this_, double step, double page);
void gtk_range_set_inverted(Range* this_, int setting);
void gtk_range_set_lower_stepper_sensitivity(Range* this_, SensitivityType sensitivity);
void gtk_range_set_min_slider_size(Range* this_, int min_size);
void gtk_range_set_range(Range* this_, double min, double max);
void gtk_range_set_restrict_to_fill_level(Range* this_, int restrict_to_fill_level);
void gtk_range_set_round_digits(Range* this_, int round_digits);
void gtk_range_set_show_fill_level(Range* this_, int show_fill_level);
void gtk_range_set_slider_size_fixed(Range* this_, int size_fixed);
void gtk_range_set_update_policy(Range* this_, UpdateType policy);
void gtk_range_set_upper_stepper_sensitivity(Range* this_, SensitivityType sensitivity);
void gtk_range_set_value(Range* this_, double value);
RcStyle* /*new*/ gtk_rc_style_new();
RcStyle* /*new*/ gtk_rc_style_copy(RcStyle* this_);
void gtk_rc_style_ref(RcStyle* this_);
void gtk_rc_style_unref(RcStyle* this_);
RecentAction* /*new*/ gtk_recent_action_new(char* name, char* label, char* tooltip, char* stock_id);
RecentAction* /*new*/ gtk_recent_action_new_for_manager(char* name, char* label, char* tooltip, char* stock_id, RecentManager* manager=null);
int gtk_recent_action_get_show_numbers(RecentAction* this_);
void gtk_recent_action_set_show_numbers(RecentAction* this_, int show_numbers);
void gtk_recent_chooser_add_filter(RecentChooser* this_, RecentFilter* filter);
RecentInfo* /*new*/ gtk_recent_chooser_get_current_item(RecentChooser* this_);
char* /*new*/ gtk_recent_chooser_get_current_uri(RecentChooser* this_);
RecentFilter* gtk_recent_chooser_get_filter(RecentChooser* this_);
GLib2.List* /*new*/ gtk_recent_chooser_get_items(RecentChooser* this_);
int gtk_recent_chooser_get_limit(RecentChooser* this_);
int gtk_recent_chooser_get_local_only(RecentChooser* this_);
int gtk_recent_chooser_get_select_multiple(RecentChooser* this_);
int gtk_recent_chooser_get_show_icons(RecentChooser* this_);
int gtk_recent_chooser_get_show_not_found(RecentChooser* this_);
int gtk_recent_chooser_get_show_numbers(RecentChooser* this_);
int gtk_recent_chooser_get_show_private(RecentChooser* this_);
int gtk_recent_chooser_get_show_tips(RecentChooser* this_);
RecentSortType gtk_recent_chooser_get_sort_type(RecentChooser* this_);
char** /*new*/ gtk_recent_chooser_get_uris(RecentChooser* this_, /*out*/ size_t* length=null);
GLib2.SList* /*new container*/ gtk_recent_chooser_list_filters(RecentChooser* this_);
void gtk_recent_chooser_remove_filter(RecentChooser* this_, RecentFilter* filter);
void gtk_recent_chooser_select_all(RecentChooser* this_);
int gtk_recent_chooser_select_uri(RecentChooser* this_, char* uri, GLib2.Error** error);
int gtk_recent_chooser_set_current_uri(RecentChooser* this_, char* uri, GLib2.Error** error);
void gtk_recent_chooser_set_filter(RecentChooser* this_, RecentFilter* filter);
void gtk_recent_chooser_set_limit(RecentChooser* this_, int limit);
void gtk_recent_chooser_set_local_only(RecentChooser* this_, int local_only);
void gtk_recent_chooser_set_select_multiple(RecentChooser* this_, int select_multiple);
void gtk_recent_chooser_set_show_icons(RecentChooser* this_, int show_icons);
void gtk_recent_chooser_set_show_not_found(RecentChooser* this_, int show_not_found);
void gtk_recent_chooser_set_show_numbers(RecentChooser* this_, int show_numbers);
void gtk_recent_chooser_set_show_private(RecentChooser* this_, int show_private);
void gtk_recent_chooser_set_show_tips(RecentChooser* this_, int show_tips);
void gtk_recent_chooser_set_sort_func(RecentChooser* this_, RecentSortFunc sort_func, void* sort_data=null, GLib2.DestroyNotify data_destroy=null);
void gtk_recent_chooser_set_sort_type(RecentChooser* this_, RecentSortType sort_type);
void gtk_recent_chooser_unselect_all(RecentChooser* this_);
void gtk_recent_chooser_unselect_uri(RecentChooser* this_, char* uri);
RecentChooserDialog* gtk_recent_chooser_dialog_new(char* title=null, Window* parent=null, char* first_button_text=null, ...);
RecentChooserDialog* gtk_recent_chooser_dialog_new_for_manager(char* title, Window* parent, RecentManager* manager, char* first_button_text=null, ...);
RecentChooserMenu* gtk_recent_chooser_menu_new();
RecentChooserMenu* gtk_recent_chooser_menu_new_for_manager(RecentManager* manager);
int gtk_recent_chooser_menu_get_show_numbers(RecentChooserMenu* this_);
void gtk_recent_chooser_menu_set_show_numbers(RecentChooserMenu* this_, int show_numbers);
RecentChooserWidget* gtk_recent_chooser_widget_new();
RecentChooserWidget* gtk_recent_chooser_widget_new_for_manager(RecentManager* manager);
RecentFilter* gtk_recent_filter_new();
void gtk_recent_filter_add_age(RecentFilter* this_, int days);
void gtk_recent_filter_add_application(RecentFilter* this_, char* application);
void gtk_recent_filter_add_custom(RecentFilter* this_, RecentFilterFlags needed, RecentFilterFunc func, void* data, GLib2.DestroyNotify data_destroy);
void gtk_recent_filter_add_group(RecentFilter* this_, char* group);
void gtk_recent_filter_add_mime_type(RecentFilter* this_, char* mime_type);
void gtk_recent_filter_add_pattern(RecentFilter* this_, char* pattern);
void gtk_recent_filter_add_pixbuf_formats(RecentFilter* this_);
int gtk_recent_filter_filter(RecentFilter* this_, RecentFilterInfo* filter_info);
char* gtk_recent_filter_get_name(RecentFilter* this_);
RecentFilterFlags gtk_recent_filter_get_needed(RecentFilter* this_);
void gtk_recent_filter_set_name(RecentFilter* this_, char* name);
int gtk_recent_info_exists(RecentInfo* this_);
time_t gtk_recent_info_get_added(RecentInfo* this_);
int gtk_recent_info_get_age(RecentInfo* this_);
int gtk_recent_info_get_application_info(RecentInfo* this_, char* app_name, /*out*/ char** app_exec, /*out*/ uint* count, /*out*/ time_t* time_);
char** /*new*/ gtk_recent_info_get_applications(RecentInfo* this_, /*out*/ size_t* length=null);
char* gtk_recent_info_get_description(RecentInfo* this_);
char* gtk_recent_info_get_display_name(RecentInfo* this_);
char** /*new*/ gtk_recent_info_get_groups(RecentInfo* this_, /*out*/ size_t* length=null);
GdkPixbuf2.Pixbuf* /*new*/ gtk_recent_info_get_icon(RecentInfo* this_, int size);
char* gtk_recent_info_get_mime_type(RecentInfo* this_);
time_t gtk_recent_info_get_modified(RecentInfo* this_);
int gtk_recent_info_get_private_hint(RecentInfo* this_);
char* /*new*/ gtk_recent_info_get_short_name(RecentInfo* this_);
char* gtk_recent_info_get_uri(RecentInfo* this_);
char* /*new*/ gtk_recent_info_get_uri_display(RecentInfo* this_);
time_t gtk_recent_info_get_visited(RecentInfo* this_);
int gtk_recent_info_has_application(RecentInfo* this_, char* app_name);
int gtk_recent_info_has_group(RecentInfo* this_, char* group_name);
int gtk_recent_info_is_local(RecentInfo* this_);
char* /*new*/ gtk_recent_info_last_application(RecentInfo* this_);
int gtk_recent_info_match(RecentInfo* this_, RecentInfo* info_b);
RecentInfo* /*new*/ gtk_recent_info_ref(RecentInfo* this_);
void gtk_recent_info_unref(RecentInfo* this_);
RecentManager* /*new*/ gtk_recent_manager_new();
RecentManager* gtk_recent_manager_get_default();
RecentManager* gtk_recent_manager_get_for_screen(Gdk2.Screen* screen);
int gtk_recent_manager_add_full(RecentManager* this_, char* uri, RecentData* recent_data);
int gtk_recent_manager_add_item(RecentManager* this_, char* uri);
GLib2.List* /*new*/ gtk_recent_manager_get_items(RecentManager* this_);
int gtk_recent_manager_get_limit(RecentManager* this_);
int gtk_recent_manager_has_item(RecentManager* this_, char* uri);
RecentInfo* /*new*/ gtk_recent_manager_lookup_item(RecentManager* this_, char* uri, GLib2.Error** error);
int gtk_recent_manager_move_item(RecentManager* this_, char* uri, char* new_uri, GLib2.Error** error);
int gtk_recent_manager_purge_items(RecentManager* this_, GLib2.Error** error);
int gtk_recent_manager_remove_item(RecentManager* this_, char* uri, GLib2.Error** error);
void gtk_recent_manager_set_limit(RecentManager* this_, int limit);
void gtk_recent_manager_set_screen(RecentManager* this_, Gdk2.Screen* screen);
Requisition* /*new*/ gtk_requisition_copy(Requisition* this_);
void gtk_requisition_free(Requisition* this_);
void gtk_ruler_draw_pos(Ruler* this_);
void gtk_ruler_draw_ticks(Ruler* this_);
MetricType gtk_ruler_get_metric(Ruler* this_);
void gtk_ruler_get_range(Ruler* this_, double* lower, double* upper, double* position, double* max_size);
void gtk_ruler_set_metric(Ruler* this_, MetricType metric);
void gtk_ruler_set_range(Ruler* this_, double lower, double upper, double position, double max_size);
void gtk_scale_add_mark(Scale* this_, double value, PositionType position, char* markup=null);
void gtk_scale_clear_marks(Scale* this_);
int gtk_scale_get_digits(Scale* this_);
int gtk_scale_get_draw_value(Scale* this_);
Pango.Layout* gtk_scale_get_layout(Scale* this_);
void gtk_scale_get_layout_offsets(Scale* this_, /*out*/ int* x=null, /*out*/ int* y=null);
PositionType gtk_scale_get_value_pos(Scale* this_);
void gtk_scale_set_digits(Scale* this_, int digits);
void gtk_scale_set_draw_value(Scale* this_, int draw_value);
void gtk_scale_set_value_pos(Scale* this_, PositionType pos);
ScaleButton* gtk_scale_button_new(IconSize size, double min, double max, double step, char** icons=null);
Adjustment* gtk_scale_button_get_adjustment(ScaleButton* this_);
Widget* gtk_scale_button_get_minus_button(ScaleButton* this_);
Orientation gtk_scale_button_get_orientation(ScaleButton* this_);
Widget* gtk_scale_button_get_plus_button(ScaleButton* this_);
Widget* gtk_scale_button_get_popup(ScaleButton* this_);
double gtk_scale_button_get_value(ScaleButton* this_);
void gtk_scale_button_set_adjustment(ScaleButton* this_, Adjustment* adjustment);
void gtk_scale_button_set_icons(ScaleButton* this_, char** icons);
void gtk_scale_button_set_orientation(ScaleButton* this_, Orientation orientation);
void gtk_scale_button_set_value(ScaleButton* this_, double value);
ScrolledWindow* gtk_scrolled_window_new(Adjustment* hadjustment=null, Adjustment* vadjustment=null);
void gtk_scrolled_window_add_with_viewport(ScrolledWindow* this_, Widget* child);
Adjustment* gtk_scrolled_window_get_hadjustment(ScrolledWindow* this_);
Widget* gtk_scrolled_window_get_hscrollbar(ScrolledWindow* this_);
CornerType gtk_scrolled_window_get_placement(ScrolledWindow* this_);
void gtk_scrolled_window_get_policy(ScrolledWindow* this_, /*out*/ PolicyType* hscrollbar_policy=null, /*out*/ PolicyType* vscrollbar_policy=null);
ShadowType gtk_scrolled_window_get_shadow_type(ScrolledWindow* this_);
Adjustment* gtk_scrolled_window_get_vadjustment(ScrolledWindow* this_);
Widget* gtk_scrolled_window_get_vscrollbar(ScrolledWindow* this_);
void gtk_scrolled_window_set_hadjustment(ScrolledWindow* this_, Adjustment* hadjustment);
void gtk_scrolled_window_set_placement(ScrolledWindow* this_, CornerType window_placement);
void gtk_scrolled_window_set_policy(ScrolledWindow* this_, PolicyType hscrollbar_policy, PolicyType vscrollbar_policy);
void gtk_scrolled_window_set_shadow_type(ScrolledWindow* this_, ShadowType type);
void gtk_scrolled_window_set_vadjustment(ScrolledWindow* this_, Adjustment* vadjustment);
void gtk_scrolled_window_unset_placement(ScrolledWindow* this_);
SelectionData* /*new*/ gtk_selection_data_copy(SelectionData* this_);
void gtk_selection_data_free(SelectionData* this_);
ubyte* gtk_selection_data_get_data(SelectionData* this_);
Gdk2.Atom gtk_selection_data_get_data_type(SelectionData* this_);
Gdk2.Display* gtk_selection_data_get_display(SelectionData* this_);
int gtk_selection_data_get_format(SelectionData* this_);
int gtk_selection_data_get_length(SelectionData* this_);
GdkPixbuf2.Pixbuf* /*new*/ gtk_selection_data_get_pixbuf(SelectionData* this_);
Gdk2.Atom gtk_selection_data_get_selection(SelectionData* this_);
Gdk2.Atom gtk_selection_data_get_target(SelectionData* this_);
int gtk_selection_data_get_targets(SelectionData* this_, /*out*/ Gdk2.Atom** targets, /*out*/ int* n_atoms);
ubyte* gtk_selection_data_get_text(SelectionData* this_);
char** /*new*/ gtk_selection_data_get_uris(SelectionData* this_);
void gtk_selection_data_set(SelectionData* this_, Gdk2.Atom type, int format, ubyte* data, int length);
int gtk_selection_data_set_pixbuf(SelectionData* this_, GdkPixbuf2.Pixbuf* pixbuf);
int gtk_selection_data_set_text(SelectionData* this_, char* str, int len);
int gtk_selection_data_set_uris(SelectionData* this_, char** uris);
int gtk_selection_data_targets_include_image(SelectionData* this_, int writable);
int gtk_selection_data_targets_include_rich_text(SelectionData* this_, TextBuffer* buffer);
int gtk_selection_data_targets_include_text(SelectionData* this_);
int gtk_selection_data_targets_include_uri(SelectionData* this_);
SeparatorMenuItem* gtk_separator_menu_item_new();
SeparatorToolItem* gtk_separator_tool_item_new();
int gtk_separator_tool_item_get_draw(SeparatorToolItem* this_);
void gtk_separator_tool_item_set_draw(SeparatorToolItem* this_, int draw);
Settings* gtk_settings_get_default();
Settings* gtk_settings_get_for_screen(Gdk2.Screen* screen);
void gtk_settings_install_property(GObject2.ParamSpec* pspec);
void gtk_settings_install_property_parser(GObject2.ParamSpec* pspec, RcPropertyParser parser);
void gtk_settings_set_double_property(Settings* this_, char* name, double v_double, char* origin);
void gtk_settings_set_long_property(Settings* this_, char* name, c_long v_long, char* origin);
void gtk_settings_set_property_value(Settings* this_, char* name, SettingsValue* svalue);
void gtk_settings_set_string_property(Settings* this_, char* name, char* v_string, char* origin);
SizeGroup* /*new*/ gtk_size_group_new(SizeGroupMode mode);
void gtk_size_group_add_widget(SizeGroup* this_, Widget* widget);
int gtk_size_group_get_ignore_hidden(SizeGroup* this_);
SizeGroupMode gtk_size_group_get_mode(SizeGroup* this_);
GLib2.SList* gtk_size_group_get_widgets(SizeGroup* this_);
void gtk_size_group_remove_widget(SizeGroup* this_, Widget* widget);
void gtk_size_group_set_ignore_hidden(SizeGroup* this_, int ignore_hidden);
void gtk_size_group_set_mode(SizeGroup* this_, SizeGroupMode mode);
Socket* gtk_socket_new();
void gtk_socket_add_id(Socket* this_, Gdk2.NativeWindow window_id);
Gdk2.NativeWindow gtk_socket_get_id(Socket* this_);
Gdk2.Window* gtk_socket_get_plug_window(Socket* this_);
void gtk_socket_steal(Socket* this_, Gdk2.NativeWindow wid);
SpinButton* gtk_spin_button_new(Adjustment* adjustment, double climb_rate, uint digits);
SpinButton* gtk_spin_button_new_with_range(double min, double max, double step);
void gtk_spin_button_configure(SpinButton* this_, Adjustment* adjustment, double climb_rate, uint digits);
Adjustment* gtk_spin_button_get_adjustment(SpinButton* this_);
uint gtk_spin_button_get_digits(SpinButton* this_);
void gtk_spin_button_get_increments(SpinButton* this_, /*out*/ double* step=null, /*out*/ double* page=null);
int gtk_spin_button_get_numeric(SpinButton* this_);
void gtk_spin_button_get_range(SpinButton* this_, /*out*/ double* min=null, /*out*/ double* max=null);
int gtk_spin_button_get_snap_to_ticks(SpinButton* this_);
SpinButtonUpdatePolicy gtk_spin_button_get_update_policy(SpinButton* this_);
double gtk_spin_button_get_value(SpinButton* this_);
int gtk_spin_button_get_value_as_int(SpinButton* this_);
int gtk_spin_button_get_wrap(SpinButton* this_);
void gtk_spin_button_set_adjustment(SpinButton* this_, Adjustment* adjustment);
void gtk_spin_button_set_digits(SpinButton* this_, uint digits);
void gtk_spin_button_set_increments(SpinButton* this_, double step, double page);
void gtk_spin_button_set_numeric(SpinButton* this_, int numeric);
void gtk_spin_button_set_range(SpinButton* this_, double min, double max);
void gtk_spin_button_set_snap_to_ticks(SpinButton* this_, int snap_to_ticks);
void gtk_spin_button_set_update_policy(SpinButton* this_, SpinButtonUpdatePolicy policy);
void gtk_spin_button_set_value(SpinButton* this_, double value);
void gtk_spin_button_set_wrap(SpinButton* this_, int wrap);
void gtk_spin_button_spin(SpinButton* this_, SpinType direction, double increment);
void gtk_spin_button_update(SpinButton* this_);
Spinner* gtk_spinner_new();
void gtk_spinner_start(Spinner* this_);
void gtk_spinner_stop(Spinner* this_);
StatusIcon* /*new*/ gtk_status_icon_new();
StatusIcon* /*new*/ gtk_status_icon_new_from_file(char* filename);
StatusIcon* /*new*/ gtk_status_icon_new_from_gicon(Gio2.Icon* icon);
StatusIcon* /*new*/ gtk_status_icon_new_from_icon_name(char* icon_name);
StatusIcon* /*new*/ gtk_status_icon_new_from_pixbuf(GdkPixbuf2.Pixbuf* pixbuf);
StatusIcon* /*new*/ gtk_status_icon_new_from_stock(char* stock_id);
void gtk_status_icon_position_menu(Menu* menu, int* x, int* y, int* push_in, void* user_data);
int gtk_status_icon_get_blinking(StatusIcon* this_);
int gtk_status_icon_get_geometry(StatusIcon* this_, /*out*/ Gdk2.Screen** screen=null, /*out*/ Gdk2.Rectangle* area=null, /*out*/ Orientation* orientation=null);
Gio2.Icon* gtk_status_icon_get_gicon(StatusIcon* this_);
int gtk_status_icon_get_has_tooltip(StatusIcon* this_);
char* gtk_status_icon_get_icon_name(StatusIcon* this_);
GdkPixbuf2.Pixbuf* gtk_status_icon_get_pixbuf(StatusIcon* this_);
Gdk2.Screen* gtk_status_icon_get_screen(StatusIcon* this_);
int gtk_status_icon_get_size(StatusIcon* this_);
char* gtk_status_icon_get_stock(StatusIcon* this_);
ImageType gtk_status_icon_get_storage_type(StatusIcon* this_);
char* gtk_status_icon_get_title(StatusIcon* this_);
char* /*new*/ gtk_status_icon_get_tooltip_markup(StatusIcon* this_);
char* /*new*/ gtk_status_icon_get_tooltip_text(StatusIcon* this_);
int gtk_status_icon_get_visible(StatusIcon* this_);
uint gtk_status_icon_get_x11_window_id(StatusIcon* this_);
int gtk_status_icon_is_embedded(StatusIcon* this_);
void gtk_status_icon_set_blinking(StatusIcon* this_, int blinking);
void gtk_status_icon_set_from_file(StatusIcon* this_, char* filename);
void gtk_status_icon_set_from_gicon(StatusIcon* this_, Gio2.Icon* icon);
void gtk_status_icon_set_from_icon_name(StatusIcon* this_, char* icon_name);
void gtk_status_icon_set_from_pixbuf(StatusIcon* this_, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_status_icon_set_from_stock(StatusIcon* this_, char* stock_id);
void gtk_status_icon_set_has_tooltip(StatusIcon* this_, int has_tooltip);
void gtk_status_icon_set_name(StatusIcon* this_, char* name);
void gtk_status_icon_set_screen(StatusIcon* this_, Gdk2.Screen* screen);
void gtk_status_icon_set_title(StatusIcon* this_, char* title);
void gtk_status_icon_set_tooltip(StatusIcon* this_, char* tooltip_text=null);
void gtk_status_icon_set_tooltip_markup(StatusIcon* this_, char* markup=null);
void gtk_status_icon_set_tooltip_text(StatusIcon* this_, char* text);
void gtk_status_icon_set_visible(StatusIcon* this_, int visible);
Statusbar* gtk_statusbar_new();
uint gtk_statusbar_get_context_id(Statusbar* this_, char* context_description);
int gtk_statusbar_get_has_resize_grip(Statusbar* this_);
Widget* gtk_statusbar_get_message_area(Statusbar* this_);
void gtk_statusbar_pop(Statusbar* this_, uint context_id);
uint gtk_statusbar_push(Statusbar* this_, uint context_id, char* text);
void gtk_statusbar_remove(Statusbar* this_, uint context_id, uint message_id);
void gtk_statusbar_remove_all(Statusbar* this_, uint context_id);
void gtk_statusbar_set_has_resize_grip(Statusbar* this_, int setting);
StockItem* gtk_stock_item_copy(StockItem* this_);
void gtk_stock_item_free(StockItem* this_);
Style* /*new*/ gtk_style_new();
void gtk_style_apply_default_background(Style* this_, Gdk2.Window* window, int set_bg, StateType state_type, Gdk2.Rectangle* area, int x, int y, int width, int height);
Style* gtk_style_attach(Style* this_, Gdk2.Window* window);
Style* /*new*/ gtk_style_copy(Style* this_);
void gtk_style_detach(Style* this_);
void gtk_style_get(Style* this_, Type widget_type, char* first_property_name, ...);
Gdk2.Font* /*new*/ gtk_style_get_font(Style* this_);
void gtk_style_get_style_property(Style* this_, Type widget_type, char* property_name, GObject2.Value* value);
void gtk_style_get_valist(Style* this_, Type widget_type, char* first_property_name, va_list var_args);
int gtk_style_lookup_color(Style* this_, char* color_name, /*out*/ Gdk2.Color* color);
IconSet* gtk_style_lookup_icon_set(Style* this_, char* stock_id);
Style* gtk_style_ref(Style* this_);
GdkPixbuf2.Pixbuf* /*new*/ gtk_style_render_icon(Style* this_, IconSource* source, TextDirection direction, StateType state, IconSize size, Widget* widget=null, char* detail=null);
void gtk_style_set_background(Style* this_, Gdk2.Window* window, StateType state_type);
void gtk_style_set_font(Style* this_, Gdk2.Font* font=null);
void gtk_style_unref(Style* this_);
Table* gtk_table_new(uint rows, uint columns, int homogeneous);
void gtk_table_attach(Table* this_, Widget* child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach, AttachOptions xoptions, AttachOptions yoptions, uint xpadding, uint ypadding);
void gtk_table_attach_defaults(Table* this_, Widget* widget, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach);
uint gtk_table_get_col_spacing(Table* this_, uint column);
uint gtk_table_get_default_col_spacing(Table* this_);
uint gtk_table_get_default_row_spacing(Table* this_);
int gtk_table_get_homogeneous(Table* this_);
uint gtk_table_get_row_spacing(Table* this_, uint row);
void gtk_table_get_size(Table* this_, /*out*/ uint* rows=null, /*out*/ uint* columns=null);
void gtk_table_resize(Table* this_, uint rows, uint columns);
void gtk_table_set_col_spacing(Table* this_, uint column, uint spacing);
void gtk_table_set_col_spacings(Table* this_, uint spacing);
void gtk_table_set_homogeneous(Table* this_, int homogeneous);
void gtk_table_set_row_spacing(Table* this_, uint row, uint spacing);
void gtk_table_set_row_spacings(Table* this_, uint spacing);
TargetList* /*new*/ gtk_target_list_new(TargetEntry* targets, uint ntargets);
void gtk_target_list_add(TargetList* this_, Gdk2.Atom target, uint flags, uint info);
void gtk_target_list_add_image_targets(TargetList* this_, uint info, int writable);
void gtk_target_list_add_rich_text_targets(TargetList* this_, uint info, int deserializable, TextBuffer* buffer);
void gtk_target_list_add_table(TargetList* this_, TargetEntry* targets, uint ntargets);
void gtk_target_list_add_text_targets(TargetList* this_, uint info);
void gtk_target_list_add_uri_targets(TargetList* this_, uint info);
int gtk_target_list_find(TargetList* this_, Gdk2.Atom target, uint* info);
TargetList* /*new*/ gtk_target_list_ref(TargetList* this_);
void gtk_target_list_remove(TargetList* this_, Gdk2.Atom target);
void gtk_target_list_unref(TargetList* this_);
TearoffMenuItem* gtk_tearoff_menu_item_new();
TextAttributes* /*new*/ gtk_text_attributes_new();
TextAttributes* /*new*/ gtk_text_attributes_copy(TextAttributes* this_);
void gtk_text_attributes_copy_values(TextAttributes* this_, TextAttributes* dest);
TextAttributes* /*new*/ gtk_text_attributes_ref(TextAttributes* this_);
void gtk_text_attributes_unref(TextAttributes* this_);
TextBuffer* /*new*/ gtk_text_buffer_new(TextTagTable* table=null);
void gtk_text_buffer_add_mark(TextBuffer* this_, TextMark* mark, TextIter* where);
void gtk_text_buffer_add_selection_clipboard(TextBuffer* this_, Clipboard* clipboard);
void gtk_text_buffer_apply_tag(TextBuffer* this_, TextTag* tag, TextIter* start, TextIter* end);
void gtk_text_buffer_apply_tag_by_name(TextBuffer* this_, char* name, TextIter* start, TextIter* end);
int gtk_text_buffer_backspace(TextBuffer* this_, TextIter* iter, int interactive, int default_editable);
void gtk_text_buffer_begin_user_action(TextBuffer* this_);
void gtk_text_buffer_copy_clipboard(TextBuffer* this_, Clipboard* clipboard);
TextChildAnchor* gtk_text_buffer_create_child_anchor(TextBuffer* this_, TextIter* iter);
TextMark* gtk_text_buffer_create_mark(TextBuffer* this_, char* mark_name, TextIter* where, int left_gravity);
TextTag* gtk_text_buffer_create_tag(TextBuffer* this_, char* tag_name=null, char* first_property_name=null, ...);
void gtk_text_buffer_cut_clipboard(TextBuffer* this_, Clipboard* clipboard, int default_editable);
void gtk_text_buffer_delete(TextBuffer* this_, TextIter* start, TextIter* end);
int gtk_text_buffer_delete_interactive(TextBuffer* this_, TextIter* start_iter, TextIter* end_iter, int default_editable);
void gtk_text_buffer_delete_mark(TextBuffer* this_, TextMark* mark);
void gtk_text_buffer_delete_mark_by_name(TextBuffer* this_, char* name);
int gtk_text_buffer_delete_selection(TextBuffer* this_, int interactive, int default_editable);
int gtk_text_buffer_deserialize(TextBuffer* this_, TextBuffer* content_buffer, Gdk2.Atom format, TextIter* iter, ubyte* data, size_t length, GLib2.Error** error);
int gtk_text_buffer_deserialize_get_can_create_tags(TextBuffer* this_, Gdk2.Atom format);
void gtk_text_buffer_deserialize_set_can_create_tags(TextBuffer* this_, Gdk2.Atom format, int can_create_tags);
void gtk_text_buffer_end_user_action(TextBuffer* this_);
void gtk_text_buffer_get_bounds(TextBuffer* this_, /*out*/ TextIter* start, /*out*/ TextIter* end);
int gtk_text_buffer_get_char_count(TextBuffer* this_);
TargetList* gtk_text_buffer_get_copy_target_list(TextBuffer* this_);
Gdk2.Atom* /*new container*/ gtk_text_buffer_get_deserialize_formats(TextBuffer* this_, /*out*/ int* n_formats);
void gtk_text_buffer_get_end_iter(TextBuffer* this_, /*out*/ TextIter* iter);
int gtk_text_buffer_get_has_selection(TextBuffer* this_);
TextMark* gtk_text_buffer_get_insert(TextBuffer* this_);
void gtk_text_buffer_get_iter_at_child_anchor(TextBuffer* this_, /*out*/ TextIter* iter, TextChildAnchor* anchor);
void gtk_text_buffer_get_iter_at_line(TextBuffer* this_, /*out*/ TextIter* iter, int line_number);
void gtk_text_buffer_get_iter_at_line_index(TextBuffer* this_, /*out*/ TextIter* iter, int line_number, int byte_index);
void gtk_text_buffer_get_iter_at_line_offset(TextBuffer* this_, /*out*/ TextIter* iter, int line_number, int char_offset);
void gtk_text_buffer_get_iter_at_mark(TextBuffer* this_, /*out*/ TextIter* iter, TextMark* mark);
void gtk_text_buffer_get_iter_at_offset(TextBuffer* this_, /*out*/ TextIter* iter, int char_offset);
int gtk_text_buffer_get_line_count(TextBuffer* this_);
TextMark* gtk_text_buffer_get_mark(TextBuffer* this_, char* name);
int gtk_text_buffer_get_modified(TextBuffer* this_);
TargetList* gtk_text_buffer_get_paste_target_list(TextBuffer* this_);
TextMark* gtk_text_buffer_get_selection_bound(TextBuffer* this_);
int gtk_text_buffer_get_selection_bounds(TextBuffer* this_, /*out*/ TextIter* start, /*out*/ TextIter* end);
Gdk2.Atom* /*new container*/ gtk_text_buffer_get_serialize_formats(TextBuffer* this_, /*out*/ int* n_formats);
char* /*new*/ gtk_text_buffer_get_slice(TextBuffer* this_, TextIter* start, TextIter* end, int include_hidden_chars);
void gtk_text_buffer_get_start_iter(TextBuffer* this_, /*out*/ TextIter* iter);
TextTagTable* gtk_text_buffer_get_tag_table(TextBuffer* this_);
char* /*new*/ gtk_text_buffer_get_text(TextBuffer* this_, TextIter* start, TextIter* end, int include_hidden_chars);
void gtk_text_buffer_insert(TextBuffer* this_, TextIter* iter, char* text, int len);
void gtk_text_buffer_insert_at_cursor(TextBuffer* this_, char* text, int len);
void gtk_text_buffer_insert_child_anchor(TextBuffer* this_, TextIter* iter, TextChildAnchor* anchor);
int gtk_text_buffer_insert_interactive(TextBuffer* this_, TextIter* iter, char* text, int len, int default_editable);
int gtk_text_buffer_insert_interactive_at_cursor(TextBuffer* this_, char* text, int len, int default_editable);
void gtk_text_buffer_insert_pixbuf(TextBuffer* this_, TextIter* iter, GdkPixbuf2.Pixbuf* pixbuf);
void gtk_text_buffer_insert_range(TextBuffer* this_, TextIter* iter, TextIter* start, TextIter* end);
int gtk_text_buffer_insert_range_interactive(TextBuffer* this_, TextIter* iter, TextIter* start, TextIter* end, int default_editable);
void gtk_text_buffer_insert_with_tags(TextBuffer* this_, TextIter* iter, char* text, int len, TextTag* first_tag, ...);
void gtk_text_buffer_insert_with_tags_by_name(TextBuffer* this_, TextIter* iter, char* text, int len, char* first_tag_name, ...);
void gtk_text_buffer_move_mark(TextBuffer* this_, TextMark* mark, TextIter* where);
void gtk_text_buffer_move_mark_by_name(TextBuffer* this_, char* name, TextIter* where);
void gtk_text_buffer_paste_clipboard(TextBuffer* this_, Clipboard* clipboard, TextIter* override_location, int default_editable);
void gtk_text_buffer_place_cursor(TextBuffer* this_, TextIter* where);
Gdk2.Atom gtk_text_buffer_register_deserialize_format(TextBuffer* this_, char* mime_type, TextBufferDeserializeFunc function_, void* user_data, GLib2.DestroyNotify user_data_destroy);
Gdk2.Atom gtk_text_buffer_register_deserialize_tagset(TextBuffer* this_, char* tagset_name=null);
Gdk2.Atom gtk_text_buffer_register_serialize_format(TextBuffer* this_, char* mime_type, TextBufferSerializeFunc function_, void* user_data, GLib2.DestroyNotify user_data_destroy);
Gdk2.Atom gtk_text_buffer_register_serialize_tagset(TextBuffer* this_, char* tagset_name=null);
void gtk_text_buffer_remove_all_tags(TextBuffer* this_, TextIter* start, TextIter* end);
void gtk_text_buffer_remove_selection_clipboard(TextBuffer* this_, Clipboard* clipboard);
void gtk_text_buffer_remove_tag(TextBuffer* this_, TextTag* tag, TextIter* start, TextIter* end);
void gtk_text_buffer_remove_tag_by_name(TextBuffer* this_, char* name, TextIter* start, TextIter* end);
void gtk_text_buffer_select_range(TextBuffer* this_, TextIter* ins, TextIter* bound);
ubyte* /*new*/ gtk_text_buffer_serialize(TextBuffer* this_, TextBuffer* content_buffer, Gdk2.Atom format, TextIter* start, TextIter* end, /*out*/ size_t* length);
void gtk_text_buffer_set_modified(TextBuffer* this_, int setting);
void gtk_text_buffer_set_text(TextBuffer* this_, char* text, int len);
void gtk_text_buffer_unregister_deserialize_format(TextBuffer* this_, Gdk2.Atom format);
void gtk_text_buffer_unregister_serialize_format(TextBuffer* this_, Gdk2.Atom format);
TextChildAnchor* /*new*/ gtk_text_child_anchor_new();
int gtk_text_child_anchor_get_deleted(TextChildAnchor* this_);
GLib2.List* /*new container*/ gtk_text_child_anchor_get_widgets(TextChildAnchor* this_);
void gtk_text_child_anchor_queue_resize(TextChildAnchor* this_, TextLayout* layout);
void gtk_text_child_anchor_register_child(TextChildAnchor* this_, Widget* child, TextLayout* layout);
void gtk_text_child_anchor_unregister_child(TextChildAnchor* this_, Widget* child);
int gtk_text_iter_backward_char(TextIter* this_);
int gtk_text_iter_backward_chars(TextIter* this_, int count);
int gtk_text_iter_backward_cursor_position(TextIter* this_);
int gtk_text_iter_backward_cursor_positions(TextIter* this_, int count);
int gtk_text_iter_backward_find_char(TextIter* this_, TextCharPredicate pred, void* user_data, TextIter* limit=null);
int gtk_text_iter_backward_line(TextIter* this_);
int gtk_text_iter_backward_lines(TextIter* this_, int count);
int gtk_text_iter_backward_search(TextIter* this_, char* str, TextSearchFlags flags, /*out*/ TextIter* match_start=null, /*out*/ TextIter* match_end=null, TextIter* limit=null);
int gtk_text_iter_backward_sentence_start(TextIter* this_);
int gtk_text_iter_backward_sentence_starts(TextIter* this_, int count);
int gtk_text_iter_backward_to_tag_toggle(TextIter* this_, TextTag* tag=null);
int gtk_text_iter_backward_visible_cursor_position(TextIter* this_);
int gtk_text_iter_backward_visible_cursor_positions(TextIter* this_, int count);
int gtk_text_iter_backward_visible_line(TextIter* this_);
int gtk_text_iter_backward_visible_lines(TextIter* this_, int count);
int gtk_text_iter_backward_visible_word_start(TextIter* this_);
int gtk_text_iter_backward_visible_word_starts(TextIter* this_, int count);
int gtk_text_iter_backward_word_start(TextIter* this_);
int gtk_text_iter_backward_word_starts(TextIter* this_, int count);
int gtk_text_iter_begins_tag(TextIter* this_, TextTag* tag=null);
int gtk_text_iter_can_insert(TextIter* this_, int default_editability);
int gtk_text_iter_compare(TextIter* this_, TextIter* rhs);
TextIter* /*new*/ gtk_text_iter_copy(TextIter* this_);
int gtk_text_iter_editable(TextIter* this_, int default_setting);
int gtk_text_iter_ends_line(TextIter* this_);
int gtk_text_iter_ends_sentence(TextIter* this_);
int gtk_text_iter_ends_tag(TextIter* this_, TextTag* tag=null);
int gtk_text_iter_ends_word(TextIter* this_);
int gtk_text_iter_equal(TextIter* this_, TextIter* rhs);
int gtk_text_iter_forward_char(TextIter* this_);
int gtk_text_iter_forward_chars(TextIter* this_, int count);
int gtk_text_iter_forward_cursor_position(TextIter* this_);
int gtk_text_iter_forward_cursor_positions(TextIter* this_, int count);
int gtk_text_iter_forward_find_char(TextIter* this_, TextCharPredicate pred, void* user_data, TextIter* limit=null);
int gtk_text_iter_forward_line(TextIter* this_);
int gtk_text_iter_forward_lines(TextIter* this_, int count);
int gtk_text_iter_forward_search(TextIter* this_, char* str, TextSearchFlags flags, /*out*/ TextIter* match_start=null, /*out*/ TextIter* match_end=null, TextIter* limit=null);
int gtk_text_iter_forward_sentence_end(TextIter* this_);
int gtk_text_iter_forward_sentence_ends(TextIter* this_, int count);
void gtk_text_iter_forward_to_end(TextIter* this_);
int gtk_text_iter_forward_to_line_end(TextIter* this_);
int gtk_text_iter_forward_to_tag_toggle(TextIter* this_, TextTag* tag=null);
int gtk_text_iter_forward_visible_cursor_position(TextIter* this_);
int gtk_text_iter_forward_visible_cursor_positions(TextIter* this_, int count);
int gtk_text_iter_forward_visible_line(TextIter* this_);
int gtk_text_iter_forward_visible_lines(TextIter* this_, int count);
int gtk_text_iter_forward_visible_word_end(TextIter* this_);
int gtk_text_iter_forward_visible_word_ends(TextIter* this_, int count);
int gtk_text_iter_forward_word_end(TextIter* this_);
int gtk_text_iter_forward_word_ends(TextIter* this_, int count);
void gtk_text_iter_free(TextIter* this_);
int gtk_text_iter_get_attributes(TextIter* this_, /*out*/ TextAttributes* values);
TextBuffer* gtk_text_iter_get_buffer(TextIter* this_);
int gtk_text_iter_get_bytes_in_line(TextIter* this_);
dchar gtk_text_iter_get_char(TextIter* this_);
int gtk_text_iter_get_chars_in_line(TextIter* this_);
TextChildAnchor* gtk_text_iter_get_child_anchor(TextIter* this_);
Pango.Language* /*new*/ gtk_text_iter_get_language(TextIter* this_);
int gtk_text_iter_get_line(TextIter* this_);
int gtk_text_iter_get_line_index(TextIter* this_);
int gtk_text_iter_get_line_offset(TextIter* this_);
GLib2.SList* /*new container*/ gtk_text_iter_get_marks(TextIter* this_);
int gtk_text_iter_get_offset(TextIter* this_);
GdkPixbuf2.Pixbuf* gtk_text_iter_get_pixbuf(TextIter* this_);
char* /*new*/ gtk_text_iter_get_slice(TextIter* this_, TextIter* end);
GLib2.SList* /*new container*/ gtk_text_iter_get_tags(TextIter* this_);
char* /*new*/ gtk_text_iter_get_text(TextIter* this_, TextIter* end);
GLib2.SList* /*new container*/ gtk_text_iter_get_toggled_tags(TextIter* this_, int toggled_on);
int gtk_text_iter_get_visible_line_index(TextIter* this_);
int gtk_text_iter_get_visible_line_offset(TextIter* this_);
char* /*new*/ gtk_text_iter_get_visible_slice(TextIter* this_, TextIter* end);
char* /*new*/ gtk_text_iter_get_visible_text(TextIter* this_, TextIter* end);
int gtk_text_iter_has_tag(TextIter* this_, TextTag* tag);
int gtk_text_iter_in_range(TextIter* this_, TextIter* start, TextIter* end);
int gtk_text_iter_inside_sentence(TextIter* this_);
int gtk_text_iter_inside_word(TextIter* this_);
int gtk_text_iter_is_cursor_position(TextIter* this_);
int gtk_text_iter_is_end(TextIter* this_);
int gtk_text_iter_is_start(TextIter* this_);
void gtk_text_iter_order(TextIter* this_, TextIter* second);
void gtk_text_iter_set_line(TextIter* this_, int line_number);
void gtk_text_iter_set_line_index(TextIter* this_, int byte_on_line);
void gtk_text_iter_set_line_offset(TextIter* this_, int char_on_line);
void gtk_text_iter_set_offset(TextIter* this_, int char_offset);
void gtk_text_iter_set_visible_line_index(TextIter* this_, int byte_on_line);
void gtk_text_iter_set_visible_line_offset(TextIter* this_, int char_on_line);
int gtk_text_iter_starts_line(TextIter* this_);
int gtk_text_iter_starts_sentence(TextIter* this_);
int gtk_text_iter_starts_word(TextIter* this_);
int gtk_text_iter_toggles_tag(TextIter* this_, TextTag* tag=null);
TextLayout* /*new*/ gtk_text_layout_new();
void gtk_text_layout_changed(TextLayout* this_, int y, int old_height, int new_height);
int gtk_text_layout_clamp_iter_to_vrange(TextLayout* this_, TextIter* iter, int top, int bottom);
void gtk_text_layout_cursors_changed(TextLayout* this_, int y, int old_height, int new_height);
void gtk_text_layout_default_style_changed(TextLayout* this_);
void gtk_text_layout_draw(TextLayout* this_, Widget* widget, Gdk2.Drawable* drawable, Gdk2.GC* cursor_gc, int x_offset, int y_offset, int x, int y, int width, int height, GLib2.List** widgets);
void gtk_text_layout_free_line_data(TextLayout* this_, TextLine* line, TextLineData* line_data);
void gtk_text_layout_free_line_display(TextLayout* this_, TextLineDisplay* display);
TextBuffer* gtk_text_layout_get_buffer(TextLayout* this_);
void gtk_text_layout_get_cursor_locations(TextLayout* this_, TextIter* iter, Gdk2.Rectangle* strong_pos=null, Gdk2.Rectangle* weak_pos=null);
int gtk_text_layout_get_cursor_visible(TextLayout* this_);
void gtk_text_layout_get_iter_at_line(TextLayout* this_, TextIter* iter, TextLine* line, int byte_offset);
void gtk_text_layout_get_iter_at_pixel(TextLayout* this_, TextIter* iter, int x, int y);
void gtk_text_layout_get_iter_at_position(TextLayout* this_, TextIter* iter, int* trailing, int x, int y);
void gtk_text_layout_get_iter_location(TextLayout* this_, TextIter* iter, Gdk2.Rectangle* rect);
void gtk_text_layout_get_line_at_y(TextLayout* this_, TextIter* target_iter, int y, int* line_top);
TextLineDisplay* gtk_text_layout_get_line_display(TextLayout* this_, TextLine* line, int size_only);
void gtk_text_layout_get_line_yrange(TextLayout* this_, TextIter* iter, int* y, int* height);
GLib2.SList* /*new container*/ gtk_text_layout_get_lines(TextLayout* this_, int top_y, int bottom_y, int* first_line_y);
void gtk_text_layout_get_size(TextLayout* this_, int* width, int* height);
void gtk_text_layout_invalidate(TextLayout* this_, TextIter* start, TextIter* end);
void gtk_text_layout_invalidate_cursors(TextLayout* this_, TextIter* start, TextIter* end);
int gtk_text_layout_is_valid(TextLayout* this_);
int gtk_text_layout_iter_starts_line(TextLayout* this_, TextIter* iter);
int gtk_text_layout_move_iter_to_line_end(TextLayout* this_, TextIter* iter, int direction);
int gtk_text_layout_move_iter_to_next_line(TextLayout* this_, TextIter* iter);
int gtk_text_layout_move_iter_to_previous_line(TextLayout* this_, TextIter* iter);
void gtk_text_layout_move_iter_to_x(TextLayout* this_, TextIter* iter, int x);
int gtk_text_layout_move_iter_visually(TextLayout* this_, TextIter* iter, int count);
void gtk_text_layout_set_buffer(TextLayout* this_, TextBuffer* buffer=null);
void gtk_text_layout_set_contexts(TextLayout* this_, Pango.Context* ltr_context, Pango.Context* rtl_context);
void gtk_text_layout_set_cursor_direction(TextLayout* this_, TextDirection direction);
void gtk_text_layout_set_cursor_visible(TextLayout* this_, int cursor_visible);
void gtk_text_layout_set_default_style(TextLayout* this_, TextAttributes* values);
void gtk_text_layout_set_keyboard_direction(TextLayout* this_, TextDirection keyboard_dir);
void gtk_text_layout_set_overwrite_mode(TextLayout* this_, int overwrite);
void gtk_text_layout_set_preedit_string(TextLayout* this_, char* preedit_string, Pango.AttrList* preedit_attrs, int cursor_pos);
void gtk_text_layout_set_screen_width(TextLayout* this_, int width);
void gtk_text_layout_spew(TextLayout* this_);
void gtk_text_layout_validate(TextLayout* this_, int max_pixels);
void gtk_text_layout_validate_yrange(TextLayout* this_, TextIter* anchor_line, int y0_, int y1_);
TextLineData* gtk_text_layout_wrap(TextLayout* this_, TextLine* line, TextLineData* line_data);
void gtk_text_layout_wrap_loop_end(TextLayout* this_);
void gtk_text_layout_wrap_loop_start(TextLayout* this_);
TextMark* /*new*/ gtk_text_mark_new(char* name, int left_gravity);
TextBuffer* gtk_text_mark_get_buffer(TextMark* this_);
int gtk_text_mark_get_deleted(TextMark* this_);
int gtk_text_mark_get_left_gravity(TextMark* this_);
char* gtk_text_mark_get_name(TextMark* this_);
int gtk_text_mark_get_visible(TextMark* this_);
void gtk_text_mark_set_visible(TextMark* this_, int setting);
TextTag* /*new*/ gtk_text_tag_new(char* name=null);
int gtk_text_tag_event(TextTag* this_, GObject2.Object* event_object, Gdk2.Event* event, TextIter* iter);
int gtk_text_tag_get_priority(TextTag* this_);
void gtk_text_tag_set_priority(TextTag* this_, int priority);
TextTagTable* /*new*/ gtk_text_tag_table_new();
void gtk_text_tag_table_add(TextTagTable* this_, TextTag* tag);
void gtk_text_tag_table_foreach(TextTagTable* this_, TextTagTableForeach func, void* data);
int gtk_text_tag_table_get_size(TextTagTable* this_);
TextTag* gtk_text_tag_table_lookup(TextTagTable* this_, char* name);
void gtk_text_tag_table_remove(TextTagTable* this_, TextTag* tag);
TextView* gtk_text_view_new();
TextView* gtk_text_view_new_with_buffer(TextBuffer* buffer);
void gtk_text_view_add_child_at_anchor(TextView* this_, Widget* child, TextChildAnchor* anchor);
void gtk_text_view_add_child_in_window(TextView* this_, Widget* child, TextWindowType which_window, int xpos, int ypos);
int gtk_text_view_backward_display_line(TextView* this_, TextIter* iter);
int gtk_text_view_backward_display_line_start(TextView* this_, TextIter* iter);
void gtk_text_view_buffer_to_window_coords(TextView* this_, TextWindowType win, int buffer_x, int buffer_y, /*out*/ int* window_x=null, /*out*/ int* window_y=null);
int gtk_text_view_forward_display_line(TextView* this_, TextIter* iter);
int gtk_text_view_forward_display_line_end(TextView* this_, TextIter* iter);
int gtk_text_view_get_accepts_tab(TextView* this_);
int gtk_text_view_get_border_window_size(TextView* this_, TextWindowType type);
TextBuffer* gtk_text_view_get_buffer(TextView* this_);
int gtk_text_view_get_cursor_visible(TextView* this_);
TextAttributes* /*new*/ gtk_text_view_get_default_attributes(TextView* this_);
int gtk_text_view_get_editable(TextView* this_);
Adjustment* gtk_text_view_get_hadjustment(TextView* this_);
int gtk_text_view_get_indent(TextView* this_);
void gtk_text_view_get_iter_at_location(TextView* this_, /*out*/ TextIter* iter, int x, int y);
void gtk_text_view_get_iter_at_position(TextView* this_, /*out*/ TextIter* iter, /*out*/ int* trailing, int x, int y);
void gtk_text_view_get_iter_location(TextView* this_, TextIter* iter, /*out*/ Gdk2.Rectangle* location);
Justification gtk_text_view_get_justification(TextView* this_);
int gtk_text_view_get_left_margin(TextView* this_);
void gtk_text_view_get_line_at_y(TextView* this_, /*out*/ TextIter* target_iter, int y, /*out*/ int* line_top);
void gtk_text_view_get_line_yrange(TextView* this_, TextIter* iter, /*out*/ int* y, /*out*/ int* height);
int gtk_text_view_get_overwrite(TextView* this_);
int gtk_text_view_get_pixels_above_lines(TextView* this_);
int gtk_text_view_get_pixels_below_lines(TextView* this_);
int gtk_text_view_get_pixels_inside_wrap(TextView* this_);
int gtk_text_view_get_right_margin(TextView* this_);
Pango.TabArray* /*new*/ gtk_text_view_get_tabs(TextView* this_);
Adjustment* gtk_text_view_get_vadjustment(TextView* this_);
void gtk_text_view_get_visible_rect(TextView* this_, /*out*/ Gdk2.Rectangle* visible_rect);
Gdk2.Window* gtk_text_view_get_window(TextView* this_, TextWindowType win);
TextWindowType gtk_text_view_get_window_type(TextView* this_, Gdk2.Window* window);
WrapMode gtk_text_view_get_wrap_mode(TextView* this_);
int gtk_text_view_im_context_filter_keypress(TextView* this_, Gdk2.EventKey* event);
void gtk_text_view_move_child(TextView* this_, Widget* child, int xpos, int ypos);
int gtk_text_view_move_mark_onscreen(TextView* this_, TextMark* mark);
int gtk_text_view_move_visually(TextView* this_, TextIter* iter, int count);
int gtk_text_view_place_cursor_onscreen(TextView* this_);
void gtk_text_view_reset_im_context(TextView* this_);
void gtk_text_view_scroll_mark_onscreen(TextView* this_, TextMark* mark);
int gtk_text_view_scroll_to_iter(TextView* this_, TextIter* iter, double within_margin, int use_align, double xalign, double yalign);
void gtk_text_view_scroll_to_mark(TextView* this_, TextMark* mark, double within_margin, int use_align, double xalign, double yalign);
void gtk_text_view_set_accepts_tab(TextView* this_, int accepts_tab);
void gtk_text_view_set_border_window_size(TextView* this_, TextWindowType type, int size);
void gtk_text_view_set_buffer(TextView* this_, TextBuffer* buffer=null);
void gtk_text_view_set_cursor_visible(TextView* this_, int setting);
void gtk_text_view_set_editable(TextView* this_, int setting);
void gtk_text_view_set_indent(TextView* this_, int indent);
void gtk_text_view_set_justification(TextView* this_, Justification justification);
void gtk_text_view_set_left_margin(TextView* this_, int left_margin);
void gtk_text_view_set_overwrite(TextView* this_, int overwrite);
void gtk_text_view_set_pixels_above_lines(TextView* this_, int pixels_above_lines);
void gtk_text_view_set_pixels_below_lines(TextView* this_, int pixels_below_lines);
void gtk_text_view_set_pixels_inside_wrap(TextView* this_, int pixels_inside_wrap);
void gtk_text_view_set_right_margin(TextView* this_, int right_margin);
void gtk_text_view_set_tabs(TextView* this_, Pango.TabArray* tabs);
void gtk_text_view_set_wrap_mode(TextView* this_, WrapMode wrap_mode);
int gtk_text_view_starts_display_line(TextView* this_, TextIter* iter);
void gtk_text_view_window_to_buffer_coords(TextView* this_, TextWindowType win, int window_x, int window_y, /*out*/ int* buffer_x=null, /*out*/ int* buffer_y=null);
TipsQuery* gtk_tips_query_new();
void gtk_tips_query_set_caller(TipsQuery* this_, Widget* caller);
void gtk_tips_query_set_labels(TipsQuery* this_, char* label_inactive, char* label_no_tip);
void gtk_tips_query_start_query(TipsQuery* this_);
void gtk_tips_query_stop_query(TipsQuery* this_);
ToggleAction* /*new*/ gtk_toggle_action_new(char* name, char* label, char* tooltip, char* stock_id);
int gtk_toggle_action_get_active(ToggleAction* this_);
int gtk_toggle_action_get_draw_as_radio(ToggleAction* this_);
void gtk_toggle_action_set_active(ToggleAction* this_, int is_active);
void gtk_toggle_action_set_draw_as_radio(ToggleAction* this_, int draw_as_radio);
void gtk_toggle_action_toggled(ToggleAction* this_);
ToggleButton* gtk_toggle_button_new();
ToggleButton* gtk_toggle_button_new_with_label(char* label);
ToggleButton* gtk_toggle_button_new_with_mnemonic(char* label);
int gtk_toggle_button_get_active(ToggleButton* this_);
int gtk_toggle_button_get_inconsistent(ToggleButton* this_);
int gtk_toggle_button_get_mode(ToggleButton* this_);
void gtk_toggle_button_set_active(ToggleButton* this_, int is_active);
void gtk_toggle_button_set_inconsistent(ToggleButton* this_, int setting);
void gtk_toggle_button_set_mode(ToggleButton* this_, int draw_indicator);
void gtk_toggle_button_toggled(ToggleButton* this_);
ToggleToolButton* gtk_toggle_tool_button_new();
ToggleToolButton* gtk_toggle_tool_button_new_from_stock(char* stock_id);
int gtk_toggle_tool_button_get_active(ToggleToolButton* this_);
void gtk_toggle_tool_button_set_active(ToggleToolButton* this_, int is_active);
ToolButton* gtk_tool_button_new(Widget* icon_widget=null, char* label=null);
ToolButton* gtk_tool_button_new_from_stock(char* stock_id);
char* gtk_tool_button_get_icon_name(ToolButton* this_);
Widget* gtk_tool_button_get_icon_widget(ToolButton* this_);
char* gtk_tool_button_get_label(ToolButton* this_);
Widget* gtk_tool_button_get_label_widget(ToolButton* this_);
char* gtk_tool_button_get_stock_id(ToolButton* this_);
int gtk_tool_button_get_use_underline(ToolButton* this_);
void gtk_tool_button_set_icon_name(ToolButton* this_, char* icon_name=null);
void gtk_tool_button_set_icon_widget(ToolButton* this_, Widget* icon_widget=null);
void gtk_tool_button_set_label(ToolButton* this_, char* label=null);
void gtk_tool_button_set_label_widget(ToolButton* this_, Widget* label_widget=null);
void gtk_tool_button_set_stock_id(ToolButton* this_, char* stock_id=null);
void gtk_tool_button_set_use_underline(ToolButton* this_, int use_underline);
ToolItem* gtk_tool_item_new();
Pango.EllipsizeMode gtk_tool_item_get_ellipsize_mode(ToolItem* this_);
int gtk_tool_item_get_expand(ToolItem* this_);
int gtk_tool_item_get_homogeneous(ToolItem* this_);
int gtk_tool_item_get_icon_size(ToolItem* this_);
int gtk_tool_item_get_is_important(ToolItem* this_);
Orientation gtk_tool_item_get_orientation(ToolItem* this_);
Widget* gtk_tool_item_get_proxy_menu_item(ToolItem* this_, char* menu_item_id);
ReliefStyle gtk_tool_item_get_relief_style(ToolItem* this_);
float gtk_tool_item_get_text_alignment(ToolItem* this_);
Orientation gtk_tool_item_get_text_orientation(ToolItem* this_);
SizeGroup* gtk_tool_item_get_text_size_group(ToolItem* this_);
ToolbarStyle gtk_tool_item_get_toolbar_style(ToolItem* this_);
int gtk_tool_item_get_use_drag_window(ToolItem* this_);
int gtk_tool_item_get_visible_horizontal(ToolItem* this_);
int gtk_tool_item_get_visible_vertical(ToolItem* this_);
void gtk_tool_item_rebuild_menu(ToolItem* this_);
Widget* gtk_tool_item_retrieve_proxy_menu_item(ToolItem* this_);
void gtk_tool_item_set_expand(ToolItem* this_, int expand);
void gtk_tool_item_set_homogeneous(ToolItem* this_, int homogeneous);
void gtk_tool_item_set_is_important(ToolItem* this_, int is_important);
void gtk_tool_item_set_proxy_menu_item(ToolItem* this_, char* menu_item_id, Widget* menu_item);
void gtk_tool_item_set_tooltip(ToolItem* this_, Tooltips* tooltips, char* tip_text=null, char* tip_private=null);
void gtk_tool_item_set_tooltip_markup(ToolItem* this_, char* markup);
void gtk_tool_item_set_tooltip_text(ToolItem* this_, char* text);
void gtk_tool_item_set_use_drag_window(ToolItem* this_, int use_drag_window);
void gtk_tool_item_set_visible_horizontal(ToolItem* this_, int visible_horizontal);
void gtk_tool_item_set_visible_vertical(ToolItem* this_, int visible_vertical);
void gtk_tool_item_toolbar_reconfigured(ToolItem* this_);
ToolItemGroup* gtk_tool_item_group_new(char* label);
int gtk_tool_item_group_get_collapsed(ToolItemGroup* this_);
ToolItem* gtk_tool_item_group_get_drop_item(ToolItemGroup* this_, int x, int y);
Pango.EllipsizeMode gtk_tool_item_group_get_ellipsize(ToolItemGroup* this_);
ReliefStyle gtk_tool_item_group_get_header_relief(ToolItemGroup* this_);
int gtk_tool_item_group_get_item_position(ToolItemGroup* this_, ToolItem* item);
char* gtk_tool_item_group_get_label(ToolItemGroup* this_);
Widget* gtk_tool_item_group_get_label_widget(ToolItemGroup* this_);
uint gtk_tool_item_group_get_n_items(ToolItemGroup* this_);
ToolItem* gtk_tool_item_group_get_nth_item(ToolItemGroup* this_, uint index);
void gtk_tool_item_group_insert(ToolItemGroup* this_, ToolItem* item, int position);
void gtk_tool_item_group_set_collapsed(ToolItemGroup* this_, int collapsed);
void gtk_tool_item_group_set_ellipsize(ToolItemGroup* this_, Pango.EllipsizeMode ellipsize);
void gtk_tool_item_group_set_header_relief(ToolItemGroup* this_, ReliefStyle style);
void gtk_tool_item_group_set_item_position(ToolItemGroup* this_, ToolItem* item, int position);
void gtk_tool_item_group_set_label(ToolItemGroup* this_, char* label);
void gtk_tool_item_group_set_label_widget(ToolItemGroup* this_, Widget* label_widget);
ToolPalette* gtk_tool_palette_new();
TargetEntry* gtk_tool_palette_get_drag_target_group();
TargetEntry* gtk_tool_palette_get_drag_target_item();
void gtk_tool_palette_add_drag_dest(ToolPalette* this_, Widget* widget, DestDefaults flags, ToolPaletteDragTargets targets, Gdk2.DragAction actions);
Widget* gtk_tool_palette_get_drag_item(ToolPalette* this_, SelectionData* selection);
ToolItemGroup* gtk_tool_palette_get_drop_group(ToolPalette* this_, int x, int y);
ToolItem* gtk_tool_palette_get_drop_item(ToolPalette* this_, int x, int y);
int gtk_tool_palette_get_exclusive(ToolPalette* this_, ToolItemGroup* group);
int gtk_tool_palette_get_expand(ToolPalette* this_, ToolItemGroup* group);
int gtk_tool_palette_get_group_position(ToolPalette* this_, ToolItemGroup* group);
Adjustment* gtk_tool_palette_get_hadjustment(ToolPalette* this_);
int gtk_tool_palette_get_icon_size(ToolPalette* this_);
ToolbarStyle gtk_tool_palette_get_style(ToolPalette* this_);
Adjustment* gtk_tool_palette_get_vadjustment(ToolPalette* this_);
void gtk_tool_palette_set_drag_source(ToolPalette* this_, ToolPaletteDragTargets targets);
void gtk_tool_palette_set_exclusive(ToolPalette* this_, ToolItemGroup* group, int exclusive);
void gtk_tool_palette_set_expand(ToolPalette* this_, ToolItemGroup* group, int expand);
void gtk_tool_palette_set_group_position(ToolPalette* this_, ToolItemGroup* group, int position);
void gtk_tool_palette_set_icon_size(ToolPalette* this_, int icon_size);
void gtk_tool_palette_set_style(ToolPalette* this_, ToolbarStyle style);
void gtk_tool_palette_unset_icon_size(ToolPalette* this_);
void gtk_tool_palette_unset_style(ToolPalette* this_);
Pango.EllipsizeMode gtk_tool_shell_get_ellipsize_mode(ToolShell* this_);
int gtk_tool_shell_get_icon_size(ToolShell* this_);
Orientation gtk_tool_shell_get_orientation(ToolShell* this_);
ReliefStyle gtk_tool_shell_get_relief_style(ToolShell* this_);
ToolbarStyle gtk_tool_shell_get_style(ToolShell* this_);
float gtk_tool_shell_get_text_alignment(ToolShell* this_);
Orientation gtk_tool_shell_get_text_orientation(ToolShell* this_);
SizeGroup* gtk_tool_shell_get_text_size_group(ToolShell* this_);
void gtk_tool_shell_rebuild_menu(ToolShell* this_);
Toolbar* gtk_toolbar_new();
Widget* gtk_toolbar_append_element(Toolbar* this_, ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data);
Widget* gtk_toolbar_append_item(Toolbar* this_, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data);
void gtk_toolbar_append_space(Toolbar* this_);
void gtk_toolbar_append_widget(Toolbar* this_, Widget* widget, char* tooltip_text=null, char* tooltip_private_text=null);
int gtk_toolbar_get_drop_index(Toolbar* this_, int x, int y);
int gtk_toolbar_get_icon_size(Toolbar* this_);
int gtk_toolbar_get_item_index(Toolbar* this_, ToolItem* item);
int gtk_toolbar_get_n_items(Toolbar* this_);
ToolItem* gtk_toolbar_get_nth_item(Toolbar* this_, int n);
Orientation gtk_toolbar_get_orientation(Toolbar* this_);
ReliefStyle gtk_toolbar_get_relief_style(Toolbar* this_);
int gtk_toolbar_get_show_arrow(Toolbar* this_);
ToolbarStyle gtk_toolbar_get_style(Toolbar* this_);
int gtk_toolbar_get_tooltips(Toolbar* this_);
void gtk_toolbar_insert(Toolbar* this_, ToolItem* item, int pos);
Widget* gtk_toolbar_insert_element(Toolbar* this_, ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data, int position);
Widget* gtk_toolbar_insert_item(Toolbar* this_, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data, int position);
void gtk_toolbar_insert_space(Toolbar* this_, int position);
Widget* gtk_toolbar_insert_stock(Toolbar* this_, char* stock_id, char* tooltip_text, char* tooltip_private_text, GObject2.Callback callback, void* user_data, int position);
void gtk_toolbar_insert_widget(Toolbar* this_, Widget* widget, char* tooltip_text, char* tooltip_private_text, int position);
Widget* gtk_toolbar_prepend_element(Toolbar* this_, ToolbarChildType type, Widget* widget, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data);
Widget* gtk_toolbar_prepend_item(Toolbar* this_, char* text, char* tooltip_text, char* tooltip_private_text, Widget* icon, GObject2.Callback callback, void* user_data);
void gtk_toolbar_prepend_space(Toolbar* this_);
void gtk_toolbar_prepend_widget(Toolbar* this_, Widget* widget, char* tooltip_text=null, char* tooltip_private_text=null);
void gtk_toolbar_remove_space(Toolbar* this_, int position);
void gtk_toolbar_set_drop_highlight_item(Toolbar* this_, ToolItem* tool_item, int index_);
void gtk_toolbar_set_icon_size(Toolbar* this_, int icon_size);
void gtk_toolbar_set_orientation(Toolbar* this_, Orientation orientation);
void gtk_toolbar_set_show_arrow(Toolbar* this_, int show_arrow);
void gtk_toolbar_set_style(Toolbar* this_, ToolbarStyle style);
void gtk_toolbar_set_tooltips(Toolbar* this_, int enable);
void gtk_toolbar_unset_icon_size(Toolbar* this_);
void gtk_toolbar_unset_style(Toolbar* this_);
void gtk_tooltip_trigger_tooltip_query(Gdk2.Display* display);
void gtk_tooltip_set_custom(Tooltip* this_, Widget* custom_widget=null);
void gtk_tooltip_set_icon(Tooltip* this_, GdkPixbuf2.Pixbuf* pixbuf=null);
void gtk_tooltip_set_icon_from_gicon(Tooltip* this_, Gio2.Icon* gicon, int size);
void gtk_tooltip_set_icon_from_icon_name(Tooltip* this_, char* icon_name, int size);
void gtk_tooltip_set_icon_from_stock(Tooltip* this_, char* stock_id, int size);
void gtk_tooltip_set_markup(Tooltip* this_, char* markup=null);
void gtk_tooltip_set_text(Tooltip* this_, char* text=null);
void gtk_tooltip_set_tip_area(Tooltip* this_, Gdk2.Rectangle* rect);
Tooltips* gtk_tooltips_new();
int gtk_tooltips_get_info_from_tip_window(Window* tip_window, Tooltips** tooltips, Widget** current_widget);
void gtk_tooltips_disable(Tooltips* this_);
void gtk_tooltips_enable(Tooltips* this_);
void gtk_tooltips_force_window(Tooltips* this_);
void gtk_tooltips_set_delay(Tooltips* this_, uint delay);
void gtk_tooltips_set_tip(Tooltips* this_, Widget* widget, char* tip_text=null, char* tip_private=null);
int gtk_tree_drag_dest_drag_data_received(TreeDragDest* this_, TreePath* dest, SelectionData* selection_data);
int gtk_tree_drag_dest_row_drop_possible(TreeDragDest* this_, TreePath* dest_path, SelectionData* selection_data);
int gtk_tree_drag_source_drag_data_delete(TreeDragSource* this_, TreePath* path);
int gtk_tree_drag_source_drag_data_get(TreeDragSource* this_, TreePath* path, /*out*/ SelectionData* selection_data);
int gtk_tree_drag_source_row_draggable(TreeDragSource* this_, TreePath* path);
TreeIter* /*new*/ gtk_tree_iter_copy(TreeIter* this_);
void gtk_tree_iter_free(TreeIter* this_);
TreeModel* /*new*/ gtk_tree_model_filter_new(TreeModel* this_, TreePath* root=null);
void gtk_tree_model_foreach(TreeModel* this_, TreeModelForeachFunc func, void* user_data);
void gtk_tree_model_get(TreeModel* this_, TreeIter* iter, ...);
Type gtk_tree_model_get_column_type(TreeModel* this_, int index_);
TreeModelFlags gtk_tree_model_get_flags(TreeModel* this_);
int gtk_tree_model_get_iter(TreeModel* this_, /*out*/ TreeIter* iter, TreePath* path);
int gtk_tree_model_get_iter_first(TreeModel* this_, /*out*/ TreeIter* iter);
int gtk_tree_model_get_iter_from_string(TreeModel* this_, /*out*/ TreeIter* iter, char* path_string);
int gtk_tree_model_get_n_columns(TreeModel* this_);
TreePath* /*new*/ gtk_tree_model_get_path(TreeModel* this_, TreeIter* iter);
char* /*new*/ gtk_tree_model_get_string_from_iter(TreeModel* this_, TreeIter* iter);
void gtk_tree_model_get_valist(TreeModel* this_, TreeIter* iter, va_list var_args);
void gtk_tree_model_get_value(TreeModel* this_, TreeIter* iter, int column, /*out*/ GObject2.Value* value);
int gtk_tree_model_iter_children(TreeModel* this_, /*out*/ TreeIter* iter, TreeIter* parent=null);
int gtk_tree_model_iter_has_child(TreeModel* this_, TreeIter* iter);
int gtk_tree_model_iter_n_children(TreeModel* this_, TreeIter* iter=null);
int gtk_tree_model_iter_next(TreeModel* this_, TreeIter* iter);
int gtk_tree_model_iter_nth_child(TreeModel* this_, /*out*/ TreeIter* iter, TreeIter* parent, int n);
int gtk_tree_model_iter_parent(TreeModel* this_, /*out*/ TreeIter* iter, TreeIter* child);
void gtk_tree_model_ref_node(TreeModel* this_, TreeIter* iter);
void gtk_tree_model_row_changed(TreeModel* this_, TreePath* path, TreeIter* iter);
void gtk_tree_model_row_deleted(TreeModel* this_, TreePath* path);
void gtk_tree_model_row_has_child_toggled(TreeModel* this_, TreePath* path, TreeIter* iter);
void gtk_tree_model_row_inserted(TreeModel* this_, TreePath* path, TreeIter* iter);
void gtk_tree_model_rows_reordered(TreeModel* this_, TreePath* path, TreeIter* iter, int* new_order);
TreeModel* /*new*/ gtk_tree_model_sort_new_with_model(TreeModel* this_);
void gtk_tree_model_unref_node(TreeModel* this_, TreeIter* iter);
void gtk_tree_model_filter_clear_cache(TreeModelFilter* this_);
int gtk_tree_model_filter_convert_child_iter_to_iter(TreeModelFilter* this_, /*out*/ TreeIter* filter_iter, TreeIter* child_iter);
TreePath* /*new*/ gtk_tree_model_filter_convert_child_path_to_path(TreeModelFilter* this_, TreePath* child_path);
void gtk_tree_model_filter_convert_iter_to_child_iter(TreeModelFilter* this_, /*out*/ TreeIter* child_iter, TreeIter* filter_iter);
TreePath* /*new*/ gtk_tree_model_filter_convert_path_to_child_path(TreeModelFilter* this_, TreePath* filter_path);
TreeModel* gtk_tree_model_filter_get_model(TreeModelFilter* this_);
void gtk_tree_model_filter_refilter(TreeModelFilter* this_);
void gtk_tree_model_filter_set_modify_func(TreeModelFilter* this_, int n_columns, Type* types, TreeModelFilterModifyFunc func, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_model_filter_set_visible_column(TreeModelFilter* this_, int column);
void gtk_tree_model_filter_set_visible_func(TreeModelFilter* this_, TreeModelFilterVisibleFunc func, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_model_sort_clear_cache(TreeModelSort* this_);
int gtk_tree_model_sort_convert_child_iter_to_iter(TreeModelSort* this_, /*out*/ TreeIter* sort_iter, TreeIter* child_iter);
TreePath* /*new*/ gtk_tree_model_sort_convert_child_path_to_path(TreeModelSort* this_, TreePath* child_path);
void gtk_tree_model_sort_convert_iter_to_child_iter(TreeModelSort* this_, /*out*/ TreeIter* child_iter, TreeIter* sorted_iter);
TreePath* /*new*/ gtk_tree_model_sort_convert_path_to_child_path(TreeModelSort* this_, TreePath* sorted_path);
TreeModel* gtk_tree_model_sort_get_model(TreeModelSort* this_);
int gtk_tree_model_sort_iter_is_valid(TreeModelSort* this_, TreeIter* iter);
void gtk_tree_model_sort_reset_default_sort_func(TreeModelSort* this_);
TreePath* /*new*/ gtk_tree_path_new();
TreePath* /*new*/ gtk_tree_path_new_first();
TreePath* /*new*/ gtk_tree_path_new_from_indices(int first_index, ...);
TreePath* /*new*/ gtk_tree_path_new_from_string(char* path);
void gtk_tree_path_append_index(TreePath* this_, int index_);
int gtk_tree_path_compare(TreePath* this_, TreePath* b);
TreePath* /*new*/ gtk_tree_path_copy(TreePath* this_);
void gtk_tree_path_down(TreePath* this_);
void gtk_tree_path_free(TreePath* this_);
int gtk_tree_path_get_depth(TreePath* this_);
int* gtk_tree_path_get_indices(TreePath* this_);
int* gtk_tree_path_get_indices_with_depth(TreePath* this_, /*out*/ int* depth);
int gtk_tree_path_is_ancestor(TreePath* this_, TreePath* descendant);
int gtk_tree_path_is_descendant(TreePath* this_, TreePath* ancestor);
void gtk_tree_path_next(TreePath* this_);
void gtk_tree_path_prepend_index(TreePath* this_, int index_);
int gtk_tree_path_prev(TreePath* this_);
char* /*new*/ gtk_tree_path_to_string(TreePath* this_);
int gtk_tree_path_up(TreePath* this_);
TreeRowReference* /*new*/ gtk_tree_row_reference_new(TreeModel* model, TreePath* path);
TreeRowReference* /*new*/ gtk_tree_row_reference_new_proxy(GObject2.Object* proxy, TreeModel* model, TreePath* path);
TreeRowReference* /*new*/ gtk_tree_row_reference_copy(TreeRowReference* this_);
void gtk_tree_row_reference_free(TreeRowReference* this_);
TreeModel* gtk_tree_row_reference_get_model(TreeRowReference* this_);
TreePath* /*new*/ gtk_tree_row_reference_get_path(TreeRowReference* this_);
int gtk_tree_row_reference_valid(TreeRowReference* this_);
int gtk_tree_selection_count_selected_rows(TreeSelection* this_);
SelectionMode gtk_tree_selection_get_mode(TreeSelection* this_);
TreeSelectionFunc gtk_tree_selection_get_select_function(TreeSelection* this_);
int gtk_tree_selection_get_selected(TreeSelection* this_, /*out*/ TreeModel** model=null, /*out*/ TreeIter* iter=null);
GLib2.List* /*new*/ gtk_tree_selection_get_selected_rows(TreeSelection* this_, /*out*/ TreeModel** model=null);
TreeView* gtk_tree_selection_get_tree_view(TreeSelection* this_);
void* gtk_tree_selection_get_user_data(TreeSelection* this_);
int gtk_tree_selection_iter_is_selected(TreeSelection* this_, TreeIter* iter);
int gtk_tree_selection_path_is_selected(TreeSelection* this_, TreePath* path);
void gtk_tree_selection_select_all(TreeSelection* this_);
void gtk_tree_selection_select_iter(TreeSelection* this_, TreeIter* iter);
void gtk_tree_selection_select_path(TreeSelection* this_, TreePath* path);
void gtk_tree_selection_select_range(TreeSelection* this_, TreePath* start_path, TreePath* end_path);
void gtk_tree_selection_selected_foreach(TreeSelection* this_, TreeSelectionForeachFunc func, void* data);
void gtk_tree_selection_set_mode(TreeSelection* this_, SelectionMode type);
void gtk_tree_selection_set_select_function(TreeSelection* this_, TreeSelectionFunc func, void* data, GLib2.DestroyNotify destroy);
void gtk_tree_selection_unselect_all(TreeSelection* this_);
void gtk_tree_selection_unselect_iter(TreeSelection* this_, TreeIter* iter);
void gtk_tree_selection_unselect_path(TreeSelection* this_, TreePath* path);
void gtk_tree_selection_unselect_range(TreeSelection* this_, TreePath* start_path, TreePath* end_path);
int gtk_tree_sortable_get_sort_column_id(TreeSortable* this_, int* sort_column_id, SortType* order);
int gtk_tree_sortable_has_default_sort_func(TreeSortable* this_);
void gtk_tree_sortable_set_default_sort_func(TreeSortable* this_, TreeIterCompareFunc sort_func, void* user_data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_sortable_set_sort_column_id(TreeSortable* this_, int sort_column_id, SortType order);
void gtk_tree_sortable_set_sort_func(TreeSortable* this_, int sort_column_id, TreeIterCompareFunc sort_func, void* user_data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_sortable_sort_column_changed(TreeSortable* this_);
TreeStore* /*new*/ gtk_tree_store_new(int n_columns, ...);
TreeStore* /*new*/ gtk_tree_store_newv(int n_columns, Type* types);
void gtk_tree_store_append(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent=null);
void gtk_tree_store_clear(TreeStore* this_);
void gtk_tree_store_insert(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent, int position);
void gtk_tree_store_insert_after(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent=null, TreeIter* sibling=null);
void gtk_tree_store_insert_before(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent=null, TreeIter* sibling=null);
void gtk_tree_store_insert_with_values(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent, int position, ...);
void gtk_tree_store_insert_with_valuesv(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent, int position, int* columns, GObject2.Value* values, int n_values);
int gtk_tree_store_is_ancestor(TreeStore* this_, TreeIter* iter, TreeIter* descendant);
int gtk_tree_store_iter_depth(TreeStore* this_, TreeIter* iter);
int gtk_tree_store_iter_is_valid(TreeStore* this_, TreeIter* iter);
void gtk_tree_store_move_after(TreeStore* this_, TreeIter* iter, TreeIter* position=null);
void gtk_tree_store_move_before(TreeStore* this_, TreeIter* iter, TreeIter* position=null);
void gtk_tree_store_prepend(TreeStore* this_, /*out*/ TreeIter* iter, TreeIter* parent=null);
int gtk_tree_store_remove(TreeStore* this_, TreeIter* iter);
void gtk_tree_store_reorder(TreeStore* this_, TreeIter* parent, int* new_order);
void gtk_tree_store_set(TreeStore* this_, TreeIter* iter, ...);
void gtk_tree_store_set_column_types(TreeStore* this_, int n_columns, Type* types);
void gtk_tree_store_set_valist(TreeStore* this_, TreeIter* iter, va_list var_args);
void gtk_tree_store_set_value(TreeStore* this_, TreeIter* iter, int column, GObject2.Value* value);
void gtk_tree_store_set_valuesv(TreeStore* this_, TreeIter* iter, int* columns, GObject2.Value* values, int n_values);
void gtk_tree_store_swap(TreeStore* this_, TreeIter* a, TreeIter* b);
TreeView* gtk_tree_view_new();
TreeView* gtk_tree_view_new_with_model(TreeModel* model);
int gtk_tree_view_append_column(TreeView* this_, TreeViewColumn* column);
void gtk_tree_view_collapse_all(TreeView* this_);
int gtk_tree_view_collapse_row(TreeView* this_, TreePath* path);
void gtk_tree_view_columns_autosize(TreeView* this_);
void gtk_tree_view_convert_bin_window_to_tree_coords(TreeView* this_, int bx, int by, /*out*/ int* tx, /*out*/ int* ty);
void gtk_tree_view_convert_bin_window_to_widget_coords(TreeView* this_, int bx, int by, /*out*/ int* wx, /*out*/ int* wy);
void gtk_tree_view_convert_tree_to_bin_window_coords(TreeView* this_, int tx, int ty, /*out*/ int* bx, /*out*/ int* by);
void gtk_tree_view_convert_tree_to_widget_coords(TreeView* this_, int tx, int ty, /*out*/ int* wx, /*out*/ int* wy);
void gtk_tree_view_convert_widget_to_bin_window_coords(TreeView* this_, int wx, int wy, /*out*/ int* bx, /*out*/ int* by);
void gtk_tree_view_convert_widget_to_tree_coords(TreeView* this_, int wx, int wy, /*out*/ int* tx, /*out*/ int* ty);
Gdk2.Pixmap* gtk_tree_view_create_row_drag_icon(TreeView* this_, TreePath* path);
void gtk_tree_view_enable_model_drag_dest(TreeView* this_, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
void gtk_tree_view_enable_model_drag_source(TreeView* this_, Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
void gtk_tree_view_expand_all(TreeView* this_);
int gtk_tree_view_expand_row(TreeView* this_, TreePath* path, int open_all);
void gtk_tree_view_expand_to_path(TreeView* this_, TreePath* path);
void gtk_tree_view_get_background_area(TreeView* this_, TreePath* path, TreeViewColumn* column, /*out*/ Gdk2.Rectangle* rect);
Gdk2.Window* gtk_tree_view_get_bin_window(TreeView* this_);
void gtk_tree_view_get_cell_area(TreeView* this_, TreePath* path, TreeViewColumn* column, /*out*/ Gdk2.Rectangle* rect);
TreeViewColumn* gtk_tree_view_get_column(TreeView* this_, int n);
GLib2.List* /*new container*/ gtk_tree_view_get_columns(TreeView* this_);
void gtk_tree_view_get_cursor(TreeView* this_, /*out*/ TreePath** path=null, /*out*/ TreeViewColumn** focus_column=null);
int gtk_tree_view_get_dest_row_at_pos(TreeView* this_, int drag_x, int drag_y, /*out*/ TreePath** path=null, /*out*/ TreeViewDropPosition* pos=null);
void gtk_tree_view_get_drag_dest_row(TreeView* this_, /*out*/ TreePath** path=null, /*out*/ TreeViewDropPosition* pos=null);
int gtk_tree_view_get_enable_search(TreeView* this_);
int gtk_tree_view_get_enable_tree_lines(TreeView* this_);
TreeViewColumn* gtk_tree_view_get_expander_column(TreeView* this_);
int gtk_tree_view_get_fixed_height_mode(TreeView* this_);
TreeViewGridLines gtk_tree_view_get_grid_lines(TreeView* this_);
Adjustment* gtk_tree_view_get_hadjustment(TreeView* this_);
int gtk_tree_view_get_headers_clickable(TreeView* this_);
int gtk_tree_view_get_headers_visible(TreeView* this_);
int gtk_tree_view_get_hover_expand(TreeView* this_);
int gtk_tree_view_get_hover_selection(TreeView* this_);
int gtk_tree_view_get_level_indentation(TreeView* this_);
TreeModel* gtk_tree_view_get_model(TreeView* this_);
int gtk_tree_view_get_path_at_pos(TreeView* this_, int x, int y, /*out*/ TreePath** path=null, /*out*/ TreeViewColumn** column=null, /*out*/ int* cell_x=null, /*out*/ int* cell_y=null);
int gtk_tree_view_get_reorderable(TreeView* this_);
TreeViewRowSeparatorFunc gtk_tree_view_get_row_separator_func(TreeView* this_);
int gtk_tree_view_get_rubber_banding(TreeView* this_);
int gtk_tree_view_get_rules_hint(TreeView* this_);
int gtk_tree_view_get_search_column(TreeView* this_);
Entry* gtk_tree_view_get_search_entry(TreeView* this_);
TreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func(TreeView* this_);
TreeViewSearchPositionFunc gtk_tree_view_get_search_position_func(TreeView* this_);
TreeSelection* gtk_tree_view_get_selection(TreeView* this_);
int gtk_tree_view_get_show_expanders(TreeView* this_);
int gtk_tree_view_get_tooltip_column(TreeView* this_);
int gtk_tree_view_get_tooltip_context(TreeView* this_, /*inout*/ int* x, /*inout*/ int* y, int keyboard_tip, /*out*/ TreeModel** model=null, /*out*/ TreePath** path=null, /*out*/ TreeIter* iter=null);
Adjustment* gtk_tree_view_get_vadjustment(TreeView* this_);
int gtk_tree_view_get_visible_range(TreeView* this_, /*out*/ TreePath** start_path=null, /*out*/ TreePath** end_path=null);
void gtk_tree_view_get_visible_rect(TreeView* this_, /*out*/ Gdk2.Rectangle* visible_rect);
int gtk_tree_view_insert_column(TreeView* this_, TreeViewColumn* column, int position);
int gtk_tree_view_insert_column_with_attributes(TreeView* this_, int position, char* title, CellRenderer* cell, ...);
int gtk_tree_view_insert_column_with_data_func(TreeView* this_, int position, char* title, CellRenderer* cell, TreeCellDataFunc func, void* data, GLib2.DestroyNotify dnotify);
int gtk_tree_view_is_rubber_banding_active(TreeView* this_);
void gtk_tree_view_map_expanded_rows(TreeView* this_, TreeViewMappingFunc func, void* data);
void gtk_tree_view_move_column_after(TreeView* this_, TreeViewColumn* column, TreeViewColumn* base_column=null);
int gtk_tree_view_remove_column(TreeView* this_, TreeViewColumn* column);
void gtk_tree_view_row_activated(TreeView* this_, TreePath* path, TreeViewColumn* column);
int gtk_tree_view_row_expanded(TreeView* this_, TreePath* path);
void gtk_tree_view_scroll_to_cell(TreeView* this_, TreePath* path, TreeViewColumn* column, int use_align, float row_align, float col_align);
void gtk_tree_view_scroll_to_point(TreeView* this_, int tree_x, int tree_y);
void gtk_tree_view_set_column_drag_function(TreeView* this_, TreeViewColumnDropFunc func=null, void* user_data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_view_set_cursor(TreeView* this_, TreePath* path, TreeViewColumn* focus_column, int start_editing);
void gtk_tree_view_set_cursor_on_cell(TreeView* this_, TreePath* path, TreeViewColumn* focus_column, CellRenderer* focus_cell, int start_editing);
void gtk_tree_view_set_destroy_count_func(TreeView* this_, TreeDestroyCountFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_view_set_drag_dest_row(TreeView* this_, TreePath* path, TreeViewDropPosition pos);
void gtk_tree_view_set_enable_search(TreeView* this_, int enable_search);
void gtk_tree_view_set_enable_tree_lines(TreeView* this_, int enabled);
void gtk_tree_view_set_expander_column(TreeView* this_, TreeViewColumn* column);
void gtk_tree_view_set_fixed_height_mode(TreeView* this_, int enable);
void gtk_tree_view_set_grid_lines(TreeView* this_, TreeViewGridLines grid_lines);
void gtk_tree_view_set_hadjustment(TreeView* this_, Adjustment* adjustment=null);
void gtk_tree_view_set_headers_clickable(TreeView* this_, int setting);
void gtk_tree_view_set_headers_visible(TreeView* this_, int headers_visible);
void gtk_tree_view_set_hover_expand(TreeView* this_, int expand);
void gtk_tree_view_set_hover_selection(TreeView* this_, int hover);
void gtk_tree_view_set_level_indentation(TreeView* this_, int indentation);
void gtk_tree_view_set_model(TreeView* this_, TreeModel* model=null);
void gtk_tree_view_set_reorderable(TreeView* this_, int reorderable);
void gtk_tree_view_set_row_separator_func(TreeView* this_, TreeViewRowSeparatorFunc func, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_view_set_rubber_banding(TreeView* this_, int enable);
void gtk_tree_view_set_rules_hint(TreeView* this_, int setting);
void gtk_tree_view_set_search_column(TreeView* this_, int column);
void gtk_tree_view_set_search_entry(TreeView* this_, Entry* entry=null);
void gtk_tree_view_set_search_equal_func(TreeView* this_, TreeViewSearchEqualFunc search_equal_func, void* search_user_data=null, GLib2.DestroyNotify search_destroy=null);
void gtk_tree_view_set_search_position_func(TreeView* this_, TreeViewSearchPositionFunc func=null, void* data=null, GLib2.DestroyNotify destroy=null);
void gtk_tree_view_set_show_expanders(TreeView* this_, int enabled);
void gtk_tree_view_set_tooltip_cell(TreeView* this_, Tooltip* tooltip, TreePath* path=null, TreeViewColumn* column=null, CellRenderer* cell=null);
void gtk_tree_view_set_tooltip_column(TreeView* this_, int column);
void gtk_tree_view_set_tooltip_row(TreeView* this_, Tooltip* tooltip, TreePath* path);
void gtk_tree_view_set_vadjustment(TreeView* this_, Adjustment* adjustment=null);
void gtk_tree_view_tree_to_widget_coords(TreeView* this_, int tx, int ty, int* wx, int* wy);
void gtk_tree_view_unset_rows_drag_dest(TreeView* this_);
void gtk_tree_view_unset_rows_drag_source(TreeView* this_);
void gtk_tree_view_widget_to_tree_coords(TreeView* this_, int wx, int wy, int* tx, int* ty);
TreeViewColumn* gtk_tree_view_column_new();
TreeViewColumn* gtk_tree_view_column_new_with_attributes(char* title, CellRenderer* cell, ...);
void gtk_tree_view_column_add_attribute(TreeViewColumn* this_, CellRenderer* cell_renderer, char* attribute, int column);
int gtk_tree_view_column_cell_get_position(TreeViewColumn* this_, CellRenderer* cell_renderer, int* start_pos, int* width);
void gtk_tree_view_column_cell_get_size(TreeViewColumn* this_, Gdk2.Rectangle* cell_area=null, /*out*/ int* x_offset=null, /*out*/ int* y_offset=null, /*out*/ int* width=null, /*out*/ int* height=null);
int gtk_tree_view_column_cell_is_visible(TreeViewColumn* this_);
void gtk_tree_view_column_cell_set_cell_data(TreeViewColumn* this_, TreeModel* tree_model, TreeIter* iter, int is_expander, int is_expanded);
void gtk_tree_view_column_clear(TreeViewColumn* this_);
void gtk_tree_view_column_clear_attributes(TreeViewColumn* this_, CellRenderer* cell_renderer);
void gtk_tree_view_column_clicked(TreeViewColumn* this_);
void gtk_tree_view_column_focus_cell(TreeViewColumn* this_, CellRenderer* cell);
float gtk_tree_view_column_get_alignment(TreeViewColumn* this_);
GLib2.List* gtk_tree_view_column_get_cell_renderers(TreeViewColumn* this_);
int gtk_tree_view_column_get_clickable(TreeViewColumn* this_);
int gtk_tree_view_column_get_expand(TreeViewColumn* this_);
int gtk_tree_view_column_get_fixed_width(TreeViewColumn* this_);
int gtk_tree_view_column_get_max_width(TreeViewColumn* this_);
int gtk_tree_view_column_get_min_width(TreeViewColumn* this_);
int gtk_tree_view_column_get_reorderable(TreeViewColumn* this_);
int gtk_tree_view_column_get_resizable(TreeViewColumn* this_);
TreeViewColumnSizing gtk_tree_view_column_get_sizing(TreeViewColumn* this_);
int gtk_tree_view_column_get_sort_column_id(TreeViewColumn* this_);
int gtk_tree_view_column_get_sort_indicator(TreeViewColumn* this_);
SortType gtk_tree_view_column_get_sort_order(TreeViewColumn* this_);
int gtk_tree_view_column_get_spacing(TreeViewColumn* this_);
char* gtk_tree_view_column_get_title(TreeViewColumn* this_);
Widget* gtk_tree_view_column_get_tree_view(TreeViewColumn* this_);
int gtk_tree_view_column_get_visible(TreeViewColumn* this_);
Widget* gtk_tree_view_column_get_widget(TreeViewColumn* this_);
int gtk_tree_view_column_get_width(TreeViewColumn* this_);
void gtk_tree_view_column_pack_end(TreeViewColumn* this_, CellRenderer* cell, int expand);
void gtk_tree_view_column_pack_start(TreeViewColumn* this_, CellRenderer* cell, int expand);
void gtk_tree_view_column_queue_resize(TreeViewColumn* this_);
void gtk_tree_view_column_set_alignment(TreeViewColumn* this_, float xalign);
void gtk_tree_view_column_set_attributes(TreeViewColumn* this_, CellRenderer* cell_renderer, ...);
void gtk_tree_view_column_set_cell_data_func(TreeViewColumn* this_, CellRenderer* cell_renderer, TreeCellDataFunc func, void* func_data, GLib2.DestroyNotify destroy);
void gtk_tree_view_column_set_clickable(TreeViewColumn* this_, int clickable);
void gtk_tree_view_column_set_expand(TreeViewColumn* this_, int expand);
void gtk_tree_view_column_set_fixed_width(TreeViewColumn* this_, int fixed_width);
void gtk_tree_view_column_set_max_width(TreeViewColumn* this_, int max_width);
void gtk_tree_view_column_set_min_width(TreeViewColumn* this_, int min_width);
void gtk_tree_view_column_set_reorderable(TreeViewColumn* this_, int reorderable);
void gtk_tree_view_column_set_resizable(TreeViewColumn* this_, int resizable);
void gtk_tree_view_column_set_sizing(TreeViewColumn* this_, TreeViewColumnSizing type);
void gtk_tree_view_column_set_sort_column_id(TreeViewColumn* this_, int sort_column_id);
void gtk_tree_view_column_set_sort_indicator(TreeViewColumn* this_, int setting);
void gtk_tree_view_column_set_sort_order(TreeViewColumn* this_, SortType order);
void gtk_tree_view_column_set_spacing(TreeViewColumn* this_, int spacing);
void gtk_tree_view_column_set_title(TreeViewColumn* this_, char* title);
void gtk_tree_view_column_set_visible(TreeViewColumn* this_, int visible);
void gtk_tree_view_column_set_widget(TreeViewColumn* this_, Widget* widget=null);
UIManager* /*new*/ gtk_ui_manager_new();
void gtk_ui_manager_add_ui(UIManager* this_, uint merge_id, char* path, char* name, char* action, UIManagerItemType type, int top);
uint gtk_ui_manager_add_ui_from_file(UIManager* this_, char* filename, GLib2.Error** error);
uint gtk_ui_manager_add_ui_from_string(UIManager* this_, char* buffer, ssize_t length, GLib2.Error** error);
void gtk_ui_manager_ensure_update(UIManager* this_);
AccelGroup* gtk_ui_manager_get_accel_group(UIManager* this_);
Action* gtk_ui_manager_get_action(UIManager* this_, char* path);
GLib2.List* gtk_ui_manager_get_action_groups(UIManager* this_);
int gtk_ui_manager_get_add_tearoffs(UIManager* this_);
GLib2.SList* /*new container*/ gtk_ui_manager_get_toplevels(UIManager* this_, UIManagerItemType types);
char* /*new*/ gtk_ui_manager_get_ui(UIManager* this_);
Widget* gtk_ui_manager_get_widget(UIManager* this_, char* path);
void gtk_ui_manager_insert_action_group(UIManager* this_, ActionGroup* action_group, int pos);
uint gtk_ui_manager_new_merge_id(UIManager* this_);
void gtk_ui_manager_remove_action_group(UIManager* this_, ActionGroup* action_group);
void gtk_ui_manager_remove_ui(UIManager* this_, uint merge_id);
void gtk_ui_manager_set_add_tearoffs(UIManager* this_, int add_tearoffs);
VBox* gtk_vbox_new(int homogeneous, int spacing);
VButtonBox* gtk_vbutton_box_new();
ButtonBoxStyle gtk_vbutton_box_get_layout_default();
int gtk_vbutton_box_get_spacing_default();
void gtk_vbutton_box_set_layout_default(ButtonBoxStyle layout);
void gtk_vbutton_box_set_spacing_default(int spacing);
VPaned* gtk_vpaned_new();
VRuler* gtk_vruler_new();
VScale* gtk_vscale_new(Adjustment* adjustment);
VScale* gtk_vscale_new_with_range(double min, double max, double step);
VScrollbar* gtk_vscrollbar_new(Adjustment* adjustment=null);
VSeparator* gtk_vseparator_new();
Viewport* gtk_viewport_new(Adjustment* hadjustment, Adjustment* vadjustment);
Gdk2.Window* gtk_viewport_get_bin_window(Viewport* this_);
Adjustment* gtk_viewport_get_hadjustment(Viewport* this_);
ShadowType gtk_viewport_get_shadow_type(Viewport* this_);
Adjustment* gtk_viewport_get_vadjustment(Viewport* this_);
Gdk2.Window* gtk_viewport_get_view_window(Viewport* this_);
void gtk_viewport_set_hadjustment(Viewport* this_, Adjustment* adjustment=null);
void gtk_viewport_set_shadow_type(Viewport* this_, ShadowType type);
void gtk_viewport_set_vadjustment(Viewport* this_, Adjustment* adjustment=null);
VolumeButton* gtk_volume_button_new();
Widget* gtk_widget_new(Type type, char* first_property_name, ...);
Gdk2.Colormap* gtk_widget_get_default_colormap();
TextDirection gtk_widget_get_default_direction();
Style* gtk_widget_get_default_style();
Gdk2.Visual* gtk_widget_get_default_visual();
void gtk_widget_pop_colormap();
void gtk_widget_pop_composite_child();
void gtk_widget_push_colormap(Gdk2.Colormap* cmap);
void gtk_widget_push_composite_child();
void gtk_widget_set_default_colormap(Gdk2.Colormap* colormap);
void gtk_widget_set_default_direction(TextDirection dir);
int gtk_widget_activate(Widget* this_);
void gtk_widget_add_accelerator(Widget* this_, char* accel_signal, AccelGroup* accel_group, uint accel_key, Gdk2.ModifierType accel_mods, AccelFlags accel_flags);
void gtk_widget_add_events(Widget* this_, int events);
void gtk_widget_add_mnemonic_label(Widget* this_, Widget* label);
int gtk_widget_can_activate_accel(Widget* this_, uint signal_id);
int gtk_widget_child_focus(Widget* this_, DirectionType direction);
void gtk_widget_child_notify(Widget* this_, char* child_property);
void gtk_widget_class_path(Widget* this_, /*out*/ uint* path_length=null, /*out*/ char** path=null, /*out*/ char** path_reversed=null);
Pango.Context* /*new*/ gtk_widget_create_pango_context(Widget* this_);
Pango.Layout* /*new*/ gtk_widget_create_pango_layout(Widget* this_, char* text);
void gtk_widget_destroy(Widget* this_);
void gtk_widget_destroyed(Widget* this_, /*inout*/ Widget** widget_pointer);
void gtk_widget_draw(Widget* this_, Gdk2.Rectangle* area);
void gtk_widget_ensure_style(Widget* this_);
void gtk_widget_error_bell(Widget* this_);
int gtk_widget_event(Widget* this_, Gdk2.Event* event);
void gtk_widget_freeze_child_notify(Widget* this_);
Atk.Object* gtk_widget_get_accessible(Widget* this_);
Action* gtk_widget_get_action(Widget* this_);
void gtk_widget_get_allocation(Widget* this_, /*out*/ Allocation* allocation);
Widget* gtk_widget_get_ancestor(Widget* this_, Type widget_type);
int gtk_widget_get_app_paintable(Widget* this_);
int gtk_widget_get_can_default(Widget* this_);
int gtk_widget_get_can_focus(Widget* this_);
void gtk_widget_get_child_requisition(Widget* this_, Requisition* requisition);
int gtk_widget_get_child_visible(Widget* this_);
Clipboard* gtk_widget_get_clipboard(Widget* this_, Gdk2.Atom selection);
Gdk2.Colormap* gtk_widget_get_colormap(Widget* this_);
char* /*new*/ gtk_widget_get_composite_name(Widget* this_);
TextDirection gtk_widget_get_direction(Widget* this_);
Gdk2.Display* gtk_widget_get_display(Widget* this_);
int gtk_widget_get_double_buffered(Widget* this_);
int gtk_widget_get_events(Widget* this_);
Gdk2.ExtensionMode gtk_widget_get_extension_events(Widget* this_);
int gtk_widget_get_has_tooltip(Widget* this_);
int gtk_widget_get_has_window(Widget* this_);
int gtk_widget_get_mapped(Widget* this_);
RcStyle* gtk_widget_get_modifier_style(Widget* this_);
char* gtk_widget_get_name(Widget* this_);
int gtk_widget_get_no_show_all(Widget* this_);
Pango.Context* gtk_widget_get_pango_context(Widget* this_);
Widget* gtk_widget_get_parent(Widget* this_);
Gdk2.Window* gtk_widget_get_parent_window(Widget* this_);
void gtk_widget_get_pointer(Widget* this_, /*out*/ int* x=null, /*out*/ int* y=null);
int gtk_widget_get_realized(Widget* this_);
int gtk_widget_get_receives_default(Widget* this_);
void gtk_widget_get_requisition(Widget* this_, /*out*/ Requisition* requisition);
Gdk2.Window* gtk_widget_get_root_window(Widget* this_);
Gdk2.Screen* gtk_widget_get_screen(Widget* this_);
int gtk_widget_get_sensitive(Widget* this_);
Settings* gtk_widget_get_settings(Widget* this_);
void gtk_widget_get_size_request(Widget* this_, /*out*/ int* width=null, /*out*/ int* height=null);
Gdk2.Pixmap* gtk_widget_get_snapshot(Widget* this_, Gdk2.Rectangle* clip_rect=null);
StateType gtk_widget_get_state(Widget* this_);
Style* gtk_widget_get_style(Widget* this_);
char* /*new*/ gtk_widget_get_tooltip_markup(Widget* this_);
char* /*new*/ gtk_widget_get_tooltip_text(Widget* this_);
Window* gtk_widget_get_tooltip_window(Widget* this_);
Widget* gtk_widget_get_toplevel(Widget* this_);
int gtk_widget_get_visible(Widget* this_);
Gdk2.Visual* gtk_widget_get_visual(Widget* this_);
Gdk2.Window* gtk_widget_get_window(Widget* this_);
void gtk_widget_grab_default(Widget* this_);
void gtk_widget_grab_focus(Widget* this_);
int gtk_widget_has_default(Widget* this_);
int gtk_widget_has_focus(Widget* this_);
int gtk_widget_has_grab(Widget* this_);
int gtk_widget_has_rc_style(Widget* this_);
int gtk_widget_has_screen(Widget* this_);
void gtk_widget_hide(Widget* this_);
void gtk_widget_hide_all(Widget* this_);
int gtk_widget_hide_on_delete(Widget* this_);
void gtk_widget_input_shape_combine_mask(Widget* this_, Gdk2.Bitmap* shape_mask, int offset_x, int offset_y);
int gtk_widget_intersect(Widget* this_, Gdk2.Rectangle* area, Gdk2.Rectangle* intersection);
int gtk_widget_is_ancestor(Widget* this_, Widget* ancestor);
int gtk_widget_is_composited(Widget* this_);
int gtk_widget_is_drawable(Widget* this_);
int gtk_widget_is_focus(Widget* this_);
int gtk_widget_is_sensitive(Widget* this_);
int gtk_widget_is_toplevel(Widget* this_);
int gtk_widget_keynav_failed(Widget* this_, DirectionType direction);
GLib2.List* /*new container*/ gtk_widget_list_accel_closures(Widget* this_);
GLib2.List* /*new container*/ gtk_widget_list_mnemonic_labels(Widget* this_);
void gtk_widget_map(Widget* this_);
int gtk_widget_mnemonic_activate(Widget* this_, int group_cycling);
void gtk_widget_modify_base(Widget* this_, StateType state, Gdk2.Color* color=null);
void gtk_widget_modify_bg(Widget* this_, StateType state, Gdk2.Color* color=null);
void gtk_widget_modify_cursor(Widget* this_, Gdk2.Color* primary, Gdk2.Color* secondary);
void gtk_widget_modify_fg(Widget* this_, StateType state, Gdk2.Color* color=null);
void gtk_widget_modify_font(Widget* this_, Pango.FontDescription* font_desc=null);
void gtk_widget_modify_style(Widget* this_, RcStyle* style);
void gtk_widget_modify_text(Widget* this_, StateType state, Gdk2.Color* color=null);
void gtk_widget_path(Widget* this_, /*out*/ uint* path_length=null, /*out*/ char** path=null, /*out*/ char** path_reversed=null);
void gtk_widget_queue_clear(Widget* this_);
void gtk_widget_queue_clear_area(Widget* this_, int x, int y, int width, int height);
void gtk_widget_queue_draw(Widget* this_);
void gtk_widget_queue_draw_area(Widget* this_, int x, int y, int width, int height);
void gtk_widget_queue_resize(Widget* this_);
void gtk_widget_queue_resize_no_redraw(Widget* this_);
void gtk_widget_realize(Widget* this_);
Widget* gtk_widget_ref(Widget* this_);
Gdk2.Region* gtk_widget_region_intersect(Widget* this_, Gdk2.Region* region);
int gtk_widget_remove_accelerator(Widget* this_, AccelGroup* accel_group, uint accel_key, Gdk2.ModifierType accel_mods);
void gtk_widget_remove_mnemonic_label(Widget* this_, Widget* label);
GdkPixbuf2.Pixbuf* /*new*/ gtk_widget_render_icon(Widget* this_, char* stock_id, IconSize size, char* detail=null);
void gtk_widget_reparent(Widget* this_, Widget* new_parent);
void gtk_widget_reset_rc_styles(Widget* this_);
void gtk_widget_reset_shapes(Widget* this_);
int gtk_widget_send_expose(Widget* this_, Gdk2.Event* event);
int gtk_widget_send_focus_change(Widget* this_, Gdk2.Event* event);
void gtk_widget_set(Widget* this_, char* first_property_name, ...);
void gtk_widget_set_accel_path(Widget* this_, char* accel_path=null, AccelGroup* accel_group=null);
void gtk_widget_set_allocation(Widget* this_, Allocation* allocation);
void gtk_widget_set_app_paintable(Widget* this_, int app_paintable);
void gtk_widget_set_can_default(Widget* this_, int can_default);
void gtk_widget_set_can_focus(Widget* this_, int can_focus);
void gtk_widget_set_child_visible(Widget* this_, int is_visible);
void gtk_widget_set_colormap(Widget* this_, Gdk2.Colormap* colormap);
void gtk_widget_set_composite_name(Widget* this_, char* name);
void gtk_widget_set_direction(Widget* this_, TextDirection dir);
void gtk_widget_set_double_buffered(Widget* this_, int double_buffered);
void gtk_widget_set_events(Widget* this_, int events);
void gtk_widget_set_extension_events(Widget* this_, Gdk2.ExtensionMode mode);
void gtk_widget_set_has_tooltip(Widget* this_, int has_tooltip);
void gtk_widget_set_has_window(Widget* this_, int has_window);
void gtk_widget_set_mapped(Widget* this_, int mapped);
void gtk_widget_set_name(Widget* this_, char* name);
void gtk_widget_set_no_show_all(Widget* this_, int no_show_all);
void gtk_widget_set_parent(Widget* this_, Widget* parent);
void gtk_widget_set_parent_window(Widget* this_, Gdk2.Window* parent_window);
void gtk_widget_set_realized(Widget* this_, int realized);
void gtk_widget_set_receives_default(Widget* this_, int receives_default);
void gtk_widget_set_redraw_on_allocate(Widget* this_, int redraw_on_allocate);
int gtk_widget_set_scroll_adjustments(Widget* this_, Adjustment* hadjustment=null, Adjustment* vadjustment=null);
void gtk_widget_set_sensitive(Widget* this_, int sensitive);
void gtk_widget_set_size_request(Widget* this_, int width, int height);
void gtk_widget_set_state(Widget* this_, StateType state);
void gtk_widget_set_style(Widget* this_, Style* style=null);
void gtk_widget_set_tooltip_markup(Widget* this_, char* markup=null);
void gtk_widget_set_tooltip_text(Widget* this_, char* text);
void gtk_widget_set_tooltip_window(Widget* this_, Window* custom_window=null);
void gtk_widget_set_uposition(Widget* this_, int x, int y);
void gtk_widget_set_usize(Widget* this_, int width, int height);
void gtk_widget_set_visible(Widget* this_, int visible);
void gtk_widget_set_window(Widget* this_, Gdk2.Window* window);
void gtk_widget_shape_combine_mask(Widget* this_, Gdk2.Bitmap* shape_mask, int offset_x, int offset_y);
void gtk_widget_show(Widget* this_);
void gtk_widget_show_all(Widget* this_);
void gtk_widget_show_now(Widget* this_);
void gtk_widget_size_allocate(Widget* this_, Allocation* allocation);
void gtk_widget_size_request(Widget* this_, Requisition* requisition);
void gtk_widget_style_attach(Widget* this_);
void gtk_widget_style_get(Widget* this_, char* first_property_name, ...);
void gtk_widget_style_get_property(Widget* this_, char* property_name, GObject2.Value* value);
void gtk_widget_style_get_valist(Widget* this_, char* first_property_name, va_list var_args);
void gtk_widget_thaw_child_notify(Widget* this_);
int gtk_widget_translate_coordinates(Widget* this_, Widget* dest_widget, int src_x, int src_y, /*out*/ int* dest_x, /*out*/ int* dest_y);
void gtk_widget_trigger_tooltip_query(Widget* this_);
void gtk_widget_unmap(Widget* this_);
void gtk_widget_unparent(Widget* this_);
void gtk_widget_unrealize(Widget* this_);
void gtk_widget_unref(Widget* this_);
GObject2.ParamSpec* gtk_widget_class_find_style_property(WidgetClass* this_, char* property_name);
void gtk_widget_class_install_style_property(WidgetClass* this_, GObject2.ParamSpec* pspec);
void gtk_widget_class_install_style_property_parser(WidgetClass* this_, GObject2.ParamSpec* pspec, RcPropertyParser parser);
GObject2.ParamSpec** /*new container*/ gtk_widget_class_list_style_properties(WidgetClass* this_, /*out*/ uint* n_properties);
Window* gtk_window_new(WindowType type);
GLib2.List* /*new container*/ gtk_window_get_default_icon_list();
char* gtk_window_get_default_icon_name();
GLib2.List* /*new container*/ gtk_window_list_toplevels();
void gtk_window_set_auto_startup_notification(int setting);
void gtk_window_set_default_icon(GdkPixbuf2.Pixbuf* icon);
int gtk_window_set_default_icon_from_file(char* filename, GLib2.Error** error);
void gtk_window_set_default_icon_list(GLib2.List* list);
void gtk_window_set_default_icon_name(char* name);
int gtk_window_activate_default(Window* this_);
int gtk_window_activate_focus(Window* this_);
int gtk_window_activate_key(Window* this_, Gdk2.EventKey* event);
void gtk_window_add_accel_group(Window* this_, AccelGroup* accel_group);
void gtk_window_add_embedded_xid(Window* this_, Gdk2.NativeWindow xid);
void gtk_window_add_mnemonic(Window* this_, uint keyval, Widget* target);
void gtk_window_begin_move_drag(Window* this_, int button, int root_x, int root_y, uint timestamp);
void gtk_window_begin_resize_drag(Window* this_, Gdk2.WindowEdge edge, int button, int root_x, int root_y, uint timestamp);
void gtk_window_deiconify(Window* this_);
void gtk_window_fullscreen(Window* this_);
int gtk_window_get_accept_focus(Window* this_);
int gtk_window_get_decorated(Window* this_);
void gtk_window_get_default_size(Window* this_, int* width=null, int* height=null);
Widget* gtk_window_get_default_widget(Window* this_);
int gtk_window_get_deletable(Window* this_);
int gtk_window_get_destroy_with_parent(Window* this_);
Widget* gtk_window_get_focus(Window* this_);
int gtk_window_get_focus_on_map(Window* this_);
void gtk_window_get_frame_dimensions(Window* this_, /*out*/ int* left=null, /*out*/ int* top=null, /*out*/ int* right=null, /*out*/ int* bottom=null);
Gdk2.Gravity gtk_window_get_gravity(Window* this_);
WindowGroup* gtk_window_get_group(Window* this_);
int gtk_window_get_has_frame(Window* this_);
GdkPixbuf2.Pixbuf* gtk_window_get_icon(Window* this_);
GLib2.List* /*new container*/ gtk_window_get_icon_list(Window* this_);
char* gtk_window_get_icon_name(Window* this_);
Gdk2.ModifierType gtk_window_get_mnemonic_modifier(Window* this_);
int gtk_window_get_mnemonics_visible(Window* this_);
int gtk_window_get_modal(Window* this_);
double gtk_window_get_opacity(Window* this_);
void gtk_window_get_position(Window* this_, /*out*/ int* root_x=null, /*out*/ int* root_y=null);
int gtk_window_get_resizable(Window* this_);
char* gtk_window_get_role(Window* this_);
Gdk2.Screen* gtk_window_get_screen(Window* this_);
void gtk_window_get_size(Window* this_, /*out*/ int* width=null, /*out*/ int* height=null);
int gtk_window_get_skip_pager_hint(Window* this_);
int gtk_window_get_skip_taskbar_hint(Window* this_);
char* gtk_window_get_title(Window* this_);
Window* gtk_window_get_transient_for(Window* this_);
Gdk2.WindowTypeHint gtk_window_get_type_hint(Window* this_);
int gtk_window_get_urgency_hint(Window* this_);
WindowType gtk_window_get_window_type(Window* this_);
int gtk_window_has_group(Window* this_);
int gtk_window_has_toplevel_focus(Window* this_);
void gtk_window_iconify(Window* this_);
int gtk_window_is_active(Window* this_);
void gtk_window_maximize(Window* this_);
int gtk_window_mnemonic_activate(Window* this_, uint keyval, Gdk2.ModifierType modifier);
void gtk_window_move(Window* this_, int x, int y);
int gtk_window_parse_geometry(Window* this_, char* geometry);
void gtk_window_present(Window* this_);
void gtk_window_present_with_time(Window* this_, uint timestamp);
int gtk_window_propagate_key_event(Window* this_, Gdk2.EventKey* event);
void gtk_window_remove_accel_group(Window* this_, AccelGroup* accel_group);
void gtk_window_remove_embedded_xid(Window* this_, Gdk2.NativeWindow xid);
void gtk_window_remove_mnemonic(Window* this_, uint keyval, Widget* target);
void gtk_window_reshow_with_initial_size(Window* this_);
void gtk_window_resize(Window* this_, int width, int height);
void gtk_window_set_accept_focus(Window* this_, int setting);
void gtk_window_set_decorated(Window* this_, int setting);
void gtk_window_set_default(Window* this_, Widget* default_widget=null);
void gtk_window_set_default_size(Window* this_, int width, int height);
void gtk_window_set_deletable(Window* this_, int setting);
void gtk_window_set_destroy_with_parent(Window* this_, int setting);
void gtk_window_set_focus(Window* this_, Widget* focus=null);
void gtk_window_set_focus_on_map(Window* this_, int setting);
void gtk_window_set_frame_dimensions(Window* this_, int left, int top, int right, int bottom);
void gtk_window_set_geometry_hints(Window* this_, Widget* geometry_widget, Gdk2.Geometry* geometry, Gdk2.WindowHints geom_mask);
void gtk_window_set_gravity(Window* this_, Gdk2.Gravity gravity);
void gtk_window_set_has_frame(Window* this_, int setting);
void gtk_window_set_icon(Window* this_, GdkPixbuf2.Pixbuf* icon=null);
int gtk_window_set_icon_from_file(Window* this_, char* filename, GLib2.Error** error);
void gtk_window_set_icon_list(Window* this_, GLib2.List* list);
void gtk_window_set_icon_name(Window* this_, char* name=null);
void gtk_window_set_keep_above(Window* this_, int setting);
void gtk_window_set_keep_below(Window* this_, int setting);
void gtk_window_set_mnemonic_modifier(Window* this_, Gdk2.ModifierType modifier);
void gtk_window_set_mnemonics_visible(Window* this_, int setting);
void gtk_window_set_modal(Window* this_, int modal);
void gtk_window_set_opacity(Window* this_, double opacity);
void gtk_window_set_policy(Window* this_, int allow_shrink, int allow_grow, int auto_shrink);
void gtk_window_set_position(Window* this_, WindowPosition position);
void gtk_window_set_resizable(Window* this_, int resizable);
void gtk_window_set_role(Window* this_, char* role);
void gtk_window_set_screen(Window* this_, Gdk2.Screen* screen);
void gtk_window_set_skip_pager_hint(Window* this_, int setting);
void gtk_window_set_skip_taskbar_hint(Window* this_, int setting);
void gtk_window_set_startup_id(Window* this_, char* startup_id);
void gtk_window_set_title(Window* this_, char* title);
void gtk_window_set_transient_for(Window* this_, Window* parent=null);
void gtk_window_set_type_hint(Window* this_, Gdk2.WindowTypeHint hint);
void gtk_window_set_urgency_hint(Window* this_, int setting);
void gtk_window_set_wmclass(Window* this_, char* wmclass_name, char* wmclass_class);
void gtk_window_stick(Window* this_);
void gtk_window_unfullscreen(Window* this_);
void gtk_window_unmaximize(Window* this_);
void gtk_window_unstick(Window* this_);
WindowGroup* /*new*/ gtk_window_group_new();
void gtk_window_group_add_window(WindowGroup* this_, Window* window);
Widget* gtk_window_group_get_current_grab(WindowGroup* this_);
GLib2.List* /*new container*/ gtk_window_group_list_windows(WindowGroup* this_);
void gtk_window_group_remove_window(WindowGroup* this_, Window* window);
int gtk_accel_groups_activate(GObject2.Object* object, uint accel_key, Gdk2.ModifierType accel_mods);
GLib2.SList* gtk_accel_groups_from_object(GObject2.Object* object);
uint gtk_accelerator_get_default_mod_mask();
char* /*new*/ gtk_accelerator_get_label(uint accelerator_key, Gdk2.ModifierType accelerator_mods);
char* /*new*/ gtk_accelerator_name(uint accelerator_key, Gdk2.ModifierType accelerator_mods);
void gtk_accelerator_parse(char* accelerator, /*out*/ uint* accelerator_key=null, /*out*/ Gdk2.ModifierType* accelerator_mods=null);
void gtk_accelerator_set_default_mod_mask(Gdk2.ModifierType default_mod_mask);
int gtk_accelerator_valid(uint keyval, Gdk2.ModifierType modifiers);
int gtk_alternative_dialog_button_order(Gdk2.Screen* screen=null);
void gtk_binding_entry_add_signal(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers, char* signal_name, uint n_args, ...);
void gtk_binding_entry_add_signall(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers, char* signal_name, GLib2.SList* binding_args);
void gtk_binding_entry_clear(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers);
void gtk_binding_entry_remove(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers);
void gtk_binding_entry_skip(BindingSet* binding_set, uint keyval, Gdk2.ModifierType modifiers);
uint gtk_binding_parse_binding(GLib2.Scanner* scanner);
BindingSet* gtk_binding_set_by_class(void* object_class);
BindingSet* gtk_binding_set_find(char* set_name);
BindingSet* gtk_binding_set_new(char* set_name);
int gtk_bindings_activate(Object* object, uint keyval, Gdk2.ModifierType modifiers);
int gtk_bindings_activate_event(Object* object, Gdk2.EventKey* event);
GLib2.Quark gtk_builder_error_quark();
char* gtk_check_version(uint required_major, uint required_minor, uint required_micro);
Type gtk_ctree_node_get_type();
void gtk_disable_setlocale();
Gdk2.DragContext* gtk_drag_begin(Widget* widget, TargetList* targets, Gdk2.DragAction actions, int button, Gdk2.Event* event);
int gtk_drag_check_threshold(Widget* widget, int start_x, int start_y, int current_x, int current_y);
void gtk_drag_dest_add_image_targets(Widget* widget);
void gtk_drag_dest_add_text_targets(Widget* widget);
void gtk_drag_dest_add_uri_targets(Widget* widget);
Gdk2.Atom gtk_drag_dest_find_target(Widget* widget, Gdk2.DragContext* context, TargetList* target_list=null);
TargetList* gtk_drag_dest_get_target_list(Widget* widget);
int gtk_drag_dest_get_track_motion(Widget* widget);
void gtk_drag_dest_set(Widget* widget, DestDefaults flags, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
void gtk_drag_dest_set_proxy(Widget* widget, Gdk2.Window* proxy_window, Gdk2.DragProtocol protocol, int use_coordinates);
void gtk_drag_dest_set_target_list(Widget* widget, TargetList* target_list=null);
void gtk_drag_dest_set_track_motion(Widget* widget, int track_motion);
void gtk_drag_dest_unset(Widget* widget);
void gtk_drag_finish(Gdk2.DragContext* context, int success, int del, uint time_);
void gtk_drag_get_data(Widget* widget, Gdk2.DragContext* context, Gdk2.Atom target, uint time_);
Widget* gtk_drag_get_source_widget(Gdk2.DragContext* context);
void gtk_drag_highlight(Widget* widget);
void gtk_drag_set_default_icon(Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask, int hot_x, int hot_y);
void gtk_drag_set_icon_default(Gdk2.DragContext* context);
void gtk_drag_set_icon_name(Gdk2.DragContext* context, char* icon_name, int hot_x, int hot_y);
void gtk_drag_set_icon_pixbuf(Gdk2.DragContext* context, GdkPixbuf2.Pixbuf* pixbuf, int hot_x, int hot_y);
void gtk_drag_set_icon_pixmap(Gdk2.DragContext* context, Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask, int hot_x, int hot_y);
void gtk_drag_set_icon_stock(Gdk2.DragContext* context, char* stock_id, int hot_x, int hot_y);
void gtk_drag_set_icon_widget(Gdk2.DragContext* context, Widget* widget, int hot_x, int hot_y);
void gtk_drag_source_add_image_targets(Widget* widget);
void gtk_drag_source_add_text_targets(Widget* widget);
void gtk_drag_source_add_uri_targets(Widget* widget);
TargetList* gtk_drag_source_get_target_list(Widget* widget);
void gtk_drag_source_set(Widget* widget, Gdk2.ModifierType start_button_mask, TargetEntry* targets, int n_targets, Gdk2.DragAction actions);
void gtk_drag_source_set_icon(Widget* widget, Gdk2.Colormap* colormap, Gdk2.Pixmap* pixmap, Gdk2.Bitmap* mask=null);
void gtk_drag_source_set_icon_name(Widget* widget, char* icon_name);
void gtk_drag_source_set_icon_pixbuf(Widget* widget, GdkPixbuf2.Pixbuf* pixbuf);
void gtk_drag_source_set_icon_stock(Widget* widget, char* stock_id);
void gtk_drag_source_set_target_list(Widget* widget, TargetList* target_list=null);
void gtk_drag_source_unset(Widget* widget);
void gtk_drag_unhighlight(Widget* widget);
void gtk_draw_arrow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, ArrowType arrow_type, int fill, int x, int y, int width, int height);
void gtk_draw_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_box_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width);
void gtk_draw_check(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_diamond(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_expander(Style* style, Gdk2.Window* window, StateType state_type, int x, int y, ExpanderStyle expander_style);
void gtk_draw_extension(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side);
void gtk_draw_flat_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_focus(Style* style, Gdk2.Window* window, int x, int y, int width, int height);
void gtk_draw_handle(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, Orientation orientation);
void gtk_draw_hline(Style* style, Gdk2.Window* window, StateType state_type, int x1, int x2, int y);
void gtk_draw_insertion_cursor(Widget* widget, Gdk2.Drawable* drawable, Gdk2.Rectangle* area, Gdk2.Rectangle* location, int is_primary, TextDirection direction, int draw_arrow);
void gtk_draw_layout(Style* style, Gdk2.Window* window, StateType state_type, int use_text, int x, int y, Pango.Layout* layout);
void gtk_draw_option(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_polygon(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Point* points, int npoints, int fill);
void gtk_draw_resize_grip(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.WindowEdge edge, int x, int y, int width, int height);
void gtk_draw_shadow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_shadow_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width);
void gtk_draw_slider(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height, Orientation orientation);
void gtk_draw_string(Style* style, Gdk2.Window* window, StateType state_type, int x, int y, char* string_);
void gtk_draw_tab(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, int x, int y, int width, int height);
void gtk_draw_vline(Style* style, Gdk2.Window* window, StateType state_type, int y1_, int y2_, int x);
int gtk_events_pending();
void gtk_exit(int error_code);
int gtk_false();
GLib2.Quark gtk_file_chooser_error_quark();
Gdk2.GC* gtk_gc_get(int depth, Gdk2.Colormap* colormap, Gdk2.GCValues* values, Gdk2.GCValuesMask values_mask);
void gtk_gc_release(Gdk2.GC* gc);
Gdk2.Event* /*new*/ gtk_get_current_event();
int gtk_get_current_event_state(/*out*/ Gdk2.ModifierType* state);
uint gtk_get_current_event_time();
Pango.Language* /*new*/ gtk_get_default_language();
Widget* gtk_get_event_widget(Gdk2.Event* event);
GLib2.OptionGroup* gtk_get_option_group(int open_default_display);
void gtk_grab_add(Widget* widget);
Widget* gtk_grab_get_current();
void gtk_grab_remove(Widget* widget);
int gtk_icon_size_from_name(char* name);
char* gtk_icon_size_get_name(int size);
int gtk_icon_size_lookup(int size, /*out*/ int* width, /*out*/ int* height);
int gtk_icon_size_lookup_for_settings(Settings* settings, int size, /*out*/ int* width, /*out*/ int* height);
int gtk_icon_size_register(char* name, int width, int height);
void gtk_icon_size_register_alias(char* alias_, int target);
GLib2.Quark gtk_icon_theme_error_quark();
Type gtk_identifier_get_type();
uint gtk_idle_add(Function function_, void* data);
uint gtk_idle_add_full(int priority, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy);
uint gtk_idle_add_priority(int priority, Function function_, void* data);
void gtk_idle_remove(uint idle_handler_id);
void gtk_idle_remove_by_data(void* data);
void gtk_init(/*inout*/ int* argc, /*inout*/ char*** argv=null);
void gtk_init_add(Function function_, void* data);
int gtk_init_check(/*inout*/ int* argc, /*inout*/ char*** argv=null);
int gtk_init_with_args(/*inout*/ int* argc, /*inout*/ char*** argv, char* parameter_string, GLib2.OptionEntry* entries, char* translation_domain, GLib2.Error** error);
uint gtk_input_add_full(int source, Gdk2.InputCondition condition, Gdk2.InputFunction function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy);
void gtk_input_remove(uint input_handler_id);
uint gtk_key_snooper_install(KeySnoopFunc snooper, void* func_data);
void gtk_key_snooper_remove(uint snooper_handler_id);
void gtk_main();
void gtk_main_do_event(Gdk2.Event* event);
int gtk_main_iteration();
int gtk_main_iteration_do(int blocking);
uint gtk_main_level();
void gtk_main_quit();
void gtk_marshal_BOOLEAN__POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_BOOLEAN__POINTER_INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_BOOLEAN__VOID(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_ENUM__ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_INT__POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_INT__POINTER_CHAR_CHAR(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__ENUM_FLOAT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__INT_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__INT_INT_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_INT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_POINTER_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_STRING_STRING(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_UINT_ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__POINTER_UINT_UINT(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__STRING_INT_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_marshal_VOID__UINT_STRING(GObject2.Closure* closure, GObject2.Value* return_value, uint n_param_values, GObject2.Value* param_values, void* invocation_hint, void* marshal_data);
void gtk_paint_arrow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, ArrowType arrow_type, int fill, int x, int y, int width, int height);
void gtk_paint_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_box_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width);
void gtk_paint_check(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_diamond(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_expander(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, ExpanderStyle expander_style);
void gtk_paint_extension(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side);
void gtk_paint_flat_box(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_focus(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_handle(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation);
void gtk_paint_hline(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x1, int x2, int y);
void gtk_paint_layout(Style* style, Gdk2.Window* window, StateType state_type, int use_text, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, Pango.Layout* layout);
void gtk_paint_option(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_polygon(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.Point* points, int n_points, int fill);
void gtk_paint_resize_grip(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, Gdk2.WindowEdge edge, int x, int y, int width, int height);
void gtk_paint_shadow(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_shadow_gap(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width);
void gtk_paint_slider(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height, Orientation orientation);
void gtk_paint_spinner(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, uint step, int x, int y, int width, int height);
void gtk_paint_string(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, char* string_);
void gtk_paint_tab(Style* style, Gdk2.Window* window, StateType state_type, ShadowType shadow_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int x, int y, int width, int height);
void gtk_paint_vline(Style* style, Gdk2.Window* window, StateType state_type, Gdk2.Rectangle* area, Widget* widget, char* detail, int y1_, int y2_, int x);
char* gtk_paper_size_get_default();
GLib2.List* /*new*/ gtk_paper_size_get_paper_sizes(int include_custom);
int gtk_parse_args(/*inout*/ int* argc, /*inout*/ char*** argv);
GLib2.Quark gtk_print_error_quark();
PageSetup* /*new*/ gtk_print_run_page_setup_dialog(Window* parent, PageSetup* page_setup, PrintSettings* settings);
void gtk_print_run_page_setup_dialog_async(Window* parent, PageSetup* page_setup, PrintSettings* settings, PageSetupDoneFunc done_cb, void* data);
void gtk_propagate_event(Widget* widget, Gdk2.Event* event);
uint gtk_quit_add(uint main_level, Function function_, void* data);
void gtk_quit_add_destroy(uint main_level, Object* object);
uint gtk_quit_add_full(uint main_level, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy);
void gtk_quit_remove(uint quit_handler_id);
void gtk_quit_remove_by_data(void* data);
void gtk_rc_add_class_style(RcStyle* rc_style, char* pattern);
void gtk_rc_add_default_file(char* filename);
void gtk_rc_add_widget_class_style(RcStyle* rc_style, char* pattern);
void gtk_rc_add_widget_name_style(RcStyle* rc_style, char* pattern);
char* /*new*/ gtk_rc_find_module_in_path(char* module_file);
char* /*new*/ gtk_rc_find_pixmap_in_path(Settings* settings, GLib2.Scanner* scanner, char* pixmap_file);
char** gtk_rc_get_default_files();
char* /*new*/ gtk_rc_get_im_module_file();
char* /*new*/ gtk_rc_get_im_module_path();
char* /*new*/ gtk_rc_get_module_dir();
Style* gtk_rc_get_style(Widget* widget);
Style* gtk_rc_get_style_by_paths(Settings* settings, char* widget_path, char* class_path, Type type);
char* /*new*/ gtk_rc_get_theme_dir();
void gtk_rc_parse(char* filename);
uint gtk_rc_parse_color(GLib2.Scanner* scanner, /*out*/ Gdk2.Color* color);
uint gtk_rc_parse_color_full(GLib2.Scanner* scanner, RcStyle* style, /*out*/ Gdk2.Color* color);
uint gtk_rc_parse_priority(GLib2.Scanner* scanner, PathPriorityType* priority);
uint gtk_rc_parse_state(GLib2.Scanner* scanner, StateType* state);
void gtk_rc_parse_string(char* rc_string);
int gtk_rc_property_parse_border(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value);
int gtk_rc_property_parse_color(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value);
int gtk_rc_property_parse_enum(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value);
int gtk_rc_property_parse_flags(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value);
int gtk_rc_property_parse_requisition(GObject2.ParamSpec* pspec, GLib2.String* gstring, GObject2.Value* property_value);
int gtk_rc_reparse_all();
int gtk_rc_reparse_all_for_settings(Settings* settings, int force_load);
void gtk_rc_reset_styles(Settings* settings);
GLib2.Scanner* gtk_rc_scanner_new();
void gtk_rc_set_default_files(char** filenames);
GLib2.Quark gtk_recent_chooser_error_quark();
GLib2.Quark gtk_recent_manager_error_quark();
void gtk_rgb_to_hsv(double r, double g, double b, /*out*/ double* h, /*out*/ double* s, /*out*/ double* v);
void gtk_selection_add_target(Widget* widget, Gdk2.Atom selection, Gdk2.Atom target, uint info);
void gtk_selection_add_targets(Widget* widget, Gdk2.Atom selection, TargetEntry* targets, uint ntargets);
int gtk_selection_clear(Widget* widget, Gdk2.EventSelection* event);
void gtk_selection_clear_targets(Widget* widget, Gdk2.Atom selection);
int gtk_selection_convert(Widget* widget, Gdk2.Atom selection, Gdk2.Atom target, uint time_);
int gtk_selection_owner_set(Widget* widget, Gdk2.Atom selection, uint time_);
int gtk_selection_owner_set_for_display(Gdk2.Display* display, Widget* widget, Gdk2.Atom selection, uint time_);
void gtk_selection_remove_all(Widget* widget);
char* /*new*/ gtk_set_locale();
void gtk_show_about_dialog(Window* parent, char* first_property_name, ...);
int gtk_show_uri(Gdk2.Screen* screen, char* uri, uint timestamp, GLib2.Error** error);
void gtk_signal_compat_matched(Object* object, GObject2.Callback func, void* data, GObject2.SignalMatchType match, uint action);
c_ulong gtk_signal_connect_full(Object* object, char* name, GObject2.Callback func, CallbackMarshal unsupported, void* data, GLib2.DestroyNotify destroy_func, int object_signal, int after);
void gtk_signal_connect_object_while_alive(Object* object, char* name, GObject2.Callback func, Object* alive_object);
void gtk_signal_connect_while_alive(Object* object, char* name, GObject2.Callback func, void* func_data, Object* alive_object);
void gtk_signal_emit(Object* object, uint signal_id, ...);
void gtk_signal_emit_by_name(Object* object, char* name, ...);
void gtk_signal_emit_stop_by_name(Object* object, char* name);
void gtk_signal_emitv(Object* object, uint signal_id, Arg* args);
void gtk_signal_emitv_by_name(Object* object, char* name, Arg* args);
uint gtk_signal_new(char* name, SignalRunType signal_flags, Type object_type, uint function_offset, GObject2.SignalCMarshaller marshaller, Type return_val, uint n_args, ...);
uint gtk_signal_newv(char* name, SignalRunType signal_flags, Type object_type, uint function_offset, GObject2.SignalCMarshaller marshaller, Type return_val, uint n_args, Type* args);
void gtk_stock_add(StockItem* items, uint n_items);
void gtk_stock_add_static(StockItem* items, uint n_items);
GLib2.SList* /*new*/ gtk_stock_list_ids();
int gtk_stock_lookup(char* stock_id, /*out*/ StockItem* item);
void gtk_stock_set_translate_func(char* domain, TranslateFunc func, void* data, GLib2.DestroyNotify notify);
void gtk_target_table_free(TargetEntry* targets, int n_targets);
TargetEntry* /*new*/ gtk_target_table_new_from_list(TargetList* list, /*out*/ int* n_targets);
int gtk_targets_include_image(Gdk2.Atom* targets, int n_targets, int writable);
int gtk_targets_include_rich_text(Gdk2.Atom* targets, int n_targets, TextBuffer* buffer);
int gtk_targets_include_text(Gdk2.Atom* targets, int n_targets);
int gtk_targets_include_uri(Gdk2.Atom* targets, int n_targets);
Widget* gtk_test_create_simple_window(char* window_title, char* dialog_text);
Widget* gtk_test_create_widget(Type widget_type, char* first_property_name=null, ...);
Widget* gtk_test_display_button_window(char* window_title, char* dialog_text, ...);
Widget* gtk_test_find_label(Widget* widget, char* label_pattern);
Widget* gtk_test_find_sibling(Widget* base_widget, Type widget_type);
Widget* gtk_test_find_widget(Widget* widget, char* label_pattern, Type widget_type);
void gtk_test_init(/*inout*/ int* argcp, /*inout*/ char*** argvp, ...);
Type* gtk_test_list_all_types(/*out*/ uint* n_types);
void gtk_test_register_all_types();
double gtk_test_slider_get_value(Widget* widget);
void gtk_test_slider_set_perc(Widget* widget, double percentage);
int gtk_test_spin_button_click(SpinButton* spinner, uint button, int upwards);
char* /*new*/ gtk_test_text_get(Widget* widget);
void gtk_test_text_set(Widget* widget, char* string_);
int gtk_test_widget_click(Widget* widget, uint button, Gdk2.ModifierType modifiers);
int gtk_test_widget_send_key(Widget* widget, uint keyval, Gdk2.ModifierType modifiers);
void gtk_text_anchored_child_set_layout(Widget* child, TextLayout* layout);
uint gtk_timeout_add(uint interval, Function function_, void* data);
uint gtk_timeout_add_full(uint interval, Function function_, CallbackMarshal marshal, void* data, GLib2.DestroyNotify destroy);
void gtk_timeout_remove(uint timeout_handler_id);
TooltipsData* gtk_tooltips_data_get(Widget* widget);
int gtk_tree_get_row_drag_data(SelectionData* selection_data, /*out*/ TreeModel** tree_model, /*out*/ TreePath** path);
void gtk_tree_row_reference_deleted(GObject2.Object* proxy, TreePath* path);
void gtk_tree_row_reference_inserted(GObject2.Object* proxy, TreePath* path);
void gtk_tree_row_reference_reordered(GObject2.Object* proxy, TreePath* path, TreeIter* iter, int* new_order);
int gtk_tree_set_row_drag_data(SelectionData* selection_data, TreeModel* tree_model, TreePath* path);
int gtk_true();
void* gtk_type_class(Type type);
EnumValue* gtk_type_enum_find_value(Type enum_type, char* value_name);
EnumValue* gtk_type_enum_get_values(Type enum_type);
FlagValue* gtk_type_flags_find_value(Type flags_type, char* value_name);
FlagValue* gtk_type_flags_get_values(Type flags_type);
void gtk_type_init(GObject2.TypeDebugFlags debug_flags);
void* gtk_type_new(Type type);
Type gtk_type_unique(Type parent_type, TypeInfo* gtkinfo);
}