
/* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */

#include "config.h"
#include "gtktypebuiltins.h"
#include "gtkaboutdialog.h"
#include "gtkaccelgroup.h"
#include "gtkaccessible.h"
#include "gtkactionable.h"
#include "gtkactionbar.h"
#include "gtkadjustment.h"
#include "gtkappchooser.h"
#include "gtkappchooserbutton.h"
#include "gtkappchooserdialog.h"
#include "gtkappchooserwidget.h"
#include "gtkapplication.h"
#include "gtkapplicationwindow.h"
#include "gtkaspectframe.h"
#include "gtkassistant.h"
#include "gtkatcontext.h"
#include "gtkbinlayout.h"
#include "gtkbitset.h"
#include "gtkbookmarklist.h"
#include "gtkboolfilter.h"
#include "gtkborder.h"
#include "gtkbox.h"
#include "gtkboxlayout.h"
#include "gtkbuildable.h"
#include "gtkbuilder.h"
#include "gtkbuilderlistitemfactory.h"
#include "gtkbuilderscope.h"
#include "gtkbutton.h"
#include "gtkcalendar.h"
#include "gtkcenterbox.h"
#include "gtkcenterlayout.h"
#include "gtkcellarea.h"
#include "gtkcellareabox.h"
#include "gtkcellareacontext.h"
#include "gtkcelleditable.h"
#include "gtkcelllayout.h"
#include "gtkcellrenderer.h"
#include "gtkcellrendereraccel.h"
#include "gtkcellrenderercombo.h"
#include "gtkcellrendererpixbuf.h"
#include "gtkcellrendererprogress.h"
#include "gtkcellrendererspin.h"
#include "gtkcellrendererspinner.h"
#include "gtkcellrenderertext.h"
#include "gtkcellrenderertoggle.h"
#include "gtkcellview.h"
#include "gtkcheckbutton.h"
#include "gtkcolorbutton.h"
#include "gtkcolorchooser.h"
#include "gtkcolorchooserdialog.h"
#include "gtkcolorchooserwidget.h"
#include "gtkcolorutils.h"
#include "gtkcolumnview.h"
#include "gtkcolumnviewcolumn.h"
#include "gtkcombobox.h"
#include "gtkcomboboxtext.h"
#include "gtkconstraintguide.h"
#include "gtkconstraintlayout.h"
#include "gtkconstraint.h"
#include "gtkcssprovider.h"
#include "gtkcustomfilter.h"
#include "gtkcustomlayout.h"
#include "gtkcustomsorter.h"
#include "gtkdebug.h"
#include "gtkdialog.h"
#include "gtkdirectorylist.h"
#include "gtkdragicon.h"
#include "gtkdragsource.h"
#include "gtkdrawingarea.h"
#include "gtkdropcontrollermotion.h"
#include "gtkdroptarget.h"
#include "gtkdroptargetasync.h"
#include "gtkdropdown.h"
#include "gtkeditable.h"
#include "gtkeditablelabel.h"
#include "gtkemojichooser.h"
#include "gtkentry.h"
#include "gtkentrybuffer.h"
#include "gtkentrycompletion.h"
#include "gtkenums.h"
#include "gtkeventcontroller.h"
#include "gtkeventcontrollerfocus.h"
#include "gtkeventcontrollerkey.h"
#include "gtkeventcontrollerscroll.h"
#include "gtkeventcontrollermotion.h"
#include "gtkeventcontrollerlegacy.h"
#include "gtkexpander.h"
#include "gtkexpression.h"
#include "gtkfilechooser.h"
#include "gtkfilechooserdialog.h"
#include "gtkfilechoosernative.h"
#include "gtkfilechooserwidget.h"
#include "gtkfilefilter.h"
#include "gtkfilter.h"
#include "gtkfilterlistmodel.h"
#include "gtkfixed.h"
#include "gtkfixedlayout.h"
#include "gtkflattenlistmodel.h"
#include "gtkflowbox.h"
#include "gtkfontbutton.h"
#include "gtkfontchooser.h"
#include "gtkfontchooserdialog.h"
#include "gtkfontchooserwidget.h"
#include "gtkframe.h"
#include "gtkgesture.h"
#include "gtkgesturedrag.h"
#include "gtkgesturelongpress.h"
#include "gtkgestureclick.h"
#include "gtkgesturepan.h"
#include "gtkgesturerotate.h"
#include "gtkgesturesingle.h"
#include "gtkgesturestylus.h"
#include "gtkgestureswipe.h"
#include "gtkgesturezoom.h"
#include "gtkglarea.h"
#include "gtkgrid.h"
#include "gtkgridlayout.h"
#include "gtkgridview.h"
#include "gtkheaderbar.h"
#include "gtkicontheme.h"
#include "gtkiconview.h"
#include "gtkimage.h"
#include "gtkimcontext.h"
#include "gtkimcontextsimple.h"
#include "gtkimmodule.h"
#include "gtkimmulticontext.h"
#include "gtkinfobar.h"
#include "gtkinscription.h"
#include "gtklabel.h"
#include "gtklayoutchild.h"
#include "gtklayoutmanager.h"
#include "gtklevelbar.h"
#include "gtklinkbutton.h"
#include "gtklistbase.h"
#include "gtklistbox.h"
#include "gtklistitem.h"
#include "gtklistitemfactory.h"
#include "gtkliststore.h"
#include "gtklistview.h"
#include "gtklockbutton.h"
#include "gtkmain.h"
#include "gtkmaplistmodel.h"
#include "gtkmediacontrols.h"
#include "gtkmediafile.h"
#include "gtkmediastream.h"
#include "gtkmenubutton.h"
#include "gtkmessagedialog.h"
#include "gtkmountoperation.h"
#include "gtkmultifilter.h"
#include "gtkmultiselection.h"
#include "gtkmultisorter.h"
#include "gtknative.h"
#include "gtknativedialog.h"
#include "gtknoselection.h"
#include "gtknotebook.h"
#include "gtknumericsorter.h"
#include "gtkorientable.h"
#include "gtkoverlay.h"
#include "gtkoverlaylayout.h"
#include "gtkpadcontroller.h"
#include "gtkpagesetup.h"
#include "gtkpaned.h"
#include "gtkpapersize.h"
#include "gtkpasswordentry.h"
#include "gtkpasswordentrybuffer.h"
#include "gtkpicture.h"
#include "gtkpopover.h"
#include "gtkpopovermenu.h"
#include "gtkpopovermenubar.h"
#include "gtkprintcontext.h"
#include "gtkprintoperation.h"
#include "gtkprintoperationpreview.h"
#include "gtkprintsettings.h"
#include "gtkprogressbar.h"
#include "gtkrange.h"
#include "gtkrecentmanager.h"
#include "gtkrender.h"
#include "gtkrevealer.h"
#include "gtkroot.h"
#include "gtkscale.h"
#include "gtkscalebutton.h"
#include "gtkscrollable.h"
#include "gtkscrollbar.h"
#include "gtkscrolledwindow.h"
#include "gtksearchbar.h"
#include "gtksearchentry.h"
#include "gtkselectionfiltermodel.h"
#include "gtkselectionmodel.h"
#include "gtkseparator.h"
#include "gtksettings.h"
#include "gtkshortcut.h"
#include "gtkshortcutaction.h"
#include "gtkshortcutcontroller.h"
#include "gtkshortcutlabel.h"
#include "gtkshortcutmanager.h"
#include "gtkshortcutsgroup.h"
#include "gtkshortcutssection.h"
#include "gtkshortcutsshortcut.h"
#include "gtkshortcutswindow.h"
#include "gtkshortcuttrigger.h"
#include "gtkshow.h"
#include "gtksignallistitemfactory.h"
#include "gtksingleselection.h"
#include "gtksizegroup.h"
#include "gtksizerequest.h"
#include "gtkslicelistmodel.h"
#include "gtksnapshot.h"
#include "gtksorter.h"
#include "gtksortlistmodel.h"
#include "gtkspinbutton.h"
#include "gtkspinner.h"
#include "gtkstack.h"
#include "gtkstacksidebar.h"
#include "gtkstackswitcher.h"
#include "gtkstatusbar.h"
#include "gtkstringfilter.h"
#include "gtkstringlist.h"
#include "gtkstringsorter.h"
#include "gtkstylecontext.h"
#include "gtkstyleprovider.h"
#include "gtkswitch.h"
#include "gtksymbolicpaintable.h"
#include "gtktestatcontext.h"
#include "gtktestutils.h"
#include "gtktext.h"
#include "gtktextbuffer.h"
#include "gtktextchild.h"
#include "gtktextiter.h"
#include "gtktextmark.h"
#include "gtktexttag.h"
#include "gtktexttagtable.h"
#include "gtktextview.h"
#include "gtktogglebutton.h"
#include "gtktooltip.h"
#include "gtktreednd.h"
#include "gtktreeexpander.h"
#include "gtktreelistmodel.h"
#include "gtktreelistrowsorter.h"
#include "gtktreemodel.h"
#include "gtktreemodelfilter.h"
#include "gtktreemodelsort.h"
#include "gtktreeselection.h"
#include "gtktreesortable.h"
#include "gtktreestore.h"
#include "gtktreeview.h"
#include "gtktreeviewcolumn.h"
#include "gtktypes.h"
#include "gtkvideo.h"
#include "gtkviewport.h"
#include "gtkvolumebutton.h"
#include "gtkwidget.h"
#include "gtkwidgetpaintable.h"
#include "gtkwindow.h"
#include "gtkwindowcontrols.h"
#include "gtkwindowgroup.h"
#include "gtkwindowhandle.h"
#include "gtk.h"

#define C_ENUM(v) ((gint) v)
#define C_FLAGS(v) ((guint) v)

/* enumerations from "gtkaboutdialog.h" */

GType
gtk_license_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_LICENSE_UNKNOWN), "GTK_LICENSE_UNKNOWN", "unknown" },
    { C_ENUM(GTK_LICENSE_CUSTOM), "GTK_LICENSE_CUSTOM", "custom" },
    { C_ENUM(GTK_LICENSE_GPL_2_0), "GTK_LICENSE_GPL_2_0", "gpl-2-0" },
    { C_ENUM(GTK_LICENSE_GPL_3_0), "GTK_LICENSE_GPL_3_0", "gpl-3-0" },
    { C_ENUM(GTK_LICENSE_LGPL_2_1), "GTK_LICENSE_LGPL_2_1", "lgpl-2-1" },
    { C_ENUM(GTK_LICENSE_LGPL_3_0), "GTK_LICENSE_LGPL_3_0", "lgpl-3-0" },
    { C_ENUM(GTK_LICENSE_BSD), "GTK_LICENSE_BSD", "bsd" },
    { C_ENUM(GTK_LICENSE_MIT_X11), "GTK_LICENSE_MIT_X11", "mit-x11" },
    { C_ENUM(GTK_LICENSE_ARTISTIC), "GTK_LICENSE_ARTISTIC", "artistic" },
    { C_ENUM(GTK_LICENSE_GPL_2_0_ONLY), "GTK_LICENSE_GPL_2_0_ONLY", "gpl-2-0-only" },
    { C_ENUM(GTK_LICENSE_GPL_3_0_ONLY), "GTK_LICENSE_GPL_3_0_ONLY", "gpl-3-0-only" },
    { C_ENUM(GTK_LICENSE_LGPL_2_1_ONLY), "GTK_LICENSE_LGPL_2_1_ONLY", "lgpl-2-1-only" },
    { C_ENUM(GTK_LICENSE_LGPL_3_0_ONLY), "GTK_LICENSE_LGPL_3_0_ONLY", "lgpl-3-0-only" },
    { C_ENUM(GTK_LICENSE_AGPL_3_0), "GTK_LICENSE_AGPL_3_0", "agpl-3-0" },
    { C_ENUM(GTK_LICENSE_AGPL_3_0_ONLY), "GTK_LICENSE_AGPL_3_0_ONLY", "agpl-3-0-only" },
    { C_ENUM(GTK_LICENSE_BSD_3), "GTK_LICENSE_BSD_3", "bsd-3" },
    { C_ENUM(GTK_LICENSE_APACHE_2_0), "GTK_LICENSE_APACHE_2_0", "apache-2-0" },
    { C_ENUM(GTK_LICENSE_MPL_2_0), "GTK_LICENSE_MPL_2_0", "mpl-2-0" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkLicense"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkapplication.h" */

GType
gtk_application_inhibit_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_APPLICATION_INHIBIT_LOGOUT), "GTK_APPLICATION_INHIBIT_LOGOUT", "logout" },
    { C_FLAGS(GTK_APPLICATION_INHIBIT_SWITCH), "GTK_APPLICATION_INHIBIT_SWITCH", "switch" },
    { C_FLAGS(GTK_APPLICATION_INHIBIT_SUSPEND), "GTK_APPLICATION_INHIBIT_SUSPEND", "suspend" },
    { C_FLAGS(GTK_APPLICATION_INHIBIT_IDLE), "GTK_APPLICATION_INHIBIT_IDLE", "idle" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkApplicationInhibitFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkassistant.h" */

GType
gtk_assistant_page_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ASSISTANT_PAGE_CONTENT), "GTK_ASSISTANT_PAGE_CONTENT", "content" },
    { C_ENUM(GTK_ASSISTANT_PAGE_INTRO), "GTK_ASSISTANT_PAGE_INTRO", "intro" },
    { C_ENUM(GTK_ASSISTANT_PAGE_CONFIRM), "GTK_ASSISTANT_PAGE_CONFIRM", "confirm" },
    { C_ENUM(GTK_ASSISTANT_PAGE_SUMMARY), "GTK_ASSISTANT_PAGE_SUMMARY", "summary" },
    { C_ENUM(GTK_ASSISTANT_PAGE_PROGRESS), "GTK_ASSISTANT_PAGE_PROGRESS", "progress" },
    { C_ENUM(GTK_ASSISTANT_PAGE_CUSTOM), "GTK_ASSISTANT_PAGE_CUSTOM", "custom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAssistantPageType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkbuilder.h" */

GType
gtk_builder_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION), "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION", "invalid-type-function" },
    { C_ENUM(GTK_BUILDER_ERROR_UNHANDLED_TAG), "GTK_BUILDER_ERROR_UNHANDLED_TAG", "unhandled-tag" },
    { C_ENUM(GTK_BUILDER_ERROR_MISSING_ATTRIBUTE), "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE", "missing-attribute" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_ATTRIBUTE), "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE", "invalid-attribute" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_TAG), "GTK_BUILDER_ERROR_INVALID_TAG", "invalid-tag" },
    { C_ENUM(GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE), "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE", "missing-property-value" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_VALUE), "GTK_BUILDER_ERROR_INVALID_VALUE", "invalid-value" },
    { C_ENUM(GTK_BUILDER_ERROR_VERSION_MISMATCH), "GTK_BUILDER_ERROR_VERSION_MISMATCH", "version-mismatch" },
    { C_ENUM(GTK_BUILDER_ERROR_DUPLICATE_ID), "GTK_BUILDER_ERROR_DUPLICATE_ID", "duplicate-id" },
    { C_ENUM(GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED), "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED", "object-type-refused" },
    { C_ENUM(GTK_BUILDER_ERROR_TEMPLATE_MISMATCH), "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH", "template-mismatch" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_PROPERTY), "GTK_BUILDER_ERROR_INVALID_PROPERTY", "invalid-property" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_SIGNAL), "GTK_BUILDER_ERROR_INVALID_SIGNAL", "invalid-signal" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_ID), "GTK_BUILDER_ERROR_INVALID_ID", "invalid-id" },
    { C_ENUM(GTK_BUILDER_ERROR_INVALID_FUNCTION), "GTK_BUILDER_ERROR_INVALID_FUNCTION", "invalid-function" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkBuilderError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkbuilderscope.h" */

GType
gtk_builder_closure_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_BUILDER_CLOSURE_SWAPPED), "GTK_BUILDER_CLOSURE_SWAPPED", "swapped" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkBuilderClosureFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkcellrenderer.h" */

GType
gtk_cell_renderer_state_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_CELL_RENDERER_SELECTED), "GTK_CELL_RENDERER_SELECTED", "selected" },
    { C_FLAGS(GTK_CELL_RENDERER_PRELIT), "GTK_CELL_RENDERER_PRELIT", "prelit" },
    { C_FLAGS(GTK_CELL_RENDERER_INSENSITIVE), "GTK_CELL_RENDERER_INSENSITIVE", "insensitive" },
    { C_FLAGS(GTK_CELL_RENDERER_SORTED), "GTK_CELL_RENDERER_SORTED", "sorted" },
    { C_FLAGS(GTK_CELL_RENDERER_FOCUSED), "GTK_CELL_RENDERER_FOCUSED", "focused" },
    { C_FLAGS(GTK_CELL_RENDERER_EXPANDABLE), "GTK_CELL_RENDERER_EXPANDABLE", "expandable" },
    { C_FLAGS(GTK_CELL_RENDERER_EXPANDED), "GTK_CELL_RENDERER_EXPANDED", "expanded" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkCellRendererState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_cell_renderer_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CELL_RENDERER_MODE_INERT), "GTK_CELL_RENDERER_MODE_INERT", "inert" },
    { C_ENUM(GTK_CELL_RENDERER_MODE_ACTIVATABLE), "GTK_CELL_RENDERER_MODE_ACTIVATABLE", "activatable" },
    { C_ENUM(GTK_CELL_RENDERER_MODE_EDITABLE), "GTK_CELL_RENDERER_MODE_EDITABLE", "editable" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkCellRendererMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkcellrendereraccel.h" */

GType
gtk_cell_renderer_accel_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CELL_RENDERER_ACCEL_MODE_GTK), "GTK_CELL_RENDERER_ACCEL_MODE_GTK", "gtk" },
    { C_ENUM(GTK_CELL_RENDERER_ACCEL_MODE_OTHER), "GTK_CELL_RENDERER_ACCEL_MODE_OTHER", "other" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkCellRendererAccelMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkdebug.h" */

GType
gtk_debug_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_DEBUG_TEXT), "GTK_DEBUG_TEXT", "text" },
    { C_FLAGS(GTK_DEBUG_TREE), "GTK_DEBUG_TREE", "tree" },
    { C_FLAGS(GTK_DEBUG_KEYBINDINGS), "GTK_DEBUG_KEYBINDINGS", "keybindings" },
    { C_FLAGS(GTK_DEBUG_MODULES), "GTK_DEBUG_MODULES", "modules" },
    { C_FLAGS(GTK_DEBUG_GEOMETRY), "GTK_DEBUG_GEOMETRY", "geometry" },
    { C_FLAGS(GTK_DEBUG_ICONTHEME), "GTK_DEBUG_ICONTHEME", "icontheme" },
    { C_FLAGS(GTK_DEBUG_PRINTING), "GTK_DEBUG_PRINTING", "printing" },
    { C_FLAGS(GTK_DEBUG_BUILDER), "GTK_DEBUG_BUILDER", "builder" },
    { C_FLAGS(GTK_DEBUG_SIZE_REQUEST), "GTK_DEBUG_SIZE_REQUEST", "size-request" },
    { C_FLAGS(GTK_DEBUG_NO_CSS_CACHE), "GTK_DEBUG_NO_CSS_CACHE", "no-css-cache" },
    { C_FLAGS(GTK_DEBUG_INTERACTIVE), "GTK_DEBUG_INTERACTIVE", "interactive" },
    { C_FLAGS(GTK_DEBUG_TOUCHSCREEN), "GTK_DEBUG_TOUCHSCREEN", "touchscreen" },
    { C_FLAGS(GTK_DEBUG_ACTIONS), "GTK_DEBUG_ACTIONS", "actions" },
    { C_FLAGS(GTK_DEBUG_LAYOUT), "GTK_DEBUG_LAYOUT", "layout" },
    { C_FLAGS(GTK_DEBUG_SNAPSHOT), "GTK_DEBUG_SNAPSHOT", "snapshot" },
    { C_FLAGS(GTK_DEBUG_CONSTRAINTS), "GTK_DEBUG_CONSTRAINTS", "constraints" },
    { C_FLAGS(GTK_DEBUG_BUILDER_OBJECTS), "GTK_DEBUG_BUILDER_OBJECTS", "builder-objects" },
    { C_FLAGS(GTK_DEBUG_A11Y), "GTK_DEBUG_A11Y", "a11y" },
    { C_FLAGS(GTK_DEBUG_ICONFALLBACK), "GTK_DEBUG_ICONFALLBACK", "iconfallback" },
    { C_FLAGS(GTK_DEBUG_INVERT_TEXT_DIR), "GTK_DEBUG_INVERT_TEXT_DIR", "invert-text-dir" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkDebugFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkdialog.h" */

GType
gtk_dialog_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_DIALOG_MODAL), "GTK_DIALOG_MODAL", "modal" },
    { C_FLAGS(GTK_DIALOG_DESTROY_WITH_PARENT), "GTK_DIALOG_DESTROY_WITH_PARENT", "destroy-with-parent" },
    { C_FLAGS(GTK_DIALOG_USE_HEADER_BAR), "GTK_DIALOG_USE_HEADER_BAR", "use-header-bar" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkDialogFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_response_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_RESPONSE_NONE), "GTK_RESPONSE_NONE", "none" },
    { C_ENUM(GTK_RESPONSE_REJECT), "GTK_RESPONSE_REJECT", "reject" },
    { C_ENUM(GTK_RESPONSE_ACCEPT), "GTK_RESPONSE_ACCEPT", "accept" },
    { C_ENUM(GTK_RESPONSE_DELETE_EVENT), "GTK_RESPONSE_DELETE_EVENT", "delete-event" },
    { C_ENUM(GTK_RESPONSE_OK), "GTK_RESPONSE_OK", "ok" },
    { C_ENUM(GTK_RESPONSE_CANCEL), "GTK_RESPONSE_CANCEL", "cancel" },
    { C_ENUM(GTK_RESPONSE_CLOSE), "GTK_RESPONSE_CLOSE", "close" },
    { C_ENUM(GTK_RESPONSE_YES), "GTK_RESPONSE_YES", "yes" },
    { C_ENUM(GTK_RESPONSE_NO), "GTK_RESPONSE_NO", "no" },
    { C_ENUM(GTK_RESPONSE_APPLY), "GTK_RESPONSE_APPLY", "apply" },
    { C_ENUM(GTK_RESPONSE_HELP), "GTK_RESPONSE_HELP", "help" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkResponseType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkeditable.h" */

GType
gtk_editable_properties_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_EDITABLE_PROP_TEXT), "GTK_EDITABLE_PROP_TEXT", "prop-text" },
    { C_ENUM(GTK_EDITABLE_PROP_CURSOR_POSITION), "GTK_EDITABLE_PROP_CURSOR_POSITION", "prop-cursor-position" },
    { C_ENUM(GTK_EDITABLE_PROP_SELECTION_BOUND), "GTK_EDITABLE_PROP_SELECTION_BOUND", "prop-selection-bound" },
    { C_ENUM(GTK_EDITABLE_PROP_EDITABLE), "GTK_EDITABLE_PROP_EDITABLE", "prop-editable" },
    { C_ENUM(GTK_EDITABLE_PROP_WIDTH_CHARS), "GTK_EDITABLE_PROP_WIDTH_CHARS", "prop-width-chars" },
    { C_ENUM(GTK_EDITABLE_PROP_MAX_WIDTH_CHARS), "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS", "prop-max-width-chars" },
    { C_ENUM(GTK_EDITABLE_PROP_XALIGN), "GTK_EDITABLE_PROP_XALIGN", "prop-xalign" },
    { C_ENUM(GTK_EDITABLE_PROP_ENABLE_UNDO), "GTK_EDITABLE_PROP_ENABLE_UNDO", "prop-enable-undo" },
    { C_ENUM(GTK_EDITABLE_NUM_PROPERTIES), "GTK_EDITABLE_NUM_PROPERTIES", "num-properties" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkEditableProperties"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkentry.h" */

GType
gtk_entry_icon_position_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ENTRY_ICON_PRIMARY), "GTK_ENTRY_ICON_PRIMARY", "primary" },
    { C_ENUM(GTK_ENTRY_ICON_SECONDARY), "GTK_ENTRY_ICON_SECONDARY", "secondary" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkEntryIconPosition"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkenums.h" */

GType
gtk_align_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ALIGN_FILL), "GTK_ALIGN_FILL", "fill" },
    { C_ENUM(GTK_ALIGN_START), "GTK_ALIGN_START", "start" },
    { C_ENUM(GTK_ALIGN_END), "GTK_ALIGN_END", "end" },
    { C_ENUM(GTK_ALIGN_CENTER), "GTK_ALIGN_CENTER", "center" },
    { C_ENUM(GTK_ALIGN_BASELINE), "GTK_ALIGN_BASELINE", "baseline" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAlign"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_arrow_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ARROW_UP), "GTK_ARROW_UP", "up" },
    { C_ENUM(GTK_ARROW_DOWN), "GTK_ARROW_DOWN", "down" },
    { C_ENUM(GTK_ARROW_LEFT), "GTK_ARROW_LEFT", "left" },
    { C_ENUM(GTK_ARROW_RIGHT), "GTK_ARROW_RIGHT", "right" },
    { C_ENUM(GTK_ARROW_NONE), "GTK_ARROW_NONE", "none" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkArrowType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_baseline_position_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_BASELINE_POSITION_TOP), "GTK_BASELINE_POSITION_TOP", "top" },
    { C_ENUM(GTK_BASELINE_POSITION_CENTER), "GTK_BASELINE_POSITION_CENTER", "center" },
    { C_ENUM(GTK_BASELINE_POSITION_BOTTOM), "GTK_BASELINE_POSITION_BOTTOM", "bottom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkBaselinePosition"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_content_fit_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CONTENT_FIT_FILL), "GTK_CONTENT_FIT_FILL", "fill" },
    { C_ENUM(GTK_CONTENT_FIT_CONTAIN), "GTK_CONTENT_FIT_CONTAIN", "contain" },
    { C_ENUM(GTK_CONTENT_FIT_COVER), "GTK_CONTENT_FIT_COVER", "cover" },
    { C_ENUM(GTK_CONTENT_FIT_SCALE_DOWN), "GTK_CONTENT_FIT_SCALE_DOWN", "scale-down" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkContentFit"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_delete_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_DELETE_CHARS), "GTK_DELETE_CHARS", "chars" },
    { C_ENUM(GTK_DELETE_WORD_ENDS), "GTK_DELETE_WORD_ENDS", "word-ends" },
    { C_ENUM(GTK_DELETE_WORDS), "GTK_DELETE_WORDS", "words" },
    { C_ENUM(GTK_DELETE_DISPLAY_LINES), "GTK_DELETE_DISPLAY_LINES", "display-lines" },
    { C_ENUM(GTK_DELETE_DISPLAY_LINE_ENDS), "GTK_DELETE_DISPLAY_LINE_ENDS", "display-line-ends" },
    { C_ENUM(GTK_DELETE_PARAGRAPH_ENDS), "GTK_DELETE_PARAGRAPH_ENDS", "paragraph-ends" },
    { C_ENUM(GTK_DELETE_PARAGRAPHS), "GTK_DELETE_PARAGRAPHS", "paragraphs" },
    { C_ENUM(GTK_DELETE_WHITESPACE), "GTK_DELETE_WHITESPACE", "whitespace" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkDeleteType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_direction_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_DIR_TAB_FORWARD), "GTK_DIR_TAB_FORWARD", "tab-forward" },
    { C_ENUM(GTK_DIR_TAB_BACKWARD), "GTK_DIR_TAB_BACKWARD", "tab-backward" },
    { C_ENUM(GTK_DIR_UP), "GTK_DIR_UP", "up" },
    { C_ENUM(GTK_DIR_DOWN), "GTK_DIR_DOWN", "down" },
    { C_ENUM(GTK_DIR_LEFT), "GTK_DIR_LEFT", "left" },
    { C_ENUM(GTK_DIR_RIGHT), "GTK_DIR_RIGHT", "right" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkDirectionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_icon_size_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ICON_SIZE_INHERIT), "GTK_ICON_SIZE_INHERIT", "inherit" },
    { C_ENUM(GTK_ICON_SIZE_NORMAL), "GTK_ICON_SIZE_NORMAL", "normal" },
    { C_ENUM(GTK_ICON_SIZE_LARGE), "GTK_ICON_SIZE_LARGE", "large" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkIconSize"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_sensitivity_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SENSITIVITY_AUTO), "GTK_SENSITIVITY_AUTO", "auto" },
    { C_ENUM(GTK_SENSITIVITY_ON), "GTK_SENSITIVITY_ON", "on" },
    { C_ENUM(GTK_SENSITIVITY_OFF), "GTK_SENSITIVITY_OFF", "off" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSensitivityType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_text_direction_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TEXT_DIR_NONE), "GTK_TEXT_DIR_NONE", "none" },
    { C_ENUM(GTK_TEXT_DIR_LTR), "GTK_TEXT_DIR_LTR", "ltr" },
    { C_ENUM(GTK_TEXT_DIR_RTL), "GTK_TEXT_DIR_RTL", "rtl" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTextDirection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_justification_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_JUSTIFY_LEFT), "GTK_JUSTIFY_LEFT", "left" },
    { C_ENUM(GTK_JUSTIFY_RIGHT), "GTK_JUSTIFY_RIGHT", "right" },
    { C_ENUM(GTK_JUSTIFY_CENTER), "GTK_JUSTIFY_CENTER", "center" },
    { C_ENUM(GTK_JUSTIFY_FILL), "GTK_JUSTIFY_FILL", "fill" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkJustification"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_message_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_MESSAGE_INFO), "GTK_MESSAGE_INFO", "info" },
    { C_ENUM(GTK_MESSAGE_WARNING), "GTK_MESSAGE_WARNING", "warning" },
    { C_ENUM(GTK_MESSAGE_QUESTION), "GTK_MESSAGE_QUESTION", "question" },
    { C_ENUM(GTK_MESSAGE_ERROR), "GTK_MESSAGE_ERROR", "error" },
    { C_ENUM(GTK_MESSAGE_OTHER), "GTK_MESSAGE_OTHER", "other" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkMessageType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_movement_step_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_MOVEMENT_LOGICAL_POSITIONS), "GTK_MOVEMENT_LOGICAL_POSITIONS", "logical-positions" },
    { C_ENUM(GTK_MOVEMENT_VISUAL_POSITIONS), "GTK_MOVEMENT_VISUAL_POSITIONS", "visual-positions" },
    { C_ENUM(GTK_MOVEMENT_WORDS), "GTK_MOVEMENT_WORDS", "words" },
    { C_ENUM(GTK_MOVEMENT_DISPLAY_LINES), "GTK_MOVEMENT_DISPLAY_LINES", "display-lines" },
    { C_ENUM(GTK_MOVEMENT_DISPLAY_LINE_ENDS), "GTK_MOVEMENT_DISPLAY_LINE_ENDS", "display-line-ends" },
    { C_ENUM(GTK_MOVEMENT_PARAGRAPHS), "GTK_MOVEMENT_PARAGRAPHS", "paragraphs" },
    { C_ENUM(GTK_MOVEMENT_PARAGRAPH_ENDS), "GTK_MOVEMENT_PARAGRAPH_ENDS", "paragraph-ends" },
    { C_ENUM(GTK_MOVEMENT_PAGES), "GTK_MOVEMENT_PAGES", "pages" },
    { C_ENUM(GTK_MOVEMENT_BUFFER_ENDS), "GTK_MOVEMENT_BUFFER_ENDS", "buffer-ends" },
    { C_ENUM(GTK_MOVEMENT_HORIZONTAL_PAGES), "GTK_MOVEMENT_HORIZONTAL_PAGES", "horizontal-pages" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkMovementStep"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_natural_wrap_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_NATURAL_WRAP_INHERIT), "GTK_NATURAL_WRAP_INHERIT", "inherit" },
    { C_ENUM(GTK_NATURAL_WRAP_NONE), "GTK_NATURAL_WRAP_NONE", "none" },
    { C_ENUM(GTK_NATURAL_WRAP_WORD), "GTK_NATURAL_WRAP_WORD", "word" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkNaturalWrapMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_scroll_step_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SCROLL_STEPS), "GTK_SCROLL_STEPS", "steps" },
    { C_ENUM(GTK_SCROLL_PAGES), "GTK_SCROLL_PAGES", "pages" },
    { C_ENUM(GTK_SCROLL_ENDS), "GTK_SCROLL_ENDS", "ends" },
    { C_ENUM(GTK_SCROLL_HORIZONTAL_STEPS), "GTK_SCROLL_HORIZONTAL_STEPS", "horizontal-steps" },
    { C_ENUM(GTK_SCROLL_HORIZONTAL_PAGES), "GTK_SCROLL_HORIZONTAL_PAGES", "horizontal-pages" },
    { C_ENUM(GTK_SCROLL_HORIZONTAL_ENDS), "GTK_SCROLL_HORIZONTAL_ENDS", "horizontal-ends" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkScrollStep"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_orientation_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ORIENTATION_HORIZONTAL), "GTK_ORIENTATION_HORIZONTAL", "horizontal" },
    { C_ENUM(GTK_ORIENTATION_VERTICAL), "GTK_ORIENTATION_VERTICAL", "vertical" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkOrientation"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_overflow_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_OVERFLOW_VISIBLE), "GTK_OVERFLOW_VISIBLE", "visible" },
    { C_ENUM(GTK_OVERFLOW_HIDDEN), "GTK_OVERFLOW_HIDDEN", "hidden" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkOverflow"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_pack_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PACK_START), "GTK_PACK_START", "start" },
    { C_ENUM(GTK_PACK_END), "GTK_PACK_END", "end" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPackType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_position_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_POS_LEFT), "GTK_POS_LEFT", "left" },
    { C_ENUM(GTK_POS_RIGHT), "GTK_POS_RIGHT", "right" },
    { C_ENUM(GTK_POS_TOP), "GTK_POS_TOP", "top" },
    { C_ENUM(GTK_POS_BOTTOM), "GTK_POS_BOTTOM", "bottom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPositionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_scroll_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SCROLL_NONE), "GTK_SCROLL_NONE", "none" },
    { C_ENUM(GTK_SCROLL_JUMP), "GTK_SCROLL_JUMP", "jump" },
    { C_ENUM(GTK_SCROLL_STEP_BACKWARD), "GTK_SCROLL_STEP_BACKWARD", "step-backward" },
    { C_ENUM(GTK_SCROLL_STEP_FORWARD), "GTK_SCROLL_STEP_FORWARD", "step-forward" },
    { C_ENUM(GTK_SCROLL_PAGE_BACKWARD), "GTK_SCROLL_PAGE_BACKWARD", "page-backward" },
    { C_ENUM(GTK_SCROLL_PAGE_FORWARD), "GTK_SCROLL_PAGE_FORWARD", "page-forward" },
    { C_ENUM(GTK_SCROLL_STEP_UP), "GTK_SCROLL_STEP_UP", "step-up" },
    { C_ENUM(GTK_SCROLL_STEP_DOWN), "GTK_SCROLL_STEP_DOWN", "step-down" },
    { C_ENUM(GTK_SCROLL_PAGE_UP), "GTK_SCROLL_PAGE_UP", "page-up" },
    { C_ENUM(GTK_SCROLL_PAGE_DOWN), "GTK_SCROLL_PAGE_DOWN", "page-down" },
    { C_ENUM(GTK_SCROLL_STEP_LEFT), "GTK_SCROLL_STEP_LEFT", "step-left" },
    { C_ENUM(GTK_SCROLL_STEP_RIGHT), "GTK_SCROLL_STEP_RIGHT", "step-right" },
    { C_ENUM(GTK_SCROLL_PAGE_LEFT), "GTK_SCROLL_PAGE_LEFT", "page-left" },
    { C_ENUM(GTK_SCROLL_PAGE_RIGHT), "GTK_SCROLL_PAGE_RIGHT", "page-right" },
    { C_ENUM(GTK_SCROLL_START), "GTK_SCROLL_START", "start" },
    { C_ENUM(GTK_SCROLL_END), "GTK_SCROLL_END", "end" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkScrollType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_selection_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SELECTION_NONE), "GTK_SELECTION_NONE", "none" },
    { C_ENUM(GTK_SELECTION_SINGLE), "GTK_SELECTION_SINGLE", "single" },
    { C_ENUM(GTK_SELECTION_BROWSE), "GTK_SELECTION_BROWSE", "browse" },
    { C_ENUM(GTK_SELECTION_MULTIPLE), "GTK_SELECTION_MULTIPLE", "multiple" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSelectionMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_wrap_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_WRAP_NONE), "GTK_WRAP_NONE", "none" },
    { C_ENUM(GTK_WRAP_CHAR), "GTK_WRAP_CHAR", "char" },
    { C_ENUM(GTK_WRAP_WORD), "GTK_WRAP_WORD", "word" },
    { C_ENUM(GTK_WRAP_WORD_CHAR), "GTK_WRAP_WORD_CHAR", "word-char" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkWrapMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_sort_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SORT_ASCENDING), "GTK_SORT_ASCENDING", "ascending" },
    { C_ENUM(GTK_SORT_DESCENDING), "GTK_SORT_DESCENDING", "descending" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSortType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_pages_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_PAGES_ALL), "GTK_PRINT_PAGES_ALL", "all" },
    { C_ENUM(GTK_PRINT_PAGES_CURRENT), "GTK_PRINT_PAGES_CURRENT", "current" },
    { C_ENUM(GTK_PRINT_PAGES_RANGES), "GTK_PRINT_PAGES_RANGES", "ranges" },
    { C_ENUM(GTK_PRINT_PAGES_SELECTION), "GTK_PRINT_PAGES_SELECTION", "selection" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintPages"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_page_set_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PAGE_SET_ALL), "GTK_PAGE_SET_ALL", "all" },
    { C_ENUM(GTK_PAGE_SET_EVEN), "GTK_PAGE_SET_EVEN", "even" },
    { C_ENUM(GTK_PAGE_SET_ODD), "GTK_PAGE_SET_ODD", "odd" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPageSet"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_number_up_layout_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM), "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM", "lrtb" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP), "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP", "lrbt" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM), "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM", "rltb" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP), "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP", "rlbt" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT), "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT", "tblr" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT), "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT", "tbrl" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT), "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT", "btlr" },
    { C_ENUM(GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT), "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT", "btrl" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkNumberUpLayout"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_ordering_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ORDERING_SMALLER), "GTK_ORDERING_SMALLER", "smaller" },
    { C_ENUM(GTK_ORDERING_EQUAL), "GTK_ORDERING_EQUAL", "equal" },
    { C_ENUM(GTK_ORDERING_LARGER), "GTK_ORDERING_LARGER", "larger" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkOrdering"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_page_orientation_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PAGE_ORIENTATION_PORTRAIT), "GTK_PAGE_ORIENTATION_PORTRAIT", "portrait" },
    { C_ENUM(GTK_PAGE_ORIENTATION_LANDSCAPE), "GTK_PAGE_ORIENTATION_LANDSCAPE", "landscape" },
    { C_ENUM(GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT), "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT", "reverse-portrait" },
    { C_ENUM(GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE), "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE", "reverse-landscape" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPageOrientation"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_quality_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_QUALITY_LOW), "GTK_PRINT_QUALITY_LOW", "low" },
    { C_ENUM(GTK_PRINT_QUALITY_NORMAL), "GTK_PRINT_QUALITY_NORMAL", "normal" },
    { C_ENUM(GTK_PRINT_QUALITY_HIGH), "GTK_PRINT_QUALITY_HIGH", "high" },
    { C_ENUM(GTK_PRINT_QUALITY_DRAFT), "GTK_PRINT_QUALITY_DRAFT", "draft" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintQuality"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_duplex_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_DUPLEX_SIMPLEX), "GTK_PRINT_DUPLEX_SIMPLEX", "simplex" },
    { C_ENUM(GTK_PRINT_DUPLEX_HORIZONTAL), "GTK_PRINT_DUPLEX_HORIZONTAL", "horizontal" },
    { C_ENUM(GTK_PRINT_DUPLEX_VERTICAL), "GTK_PRINT_DUPLEX_VERTICAL", "vertical" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintDuplex"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_unit_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_UNIT_NONE), "GTK_UNIT_NONE", "none" },
    { C_ENUM(GTK_UNIT_POINTS), "GTK_UNIT_POINTS", "points" },
    { C_ENUM(GTK_UNIT_INCH), "GTK_UNIT_INCH", "inch" },
    { C_ENUM(GTK_UNIT_MM), "GTK_UNIT_MM", "mm" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkUnit"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_tree_view_grid_lines_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TREE_VIEW_GRID_LINES_NONE), "GTK_TREE_VIEW_GRID_LINES_NONE", "none" },
    { C_ENUM(GTK_TREE_VIEW_GRID_LINES_HORIZONTAL), "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL", "horizontal" },
    { C_ENUM(GTK_TREE_VIEW_GRID_LINES_VERTICAL), "GTK_TREE_VIEW_GRID_LINES_VERTICAL", "vertical" },
    { C_ENUM(GTK_TREE_VIEW_GRID_LINES_BOTH), "GTK_TREE_VIEW_GRID_LINES_BOTH", "both" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTreeViewGridLines"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_size_group_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SIZE_GROUP_NONE), "GTK_SIZE_GROUP_NONE", "none" },
    { C_ENUM(GTK_SIZE_GROUP_HORIZONTAL), "GTK_SIZE_GROUP_HORIZONTAL", "horizontal" },
    { C_ENUM(GTK_SIZE_GROUP_VERTICAL), "GTK_SIZE_GROUP_VERTICAL", "vertical" },
    { C_ENUM(GTK_SIZE_GROUP_BOTH), "GTK_SIZE_GROUP_BOTH", "both" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSizeGroupMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_size_request_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH), "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH", "height-for-width" },
    { C_ENUM(GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT), "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT", "width-for-height" },
    { C_ENUM(GTK_SIZE_REQUEST_CONSTANT_SIZE), "GTK_SIZE_REQUEST_CONSTANT_SIZE", "constant-size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSizeRequestMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_scrollable_policy_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SCROLL_MINIMUM), "GTK_SCROLL_MINIMUM", "minimum" },
    { C_ENUM(GTK_SCROLL_NATURAL), "GTK_SCROLL_NATURAL", "natural" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkScrollablePolicy"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_state_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_STATE_FLAG_NORMAL), "GTK_STATE_FLAG_NORMAL", "normal" },
    { C_FLAGS(GTK_STATE_FLAG_ACTIVE), "GTK_STATE_FLAG_ACTIVE", "active" },
    { C_FLAGS(GTK_STATE_FLAG_PRELIGHT), "GTK_STATE_FLAG_PRELIGHT", "prelight" },
    { C_FLAGS(GTK_STATE_FLAG_SELECTED), "GTK_STATE_FLAG_SELECTED", "selected" },
    { C_FLAGS(GTK_STATE_FLAG_INSENSITIVE), "GTK_STATE_FLAG_INSENSITIVE", "insensitive" },
    { C_FLAGS(GTK_STATE_FLAG_INCONSISTENT), "GTK_STATE_FLAG_INCONSISTENT", "inconsistent" },
    { C_FLAGS(GTK_STATE_FLAG_FOCUSED), "GTK_STATE_FLAG_FOCUSED", "focused" },
    { C_FLAGS(GTK_STATE_FLAG_BACKDROP), "GTK_STATE_FLAG_BACKDROP", "backdrop" },
    { C_FLAGS(GTK_STATE_FLAG_DIR_LTR), "GTK_STATE_FLAG_DIR_LTR", "dir-ltr" },
    { C_FLAGS(GTK_STATE_FLAG_DIR_RTL), "GTK_STATE_FLAG_DIR_RTL", "dir-rtl" },
    { C_FLAGS(GTK_STATE_FLAG_LINK), "GTK_STATE_FLAG_LINK", "link" },
    { C_FLAGS(GTK_STATE_FLAG_VISITED), "GTK_STATE_FLAG_VISITED", "visited" },
    { C_FLAGS(GTK_STATE_FLAG_CHECKED), "GTK_STATE_FLAG_CHECKED", "checked" },
    { C_FLAGS(GTK_STATE_FLAG_DROP_ACTIVE), "GTK_STATE_FLAG_DROP_ACTIVE", "drop-active" },
    { C_FLAGS(GTK_STATE_FLAG_FOCUS_VISIBLE), "GTK_STATE_FLAG_FOCUS_VISIBLE", "focus-visible" },
    { C_FLAGS(GTK_STATE_FLAG_FOCUS_WITHIN), "GTK_STATE_FLAG_FOCUS_WITHIN", "focus-within" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkStateFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_border_style_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_BORDER_STYLE_NONE), "GTK_BORDER_STYLE_NONE", "none" },
    { C_ENUM(GTK_BORDER_STYLE_HIDDEN), "GTK_BORDER_STYLE_HIDDEN", "hidden" },
    { C_ENUM(GTK_BORDER_STYLE_SOLID), "GTK_BORDER_STYLE_SOLID", "solid" },
    { C_ENUM(GTK_BORDER_STYLE_INSET), "GTK_BORDER_STYLE_INSET", "inset" },
    { C_ENUM(GTK_BORDER_STYLE_OUTSET), "GTK_BORDER_STYLE_OUTSET", "outset" },
    { C_ENUM(GTK_BORDER_STYLE_DOTTED), "GTK_BORDER_STYLE_DOTTED", "dotted" },
    { C_ENUM(GTK_BORDER_STYLE_DASHED), "GTK_BORDER_STYLE_DASHED", "dashed" },
    { C_ENUM(GTK_BORDER_STYLE_DOUBLE), "GTK_BORDER_STYLE_DOUBLE", "double" },
    { C_ENUM(GTK_BORDER_STYLE_GROOVE), "GTK_BORDER_STYLE_GROOVE", "groove" },
    { C_ENUM(GTK_BORDER_STYLE_RIDGE), "GTK_BORDER_STYLE_RIDGE", "ridge" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkBorderStyle"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_level_bar_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_LEVEL_BAR_MODE_CONTINUOUS), "GTK_LEVEL_BAR_MODE_CONTINUOUS", "continuous" },
    { C_ENUM(GTK_LEVEL_BAR_MODE_DISCRETE), "GTK_LEVEL_BAR_MODE_DISCRETE", "discrete" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkLevelBarMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_input_purpose_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_INPUT_PURPOSE_FREE_FORM), "GTK_INPUT_PURPOSE_FREE_FORM", "free-form" },
    { C_ENUM(GTK_INPUT_PURPOSE_ALPHA), "GTK_INPUT_PURPOSE_ALPHA", "alpha" },
    { C_ENUM(GTK_INPUT_PURPOSE_DIGITS), "GTK_INPUT_PURPOSE_DIGITS", "digits" },
    { C_ENUM(GTK_INPUT_PURPOSE_NUMBER), "GTK_INPUT_PURPOSE_NUMBER", "number" },
    { C_ENUM(GTK_INPUT_PURPOSE_PHONE), "GTK_INPUT_PURPOSE_PHONE", "phone" },
    { C_ENUM(GTK_INPUT_PURPOSE_URL), "GTK_INPUT_PURPOSE_URL", "url" },
    { C_ENUM(GTK_INPUT_PURPOSE_EMAIL), "GTK_INPUT_PURPOSE_EMAIL", "email" },
    { C_ENUM(GTK_INPUT_PURPOSE_NAME), "GTK_INPUT_PURPOSE_NAME", "name" },
    { C_ENUM(GTK_INPUT_PURPOSE_PASSWORD), "GTK_INPUT_PURPOSE_PASSWORD", "password" },
    { C_ENUM(GTK_INPUT_PURPOSE_PIN), "GTK_INPUT_PURPOSE_PIN", "pin" },
    { C_ENUM(GTK_INPUT_PURPOSE_TERMINAL), "GTK_INPUT_PURPOSE_TERMINAL", "terminal" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkInputPurpose"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_input_hints_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_INPUT_HINT_NONE), "GTK_INPUT_HINT_NONE", "none" },
    { C_FLAGS(GTK_INPUT_HINT_SPELLCHECK), "GTK_INPUT_HINT_SPELLCHECK", "spellcheck" },
    { C_FLAGS(GTK_INPUT_HINT_NO_SPELLCHECK), "GTK_INPUT_HINT_NO_SPELLCHECK", "no-spellcheck" },
    { C_FLAGS(GTK_INPUT_HINT_WORD_COMPLETION), "GTK_INPUT_HINT_WORD_COMPLETION", "word-completion" },
    { C_FLAGS(GTK_INPUT_HINT_LOWERCASE), "GTK_INPUT_HINT_LOWERCASE", "lowercase" },
    { C_FLAGS(GTK_INPUT_HINT_UPPERCASE_CHARS), "GTK_INPUT_HINT_UPPERCASE_CHARS", "uppercase-chars" },
    { C_FLAGS(GTK_INPUT_HINT_UPPERCASE_WORDS), "GTK_INPUT_HINT_UPPERCASE_WORDS", "uppercase-words" },
    { C_FLAGS(GTK_INPUT_HINT_UPPERCASE_SENTENCES), "GTK_INPUT_HINT_UPPERCASE_SENTENCES", "uppercase-sentences" },
    { C_FLAGS(GTK_INPUT_HINT_INHIBIT_OSK), "GTK_INPUT_HINT_INHIBIT_OSK", "inhibit-osk" },
    { C_FLAGS(GTK_INPUT_HINT_VERTICAL_WRITING), "GTK_INPUT_HINT_VERTICAL_WRITING", "vertical-writing" },
    { C_FLAGS(GTK_INPUT_HINT_EMOJI), "GTK_INPUT_HINT_EMOJI", "emoji" },
    { C_FLAGS(GTK_INPUT_HINT_NO_EMOJI), "GTK_INPUT_HINT_NO_EMOJI", "no-emoji" },
    { C_FLAGS(GTK_INPUT_HINT_PRIVATE), "GTK_INPUT_HINT_PRIVATE", "private" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkInputHints"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_propagation_phase_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PHASE_NONE), "GTK_PHASE_NONE", "none" },
    { C_ENUM(GTK_PHASE_CAPTURE), "GTK_PHASE_CAPTURE", "capture" },
    { C_ENUM(GTK_PHASE_BUBBLE), "GTK_PHASE_BUBBLE", "bubble" },
    { C_ENUM(GTK_PHASE_TARGET), "GTK_PHASE_TARGET", "target" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPropagationPhase"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_propagation_limit_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_LIMIT_NONE), "GTK_LIMIT_NONE", "none" },
    { C_ENUM(GTK_LIMIT_SAME_NATIVE), "GTK_LIMIT_SAME_NATIVE", "same-native" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPropagationLimit"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_event_sequence_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_EVENT_SEQUENCE_NONE), "GTK_EVENT_SEQUENCE_NONE", "none" },
    { C_ENUM(GTK_EVENT_SEQUENCE_CLAIMED), "GTK_EVENT_SEQUENCE_CLAIMED", "claimed" },
    { C_ENUM(GTK_EVENT_SEQUENCE_DENIED), "GTK_EVENT_SEQUENCE_DENIED", "denied" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkEventSequenceState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_pan_direction_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PAN_DIRECTION_LEFT), "GTK_PAN_DIRECTION_LEFT", "left" },
    { C_ENUM(GTK_PAN_DIRECTION_RIGHT), "GTK_PAN_DIRECTION_RIGHT", "right" },
    { C_ENUM(GTK_PAN_DIRECTION_UP), "GTK_PAN_DIRECTION_UP", "up" },
    { C_ENUM(GTK_PAN_DIRECTION_DOWN), "GTK_PAN_DIRECTION_DOWN", "down" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPanDirection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_shortcut_scope_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SHORTCUT_SCOPE_LOCAL), "GTK_SHORTCUT_SCOPE_LOCAL", "local" },
    { C_ENUM(GTK_SHORTCUT_SCOPE_MANAGED), "GTK_SHORTCUT_SCOPE_MANAGED", "managed" },
    { C_ENUM(GTK_SHORTCUT_SCOPE_GLOBAL), "GTK_SHORTCUT_SCOPE_GLOBAL", "global" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkShortcutScope"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_pick_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_PICK_DEFAULT), "GTK_PICK_DEFAULT", "default" },
    { C_FLAGS(GTK_PICK_INSENSITIVE), "GTK_PICK_INSENSITIVE", "insensitive" },
    { C_FLAGS(GTK_PICK_NON_TARGETABLE), "GTK_PICK_NON_TARGETABLE", "non-targetable" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkPickFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_constraint_relation_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CONSTRAINT_RELATION_LE), "GTK_CONSTRAINT_RELATION_LE", "le" },
    { C_ENUM(GTK_CONSTRAINT_RELATION_EQ), "GTK_CONSTRAINT_RELATION_EQ", "eq" },
    { C_ENUM(GTK_CONSTRAINT_RELATION_GE), "GTK_CONSTRAINT_RELATION_GE", "ge" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkConstraintRelation"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_constraint_strength_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CONSTRAINT_STRENGTH_REQUIRED), "GTK_CONSTRAINT_STRENGTH_REQUIRED", "required" },
    { C_ENUM(GTK_CONSTRAINT_STRENGTH_STRONG), "GTK_CONSTRAINT_STRENGTH_STRONG", "strong" },
    { C_ENUM(GTK_CONSTRAINT_STRENGTH_MEDIUM), "GTK_CONSTRAINT_STRENGTH_MEDIUM", "medium" },
    { C_ENUM(GTK_CONSTRAINT_STRENGTH_WEAK), "GTK_CONSTRAINT_STRENGTH_WEAK", "weak" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkConstraintStrength"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_constraint_attribute_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_NONE), "GTK_CONSTRAINT_ATTRIBUTE_NONE", "none" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_LEFT), "GTK_CONSTRAINT_ATTRIBUTE_LEFT", "left" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_RIGHT), "GTK_CONSTRAINT_ATTRIBUTE_RIGHT", "right" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_TOP), "GTK_CONSTRAINT_ATTRIBUTE_TOP", "top" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_BOTTOM), "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM", "bottom" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_START), "GTK_CONSTRAINT_ATTRIBUTE_START", "start" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_END), "GTK_CONSTRAINT_ATTRIBUTE_END", "end" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_WIDTH), "GTK_CONSTRAINT_ATTRIBUTE_WIDTH", "width" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_HEIGHT), "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT", "height" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_CENTER_X), "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X", "center-x" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y), "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y", "center-y" },
    { C_ENUM(GTK_CONSTRAINT_ATTRIBUTE_BASELINE), "GTK_CONSTRAINT_ATTRIBUTE_BASELINE", "baseline" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkConstraintAttribute"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_constraint_vfl_parser_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL", "symbol" },
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE", "attribute" },
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW", "view" },
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC", "metric" },
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY", "priority" },
    { C_ENUM(GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION), "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION", "relation" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkConstraintVflParserError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_system_setting_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SYSTEM_SETTING_DPI), "GTK_SYSTEM_SETTING_DPI", "dpi" },
    { C_ENUM(GTK_SYSTEM_SETTING_FONT_NAME), "GTK_SYSTEM_SETTING_FONT_NAME", "font-name" },
    { C_ENUM(GTK_SYSTEM_SETTING_FONT_CONFIG), "GTK_SYSTEM_SETTING_FONT_CONFIG", "font-config" },
    { C_ENUM(GTK_SYSTEM_SETTING_DISPLAY), "GTK_SYSTEM_SETTING_DISPLAY", "display" },
    { C_ENUM(GTK_SYSTEM_SETTING_ICON_THEME), "GTK_SYSTEM_SETTING_ICON_THEME", "icon-theme" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSystemSetting"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_symbolic_color_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SYMBOLIC_COLOR_FOREGROUND), "GTK_SYMBOLIC_COLOR_FOREGROUND", "foreground" },
    { C_ENUM(GTK_SYMBOLIC_COLOR_ERROR), "GTK_SYMBOLIC_COLOR_ERROR", "error" },
    { C_ENUM(GTK_SYMBOLIC_COLOR_WARNING), "GTK_SYMBOLIC_COLOR_WARNING", "warning" },
    { C_ENUM(GTK_SYMBOLIC_COLOR_SUCCESS), "GTK_SYMBOLIC_COLOR_SUCCESS", "success" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSymbolicColor"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_role_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_ROLE_ALERT), "GTK_ACCESSIBLE_ROLE_ALERT", "alert" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_ALERT_DIALOG), "GTK_ACCESSIBLE_ROLE_ALERT_DIALOG", "alert-dialog" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_BANNER), "GTK_ACCESSIBLE_ROLE_BANNER", "banner" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_BUTTON), "GTK_ACCESSIBLE_ROLE_BUTTON", "button" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_CAPTION), "GTK_ACCESSIBLE_ROLE_CAPTION", "caption" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_CELL), "GTK_ACCESSIBLE_ROLE_CELL", "cell" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_CHECKBOX), "GTK_ACCESSIBLE_ROLE_CHECKBOX", "checkbox" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_COLUMN_HEADER), "GTK_ACCESSIBLE_ROLE_COLUMN_HEADER", "column-header" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_COMBO_BOX), "GTK_ACCESSIBLE_ROLE_COMBO_BOX", "combo-box" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_COMMAND), "GTK_ACCESSIBLE_ROLE_COMMAND", "command" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_COMPOSITE), "GTK_ACCESSIBLE_ROLE_COMPOSITE", "composite" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_DIALOG), "GTK_ACCESSIBLE_ROLE_DIALOG", "dialog" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_DOCUMENT), "GTK_ACCESSIBLE_ROLE_DOCUMENT", "document" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_FEED), "GTK_ACCESSIBLE_ROLE_FEED", "feed" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_FORM), "GTK_ACCESSIBLE_ROLE_FORM", "form" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_GENERIC), "GTK_ACCESSIBLE_ROLE_GENERIC", "generic" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_GRID), "GTK_ACCESSIBLE_ROLE_GRID", "grid" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_GRID_CELL), "GTK_ACCESSIBLE_ROLE_GRID_CELL", "grid-cell" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_GROUP), "GTK_ACCESSIBLE_ROLE_GROUP", "group" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_HEADING), "GTK_ACCESSIBLE_ROLE_HEADING", "heading" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_IMG), "GTK_ACCESSIBLE_ROLE_IMG", "img" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_INPUT), "GTK_ACCESSIBLE_ROLE_INPUT", "input" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LABEL), "GTK_ACCESSIBLE_ROLE_LABEL", "label" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LANDMARK), "GTK_ACCESSIBLE_ROLE_LANDMARK", "landmark" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LEGEND), "GTK_ACCESSIBLE_ROLE_LEGEND", "legend" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LINK), "GTK_ACCESSIBLE_ROLE_LINK", "link" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LIST), "GTK_ACCESSIBLE_ROLE_LIST", "list" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LIST_BOX), "GTK_ACCESSIBLE_ROLE_LIST_BOX", "list-box" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LIST_ITEM), "GTK_ACCESSIBLE_ROLE_LIST_ITEM", "list-item" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_LOG), "GTK_ACCESSIBLE_ROLE_LOG", "log" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MAIN), "GTK_ACCESSIBLE_ROLE_MAIN", "main" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MARQUEE), "GTK_ACCESSIBLE_ROLE_MARQUEE", "marquee" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MATH), "GTK_ACCESSIBLE_ROLE_MATH", "math" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_METER), "GTK_ACCESSIBLE_ROLE_METER", "meter" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MENU), "GTK_ACCESSIBLE_ROLE_MENU", "menu" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MENU_BAR), "GTK_ACCESSIBLE_ROLE_MENU_BAR", "menu-bar" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MENU_ITEM), "GTK_ACCESSIBLE_ROLE_MENU_ITEM", "menu-item" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX), "GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX", "menu-item-checkbox" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO), "GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO", "menu-item-radio" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_NAVIGATION), "GTK_ACCESSIBLE_ROLE_NAVIGATION", "navigation" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_NONE), "GTK_ACCESSIBLE_ROLE_NONE", "none" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_NOTE), "GTK_ACCESSIBLE_ROLE_NOTE", "note" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_OPTION), "GTK_ACCESSIBLE_ROLE_OPTION", "option" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_PRESENTATION), "GTK_ACCESSIBLE_ROLE_PRESENTATION", "presentation" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_PROGRESS_BAR), "GTK_ACCESSIBLE_ROLE_PROGRESS_BAR", "progress-bar" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_RADIO), "GTK_ACCESSIBLE_ROLE_RADIO", "radio" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_RADIO_GROUP), "GTK_ACCESSIBLE_ROLE_RADIO_GROUP", "radio-group" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_RANGE), "GTK_ACCESSIBLE_ROLE_RANGE", "range" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_REGION), "GTK_ACCESSIBLE_ROLE_REGION", "region" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_ROW), "GTK_ACCESSIBLE_ROLE_ROW", "row" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_ROW_GROUP), "GTK_ACCESSIBLE_ROLE_ROW_GROUP", "row-group" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_ROW_HEADER), "GTK_ACCESSIBLE_ROLE_ROW_HEADER", "row-header" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SCROLLBAR), "GTK_ACCESSIBLE_ROLE_SCROLLBAR", "scrollbar" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SEARCH), "GTK_ACCESSIBLE_ROLE_SEARCH", "search" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SEARCH_BOX), "GTK_ACCESSIBLE_ROLE_SEARCH_BOX", "search-box" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SECTION), "GTK_ACCESSIBLE_ROLE_SECTION", "section" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SECTION_HEAD), "GTK_ACCESSIBLE_ROLE_SECTION_HEAD", "section-head" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SELECT), "GTK_ACCESSIBLE_ROLE_SELECT", "select" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SEPARATOR), "GTK_ACCESSIBLE_ROLE_SEPARATOR", "separator" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SLIDER), "GTK_ACCESSIBLE_ROLE_SLIDER", "slider" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SPIN_BUTTON), "GTK_ACCESSIBLE_ROLE_SPIN_BUTTON", "spin-button" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_STATUS), "GTK_ACCESSIBLE_ROLE_STATUS", "status" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_STRUCTURE), "GTK_ACCESSIBLE_ROLE_STRUCTURE", "structure" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_SWITCH), "GTK_ACCESSIBLE_ROLE_SWITCH", "switch" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TAB), "GTK_ACCESSIBLE_ROLE_TAB", "tab" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TABLE), "GTK_ACCESSIBLE_ROLE_TABLE", "table" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TAB_LIST), "GTK_ACCESSIBLE_ROLE_TAB_LIST", "tab-list" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TAB_PANEL), "GTK_ACCESSIBLE_ROLE_TAB_PANEL", "tab-panel" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TEXT_BOX), "GTK_ACCESSIBLE_ROLE_TEXT_BOX", "text-box" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TIME), "GTK_ACCESSIBLE_ROLE_TIME", "time" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TIMER), "GTK_ACCESSIBLE_ROLE_TIMER", "timer" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TOOLBAR), "GTK_ACCESSIBLE_ROLE_TOOLBAR", "toolbar" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TOOLTIP), "GTK_ACCESSIBLE_ROLE_TOOLTIP", "tooltip" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TREE), "GTK_ACCESSIBLE_ROLE_TREE", "tree" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TREE_GRID), "GTK_ACCESSIBLE_ROLE_TREE_GRID", "tree-grid" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_TREE_ITEM), "GTK_ACCESSIBLE_ROLE_TREE_ITEM", "tree-item" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_WIDGET), "GTK_ACCESSIBLE_ROLE_WIDGET", "widget" },
    { C_ENUM(GTK_ACCESSIBLE_ROLE_WINDOW), "GTK_ACCESSIBLE_ROLE_WINDOW", "window" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleRole"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_STATE_BUSY), "GTK_ACCESSIBLE_STATE_BUSY", "busy" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_CHECKED), "GTK_ACCESSIBLE_STATE_CHECKED", "checked" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_DISABLED), "GTK_ACCESSIBLE_STATE_DISABLED", "disabled" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_EXPANDED), "GTK_ACCESSIBLE_STATE_EXPANDED", "expanded" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_HIDDEN), "GTK_ACCESSIBLE_STATE_HIDDEN", "hidden" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_INVALID), "GTK_ACCESSIBLE_STATE_INVALID", "invalid" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_PRESSED), "GTK_ACCESSIBLE_STATE_PRESSED", "pressed" },
    { C_ENUM(GTK_ACCESSIBLE_STATE_SELECTED), "GTK_ACCESSIBLE_STATE_SELECTED", "selected" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_property_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE), "GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE", "autocomplete" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_DESCRIPTION), "GTK_ACCESSIBLE_PROPERTY_DESCRIPTION", "description" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_HAS_POPUP), "GTK_ACCESSIBLE_PROPERTY_HAS_POPUP", "has-popup" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS), "GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS", "key-shortcuts" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_LABEL), "GTK_ACCESSIBLE_PROPERTY_LABEL", "label" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_LEVEL), "GTK_ACCESSIBLE_PROPERTY_LEVEL", "level" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_MODAL), "GTK_ACCESSIBLE_PROPERTY_MODAL", "modal" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_MULTI_LINE), "GTK_ACCESSIBLE_PROPERTY_MULTI_LINE", "multi-line" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE), "GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE", "multi-selectable" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_ORIENTATION), "GTK_ACCESSIBLE_PROPERTY_ORIENTATION", "orientation" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER), "GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER", "placeholder" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_READ_ONLY), "GTK_ACCESSIBLE_PROPERTY_READ_ONLY", "read-only" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_REQUIRED), "GTK_ACCESSIBLE_PROPERTY_REQUIRED", "required" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION), "GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION", "role-description" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_SORT), "GTK_ACCESSIBLE_PROPERTY_SORT", "sort" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_VALUE_MAX), "GTK_ACCESSIBLE_PROPERTY_VALUE_MAX", "value-max" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_VALUE_MIN), "GTK_ACCESSIBLE_PROPERTY_VALUE_MIN", "value-min" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_VALUE_NOW), "GTK_ACCESSIBLE_PROPERTY_VALUE_NOW", "value-now" },
    { C_ENUM(GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT), "GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT", "value-text" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleProperty"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_relation_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT), "GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT", "active-descendant" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_COL_COUNT), "GTK_ACCESSIBLE_RELATION_COL_COUNT", "col-count" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_COL_INDEX), "GTK_ACCESSIBLE_RELATION_COL_INDEX", "col-index" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT), "GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT", "col-index-text" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_COL_SPAN), "GTK_ACCESSIBLE_RELATION_COL_SPAN", "col-span" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_CONTROLS), "GTK_ACCESSIBLE_RELATION_CONTROLS", "controls" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_DESCRIBED_BY), "GTK_ACCESSIBLE_RELATION_DESCRIBED_BY", "described-by" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_DETAILS), "GTK_ACCESSIBLE_RELATION_DETAILS", "details" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE), "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE", "error-message" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_FLOW_TO), "GTK_ACCESSIBLE_RELATION_FLOW_TO", "flow-to" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_LABELLED_BY), "GTK_ACCESSIBLE_RELATION_LABELLED_BY", "labelled-by" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_OWNS), "GTK_ACCESSIBLE_RELATION_OWNS", "owns" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_POS_IN_SET), "GTK_ACCESSIBLE_RELATION_POS_IN_SET", "pos-in-set" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ROW_COUNT), "GTK_ACCESSIBLE_RELATION_ROW_COUNT", "row-count" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ROW_INDEX), "GTK_ACCESSIBLE_RELATION_ROW_INDEX", "row-index" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT), "GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT", "row-index-text" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_ROW_SPAN), "GTK_ACCESSIBLE_RELATION_ROW_SPAN", "row-span" },
    { C_ENUM(GTK_ACCESSIBLE_RELATION_SET_SIZE), "GTK_ACCESSIBLE_RELATION_SET_SIZE", "set-size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleRelation"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_tristate_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_TRISTATE_FALSE), "GTK_ACCESSIBLE_TRISTATE_FALSE", "false" },
    { C_ENUM(GTK_ACCESSIBLE_TRISTATE_TRUE), "GTK_ACCESSIBLE_TRISTATE_TRUE", "true" },
    { C_ENUM(GTK_ACCESSIBLE_TRISTATE_MIXED), "GTK_ACCESSIBLE_TRISTATE_MIXED", "mixed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleTristate"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_invalid_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_INVALID_FALSE), "GTK_ACCESSIBLE_INVALID_FALSE", "false" },
    { C_ENUM(GTK_ACCESSIBLE_INVALID_TRUE), "GTK_ACCESSIBLE_INVALID_TRUE", "true" },
    { C_ENUM(GTK_ACCESSIBLE_INVALID_GRAMMAR), "GTK_ACCESSIBLE_INVALID_GRAMMAR", "grammar" },
    { C_ENUM(GTK_ACCESSIBLE_INVALID_SPELLING), "GTK_ACCESSIBLE_INVALID_SPELLING", "spelling" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleInvalidState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_autocomplete_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_AUTOCOMPLETE_NONE), "GTK_ACCESSIBLE_AUTOCOMPLETE_NONE", "none" },
    { C_ENUM(GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE), "GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE", "inline" },
    { C_ENUM(GTK_ACCESSIBLE_AUTOCOMPLETE_LIST), "GTK_ACCESSIBLE_AUTOCOMPLETE_LIST", "list" },
    { C_ENUM(GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH), "GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH", "both" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleAutocomplete"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_accessible_sort_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ACCESSIBLE_SORT_NONE), "GTK_ACCESSIBLE_SORT_NONE", "none" },
    { C_ENUM(GTK_ACCESSIBLE_SORT_ASCENDING), "GTK_ACCESSIBLE_SORT_ASCENDING", "ascending" },
    { C_ENUM(GTK_ACCESSIBLE_SORT_DESCENDING), "GTK_ACCESSIBLE_SORT_DESCENDING", "descending" },
    { C_ENUM(GTK_ACCESSIBLE_SORT_OTHER), "GTK_ACCESSIBLE_SORT_OTHER", "other" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkAccessibleSort"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkeventcontrollerscroll.h" */

GType
gtk_event_controller_scroll_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_NONE), "GTK_EVENT_CONTROLLER_SCROLL_NONE", "none" },
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_VERTICAL), "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL", "vertical" },
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL), "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL", "horizontal" },
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_DISCRETE), "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE", "discrete" },
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_KINETIC), "GTK_EVENT_CONTROLLER_SCROLL_KINETIC", "kinetic" },
    { C_FLAGS(GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES), "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES", "both-axes" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkEventControllerScrollFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkfilechooser.h" */

GType
gtk_file_chooser_action_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_FILE_CHOOSER_ACTION_OPEN), "GTK_FILE_CHOOSER_ACTION_OPEN", "open" },
    { C_ENUM(GTK_FILE_CHOOSER_ACTION_SAVE), "GTK_FILE_CHOOSER_ACTION_SAVE", "save" },
    { C_ENUM(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER), "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER", "select-folder" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkFileChooserAction"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_file_chooser_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_FILE_CHOOSER_ERROR_NONEXISTENT), "GTK_FILE_CHOOSER_ERROR_NONEXISTENT", "nonexistent" },
    { C_ENUM(GTK_FILE_CHOOSER_ERROR_BAD_FILENAME), "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME", "bad-filename" },
    { C_ENUM(GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS), "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS", "already-exists" },
    { C_ENUM(GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME), "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME", "incomplete-hostname" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkFileChooserError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkfilter.h" */

GType
gtk_filter_match_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_FILTER_MATCH_SOME), "GTK_FILTER_MATCH_SOME", "some" },
    { C_ENUM(GTK_FILTER_MATCH_NONE), "GTK_FILTER_MATCH_NONE", "none" },
    { C_ENUM(GTK_FILTER_MATCH_ALL), "GTK_FILTER_MATCH_ALL", "all" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkFilterMatch"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_filter_change_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_FILTER_CHANGE_DIFFERENT), "GTK_FILTER_CHANGE_DIFFERENT", "different" },
    { C_ENUM(GTK_FILTER_CHANGE_LESS_STRICT), "GTK_FILTER_CHANGE_LESS_STRICT", "less-strict" },
    { C_ENUM(GTK_FILTER_CHANGE_MORE_STRICT), "GTK_FILTER_CHANGE_MORE_STRICT", "more-strict" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkFilterChange"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkfontchooser.h" */

GType
gtk_font_chooser_level_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_FONT_CHOOSER_LEVEL_FAMILY), "GTK_FONT_CHOOSER_LEVEL_FAMILY", "family" },
    { C_FLAGS(GTK_FONT_CHOOSER_LEVEL_STYLE), "GTK_FONT_CHOOSER_LEVEL_STYLE", "style" },
    { C_FLAGS(GTK_FONT_CHOOSER_LEVEL_SIZE), "GTK_FONT_CHOOSER_LEVEL_SIZE", "size" },
    { C_FLAGS(GTK_FONT_CHOOSER_LEVEL_VARIATIONS), "GTK_FONT_CHOOSER_LEVEL_VARIATIONS", "variations" },
    { C_FLAGS(GTK_FONT_CHOOSER_LEVEL_FEATURES), "GTK_FONT_CHOOSER_LEVEL_FEATURES", "features" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkFontChooserLevel"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkicontheme.h" */

GType
gtk_icon_lookup_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_ICON_LOOKUP_FORCE_REGULAR), "GTK_ICON_LOOKUP_FORCE_REGULAR", "force-regular" },
    { C_FLAGS(GTK_ICON_LOOKUP_FORCE_SYMBOLIC), "GTK_ICON_LOOKUP_FORCE_SYMBOLIC", "force-symbolic" },
    { C_FLAGS(GTK_ICON_LOOKUP_PRELOAD), "GTK_ICON_LOOKUP_PRELOAD", "preload" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkIconLookupFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_icon_theme_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ICON_THEME_NOT_FOUND), "GTK_ICON_THEME_NOT_FOUND", "not-found" },
    { C_ENUM(GTK_ICON_THEME_FAILED), "GTK_ICON_THEME_FAILED", "failed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkIconThemeError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkiconview.h" */

GType
gtk_icon_view_drop_position_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_ICON_VIEW_NO_DROP), "GTK_ICON_VIEW_NO_DROP", "no-drop" },
    { C_ENUM(GTK_ICON_VIEW_DROP_INTO), "GTK_ICON_VIEW_DROP_INTO", "drop-into" },
    { C_ENUM(GTK_ICON_VIEW_DROP_LEFT), "GTK_ICON_VIEW_DROP_LEFT", "drop-left" },
    { C_ENUM(GTK_ICON_VIEW_DROP_RIGHT), "GTK_ICON_VIEW_DROP_RIGHT", "drop-right" },
    { C_ENUM(GTK_ICON_VIEW_DROP_ABOVE), "GTK_ICON_VIEW_DROP_ABOVE", "drop-above" },
    { C_ENUM(GTK_ICON_VIEW_DROP_BELOW), "GTK_ICON_VIEW_DROP_BELOW", "drop-below" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkIconViewDropPosition"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkimage.h" */

GType
gtk_image_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_IMAGE_EMPTY), "GTK_IMAGE_EMPTY", "empty" },
    { C_ENUM(GTK_IMAGE_ICON_NAME), "GTK_IMAGE_ICON_NAME", "icon-name" },
    { C_ENUM(GTK_IMAGE_GICON), "GTK_IMAGE_GICON", "gicon" },
    { C_ENUM(GTK_IMAGE_PAINTABLE), "GTK_IMAGE_PAINTABLE", "paintable" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkImageType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkinscription.h" */

GType
gtk_inscription_overflow_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_INSCRIPTION_OVERFLOW_CLIP), "GTK_INSCRIPTION_OVERFLOW_CLIP", "clip" },
    { C_ENUM(GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START), "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START", "ellipsize-start" },
    { C_ENUM(GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE), "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE", "ellipsize-middle" },
    { C_ENUM(GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END), "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END", "ellipsize-end" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkInscriptionOverflow"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkmessagedialog.h" */

GType
gtk_buttons_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_BUTTONS_NONE), "GTK_BUTTONS_NONE", "none" },
    { C_ENUM(GTK_BUTTONS_OK), "GTK_BUTTONS_OK", "ok" },
    { C_ENUM(GTK_BUTTONS_CLOSE), "GTK_BUTTONS_CLOSE", "close" },
    { C_ENUM(GTK_BUTTONS_CANCEL), "GTK_BUTTONS_CANCEL", "cancel" },
    { C_ENUM(GTK_BUTTONS_YES_NO), "GTK_BUTTONS_YES_NO", "yes-no" },
    { C_ENUM(GTK_BUTTONS_OK_CANCEL), "GTK_BUTTONS_OK_CANCEL", "ok-cancel" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkButtonsType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtknotebook.h" */

GType
gtk_notebook_tab_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_NOTEBOOK_TAB_FIRST), "GTK_NOTEBOOK_TAB_FIRST", "first" },
    { C_ENUM(GTK_NOTEBOOK_TAB_LAST), "GTK_NOTEBOOK_TAB_LAST", "last" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkNotebookTab"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkpadcontroller.h" */

GType
gtk_pad_action_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PAD_ACTION_BUTTON), "GTK_PAD_ACTION_BUTTON", "button" },
    { C_ENUM(GTK_PAD_ACTION_RING), "GTK_PAD_ACTION_RING", "ring" },
    { C_ENUM(GTK_PAD_ACTION_STRIP), "GTK_PAD_ACTION_STRIP", "strip" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPadActionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkpopovermenu.h" */

GType
gtk_popover_menu_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_POPOVER_MENU_NESTED), "GTK_POPOVER_MENU_NESTED", "nested" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkPopoverMenuFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkprintoperation.h" */

GType
gtk_print_status_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_STATUS_INITIAL), "GTK_PRINT_STATUS_INITIAL", "initial" },
    { C_ENUM(GTK_PRINT_STATUS_PREPARING), "GTK_PRINT_STATUS_PREPARING", "preparing" },
    { C_ENUM(GTK_PRINT_STATUS_GENERATING_DATA), "GTK_PRINT_STATUS_GENERATING_DATA", "generating-data" },
    { C_ENUM(GTK_PRINT_STATUS_SENDING_DATA), "GTK_PRINT_STATUS_SENDING_DATA", "sending-data" },
    { C_ENUM(GTK_PRINT_STATUS_PENDING), "GTK_PRINT_STATUS_PENDING", "pending" },
    { C_ENUM(GTK_PRINT_STATUS_PENDING_ISSUE), "GTK_PRINT_STATUS_PENDING_ISSUE", "pending-issue" },
    { C_ENUM(GTK_PRINT_STATUS_PRINTING), "GTK_PRINT_STATUS_PRINTING", "printing" },
    { C_ENUM(GTK_PRINT_STATUS_FINISHED), "GTK_PRINT_STATUS_FINISHED", "finished" },
    { C_ENUM(GTK_PRINT_STATUS_FINISHED_ABORTED), "GTK_PRINT_STATUS_FINISHED_ABORTED", "finished-aborted" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintStatus"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_operation_result_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_OPERATION_RESULT_ERROR), "GTK_PRINT_OPERATION_RESULT_ERROR", "error" },
    { C_ENUM(GTK_PRINT_OPERATION_RESULT_APPLY), "GTK_PRINT_OPERATION_RESULT_APPLY", "apply" },
    { C_ENUM(GTK_PRINT_OPERATION_RESULT_CANCEL), "GTK_PRINT_OPERATION_RESULT_CANCEL", "cancel" },
    { C_ENUM(GTK_PRINT_OPERATION_RESULT_IN_PROGRESS), "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS", "in-progress" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintOperationResult"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_operation_action_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG), "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG", "print-dialog" },
    { C_ENUM(GTK_PRINT_OPERATION_ACTION_PRINT), "GTK_PRINT_OPERATION_ACTION_PRINT", "print" },
    { C_ENUM(GTK_PRINT_OPERATION_ACTION_PREVIEW), "GTK_PRINT_OPERATION_ACTION_PREVIEW", "preview" },
    { C_ENUM(GTK_PRINT_OPERATION_ACTION_EXPORT), "GTK_PRINT_OPERATION_ACTION_EXPORT", "export" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintOperationAction"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_print_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_PRINT_ERROR_GENERAL), "GTK_PRINT_ERROR_GENERAL", "general" },
    { C_ENUM(GTK_PRINT_ERROR_INTERNAL_ERROR), "GTK_PRINT_ERROR_INTERNAL_ERROR", "internal-error" },
    { C_ENUM(GTK_PRINT_ERROR_NOMEM), "GTK_PRINT_ERROR_NOMEM", "nomem" },
    { C_ENUM(GTK_PRINT_ERROR_INVALID_FILE), "GTK_PRINT_ERROR_INVALID_FILE", "invalid-file" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPrintError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkrecentmanager.h" */

GType
gtk_recent_manager_error_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_NOT_FOUND), "GTK_RECENT_MANAGER_ERROR_NOT_FOUND", "not-found" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_INVALID_URI), "GTK_RECENT_MANAGER_ERROR_INVALID_URI", "invalid-uri" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING), "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING", "invalid-encoding" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED), "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED", "not-registered" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_READ), "GTK_RECENT_MANAGER_ERROR_READ", "read" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_WRITE), "GTK_RECENT_MANAGER_ERROR_WRITE", "write" },
    { C_ENUM(GTK_RECENT_MANAGER_ERROR_UNKNOWN), "GTK_RECENT_MANAGER_ERROR_UNKNOWN", "unknown" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkRecentManagerError"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkrevealer.h" */

GType
gtk_revealer_transition_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_NONE), "GTK_REVEALER_TRANSITION_TYPE_NONE", "none" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_CROSSFADE), "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE", "crossfade" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT), "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT", "slide-right" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT), "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT", "slide-left" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP), "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP", "slide-up" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN), "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN", "slide-down" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT), "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT", "swing-right" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT), "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT", "swing-left" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SWING_UP), "GTK_REVEALER_TRANSITION_TYPE_SWING_UP", "swing-up" },
    { C_ENUM(GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN), "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN", "swing-down" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkRevealerTransitionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkscrolledwindow.h" */

GType
gtk_corner_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_CORNER_TOP_LEFT), "GTK_CORNER_TOP_LEFT", "top-left" },
    { C_ENUM(GTK_CORNER_BOTTOM_LEFT), "GTK_CORNER_BOTTOM_LEFT", "bottom-left" },
    { C_ENUM(GTK_CORNER_TOP_RIGHT), "GTK_CORNER_TOP_RIGHT", "top-right" },
    { C_ENUM(GTK_CORNER_BOTTOM_RIGHT), "GTK_CORNER_BOTTOM_RIGHT", "bottom-right" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkCornerType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_policy_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_POLICY_ALWAYS), "GTK_POLICY_ALWAYS", "always" },
    { C_ENUM(GTK_POLICY_AUTOMATIC), "GTK_POLICY_AUTOMATIC", "automatic" },
    { C_ENUM(GTK_POLICY_NEVER), "GTK_POLICY_NEVER", "never" },
    { C_ENUM(GTK_POLICY_EXTERNAL), "GTK_POLICY_EXTERNAL", "external" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkPolicyType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkshortcutaction.h" */

GType
gtk_shortcut_action_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_SHORTCUT_ACTION_EXCLUSIVE), "GTK_SHORTCUT_ACTION_EXCLUSIVE", "exclusive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkShortcutActionFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkshortcutsshortcut.h" */

GType
gtk_shortcut_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SHORTCUT_ACCELERATOR), "GTK_SHORTCUT_ACCELERATOR", "accelerator" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_PINCH), "GTK_SHORTCUT_GESTURE_PINCH", "gesture-pinch" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_STRETCH), "GTK_SHORTCUT_GESTURE_STRETCH", "gesture-stretch" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE), "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE", "gesture-rotate-clockwise" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE), "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE", "gesture-rotate-counterclockwise" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT), "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT", "gesture-two-finger-swipe-left" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT), "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT", "gesture-two-finger-swipe-right" },
    { C_ENUM(GTK_SHORTCUT_GESTURE), "GTK_SHORTCUT_GESTURE", "gesture" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_SWIPE_LEFT), "GTK_SHORTCUT_GESTURE_SWIPE_LEFT", "gesture-swipe-left" },
    { C_ENUM(GTK_SHORTCUT_GESTURE_SWIPE_RIGHT), "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT", "gesture-swipe-right" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkShortcutType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtksorter.h" */

GType
gtk_sorter_order_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SORTER_ORDER_PARTIAL), "GTK_SORTER_ORDER_PARTIAL", "partial" },
    { C_ENUM(GTK_SORTER_ORDER_NONE), "GTK_SORTER_ORDER_NONE", "none" },
    { C_ENUM(GTK_SORTER_ORDER_TOTAL), "GTK_SORTER_ORDER_TOTAL", "total" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSorterOrder"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_sorter_change_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SORTER_CHANGE_DIFFERENT), "GTK_SORTER_CHANGE_DIFFERENT", "different" },
    { C_ENUM(GTK_SORTER_CHANGE_INVERTED), "GTK_SORTER_CHANGE_INVERTED", "inverted" },
    { C_ENUM(GTK_SORTER_CHANGE_LESS_STRICT), "GTK_SORTER_CHANGE_LESS_STRICT", "less-strict" },
    { C_ENUM(GTK_SORTER_CHANGE_MORE_STRICT), "GTK_SORTER_CHANGE_MORE_STRICT", "more-strict" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSorterChange"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkspinbutton.h" */

GType
gtk_spin_button_update_policy_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_UPDATE_ALWAYS), "GTK_UPDATE_ALWAYS", "always" },
    { C_ENUM(GTK_UPDATE_IF_VALID), "GTK_UPDATE_IF_VALID", "if-valid" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSpinButtonUpdatePolicy"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_spin_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_SPIN_STEP_FORWARD), "GTK_SPIN_STEP_FORWARD", "step-forward" },
    { C_ENUM(GTK_SPIN_STEP_BACKWARD), "GTK_SPIN_STEP_BACKWARD", "step-backward" },
    { C_ENUM(GTK_SPIN_PAGE_FORWARD), "GTK_SPIN_PAGE_FORWARD", "page-forward" },
    { C_ENUM(GTK_SPIN_PAGE_BACKWARD), "GTK_SPIN_PAGE_BACKWARD", "page-backward" },
    { C_ENUM(GTK_SPIN_HOME), "GTK_SPIN_HOME", "home" },
    { C_ENUM(GTK_SPIN_END), "GTK_SPIN_END", "end" },
    { C_ENUM(GTK_SPIN_USER_DEFINED), "GTK_SPIN_USER_DEFINED", "user-defined" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkSpinType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkstack.h" */

GType
gtk_stack_transition_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_NONE), "GTK_STACK_TRANSITION_TYPE_NONE", "none" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_CROSSFADE), "GTK_STACK_TRANSITION_TYPE_CROSSFADE", "crossfade" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT), "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT", "slide-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT), "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT", "slide-left" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_UP), "GTK_STACK_TRANSITION_TYPE_SLIDE_UP", "slide-up" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN), "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN", "slide-down" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT), "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT", "slide-left-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN), "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN", "slide-up-down" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_UP), "GTK_STACK_TRANSITION_TYPE_OVER_UP", "over-up" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_DOWN), "GTK_STACK_TRANSITION_TYPE_OVER_DOWN", "over-down" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_LEFT), "GTK_STACK_TRANSITION_TYPE_OVER_LEFT", "over-left" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_RIGHT), "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT", "over-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_UNDER_UP), "GTK_STACK_TRANSITION_TYPE_UNDER_UP", "under-up" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_UNDER_DOWN), "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN", "under-down" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_UNDER_LEFT), "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT", "under-left" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT), "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT", "under-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN), "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN", "over-up-down" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP), "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP", "over-down-up" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT), "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT", "over-left-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT), "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT", "over-right-left" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT), "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT", "rotate-left" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT), "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT", "rotate-right" },
    { C_ENUM(GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT), "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT", "rotate-left-right" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkStackTransitionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkstringfilter.h" */

GType
gtk_string_filter_match_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_STRING_FILTER_MATCH_MODE_EXACT), "GTK_STRING_FILTER_MATCH_MODE_EXACT", "exact" },
    { C_ENUM(GTK_STRING_FILTER_MATCH_MODE_SUBSTRING), "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING", "substring" },
    { C_ENUM(GTK_STRING_FILTER_MATCH_MODE_PREFIX), "GTK_STRING_FILTER_MATCH_MODE_PREFIX", "prefix" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkStringFilterMatchMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtkstylecontext.h" */

GType
gtk_style_context_print_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_STYLE_CONTEXT_PRINT_NONE), "GTK_STYLE_CONTEXT_PRINT_NONE", "none" },
    { C_FLAGS(GTK_STYLE_CONTEXT_PRINT_RECURSE), "GTK_STYLE_CONTEXT_PRINT_RECURSE", "recurse" },
    { C_FLAGS(GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE), "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE", "show-style" },
    { C_FLAGS(GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE), "GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE", "show-change" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkStyleContextPrintFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtktextiter.h" */

GType
gtk_text_search_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_TEXT_SEARCH_VISIBLE_ONLY), "GTK_TEXT_SEARCH_VISIBLE_ONLY", "visible-only" },
    { C_FLAGS(GTK_TEXT_SEARCH_TEXT_ONLY), "GTK_TEXT_SEARCH_TEXT_ONLY", "text-only" },
    { C_FLAGS(GTK_TEXT_SEARCH_CASE_INSENSITIVE), "GTK_TEXT_SEARCH_CASE_INSENSITIVE", "case-insensitive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkTextSearchFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtktextview.h" */

GType
gtk_text_window_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TEXT_WINDOW_WIDGET), "GTK_TEXT_WINDOW_WIDGET", "widget" },
    { C_ENUM(GTK_TEXT_WINDOW_TEXT), "GTK_TEXT_WINDOW_TEXT", "text" },
    { C_ENUM(GTK_TEXT_WINDOW_LEFT), "GTK_TEXT_WINDOW_LEFT", "left" },
    { C_ENUM(GTK_TEXT_WINDOW_RIGHT), "GTK_TEXT_WINDOW_RIGHT", "right" },
    { C_ENUM(GTK_TEXT_WINDOW_TOP), "GTK_TEXT_WINDOW_TOP", "top" },
    { C_ENUM(GTK_TEXT_WINDOW_BOTTOM), "GTK_TEXT_WINDOW_BOTTOM", "bottom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTextWindowType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_text_view_layer_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TEXT_VIEW_LAYER_BELOW_TEXT), "GTK_TEXT_VIEW_LAYER_BELOW_TEXT", "below-text" },
    { C_ENUM(GTK_TEXT_VIEW_LAYER_ABOVE_TEXT), "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT", "above-text" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTextViewLayer"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gtk_text_extend_selection_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TEXT_EXTEND_SELECTION_WORD), "GTK_TEXT_EXTEND_SELECTION_WORD", "word" },
    { C_ENUM(GTK_TEXT_EXTEND_SELECTION_LINE), "GTK_TEXT_EXTEND_SELECTION_LINE", "line" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTextExtendSelection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtktreemodel.h" */

GType
gtk_tree_model_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTK_TREE_MODEL_ITERS_PERSIST), "GTK_TREE_MODEL_ITERS_PERSIST", "iters-persist" },
    { C_FLAGS(GTK_TREE_MODEL_LIST_ONLY), "GTK_TREE_MODEL_LIST_ONLY", "list-only" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GtkTreeModelFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtktreeview.h" */

GType
gtk_tree_view_drop_position_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TREE_VIEW_DROP_BEFORE), "GTK_TREE_VIEW_DROP_BEFORE", "before" },
    { C_ENUM(GTK_TREE_VIEW_DROP_AFTER), "GTK_TREE_VIEW_DROP_AFTER", "after" },
    { C_ENUM(GTK_TREE_VIEW_DROP_INTO_OR_BEFORE), "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE", "into-or-before" },
    { C_ENUM(GTK_TREE_VIEW_DROP_INTO_OR_AFTER), "GTK_TREE_VIEW_DROP_INTO_OR_AFTER", "into-or-after" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTreeViewDropPosition"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gtktreeviewcolumn.h" */

GType
gtk_tree_view_column_sizing_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTK_TREE_VIEW_COLUMN_GROW_ONLY), "GTK_TREE_VIEW_COLUMN_GROW_ONLY", "grow-only" },
    { C_ENUM(GTK_TREE_VIEW_COLUMN_AUTOSIZE), "GTK_TREE_VIEW_COLUMN_AUTOSIZE", "autosize" },
    { C_ENUM(GTK_TREE_VIEW_COLUMN_FIXED), "GTK_TREE_VIEW_COLUMN_FIXED", "fixed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GtkTreeViewColumnSizing"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* Generated data ends here */

