xref: /dports/x11-toolkits/gtkmm30/gtkmm-3.24.2/gtk/src/gtk_enums.defs

;; From gtkaboutdialog.h

;; Original typedef:
;; typedef enum {
;;   GTK_LICENSE_UNKNOWN,
;;   GTK_LICENSE_CUSTOM,
;;
;;   GTK_LICENSE_GPL_2_0,
;;   GTK_LICENSE_GPL_3_0,
;;
;;   GTK_LICENSE_LGPL_2_1,
;;   GTK_LICENSE_LGPL_3_0,
;;
;;   GTK_LICENSE_BSD,
;;   GTK_LICENSE_MIT_X11,
;;
;;   GTK_LICENSE_ARTISTIC,
;;
;;   GTK_LICENSE_GPL_2_0_ONLY,
;;   GTK_LICENSE_GPL_3_0_ONLY,
;;   GTK_LICENSE_LGPL_2_1_ONLY,
;;   GTK_LICENSE_LGPL_3_0_ONLY,
;;
;;   GTK_LICENSE_AGPL_3_0,
;;   GTK_LICENSE_AGPL_3_0_ONLY
;; } GtkLicense;

(define-enum-extended License
  (in-module "Gtk")
  (c-name "GtkLicense")
  (values
    '("unknown" "GTK_LICENSE_UNKNOWN" "0")
    '("custom" "GTK_LICENSE_CUSTOM" "1")
    '("gpl-2-0" "GTK_LICENSE_GPL_2_0" "2")
    '("gpl-3-0" "GTK_LICENSE_GPL_3_0" "3")
    '("lgpl-2-1" "GTK_LICENSE_LGPL_2_1" "4")
    '("lgpl-3-0" "GTK_LICENSE_LGPL_3_0" "5")
    '("bsd" "GTK_LICENSE_BSD" "6")
    '("mit-x11" "GTK_LICENSE_MIT_X11" "7")
    '("artistic" "GTK_LICENSE_ARTISTIC" "8")
    '("gpl-2-0-only" "GTK_LICENSE_GPL_2_0_ONLY" "9")
    '("gpl-3-0-only" "GTK_LICENSE_GPL_3_0_ONLY" "10")
    '("lgpl-2-1-only" "GTK_LICENSE_LGPL_2_1_ONLY" "11")
    '("lgpl-3-0-only" "GTK_LICENSE_LGPL_3_0_ONLY" "12")
    '("agpl-3-0" "GTK_LICENSE_AGPL_3_0" "13")
    '("agpl-3-0-only" "GTK_LICENSE_AGPL_3_0_ONLY" "14")
  )
)

;; From gtkaccelgroup.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ACCEL_VISIBLE        = 1 << 0,
;;   GTK_ACCEL_LOCKED         = 1 << 1,
;;   GTK_ACCEL_MASK           = 0x07
;; } GtkAccelFlags;

(define-flags-extended AccelFlags
  (in-module "Gtk")
  (c-name "GtkAccelFlags")
  (values
    '("visible" "GTK_ACCEL_VISIBLE" "1 << 0")
    '("locked" "GTK_ACCEL_LOCKED" "1 << 1")
    '("mask" "GTK_ACCEL_MASK" "0x07")
  )
)

;; From gtkapplication.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_APPLICATION_INHIBIT_LOGOUT  = (1 << 0),
;;   GTK_APPLICATION_INHIBIT_SWITCH  = (1 << 1),
;;   GTK_APPLICATION_INHIBIT_SUSPEND = (1 << 2),
;;   GTK_APPLICATION_INHIBIT_IDLE    = (1 << 3)
;; } GtkApplicationInhibitFlags;

(define-flags-extended ApplicationInhibitFlags
  (in-module "Gtk")
  (c-name "GtkApplicationInhibitFlags")
  (values
    '("logout" "GTK_APPLICATION_INHIBIT_LOGOUT" "(1 << 0)")
    '("switch" "GTK_APPLICATION_INHIBIT_SWITCH" "(1 << 1)")
    '("suspend" "GTK_APPLICATION_INHIBIT_SUSPEND" "(1 << 2)")
    '("idle" "GTK_APPLICATION_INHIBIT_IDLE" "(1 << 3)")
  )
)

;; From gtkassistant.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ASSISTANT_PAGE_CONTENT,
;;   GTK_ASSISTANT_PAGE_INTRO,
;;   GTK_ASSISTANT_PAGE_CONFIRM,
;;   GTK_ASSISTANT_PAGE_SUMMARY,
;;   GTK_ASSISTANT_PAGE_PROGRESS,
;;   GTK_ASSISTANT_PAGE_CUSTOM
;; } GtkAssistantPageType;

(define-enum-extended AssistantPageType
  (in-module "Gtk")
  (c-name "GtkAssistantPageType")
  (values
    '("content" "GTK_ASSISTANT_PAGE_CONTENT" "0")
    '("intro" "GTK_ASSISTANT_PAGE_INTRO" "1")
    '("confirm" "GTK_ASSISTANT_PAGE_CONFIRM" "2")
    '("summary" "GTK_ASSISTANT_PAGE_SUMMARY" "3")
    '("progress" "GTK_ASSISTANT_PAGE_PROGRESS" "4")
    '("custom" "GTK_ASSISTANT_PAGE_CUSTOM" "5")
  )
)

;; From gtkbbox.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_BUTTONBOX_SPREAD = 1,
;;   GTK_BUTTONBOX_EDGE,
;;   GTK_BUTTONBOX_START,
;;   GTK_BUTTONBOX_END,
;;   GTK_BUTTONBOX_CENTER,
;;   GTK_BUTTONBOX_EXPAND
;; } GtkButtonBoxStyle;

(define-enum-extended ButtonBoxStyle
  (in-module "Gtk")
  (c-name "GtkButtonBoxStyle")
  (values
    '("spread" "GTK_BUTTONBOX_SPREAD" "1")
    '("edge" "GTK_BUTTONBOX_EDGE" "2")
    '("start" "GTK_BUTTONBOX_START" "3")
    '("end" "GTK_BUTTONBOX_END" "4")
    '("center" "GTK_BUTTONBOX_CENTER" "5")
    '("expand" "GTK_BUTTONBOX_EXPAND" "6")
  )
)

;; From gtkbuilder.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
;;   GTK_BUILDER_ERROR_UNHANDLED_TAG,
;;   GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
;;   GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
;;   GTK_BUILDER_ERROR_INVALID_TAG,
;;   GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
;;   GTK_BUILDER_ERROR_INVALID_VALUE,
;;   GTK_BUILDER_ERROR_VERSION_MISMATCH,
;;   GTK_BUILDER_ERROR_DUPLICATE_ID,
;;   GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
;;   GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
;;   GTK_BUILDER_ERROR_INVALID_PROPERTY,
;;   GTK_BUILDER_ERROR_INVALID_SIGNAL,
;;   GTK_BUILDER_ERROR_INVALID_ID
;; } GtkBuilderError;

(define-enum-extended BuilderError
  (in-module "Gtk")
  (c-name "GtkBuilderError")
  (values
    '("invalid-type-function" "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION" "0")
    '("unhandled-tag" "GTK_BUILDER_ERROR_UNHANDLED_TAG" "1")
    '("missing-attribute" "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE" "2")
    '("invalid-attribute" "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE" "3")
    '("invalid-tag" "GTK_BUILDER_ERROR_INVALID_TAG" "4")
    '("missing-property-value" "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE" "5")
    '("invalid-value" "GTK_BUILDER_ERROR_INVALID_VALUE" "6")
    '("version-mismatch" "GTK_BUILDER_ERROR_VERSION_MISMATCH" "7")
    '("duplicate-id" "GTK_BUILDER_ERROR_DUPLICATE_ID" "8")
    '("object-type-refused" "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED" "9")
    '("template-mismatch" "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH" "10")
    '("invalid-property" "GTK_BUILDER_ERROR_INVALID_PROPERTY" "11")
    '("invalid-signal" "GTK_BUILDER_ERROR_INVALID_SIGNAL" "12")
    '("invalid-id" "GTK_BUILDER_ERROR_INVALID_ID" "13")
  )
)

;; From gtkcalendar.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CALENDAR_SHOW_HEADING		= 1 << 0,
;;   GTK_CALENDAR_SHOW_DAY_NAMES		= 1 << 1,
;;   GTK_CALENDAR_NO_MONTH_CHANGE		= 1 << 2,
;;   GTK_CALENDAR_SHOW_WEEK_NUMBERS	= 1 << 3,
;;   GTK_CALENDAR_SHOW_DETAILS		= 1 << 5
;; } GtkCalendarDisplayOptions;

(define-flags-extended CalendarDisplayOptions
  (in-module "Gtk")
  (c-name "GtkCalendarDisplayOptions")
  (values
    '("show-heading" "GTK_CALENDAR_SHOW_HEADING" "1 << 0")
    '("show-day-names" "GTK_CALENDAR_SHOW_DAY_NAMES" "1 << 1")
    '("no-month-change" "GTK_CALENDAR_NO_MONTH_CHANGE" "1 << 2")
    '("show-week-numbers" "GTK_CALENDAR_SHOW_WEEK_NUMBERS" "1 << 3")
    '("show-details" "GTK_CALENDAR_SHOW_DETAILS" "1 << 5")
  )
)

;; From gtkcellrendereraccel.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CELL_RENDERER_ACCEL_MODE_GTK,
;;   GTK_CELL_RENDERER_ACCEL_MODE_OTHER
;; } GtkCellRendererAccelMode;

(define-enum-extended CellRendererAccelMode
  (in-module "Gtk")
  (c-name "GtkCellRendererAccelMode")
  (values
    '("gtk" "GTK_CELL_RENDERER_ACCEL_MODE_GTK" "0")
    '("other" "GTK_CELL_RENDERER_ACCEL_MODE_OTHER" "1")
  )
)

;; From gtkcellrenderer.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CELL_RENDERER_SELECTED    = 1 << 0,
;;   GTK_CELL_RENDERER_PRELIT      = 1 << 1,
;;   GTK_CELL_RENDERER_INSENSITIVE = 1 << 2,
;;   /* this flag means the cell is in the sort column/row */
;;   GTK_CELL_RENDERER_SORTED      = 1 << 3,
;;   GTK_CELL_RENDERER_FOCUSED     = 1 << 4,
;;   GTK_CELL_RENDERER_EXPANDABLE  = 1 << 5,
;;   GTK_CELL_RENDERER_EXPANDED    = 1 << 6
;; } GtkCellRendererState;

(define-flags-extended CellRendererState
  (in-module "Gtk")
  (c-name "GtkCellRendererState")
  (values
    '("selected" "GTK_CELL_RENDERER_SELECTED" "1 << 0")
    '("prelit" "GTK_CELL_RENDERER_PRELIT" "1 << 1")
    '("insensitive" "GTK_CELL_RENDERER_INSENSITIVE" "1 << 2")
    '("sorted" "GTK_CELL_RENDERER_SORTED" "1 << 3")
    '("focused" "GTK_CELL_RENDERER_FOCUSED" "1 << 4")
    '("expandable" "GTK_CELL_RENDERER_EXPANDABLE" "1 << 5")
    '("expanded" "GTK_CELL_RENDERER_EXPANDED" "1 << 6")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CELL_RENDERER_MODE_INERT,
;;   GTK_CELL_RENDERER_MODE_ACTIVATABLE,
;;   GTK_CELL_RENDERER_MODE_EDITABLE
;; } GtkCellRendererMode;

(define-enum-extended CellRendererMode
  (in-module "Gtk")
  (c-name "GtkCellRendererMode")
  (values
    '("inert" "GTK_CELL_RENDERER_MODE_INERT" "0")
    '("activatable" "GTK_CELL_RENDERER_MODE_ACTIVATABLE" "1")
    '("editable" "GTK_CELL_RENDERER_MODE_EDITABLE" "2")
  )
)

;; From gtkcontainer.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RESIZE_PARENT,
;;   GTK_RESIZE_QUEUE,
;;   GTK_RESIZE_IMMEDIATE
;; } GtkResizeMode;

(define-enum-extended ResizeMode
  (in-module "Gtk")
  (c-name "GtkResizeMode")
  (values
    '("parent" "GTK_RESIZE_PARENT" "0")
    '("queue" "GTK_RESIZE_QUEUE" "1")
    '("immediate" "GTK_RESIZE_IMMEDIATE" "2")
  )
)

;; From gtkcssprovider.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CSS_PROVIDER_ERROR_FAILED,
;;   GTK_CSS_PROVIDER_ERROR_SYNTAX,
;;   GTK_CSS_PROVIDER_ERROR_IMPORT,
;;   GTK_CSS_PROVIDER_ERROR_NAME,
;;   GTK_CSS_PROVIDER_ERROR_DEPRECATED,
;;   GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE
;; } GtkCssProviderError;

(define-enum-extended CssProviderError
  (in-module "Gtk")
  (c-name "GtkCssProviderError")
  (values
    '("failed" "GTK_CSS_PROVIDER_ERROR_FAILED" "0")
    '("syntax" "GTK_CSS_PROVIDER_ERROR_SYNTAX" "1")
    '("import" "GTK_CSS_PROVIDER_ERROR_IMPORT" "2")
    '("name" "GTK_CSS_PROVIDER_ERROR_NAME" "3")
    '("deprecated" "GTK_CSS_PROVIDER_ERROR_DEPRECATED" "4")
    '("unknown-value" "GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE" "5")
  )
)

;; From gtkcsssection.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CSS_SECTION_DOCUMENT,
;;   GTK_CSS_SECTION_IMPORT,
;;   GTK_CSS_SECTION_COLOR_DEFINITION,
;;   GTK_CSS_SECTION_BINDING_SET,
;;   GTK_CSS_SECTION_RULESET,
;;   GTK_CSS_SECTION_SELECTOR,
;;   GTK_CSS_SECTION_DECLARATION,
;;   GTK_CSS_SECTION_VALUE,
;;   GTK_CSS_SECTION_KEYFRAMES
;; } GtkCssSectionType;

(define-enum-extended CssSectionType
  (in-module "Gtk")
  (c-name "GtkCssSectionType")
  (values
    '("document" "GTK_CSS_SECTION_DOCUMENT" "0")
    '("import" "GTK_CSS_SECTION_IMPORT" "1")
    '("color-definition" "GTK_CSS_SECTION_COLOR_DEFINITION" "2")
    '("binding-set" "GTK_CSS_SECTION_BINDING_SET" "3")
    '("ruleset" "GTK_CSS_SECTION_RULESET" "4")
    '("selector" "GTK_CSS_SECTION_SELECTOR" "5")
    '("declaration" "GTK_CSS_SECTION_DECLARATION" "6")
    '("value" "GTK_CSS_SECTION_VALUE" "7")
    '("keyframes" "GTK_CSS_SECTION_KEYFRAMES" "8")
  )
)

;; From gtkdebug.h

;; Original typedef:
;; typedef enum {
;;   GTK_DEBUG_MISC            = 1 << 0,
;;   GTK_DEBUG_PLUGSOCKET      = 1 << 1,
;;   GTK_DEBUG_TEXT            = 1 << 2,
;;   GTK_DEBUG_TREE            = 1 << 3,
;;   GTK_DEBUG_UPDATES         = 1 << 4,
;;   GTK_DEBUG_KEYBINDINGS     = 1 << 5,
;;   GTK_DEBUG_MULTIHEAD       = 1 << 6,
;;   GTK_DEBUG_MODULES         = 1 << 7,
;;   GTK_DEBUG_GEOMETRY        = 1 << 8,
;;   GTK_DEBUG_ICONTHEME       = 1 << 9,
;;   GTK_DEBUG_PRINTING        = 1 << 10,
;;   GTK_DEBUG_BUILDER         = 1 << 11,
;;   GTK_DEBUG_SIZE_REQUEST    = 1 << 12,
;;   GTK_DEBUG_NO_CSS_CACHE    = 1 << 13,
;;   GTK_DEBUG_BASELINES       = 1 << 14,
;;   GTK_DEBUG_PIXEL_CACHE     = 1 << 15,
;;   GTK_DEBUG_NO_PIXEL_CACHE  = 1 << 16,
;;   GTK_DEBUG_INTERACTIVE     = 1 << 17,
;;   GTK_DEBUG_TOUCHSCREEN     = 1 << 18,
;;   GTK_DEBUG_ACTIONS         = 1 << 19,
;;   GTK_DEBUG_RESIZE          = 1 << 20,
;;   GTK_DEBUG_LAYOUT          = 1 << 21
;; } GtkDebugFlag;

(define-flags-extended DebugFlag
  (in-module "Gtk")
  (c-name "GtkDebugFlag")
  (values
    '("misc" "GTK_DEBUG_MISC" "1 << 0")
    '("plugsocket" "GTK_DEBUG_PLUGSOCKET" "1 << 1")
    '("text" "GTK_DEBUG_TEXT" "1 << 2")
    '("tree" "GTK_DEBUG_TREE" "1 << 3")
    '("updates" "GTK_DEBUG_UPDATES" "1 << 4")
    '("keybindings" "GTK_DEBUG_KEYBINDINGS" "1 << 5")
    '("multihead" "GTK_DEBUG_MULTIHEAD" "1 << 6")
    '("modules" "GTK_DEBUG_MODULES" "1 << 7")
    '("geometry" "GTK_DEBUG_GEOMETRY" "1 << 8")
    '("icontheme" "GTK_DEBUG_ICONTHEME" "1 << 9")
    '("printing" "GTK_DEBUG_PRINTING" "1 << 10")
    '("builder" "GTK_DEBUG_BUILDER" "1 << 11")
    '("size-request" "GTK_DEBUG_SIZE_REQUEST" "1 << 12")
    '("no-css-cache" "GTK_DEBUG_NO_CSS_CACHE" "1 << 13")
    '("baselines" "GTK_DEBUG_BASELINES" "1 << 14")
    '("pixel-cache" "GTK_DEBUG_PIXEL_CACHE" "1 << 15")
    '("no-pixel-cache" "GTK_DEBUG_NO_PIXEL_CACHE" "1 << 16")
    '("interactive" "GTK_DEBUG_INTERACTIVE" "1 << 17")
    '("touchscreen" "GTK_DEBUG_TOUCHSCREEN" "1 << 18")
    '("actions" "GTK_DEBUG_ACTIONS" "1 << 19")
    '("resize" "GTK_DEBUG_RESIZE" "1 << 20")
    '("layout" "GTK_DEBUG_LAYOUT" "1 << 21")
  )
)

;; From gtkdialog.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_DIALOG_MODAL               = 1 << 0,
;;   GTK_DIALOG_DESTROY_WITH_PARENT = 1 << 1,
;;   GTK_DIALOG_USE_HEADER_BAR      = 1 << 2
;; } GtkDialogFlags;

(define-flags-extended DialogFlags
  (in-module "Gtk")
  (c-name "GtkDialogFlags")
  (values
    '("modal" "GTK_DIALOG_MODAL" "1 << 0")
    '("destroy-with-parent" "GTK_DIALOG_DESTROY_WITH_PARENT" "1 << 1")
    '("use-header-bar" "GTK_DIALOG_USE_HEADER_BAR" "1 << 2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RESPONSE_NONE         = -1,
;;   GTK_RESPONSE_REJECT       = -2,
;;   GTK_RESPONSE_ACCEPT       = -3,
;;   GTK_RESPONSE_DELETE_EVENT = -4,
;;   GTK_RESPONSE_OK           = -5,
;;   GTK_RESPONSE_CANCEL       = -6,
;;   GTK_RESPONSE_CLOSE        = -7,
;;   GTK_RESPONSE_YES          = -8,
;;   GTK_RESPONSE_NO           = -9,
;;   GTK_RESPONSE_APPLY        = -10,
;;   GTK_RESPONSE_HELP         = -11
;; } GtkResponseType;

(define-enum-extended ResponseType
  (in-module "Gtk")
  (c-name "GtkResponseType")
  (values
    '("none" "GTK_RESPONSE_NONE" "-1")
    '("reject" "GTK_RESPONSE_REJECT" "-2")
    '("accept" "GTK_RESPONSE_ACCEPT" "-3")
    '("delete-event" "GTK_RESPONSE_DELETE_EVENT" "-4")
    '("ok" "GTK_RESPONSE_OK" "-5")
    '("cancel" "GTK_RESPONSE_CANCEL" "-6")
    '("close" "GTK_RESPONSE_CLOSE" "-7")
    '("yes" "GTK_RESPONSE_YES" "-8")
    '("no" "GTK_RESPONSE_NO" "-9")
    '("apply" "GTK_RESPONSE_APPLY" "-10")
    '("help" "GTK_RESPONSE_HELP" "-11")
  )
)

;; From gtkdragdest.h

;; Original typedef:
;; typedef enum {
;;   GTK_DEST_DEFAULT_MOTION     = 1 << 0,
;;   GTK_DEST_DEFAULT_HIGHLIGHT  = 1 << 1,
;;   GTK_DEST_DEFAULT_DROP       = 1 << 2,
;;   GTK_DEST_DEFAULT_ALL        = 0x07
;; } GtkDestDefaults;

(define-flags-extended DestDefaults
  (in-module "Gtk")
  (c-name "GtkDestDefaults")
  (values
    '("motion" "GTK_DEST_DEFAULT_MOTION" "1 << 0")
    '("highlight" "GTK_DEST_DEFAULT_HIGHLIGHT" "1 << 1")
    '("drop" "GTK_DEST_DEFAULT_DROP" "1 << 2")
    '("all" "GTK_DEST_DEFAULT_ALL" "0x07")
  )
)

;; From gtkentry.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ENTRY_ICON_PRIMARY,
;;   GTK_ENTRY_ICON_SECONDARY
;; } GtkEntryIconPosition;

(define-enum-extended EntryIconPosition
  (in-module "Gtk")
  (c-name "GtkEntryIconPosition")
  (values
    '("primary" "GTK_ENTRY_ICON_PRIMARY" "0")
    '("secondary" "GTK_ENTRY_ICON_SECONDARY" "1")
  )
)

;; From gtkenums.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ALIGN_FILL,
;;   GTK_ALIGN_START,
;;   GTK_ALIGN_END,
;;   GTK_ALIGN_CENTER,
;;   GTK_ALIGN_BASELINE
;; } GtkAlign;

(define-enum-extended Align
  (in-module "Gtk")
  (c-name "GtkAlign")
  (values
    '("fill" "GTK_ALIGN_FILL" "0")
    '("start" "GTK_ALIGN_START" "1")
    '("end" "GTK_ALIGN_END" "2")
    '("center" "GTK_ALIGN_CENTER" "3")
    '("baseline" "GTK_ALIGN_BASELINE" "4")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ARROW_UP,
;;   GTK_ARROW_DOWN,
;;   GTK_ARROW_LEFT,
;;   GTK_ARROW_RIGHT,
;;   GTK_ARROW_NONE
;; } GtkArrowType;

(define-enum-extended ArrowType
  (in-module "Gtk")
  (c-name "GtkArrowType")
  (values
    '("up" "GTK_ARROW_UP" "0")
    '("down" "GTK_ARROW_DOWN" "1")
    '("left" "GTK_ARROW_LEFT" "2")
    '("right" "GTK_ARROW_RIGHT" "3")
    '("none" "GTK_ARROW_NONE" "4")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_BASELINE_POSITION_TOP,
;;   GTK_BASELINE_POSITION_CENTER,
;;   GTK_BASELINE_POSITION_BOTTOM
;; } GtkBaselinePosition;

(define-enum-extended BaselinePosition
  (in-module "Gtk")
  (c-name "GtkBaselinePosition")
  (values
    '("top" "GTK_BASELINE_POSITION_TOP" "0")
    '("center" "GTK_BASELINE_POSITION_CENTER" "1")
    '("bottom" "GTK_BASELINE_POSITION_BOTTOM" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_DELETE_CHARS,
;;   GTK_DELETE_WORD_ENDS,
;;   GTK_DELETE_WORDS,
;;   GTK_DELETE_DISPLAY_LINES,
;;   GTK_DELETE_DISPLAY_LINE_ENDS,
;;   GTK_DELETE_PARAGRAPH_ENDS,
;;   GTK_DELETE_PARAGRAPHS,
;;   GTK_DELETE_WHITESPACE
;; } GtkDeleteType;

(define-enum-extended DeleteType
  (in-module "Gtk")
  (c-name "GtkDeleteType")
  (values
    '("chars" "GTK_DELETE_CHARS" "0")
    '("word-ends" "GTK_DELETE_WORD_ENDS" "1")
    '("words" "GTK_DELETE_WORDS" "2")
    '("display-lines" "GTK_DELETE_DISPLAY_LINES" "3")
    '("display-line-ends" "GTK_DELETE_DISPLAY_LINE_ENDS" "4")
    '("paragraph-ends" "GTK_DELETE_PARAGRAPH_ENDS" "5")
    '("paragraphs" "GTK_DELETE_PARAGRAPHS" "6")
    '("whitespace" "GTK_DELETE_WHITESPACE" "7")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_DIR_TAB_FORWARD,
;;   GTK_DIR_TAB_BACKWARD,
;;   GTK_DIR_UP,
;;   GTK_DIR_DOWN,
;;   GTK_DIR_LEFT,
;;   GTK_DIR_RIGHT
;; } GtkDirectionType;

(define-enum-extended DirectionType
  (in-module "Gtk")
  (c-name "GtkDirectionType")
  (values
    '("tab-forward" "GTK_DIR_TAB_FORWARD" "0")
    '("tab-backward" "GTK_DIR_TAB_BACKWARD" "1")
    '("up" "GTK_DIR_UP" "2")
    '("down" "GTK_DIR_DOWN" "3")
    '("left" "GTK_DIR_LEFT" "4")
    '("right" "GTK_DIR_RIGHT" "5")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ICON_SIZE_INVALID,
;;   GTK_ICON_SIZE_MENU,
;;   GTK_ICON_SIZE_SMALL_TOOLBAR,
;;   GTK_ICON_SIZE_LARGE_TOOLBAR,
;;   GTK_ICON_SIZE_BUTTON,
;;   GTK_ICON_SIZE_DND,
;;   GTK_ICON_SIZE_DIALOG
;; } GtkIconSize;

(define-enum-extended IconSize
  (in-module "Gtk")
  (c-name "GtkIconSize")
  (values
    '("invalid" "GTK_ICON_SIZE_INVALID" "0")
    '("menu" "GTK_ICON_SIZE_MENU" "1")
    '("small-toolbar" "GTK_ICON_SIZE_SMALL_TOOLBAR" "2")
    '("large-toolbar" "GTK_ICON_SIZE_LARGE_TOOLBAR" "3")
    '("button" "GTK_ICON_SIZE_BUTTON" "4")
    '("dnd" "GTK_ICON_SIZE_DND" "5")
    '("dialog" "GTK_ICON_SIZE_DIALOG" "6")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SENSITIVITY_AUTO,
;;   GTK_SENSITIVITY_ON,
;;   GTK_SENSITIVITY_OFF
;; } GtkSensitivityType;

(define-enum-extended SensitivityType
  (in-module "Gtk")
  (c-name "GtkSensitivityType")
  (values
    '("auto" "GTK_SENSITIVITY_AUTO" "0")
    '("on" "GTK_SENSITIVITY_ON" "1")
    '("off" "GTK_SENSITIVITY_OFF" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TEXT_DIR_NONE,
;;   GTK_TEXT_DIR_LTR,
;;   GTK_TEXT_DIR_RTL
;; } GtkTextDirection;

(define-enum-extended TextDirection
  (in-module "Gtk")
  (c-name "GtkTextDirection")
  (values
    '("none" "GTK_TEXT_DIR_NONE" "0")
    '("ltr" "GTK_TEXT_DIR_LTR" "1")
    '("rtl" "GTK_TEXT_DIR_RTL" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_JUSTIFY_LEFT,
;;   GTK_JUSTIFY_RIGHT,
;;   GTK_JUSTIFY_CENTER,
;;   GTK_JUSTIFY_FILL
;; } GtkJustification;

(define-enum-extended Justification
  (in-module "Gtk")
  (c-name "GtkJustification")
  (values
    '("left" "GTK_JUSTIFY_LEFT" "0")
    '("right" "GTK_JUSTIFY_RIGHT" "1")
    '("center" "GTK_JUSTIFY_CENTER" "2")
    '("fill" "GTK_JUSTIFY_FILL" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_MENU_DIR_PARENT,
;;   GTK_MENU_DIR_CHILD,
;;   GTK_MENU_DIR_NEXT,
;;   GTK_MENU_DIR_PREV
;; } GtkMenuDirectionType;

(define-enum-extended MenuDirectionType
  (in-module "Gtk")
  (c-name "GtkMenuDirectionType")
  (values
    '("parent" "GTK_MENU_DIR_PARENT" "0")
    '("child" "GTK_MENU_DIR_CHILD" "1")
    '("next" "GTK_MENU_DIR_NEXT" "2")
    '("prev" "GTK_MENU_DIR_PREV" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_MESSAGE_INFO,
;;   GTK_MESSAGE_WARNING,
;;   GTK_MESSAGE_QUESTION,
;;   GTK_MESSAGE_ERROR,
;;   GTK_MESSAGE_OTHER
;; } GtkMessageType;

(define-enum-extended MessageType
  (in-module "Gtk")
  (c-name "GtkMessageType")
  (values
    '("info" "GTK_MESSAGE_INFO" "0")
    '("warning" "GTK_MESSAGE_WARNING" "1")
    '("question" "GTK_MESSAGE_QUESTION" "2")
    '("error" "GTK_MESSAGE_ERROR" "3")
    '("other" "GTK_MESSAGE_OTHER" "4")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_MOVEMENT_LOGICAL_POSITIONS,
;;   GTK_MOVEMENT_VISUAL_POSITIONS,
;;   GTK_MOVEMENT_WORDS,
;;   GTK_MOVEMENT_DISPLAY_LINES,
;;   GTK_MOVEMENT_DISPLAY_LINE_ENDS,
;;   GTK_MOVEMENT_PARAGRAPHS,
;;   GTK_MOVEMENT_PARAGRAPH_ENDS,
;;   GTK_MOVEMENT_PAGES,
;;   GTK_MOVEMENT_BUFFER_ENDS,
;;   GTK_MOVEMENT_HORIZONTAL_PAGES
;; } GtkMovementStep;

(define-enum-extended MovementStep
  (in-module "Gtk")
  (c-name "GtkMovementStep")
  (values
    '("logical-positions" "GTK_MOVEMENT_LOGICAL_POSITIONS" "0")
    '("visual-positions" "GTK_MOVEMENT_VISUAL_POSITIONS" "1")
    '("words" "GTK_MOVEMENT_WORDS" "2")
    '("display-lines" "GTK_MOVEMENT_DISPLAY_LINES" "3")
    '("display-line-ends" "GTK_MOVEMENT_DISPLAY_LINE_ENDS" "4")
    '("paragraphs" "GTK_MOVEMENT_PARAGRAPHS" "5")
    '("paragraph-ends" "GTK_MOVEMENT_PARAGRAPH_ENDS" "6")
    '("pages" "GTK_MOVEMENT_PAGES" "7")
    '("buffer-ends" "GTK_MOVEMENT_BUFFER_ENDS" "8")
    '("horizontal-pages" "GTK_MOVEMENT_HORIZONTAL_PAGES" "9")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SCROLL_STEPS,
;;   GTK_SCROLL_PAGES,
;;   GTK_SCROLL_ENDS,
;;   GTK_SCROLL_HORIZONTAL_STEPS,
;;   GTK_SCROLL_HORIZONTAL_PAGES,
;;   GTK_SCROLL_HORIZONTAL_ENDS
;; } GtkScrollStep;

(define-enum-extended ScrollStep
  (in-module "Gtk")
  (c-name "GtkScrollStep")
  (values
    '("steps" "GTK_SCROLL_STEPS" "0")
    '("pages" "GTK_SCROLL_PAGES" "1")
    '("ends" "GTK_SCROLL_ENDS" "2")
    '("horizontal-steps" "GTK_SCROLL_HORIZONTAL_STEPS" "3")
    '("horizontal-pages" "GTK_SCROLL_HORIZONTAL_PAGES" "4")
    '("horizontal-ends" "GTK_SCROLL_HORIZONTAL_ENDS" "5")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ORIENTATION_HORIZONTAL,
;;   GTK_ORIENTATION_VERTICAL
;; } GtkOrientation;

(define-enum-extended Orientation
  (in-module "Gtk")
  (c-name "GtkOrientation")
  (values
    '("horizontal" "GTK_ORIENTATION_HORIZONTAL" "0")
    '("vertical" "GTK_ORIENTATION_VERTICAL" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PACK_START,
;;   GTK_PACK_END
;; } GtkPackType;

(define-enum-extended PackType
  (in-module "Gtk")
  (c-name "GtkPackType")
  (values
    '("start" "GTK_PACK_START" "0")
    '("end" "GTK_PACK_END" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_POS_LEFT,
;;   GTK_POS_RIGHT,
;;   GTK_POS_TOP,
;;   GTK_POS_BOTTOM
;; } GtkPositionType;

(define-enum-extended PositionType
  (in-module "Gtk")
  (c-name "GtkPositionType")
  (values
    '("left" "GTK_POS_LEFT" "0")
    '("right" "GTK_POS_RIGHT" "1")
    '("top" "GTK_POS_TOP" "2")
    '("bottom" "GTK_POS_BOTTOM" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RELIEF_NORMAL,
;;   GTK_RELIEF_HALF,
;;   GTK_RELIEF_NONE
;; } GtkReliefStyle;

(define-enum-extended ReliefStyle
  (in-module "Gtk")
  (c-name "GtkReliefStyle")
  (values
    '("normal" "GTK_RELIEF_NORMAL" "0")
    '("half" "GTK_RELIEF_HALF" "1")
    '("none" "GTK_RELIEF_NONE" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SCROLL_NONE,
;;   GTK_SCROLL_JUMP,
;;   GTK_SCROLL_STEP_BACKWARD,
;;   GTK_SCROLL_STEP_FORWARD,
;;   GTK_SCROLL_PAGE_BACKWARD,
;;   GTK_SCROLL_PAGE_FORWARD,
;;   GTK_SCROLL_STEP_UP,
;;   GTK_SCROLL_STEP_DOWN,
;;   GTK_SCROLL_PAGE_UP,
;;   GTK_SCROLL_PAGE_DOWN,
;;   GTK_SCROLL_STEP_LEFT,
;;   GTK_SCROLL_STEP_RIGHT,
;;   GTK_SCROLL_PAGE_LEFT,
;;   GTK_SCROLL_PAGE_RIGHT,
;;   GTK_SCROLL_START,
;;   GTK_SCROLL_END
;; } GtkScrollType;

(define-enum-extended ScrollType
  (in-module "Gtk")
  (c-name "GtkScrollType")
  (values
    '("none" "GTK_SCROLL_NONE" "0")
    '("jump" "GTK_SCROLL_JUMP" "1")
    '("step-backward" "GTK_SCROLL_STEP_BACKWARD" "2")
    '("step-forward" "GTK_SCROLL_STEP_FORWARD" "3")
    '("page-backward" "GTK_SCROLL_PAGE_BACKWARD" "4")
    '("page-forward" "GTK_SCROLL_PAGE_FORWARD" "5")
    '("step-up" "GTK_SCROLL_STEP_UP" "6")
    '("step-down" "GTK_SCROLL_STEP_DOWN" "7")
    '("page-up" "GTK_SCROLL_PAGE_UP" "8")
    '("page-down" "GTK_SCROLL_PAGE_DOWN" "9")
    '("step-left" "GTK_SCROLL_STEP_LEFT" "10")
    '("step-right" "GTK_SCROLL_STEP_RIGHT" "11")
    '("page-left" "GTK_SCROLL_PAGE_LEFT" "12")
    '("page-right" "GTK_SCROLL_PAGE_RIGHT" "13")
    '("start" "GTK_SCROLL_START" "14")
    '("end" "GTK_SCROLL_END" "15")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SELECTION_NONE,
;;   GTK_SELECTION_SINGLE,
;;   GTK_SELECTION_BROWSE,
;;   GTK_SELECTION_MULTIPLE
;; } GtkSelectionMode;

(define-enum-extended SelectionMode
  (in-module "Gtk")
  (c-name "GtkSelectionMode")
  (values
    '("none" "GTK_SELECTION_NONE" "0")
    '("single" "GTK_SELECTION_SINGLE" "1")
    '("browse" "GTK_SELECTION_BROWSE" "2")
    '("multiple" "GTK_SELECTION_MULTIPLE" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SHADOW_NONE,
;;   GTK_SHADOW_IN,
;;   GTK_SHADOW_OUT,
;;   GTK_SHADOW_ETCHED_IN,
;;   GTK_SHADOW_ETCHED_OUT
;; } GtkShadowType;

(define-enum-extended ShadowType
  (in-module "Gtk")
  (c-name "GtkShadowType")
  (values
    '("none" "GTK_SHADOW_NONE" "0")
    '("in" "GTK_SHADOW_IN" "1")
    '("out" "GTK_SHADOW_OUT" "2")
    '("etched-in" "GTK_SHADOW_ETCHED_IN" "3")
    '("etched-out" "GTK_SHADOW_ETCHED_OUT" "4")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_STATE_NORMAL,
;;   GTK_STATE_ACTIVE,
;;   GTK_STATE_PRELIGHT,
;;   GTK_STATE_SELECTED,
;;   GTK_STATE_INSENSITIVE,
;;   GTK_STATE_INCONSISTENT,
;;   GTK_STATE_FOCUSED
;; } GtkStateType;

(define-enum-extended StateType
  (in-module "Gtk")
  (c-name "GtkStateType")
  (values
    '("normal" "GTK_STATE_NORMAL" "0")
    '("active" "GTK_STATE_ACTIVE" "1")
    '("prelight" "GTK_STATE_PRELIGHT" "2")
    '("selected" "GTK_STATE_SELECTED" "3")
    '("insensitive" "GTK_STATE_INSENSITIVE" "4")
    '("inconsistent" "GTK_STATE_INCONSISTENT" "5")
    '("focused" "GTK_STATE_FOCUSED" "6")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TOOLBAR_ICONS,
;;   GTK_TOOLBAR_TEXT,
;;   GTK_TOOLBAR_BOTH,
;;   GTK_TOOLBAR_BOTH_HORIZ
;; } GtkToolbarStyle;

(define-enum-extended ToolbarStyle
  (in-module "Gtk")
  (c-name "GtkToolbarStyle")
  (values
    '("icons" "GTK_TOOLBAR_ICONS" "0")
    '("text" "GTK_TOOLBAR_TEXT" "1")
    '("both" "GTK_TOOLBAR_BOTH" "2")
    '("both-horiz" "GTK_TOOLBAR_BOTH_HORIZ" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_WRAP_NONE,
;;   GTK_WRAP_CHAR,
;;   GTK_WRAP_WORD,
;;   GTK_WRAP_WORD_CHAR
;; } GtkWrapMode;

(define-enum-extended WrapMode
  (in-module "Gtk")
  (c-name "GtkWrapMode")
  (values
    '("none" "GTK_WRAP_NONE" "0")
    '("char" "GTK_WRAP_CHAR" "1")
    '("word" "GTK_WRAP_WORD" "2")
    '("word-char" "GTK_WRAP_WORD_CHAR" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SORT_ASCENDING,
;;   GTK_SORT_DESCENDING
;; } GtkSortType;

(define-enum-extended SortType
  (in-module "Gtk")
  (c-name "GtkSortType")
  (values
    '("ascending" "GTK_SORT_ASCENDING" "0")
    '("descending" "GTK_SORT_DESCENDING" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_IM_PREEDIT_NOTHING,
;;   GTK_IM_PREEDIT_CALLBACK,
;;   GTK_IM_PREEDIT_NONE
;; } GtkIMPreeditStyle;

(define-enum-extended IMPreeditStyle
  (in-module "Gtk")
  (c-name "GtkIMPreeditStyle")
  (values
    '("nothing" "GTK_IM_PREEDIT_NOTHING" "0")
    '("callback" "GTK_IM_PREEDIT_CALLBACK" "1")
    '("none" "GTK_IM_PREEDIT_NONE" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_IM_STATUS_NOTHING,
;;   GTK_IM_STATUS_CALLBACK,
;;   GTK_IM_STATUS_NONE
;; } GtkIMStatusStyle;

(define-enum-extended IMStatusStyle
  (in-module "Gtk")
  (c-name "GtkIMStatusStyle")
  (values
    '("nothing" "GTK_IM_STATUS_NOTHING" "0")
    '("callback" "GTK_IM_STATUS_CALLBACK" "1")
    '("none" "GTK_IM_STATUS_NONE" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PACK_DIRECTION_LTR,
;;   GTK_PACK_DIRECTION_RTL,
;;   GTK_PACK_DIRECTION_TTB,
;;   GTK_PACK_DIRECTION_BTT
;; } GtkPackDirection;

(define-enum-extended PackDirection
  (in-module "Gtk")
  (c-name "GtkPackDirection")
  (values
    '("ltr" "GTK_PACK_DIRECTION_LTR" "0")
    '("rtl" "GTK_PACK_DIRECTION_RTL" "1")
    '("ttb" "GTK_PACK_DIRECTION_TTB" "2")
    '("btt" "GTK_PACK_DIRECTION_BTT" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_PAGES_ALL,
;;   GTK_PRINT_PAGES_CURRENT,
;;   GTK_PRINT_PAGES_RANGES,
;;   GTK_PRINT_PAGES_SELECTION
;; } GtkPrintPages;

(define-enum-extended PrintPages
  (in-module "Gtk")
  (c-name "GtkPrintPages")
  (values
    '("all" "GTK_PRINT_PAGES_ALL" "0")
    '("current" "GTK_PRINT_PAGES_CURRENT" "1")
    '("ranges" "GTK_PRINT_PAGES_RANGES" "2")
    '("selection" "GTK_PRINT_PAGES_SELECTION" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PAGE_SET_ALL,
;;   GTK_PAGE_SET_EVEN,
;;   GTK_PAGE_SET_ODD
;; } GtkPageSet;

(define-enum-extended PageSet
  (in-module "Gtk")
  (c-name "GtkPageSet")
  (values
    '("all" "GTK_PAGE_SET_ALL" "0")
    '("even" "GTK_PAGE_SET_EVEN" "1")
    '("odd" "GTK_PAGE_SET_ODD" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, /*< nick=lrtb >*/
;;   GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP, /*< nick=lrbt >*/
;;   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM, /*< nick=rltb >*/
;;   GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP, /*< nick=rlbt >*/
;;   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT, /*< nick=tblr >*/
;;   GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT, /*< nick=tbrl >*/
;;   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT, /*< nick=btlr >*/
;;   GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT  /*< nick=btrl >*/
;; } GtkNumberUpLayout;

(define-enum-extended NumberUpLayout
  (in-module "Gtk")
  (c-name "GtkNumberUpLayout")
  (values
    '("left-to-right-top-to-bottom" "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM" "0")
    '("left-to-right-bottom-to-top" "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP" "1")
    '("right-to-left-top-to-bottom" "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM" "2")
    '("right-to-left-bottom-to-top" "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP" "3")
    '("top-to-bottom-left-to-right" "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT" "4")
    '("top-to-bottom-right-to-left" "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT" "5")
    '("bottom-to-top-left-to-right" "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT" "6")
    '("bottom-to-top-right-to-left" "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT" "7")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PAGE_ORIENTATION_PORTRAIT,
;;   GTK_PAGE_ORIENTATION_LANDSCAPE,
;;   GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
;;   GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
;; } GtkPageOrientation;

(define-enum-extended PageOrientation
  (in-module "Gtk")
  (c-name "GtkPageOrientation")
  (values
    '("portrait" "GTK_PAGE_ORIENTATION_PORTRAIT" "0")
    '("landscape" "GTK_PAGE_ORIENTATION_LANDSCAPE" "1")
    '("reverse-portrait" "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT" "2")
    '("reverse-landscape" "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_QUALITY_LOW,
;;   GTK_PRINT_QUALITY_NORMAL,
;;   GTK_PRINT_QUALITY_HIGH,
;;   GTK_PRINT_QUALITY_DRAFT
;; } GtkPrintQuality;

(define-enum-extended PrintQuality
  (in-module "Gtk")
  (c-name "GtkPrintQuality")
  (values
    '("low" "GTK_PRINT_QUALITY_LOW" "0")
    '("normal" "GTK_PRINT_QUALITY_NORMAL" "1")
    '("high" "GTK_PRINT_QUALITY_HIGH" "2")
    '("draft" "GTK_PRINT_QUALITY_DRAFT" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_DUPLEX_SIMPLEX,
;;   GTK_PRINT_DUPLEX_HORIZONTAL,
;;   GTK_PRINT_DUPLEX_VERTICAL
;; } GtkPrintDuplex;

(define-enum-extended PrintDuplex
  (in-module "Gtk")
  (c-name "GtkPrintDuplex")
  (values
    '("simplex" "GTK_PRINT_DUPLEX_SIMPLEX" "0")
    '("horizontal" "GTK_PRINT_DUPLEX_HORIZONTAL" "1")
    '("vertical" "GTK_PRINT_DUPLEX_VERTICAL" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_UNIT_NONE,
;;   GTK_UNIT_POINTS,
;;   GTK_UNIT_INCH,
;;   GTK_UNIT_MM
;; } GtkUnit;

(define-enum-extended Unit
  (in-module "Gtk")
  (c-name "GtkUnit")
  (values
    '("none" "GTK_UNIT_NONE" "0")
    '("points" "GTK_UNIT_POINTS" "1")
    '("inch" "GTK_UNIT_INCH" "2")
    '("mm" "GTK_UNIT_MM" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TREE_VIEW_GRID_LINES_NONE,
;;   GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
;;   GTK_TREE_VIEW_GRID_LINES_VERTICAL,
;;   GTK_TREE_VIEW_GRID_LINES_BOTH
;; } GtkTreeViewGridLines;

(define-enum-extended TreeViewGridLines
  (in-module "Gtk")
  (c-name "GtkTreeViewGridLines")
  (values
    '("none" "GTK_TREE_VIEW_GRID_LINES_NONE" "0")
    '("horizontal" "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL" "1")
    '("vertical" "GTK_TREE_VIEW_GRID_LINES_VERTICAL" "2")
    '("both" "GTK_TREE_VIEW_GRID_LINES_BOTH" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_DRAG_RESULT_SUCCESS,
;;   GTK_DRAG_RESULT_NO_TARGET,
;;   GTK_DRAG_RESULT_USER_CANCELLED,
;;   GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
;;   GTK_DRAG_RESULT_GRAB_BROKEN,
;;   GTK_DRAG_RESULT_ERROR
;; } GtkDragResult;

(define-enum-extended DragResult
  (in-module "Gtk")
  (c-name "GtkDragResult")
  (values
    '("success" "GTK_DRAG_RESULT_SUCCESS" "0")
    '("no-target" "GTK_DRAG_RESULT_NO_TARGET" "1")
    '("user-cancelled" "GTK_DRAG_RESULT_USER_CANCELLED" "2")
    '("timeout-expired" "GTK_DRAG_RESULT_TIMEOUT_EXPIRED" "3")
    '("grab-broken" "GTK_DRAG_RESULT_GRAB_BROKEN" "4")
    '("error" "GTK_DRAG_RESULT_ERROR" "5")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_SIZE_GROUP_NONE,
;;   GTK_SIZE_GROUP_HORIZONTAL,
;;   GTK_SIZE_GROUP_VERTICAL,
;;   GTK_SIZE_GROUP_BOTH
;; } GtkSizeGroupMode;

(define-enum-extended SizeGroupMode
  (in-module "Gtk")
  (c-name "GtkSizeGroupMode")
  (values
    '("none" "GTK_SIZE_GROUP_NONE" "0")
    '("horizontal" "GTK_SIZE_GROUP_HORIZONTAL" "1")
    '("vertical" "GTK_SIZE_GROUP_VERTICAL" "2")
    '("both" "GTK_SIZE_GROUP_BOTH" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH = 0,
;;   GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
;;   GTK_SIZE_REQUEST_CONSTANT_SIZE
;; } GtkSizeRequestMode;

(define-enum-extended SizeRequestMode
  (in-module "Gtk")
  (c-name "GtkSizeRequestMode")
  (values
    '("height-for-width" "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH" "0")
    '("width-for-height" "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT" "1")
    '("constant-size" "GTK_SIZE_REQUEST_CONSTANT_SIZE" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SCROLL_MINIMUM = 0,
;;   GTK_SCROLL_NATURAL
;; } GtkScrollablePolicy;

(define-enum-extended ScrollablePolicy
  (in-module "Gtk")
  (c-name "GtkScrollablePolicy")
  (values
    '("minimum" "GTK_SCROLL_MINIMUM" "0")
    '("natural" "GTK_SCROLL_NATURAL" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_STATE_FLAG_NORMAL       = 0,
;;   GTK_STATE_FLAG_ACTIVE       = 1 << 0,
;;   GTK_STATE_FLAG_PRELIGHT     = 1 << 1,
;;   GTK_STATE_FLAG_SELECTED     = 1 << 2,
;;   GTK_STATE_FLAG_INSENSITIVE  = 1 << 3,
;;   GTK_STATE_FLAG_INCONSISTENT = 1 << 4,
;;   GTK_STATE_FLAG_FOCUSED      = 1 << 5,
;;   GTK_STATE_FLAG_BACKDROP     = 1 << 6,
;;   GTK_STATE_FLAG_DIR_LTR      = 1 << 7,
;;   GTK_STATE_FLAG_DIR_RTL      = 1 << 8,
;;   GTK_STATE_FLAG_LINK         = 1 << 9,
;;   GTK_STATE_FLAG_VISITED      = 1 << 10,
;;   GTK_STATE_FLAG_CHECKED      = 1 << 11,
;;   GTK_STATE_FLAG_DROP_ACTIVE  = 1 << 12
;; } GtkStateFlags;

(define-flags-extended StateFlags
  (in-module "Gtk")
  (c-name "GtkStateFlags")
  (values
    '("normal" "GTK_STATE_FLAG_NORMAL" "0x0")
    '("active" "GTK_STATE_FLAG_ACTIVE" "1 << 0")
    '("prelight" "GTK_STATE_FLAG_PRELIGHT" "1 << 1")
    '("selected" "GTK_STATE_FLAG_SELECTED" "1 << 2")
    '("insensitive" "GTK_STATE_FLAG_INSENSITIVE" "1 << 3")
    '("inconsistent" "GTK_STATE_FLAG_INCONSISTENT" "1 << 4")
    '("focused" "GTK_STATE_FLAG_FOCUSED" "1 << 5")
    '("backdrop" "GTK_STATE_FLAG_BACKDROP" "1 << 6")
    '("dir-ltr" "GTK_STATE_FLAG_DIR_LTR" "1 << 7")
    '("dir-rtl" "GTK_STATE_FLAG_DIR_RTL" "1 << 8")
    '("link" "GTK_STATE_FLAG_LINK" "1 << 9")
    '("visited" "GTK_STATE_FLAG_VISITED" "1 << 10")
    '("checked" "GTK_STATE_FLAG_CHECKED" "1 << 11")
    '("drop-active" "GTK_STATE_FLAG_DROP_ACTIVE" "1 << 12")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_REGION_EVEN    = 1 << 0,
;;   GTK_REGION_ODD     = 1 << 1,
;;   GTK_REGION_FIRST   = 1 << 2,
;;   GTK_REGION_LAST    = 1 << 3,
;;   GTK_REGION_ONLY    = 1 << 4,
;;   GTK_REGION_SORTED  = 1 << 5
;; } GtkRegionFlags;

(define-flags-extended RegionFlags
  (in-module "Gtk")
  (c-name "GtkRegionFlags")
  (values
    '("even" "GTK_REGION_EVEN" "1 << 0")
    '("odd" "GTK_REGION_ODD" "1 << 1")
    '("first" "GTK_REGION_FIRST" "1 << 2")
    '("last" "GTK_REGION_LAST" "1 << 3")
    '("only" "GTK_REGION_ONLY" "1 << 4")
    '("sorted" "GTK_REGION_SORTED" "1 << 5")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_JUNCTION_NONE   = 0,
;;   GTK_JUNCTION_CORNER_TOPLEFT = 1 << 0,
;;   GTK_JUNCTION_CORNER_TOPRIGHT = 1 << 1,
;;   GTK_JUNCTION_CORNER_BOTTOMLEFT = 1 << 2,
;;   GTK_JUNCTION_CORNER_BOTTOMRIGHT = 1 << 3,
;;   GTK_JUNCTION_TOP    = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_TOPRIGHT),
;;   GTK_JUNCTION_BOTTOM = (GTK_JUNCTION_CORNER_BOTTOMLEFT | GTK_JUNCTION_CORNER_BOTTOMRIGHT),
;;   GTK_JUNCTION_LEFT   = (GTK_JUNCTION_CORNER_TOPLEFT | GTK_JUNCTION_CORNER_BOTTOMLEFT),
;;   GTK_JUNCTION_RIGHT  = (GTK_JUNCTION_CORNER_TOPRIGHT | GTK_JUNCTION_CORNER_BOTTOMRIGHT)
;; } GtkJunctionSides;

(define-flags-extended JunctionSides
  (in-module "Gtk")
  (c-name "GtkJunctionSides")
  (values
    '("none" "GTK_JUNCTION_NONE" "0x0")
    '("corner-topleft" "GTK_JUNCTION_CORNER_TOPLEFT" "1 << 0")
    '("corner-topright" "GTK_JUNCTION_CORNER_TOPRIGHT" "1 << 1")
    '("corner-bottomleft" "GTK_JUNCTION_CORNER_BOTTOMLEFT" "1 << 2")
    '("corner-bottomright" "GTK_JUNCTION_CORNER_BOTTOMRIGHT" "1 << 3")
    '("top" "GTK_JUNCTION_TOP" "0x3")
    '("bottom" "GTK_JUNCTION_BOTTOM" "0xC")
    '("left" "GTK_JUNCTION_LEFT" "0x5")
    '("right" "GTK_JUNCTION_RIGHT" "0xA")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_BORDER_STYLE_NONE,
;;   GTK_BORDER_STYLE_SOLID,
;;   GTK_BORDER_STYLE_INSET,
;;   GTK_BORDER_STYLE_OUTSET,
;;   GTK_BORDER_STYLE_HIDDEN,
;;   GTK_BORDER_STYLE_DOTTED,
;;   GTK_BORDER_STYLE_DASHED,
;;   GTK_BORDER_STYLE_DOUBLE,
;;   GTK_BORDER_STYLE_GROOVE,
;;   GTK_BORDER_STYLE_RIDGE
;; } GtkBorderStyle;

(define-enum-extended BorderStyle
  (in-module "Gtk")
  (c-name "GtkBorderStyle")
  (values
    '("none" "GTK_BORDER_STYLE_NONE" "0")
    '("solid" "GTK_BORDER_STYLE_SOLID" "1")
    '("inset" "GTK_BORDER_STYLE_INSET" "2")
    '("outset" "GTK_BORDER_STYLE_OUTSET" "3")
    '("hidden" "GTK_BORDER_STYLE_HIDDEN" "4")
    '("dotted" "GTK_BORDER_STYLE_DOTTED" "5")
    '("dashed" "GTK_BORDER_STYLE_DASHED" "6")
    '("double" "GTK_BORDER_STYLE_DOUBLE" "7")
    '("groove" "GTK_BORDER_STYLE_GROOVE" "8")
    '("ridge" "GTK_BORDER_STYLE_RIDGE" "9")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_LEVEL_BAR_MODE_CONTINUOUS,
;;   GTK_LEVEL_BAR_MODE_DISCRETE
;; } GtkLevelBarMode;

(define-enum-extended LevelBarMode
  (in-module "Gtk")
  (c-name "GtkLevelBarMode")
  (values
    '("continuous" "GTK_LEVEL_BAR_MODE_CONTINUOUS" "0")
    '("discrete" "GTK_LEVEL_BAR_MODE_DISCRETE" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_INPUT_PURPOSE_FREE_FORM,
;;   GTK_INPUT_PURPOSE_ALPHA,
;;   GTK_INPUT_PURPOSE_DIGITS,
;;   GTK_INPUT_PURPOSE_NUMBER,
;;   GTK_INPUT_PURPOSE_PHONE,
;;   GTK_INPUT_PURPOSE_URL,
;;   GTK_INPUT_PURPOSE_EMAIL,
;;   GTK_INPUT_PURPOSE_NAME,
;;   GTK_INPUT_PURPOSE_PASSWORD,
;;   GTK_INPUT_PURPOSE_PIN
;; } GtkInputPurpose;

(define-enum-extended InputPurpose
  (in-module "Gtk")
  (c-name "GtkInputPurpose")
  (values
    '("free-form" "GTK_INPUT_PURPOSE_FREE_FORM" "0")
    '("alpha" "GTK_INPUT_PURPOSE_ALPHA" "1")
    '("digits" "GTK_INPUT_PURPOSE_DIGITS" "2")
    '("number" "GTK_INPUT_PURPOSE_NUMBER" "3")
    '("phone" "GTK_INPUT_PURPOSE_PHONE" "4")
    '("url" "GTK_INPUT_PURPOSE_URL" "5")
    '("email" "GTK_INPUT_PURPOSE_EMAIL" "6")
    '("name" "GTK_INPUT_PURPOSE_NAME" "7")
    '("password" "GTK_INPUT_PURPOSE_PASSWORD" "8")
    '("pin" "GTK_INPUT_PURPOSE_PIN" "9")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_INPUT_HINT_NONE                = 0,
;;   GTK_INPUT_HINT_SPELLCHECK          = 1 << 0,
;;   GTK_INPUT_HINT_NO_SPELLCHECK       = 1 << 1,
;;   GTK_INPUT_HINT_WORD_COMPLETION     = 1 << 2,
;;   GTK_INPUT_HINT_LOWERCASE           = 1 << 3,
;;   GTK_INPUT_HINT_UPPERCASE_CHARS     = 1 << 4,
;;   GTK_INPUT_HINT_UPPERCASE_WORDS     = 1 << 5,
;;   GTK_INPUT_HINT_UPPERCASE_SENTENCES = 1 << 6,
;;   GTK_INPUT_HINT_INHIBIT_OSK         = 1 << 7,
;;   GTK_INPUT_HINT_VERTICAL_WRITING    = 1 << 8,
;;   GTK_INPUT_HINT_EMOJI               = 1 << 9,
;;   GTK_INPUT_HINT_NO_EMOJI            = 1 << 10
;; } GtkInputHints;

(define-flags-extended InputHints
  (in-module "Gtk")
  (c-name "GtkInputHints")
  (values
    '("none" "GTK_INPUT_HINT_NONE" "0x0")
    '("spellcheck" "GTK_INPUT_HINT_SPELLCHECK" "1 << 0")
    '("no-spellcheck" "GTK_INPUT_HINT_NO_SPELLCHECK" "1 << 1")
    '("word-completion" "GTK_INPUT_HINT_WORD_COMPLETION" "1 << 2")
    '("lowercase" "GTK_INPUT_HINT_LOWERCASE" "1 << 3")
    '("uppercase-chars" "GTK_INPUT_HINT_UPPERCASE_CHARS" "1 << 4")
    '("uppercase-words" "GTK_INPUT_HINT_UPPERCASE_WORDS" "1 << 5")
    '("uppercase-sentences" "GTK_INPUT_HINT_UPPERCASE_SENTENCES" "1 << 6")
    '("inhibit-osk" "GTK_INPUT_HINT_INHIBIT_OSK" "1 << 7")
    '("vertical-writing" "GTK_INPUT_HINT_VERTICAL_WRITING" "1 << 8")
    '("emoji" "GTK_INPUT_HINT_EMOJI" "1 << 9")
    '("no-emoji" "GTK_INPUT_HINT_NO_EMOJI" "1 << 10")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PHASE_NONE,
;;   GTK_PHASE_CAPTURE,
;;   GTK_PHASE_BUBBLE,
;;   GTK_PHASE_TARGET
;; } GtkPropagationPhase;

(define-enum-extended PropagationPhase
  (in-module "Gtk")
  (c-name "GtkPropagationPhase")
  (values
    '("none" "GTK_PHASE_NONE" "0")
    '("capture" "GTK_PHASE_CAPTURE" "1")
    '("bubble" "GTK_PHASE_BUBBLE" "2")
    '("target" "GTK_PHASE_TARGET" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_EVENT_SEQUENCE_NONE,
;;   GTK_EVENT_SEQUENCE_CLAIMED,
;;   GTK_EVENT_SEQUENCE_DENIED
;; } GtkEventSequenceState;

(define-enum-extended EventSequenceState
  (in-module "Gtk")
  (c-name "GtkEventSequenceState")
  (values
    '("none" "GTK_EVENT_SEQUENCE_NONE" "0")
    '("claimed" "GTK_EVENT_SEQUENCE_CLAIMED" "1")
    '("denied" "GTK_EVENT_SEQUENCE_DENIED" "2")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PAN_DIRECTION_LEFT,
;;   GTK_PAN_DIRECTION_RIGHT,
;;   GTK_PAN_DIRECTION_UP,
;;   GTK_PAN_DIRECTION_DOWN
;; } GtkPanDirection;

(define-enum-extended PanDirection
  (in-module "Gtk")
  (c-name "GtkPanDirection")
  (values
    '("left" "GTK_PAN_DIRECTION_LEFT" "0")
    '("right" "GTK_PAN_DIRECTION_RIGHT" "1")
    '("up" "GTK_PAN_DIRECTION_UP" "2")
    '("down" "GTK_PAN_DIRECTION_DOWN" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_POPOVER_CONSTRAINT_NONE,
;;   GTK_POPOVER_CONSTRAINT_WINDOW
;; } GtkPopoverConstraint;

(define-enum-extended PopoverConstraint
  (in-module "Gtk")
  (c-name "GtkPopoverConstraint")
  (values
    '("none" "GTK_POPOVER_CONSTRAINT_NONE" "0")
    '("window" "GTK_POPOVER_CONSTRAINT_WINDOW" "1")
  )
)

;; From gtkeventcontrollerscroll.h

;; Original typedef:
;; typedef enum {
;;   GTK_EVENT_CONTROLLER_SCROLL_NONE       = 0,
;;   GTK_EVENT_CONTROLLER_SCROLL_VERTICAL   = 1 << 0,
;;   GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL = 1 << 1,
;;   GTK_EVENT_CONTROLLER_SCROLL_DISCRETE   = 1 << 2,
;;   GTK_EVENT_CONTROLLER_SCROLL_KINETIC    = 1 << 3,
;;   GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES  = (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL | GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL),
;; } GtkEventControllerScrollFlags;

(define-flags-extended EventControllerScrollFlags
  (in-module "Gtk")
  (c-name "GtkEventControllerScrollFlags")
  (values
    '("none" "GTK_EVENT_CONTROLLER_SCROLL_NONE" "0x0")
    '("vertical" "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL" "1 << 0")
    '("horizontal" "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL" "1 << 1")
    '("discrete" "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE" "1 << 2")
    '("kinetic" "GTK_EVENT_CONTROLLER_SCROLL_KINETIC" "1 << 3")
    '("both-axes" "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES" "0x3")
  )
)

;; From gtkfilechooser.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_FILE_CHOOSER_ACTION_OPEN,
;;   GTK_FILE_CHOOSER_ACTION_SAVE,
;;   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
;;   GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
;; } GtkFileChooserAction;

(define-enum-extended FileChooserAction
  (in-module "Gtk")
  (c-name "GtkFileChooserAction")
  (values
    '("open" "GTK_FILE_CHOOSER_ACTION_OPEN" "0")
    '("save" "GTK_FILE_CHOOSER_ACTION_SAVE" "1")
    '("select-folder" "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER" "2")
    '("create-folder" "GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM,
;;   GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME,
;;   GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
;; } GtkFileChooserConfirmation;

(define-enum-extended FileChooserConfirmation
  (in-module "Gtk")
  (c-name "GtkFileChooserConfirmation")
  (values
    '("confirm" "GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM" "0")
    '("accept-filename" "GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME" "1")
    '("select-again" "GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN" "2")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
;;   GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
;;   GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
;;   GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME
;; } GtkFileChooserError;

(define-enum-extended FileChooserError
  (in-module "Gtk")
  (c-name "GtkFileChooserError")
  (values
    '("nonexistent" "GTK_FILE_CHOOSER_ERROR_NONEXISTENT" "0")
    '("bad-filename" "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME" "1")
    '("already-exists" "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS" "2")
    '("incomplete-hostname" "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME" "3")
  )
)

;; From gtkfilechooserutils.h

;; Original typedef:
;; typedef enum {
;;   GTK_FILE_CHOOSER_PROP_FIRST                  = 0x1000,
;;   GTK_FILE_CHOOSER_PROP_ACTION                 = GTK_FILE_CHOOSER_PROP_FIRST,
;;   GTK_FILE_CHOOSER_PROP_FILTER,
;;   GTK_FILE_CHOOSER_PROP_LOCAL_ONLY,
;;   GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET,
;;   GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE,
;;   GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL,
;;   GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET,
;;   GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE,
;;   GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN,
;;   GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION,
;;   GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS,
;;   GTK_FILE_CHOOSER_PROP_LAST                   = GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS
;; } GtkFileChooserProp;

(define-enum-extended FileChooserProp
  (in-module "Gtk")
  (c-name "GtkFileChooserProp")
  (values
    '("first" "GTK_FILE_CHOOSER_PROP_FIRST" "0x1000")
    '("action" "GTK_FILE_CHOOSER_PROP_ACTION" "4096")
    '("filter" "GTK_FILE_CHOOSER_PROP_FILTER" "4097")
    '("local-only" "GTK_FILE_CHOOSER_PROP_LOCAL_ONLY" "4098")
    '("preview-widget" "GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET" "4099")
    '("preview-widget-active" "GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE" "4100")
    '("use-preview-label" "GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL" "4101")
    '("extra-widget" "GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET" "4102")
    '("select-multiple" "GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE" "4103")
    '("show-hidden" "GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN" "4104")
    '("do-overwrite-confirmation" "GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION" "4105")
    '("create-folders" "GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS" "4106")
    '("last" "GTK_FILE_CHOOSER_PROP_LAST" "4106")
  )
)

;; From gtkfilefilter.h

;; Original typedef:
;; typedef enum {
;;   GTK_FILE_FILTER_FILENAME     = 1 << 0,
;;   GTK_FILE_FILTER_URI          = 1 << 1,
;;   GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2,
;;   GTK_FILE_FILTER_MIME_TYPE    = 1 << 3
;; } GtkFileFilterFlags;

(define-flags-extended FileFilterFlags
  (in-module "Gtk")
  (c-name "GtkFileFilterFlags")
  (values
    '("filename" "GTK_FILE_FILTER_FILENAME" "1 << 0")
    '("uri" "GTK_FILE_FILTER_URI" "1 << 1")
    '("display-name" "GTK_FILE_FILTER_DISPLAY_NAME" "1 << 2")
    '("mime-type" "GTK_FILE_FILTER_MIME_TYPE" "1 << 3")
  )
)

;; From gtkfontchooser.h

;; Original typedef:
;; typedef enum {
;;   GTK_FONT_CHOOSER_LEVEL_FAMILY     = 0,
;;   GTK_FONT_CHOOSER_LEVEL_STYLE      = 1 << 0,
;;   GTK_FONT_CHOOSER_LEVEL_SIZE       = 1 << 1,
;;   GTK_FONT_CHOOSER_LEVEL_VARIATIONS = 1 << 2,
;;   GTK_FONT_CHOOSER_LEVEL_FEATURES   = 1 << 3
;; } GtkFontChooserLevel;

(define-flags-extended FontChooserLevel
  (in-module "Gtk")
  (c-name "GtkFontChooserLevel")
  (values
    '("family" "GTK_FONT_CHOOSER_LEVEL_FAMILY" "0x0")
    '("style" "GTK_FONT_CHOOSER_LEVEL_STYLE" "1 << 0")
    '("size" "GTK_FONT_CHOOSER_LEVEL_SIZE" "1 << 1")
    '("variations" "GTK_FONT_CHOOSER_LEVEL_VARIATIONS" "1 << 2")
    '("features" "GTK_FONT_CHOOSER_LEVEL_FEATURES" "1 << 3")
  )
)

;; From gtkfontchooserutils.h

;; Original typedef:
;; typedef enum {
;;   GTK_FONT_CHOOSER_PROP_FIRST           = 0x4000,
;;   GTK_FONT_CHOOSER_PROP_FONT,
;;   GTK_FONT_CHOOSER_PROP_FONT_DESC,
;;   GTK_FONT_CHOOSER_PROP_PREVIEW_TEXT,
;;   GTK_FONT_CHOOSER_PROP_SHOW_PREVIEW_ENTRY,
;;   GTK_FONT_CHOOSER_PROP_LEVEL,
;;   GTK_FONT_CHOOSER_PROP_FONT_FEATURES,
;;   GTK_FONT_CHOOSER_PROP_LANGUAGE,
;;   GTK_FONT_CHOOSER_PROP_LAST
;; } GtkFontChooserProp;

(define-enum-extended FontChooserProp
  (in-module "Gtk")
  (c-name "GtkFontChooserProp")
  (values
    '("first" "GTK_FONT_CHOOSER_PROP_FIRST" "0x4000")
    '("font" "GTK_FONT_CHOOSER_PROP_FONT" "16385")
    '("font-desc" "GTK_FONT_CHOOSER_PROP_FONT_DESC" "16386")
    '("preview-text" "GTK_FONT_CHOOSER_PROP_PREVIEW_TEXT" "16387")
    '("show-preview-entry" "GTK_FONT_CHOOSER_PROP_SHOW_PREVIEW_ENTRY" "16388")
    '("level" "GTK_FONT_CHOOSER_PROP_LEVEL" "16389")
    '("font-features" "GTK_FONT_CHOOSER_PROP_FONT_FEATURES" "16390")
    '("language" "GTK_FONT_CHOOSER_PROP_LANGUAGE" "16391")
    '("last" "GTK_FONT_CHOOSER_PROP_LAST" "16392")
  )
)

;; From gtkicontheme.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ICON_LOOKUP_NO_SVG           = 1 << 0,
;;   GTK_ICON_LOOKUP_FORCE_SVG        = 1 << 1,
;;   GTK_ICON_LOOKUP_USE_BUILTIN      = 1 << 2,
;;   GTK_ICON_LOOKUP_GENERIC_FALLBACK = 1 << 3,
;;   GTK_ICON_LOOKUP_FORCE_SIZE       = 1 << 4,
;;   GTK_ICON_LOOKUP_FORCE_REGULAR    = 1 << 5,
;;   GTK_ICON_LOOKUP_FORCE_SYMBOLIC   = 1 << 6,
;;   GTK_ICON_LOOKUP_DIR_LTR          = 1 << 7,
;;   GTK_ICON_LOOKUP_DIR_RTL          = 1 << 8
;; } GtkIconLookupFlags;

(define-flags-extended IconLookupFlags
  (in-module "Gtk")
  (c-name "GtkIconLookupFlags")
  (values
    '("no-svg" "GTK_ICON_LOOKUP_NO_SVG" "1 << 0")
    '("force-svg" "GTK_ICON_LOOKUP_FORCE_SVG" "1 << 1")
    '("use-builtin" "GTK_ICON_LOOKUP_USE_BUILTIN" "1 << 2")
    '("generic-fallback" "GTK_ICON_LOOKUP_GENERIC_FALLBACK" "1 << 3")
    '("force-size" "GTK_ICON_LOOKUP_FORCE_SIZE" "1 << 4")
    '("force-regular" "GTK_ICON_LOOKUP_FORCE_REGULAR" "1 << 5")
    '("force-symbolic" "GTK_ICON_LOOKUP_FORCE_SYMBOLIC" "1 << 6")
    '("dir-ltr" "GTK_ICON_LOOKUP_DIR_LTR" "1 << 7")
    '("dir-rtl" "GTK_ICON_LOOKUP_DIR_RTL" "1 << 8")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_ICON_THEME_NOT_FOUND,
;;   GTK_ICON_THEME_FAILED
;; } GtkIconThemeError;

(define-enum-extended IconThemeError
  (in-module "Gtk")
  (c-name "GtkIconThemeError")
  (values
    '("not-found" "GTK_ICON_THEME_NOT_FOUND" "0")
    '("failed" "GTK_ICON_THEME_FAILED" "1")
  )
)

;; From gtkiconview.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ICON_VIEW_NO_DROP,
;;   GTK_ICON_VIEW_DROP_INTO,
;;   GTK_ICON_VIEW_DROP_LEFT,
;;   GTK_ICON_VIEW_DROP_RIGHT,
;;   GTK_ICON_VIEW_DROP_ABOVE,
;;   GTK_ICON_VIEW_DROP_BELOW
;; } GtkIconViewDropPosition;

(define-enum-extended IconViewDropPosition
  (in-module "Gtk")
  (c-name "GtkIconViewDropPosition")
  (values
    '("no-drop" "GTK_ICON_VIEW_NO_DROP" "0")
    '("drop-into" "GTK_ICON_VIEW_DROP_INTO" "1")
    '("drop-left" "GTK_ICON_VIEW_DROP_LEFT" "2")
    '("drop-right" "GTK_ICON_VIEW_DROP_RIGHT" "3")
    '("drop-above" "GTK_ICON_VIEW_DROP_ABOVE" "4")
    '("drop-below" "GTK_ICON_VIEW_DROP_BELOW" "5")
  )
)

;; From gtkimage.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_IMAGE_EMPTY,
;;   GTK_IMAGE_PIXBUF,
;;   GTK_IMAGE_STOCK,
;;   GTK_IMAGE_ICON_SET,
;;   GTK_IMAGE_ANIMATION,
;;   GTK_IMAGE_ICON_NAME,
;;   GTK_IMAGE_GICON,
;;   GTK_IMAGE_SURFACE
;; } GtkImageType;

(define-enum-extended ImageType
  (in-module "Gtk")
  (c-name "GtkImageType")
  (values
    '("empty" "GTK_IMAGE_EMPTY" "0")
    '("pixbuf" "GTK_IMAGE_PIXBUF" "1")
    '("stock" "GTK_IMAGE_STOCK" "2")
    '("icon-set" "GTK_IMAGE_ICON_SET" "3")
    '("animation" "GTK_IMAGE_ANIMATION" "4")
    '("icon-name" "GTK_IMAGE_ICON_NAME" "5")
    '("gicon" "GTK_IMAGE_GICON" "6")
    '("surface" "GTK_IMAGE_SURFACE" "7")
  )
)

;; From gtkmenu.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_ARROWS_BOTH,
;;   GTK_ARROWS_START,
;;   GTK_ARROWS_END
;; } GtkArrowPlacement;

(define-enum-extended ArrowPlacement
  (in-module "Gtk")
  (c-name "GtkArrowPlacement")
  (values
    '("both" "GTK_ARROWS_BOTH" "0")
    '("start" "GTK_ARROWS_START" "1")
    '("end" "GTK_ARROWS_END" "2")
  )
)

;; From gtkmenutrackeritem.h

;; Original typedef:
;; typedef enum  {
;;   GTK_MENU_TRACKER_ITEM_ROLE_NORMAL,
;;   GTK_MENU_TRACKER_ITEM_ROLE_CHECK,
;;   GTK_MENU_TRACKER_ITEM_ROLE_RADIO,
;; } GtkMenuTrackerItemRole;

(define-enum-extended MenuTrackerItemRole
  (in-module "Gtk")
  (c-name "GtkMenuTrackerItemRole")
  (values
    '("normal" "GTK_MENU_TRACKER_ITEM_ROLE_NORMAL" "0")
    '("check" "GTK_MENU_TRACKER_ITEM_ROLE_CHECK" "1")
    '("radio" "GTK_MENU_TRACKER_ITEM_ROLE_RADIO" "2")
  )
)

;; From gtkmessagedialog.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_BUTTONS_NONE,
;;   GTK_BUTTONS_OK,
;;   GTK_BUTTONS_CLOSE,
;;   GTK_BUTTONS_CANCEL,
;;   GTK_BUTTONS_YES_NO,
;;   GTK_BUTTONS_OK_CANCEL
;; } GtkButtonsType;

(define-enum-extended ButtonsType
  (in-module "Gtk")
  (c-name "GtkButtonsType")
  (values
    '("none" "GTK_BUTTONS_NONE" "0")
    '("ok" "GTK_BUTTONS_OK" "1")
    '("close" "GTK_BUTTONS_CLOSE" "2")
    '("cancel" "GTK_BUTTONS_CANCEL" "3")
    '("yes-no" "GTK_BUTTONS_YES_NO" "4")
    '("ok-cancel" "GTK_BUTTONS_OK_CANCEL" "5")
  )
)

;; From gtkmodelbutton.h

;; Original typedef:
;; typedef enum {
;;   GTK_BUTTON_ROLE_NORMAL,
;;   GTK_BUTTON_ROLE_CHECK,
;;   GTK_BUTTON_ROLE_RADIO
;; } GtkButtonRole;

(define-enum-extended ButtonRole
  (in-module "Gtk")
  (c-name "GtkButtonRole")
  (values
    '("normal" "GTK_BUTTON_ROLE_NORMAL" "0")
    '("check" "GTK_BUTTON_ROLE_CHECK" "1")
    '("radio" "GTK_BUTTON_ROLE_RADIO" "2")
  )
)

;; From gtknotebook.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_NOTEBOOK_TAB_FIRST,
;;   GTK_NOTEBOOK_TAB_LAST
;; } GtkNotebookTab;

(define-enum-extended NotebookTab
  (in-module "Gtk")
  (c-name "GtkNotebookTab")
  (values
    '("first" "GTK_NOTEBOOK_TAB_FIRST" "0")
    '("last" "GTK_NOTEBOOK_TAB_LAST" "1")
  )
)

;; From gtkpadcontroller.h

;; Original typedef:
;; typedef enum {
;;   GTK_PAD_ACTION_BUTTON,
;;   GTK_PAD_ACTION_RING,
;;   GTK_PAD_ACTION_STRIP
;; } GtkPadActionType;

(define-enum-extended PadActionType
  (in-module "Gtk")
  (c-name "GtkPadActionType")
  (values
    '("button" "GTK_PAD_ACTION_BUTTON" "0")
    '("ring" "GTK_PAD_ACTION_RING" "1")
    '("strip" "GTK_PAD_ACTION_STRIP" "2")
  )
)

;; From gtkplacessidebar.h

;; Original typedef:
;; typedef enum {
;;   GTK_PLACES_OPEN_NORMAL     = 1 << 0,
;;   GTK_PLACES_OPEN_NEW_TAB    = 1 << 1,
;;   GTK_PLACES_OPEN_NEW_WINDOW = 1 << 2
;; } GtkPlacesOpenFlags;

(define-flags-extended PlacesOpenFlags
  (in-module "Gtk")
  (c-name "GtkPlacesOpenFlags")
  (values
    '("normal" "GTK_PLACES_OPEN_NORMAL" "1 << 0")
    '("new-tab" "GTK_PLACES_OPEN_NEW_TAB" "1 << 1")
    '("new-window" "GTK_PLACES_OPEN_NEW_WINDOW" "1 << 2")
  )
)

;; From gtkprintbackend.h

;; Original typedef:
;; typedef enum
;; {
;;   /* TODO: add specific errors */
;;   GTK_PRINT_BACKEND_ERROR_GENERIC
;; } GtkPrintBackendError;

(define-enum-extended PrintBackendError
  (in-module "Gtk")
  (c-name "GtkPrintBackendError")
  (values
    '("generic" "GTK_PRINT_BACKEND_ERROR_GENERIC" "0")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_BACKEND_STATUS_UNKNOWN,
;;   GTK_PRINT_BACKEND_STATUS_OK,
;;   GTK_PRINT_BACKEND_STATUS_UNAVAILABLE
;; } GtkPrintBackendStatus;

(define-enum-extended PrintBackendStatus
  (in-module "Gtk")
  (c-name "GtkPrintBackendStatus")
  (values
    '("unknown" "GTK_PRINT_BACKEND_STATUS_UNKNOWN" "0")
    '("ok" "GTK_PRINT_BACKEND_STATUS_OK" "1")
    '("unavailable" "GTK_PRINT_BACKEND_STATUS_UNAVAILABLE" "2")
  )
)

;; From gtkprinter.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_CAPABILITY_PAGE_SET         = 1 << 0,
;;   GTK_PRINT_CAPABILITY_COPIES           = 1 << 1,
;;   GTK_PRINT_CAPABILITY_COLLATE          = 1 << 2,
;;   GTK_PRINT_CAPABILITY_REVERSE          = 1 << 3,
;;   GTK_PRINT_CAPABILITY_SCALE            = 1 << 4,
;;   GTK_PRINT_CAPABILITY_GENERATE_PDF     = 1 << 5,
;;   GTK_PRINT_CAPABILITY_GENERATE_PS      = 1 << 6,
;;   GTK_PRINT_CAPABILITY_PREVIEW          = 1 << 7,
;;   GTK_PRINT_CAPABILITY_NUMBER_UP        = 1 << 8,
;;   GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT = 1 << 9
;; } GtkPrintCapabilities;

(define-flags-extended PrintCapabilities
  (in-module "Gtk")
  (c-name "GtkPrintCapabilities")
  (values
    '("page-set" "GTK_PRINT_CAPABILITY_PAGE_SET" "1 << 0")
    '("copies" "GTK_PRINT_CAPABILITY_COPIES" "1 << 1")
    '("collate" "GTK_PRINT_CAPABILITY_COLLATE" "1 << 2")
    '("reverse" "GTK_PRINT_CAPABILITY_REVERSE" "1 << 3")
    '("scale" "GTK_PRINT_CAPABILITY_SCALE" "1 << 4")
    '("generate-pdf" "GTK_PRINT_CAPABILITY_GENERATE_PDF" "1 << 5")
    '("generate-ps" "GTK_PRINT_CAPABILITY_GENERATE_PS" "1 << 6")
    '("preview" "GTK_PRINT_CAPABILITY_PREVIEW" "1 << 7")
    '("number-up" "GTK_PRINT_CAPABILITY_NUMBER_UP" "1 << 8")
    '("number-up-layout" "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT" "1 << 9")
  )
)

;; From gtkprinteroption.h

;; Original typedef:
;; typedef enum {
;;   GTK_PRINTER_OPTION_TYPE_BOOLEAN,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE_REAL,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE_INT,
;;   GTK_PRINTER_OPTION_TYPE_PICKONE_STRING,
;;   GTK_PRINTER_OPTION_TYPE_ALTERNATIVE,
;;   GTK_PRINTER_OPTION_TYPE_STRING,
;;   GTK_PRINTER_OPTION_TYPE_FILESAVE,
;;   GTK_PRINTER_OPTION_TYPE_INFO
;; } GtkPrinterOptionType;

(define-enum-extended PrinterOptionType
  (in-module "Gtk")
  (c-name "GtkPrinterOptionType")
  (values
    '("boolean" "GTK_PRINTER_OPTION_TYPE_BOOLEAN" "0")
    '("pickone" "GTK_PRINTER_OPTION_TYPE_PICKONE" "1")
    '("pickone-password" "GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD" "2")
    '("pickone-passcode" "GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE" "3")
    '("pickone-real" "GTK_PRINTER_OPTION_TYPE_PICKONE_REAL" "4")
    '("pickone-int" "GTK_PRINTER_OPTION_TYPE_PICKONE_INT" "5")
    '("pickone-string" "GTK_PRINTER_OPTION_TYPE_PICKONE_STRING" "6")
    '("alternative" "GTK_PRINTER_OPTION_TYPE_ALTERNATIVE" "7")
    '("string" "GTK_PRINTER_OPTION_TYPE_STRING" "8")
    '("filesave" "GTK_PRINTER_OPTION_TYPE_FILESAVE" "9")
    '("info" "GTK_PRINTER_OPTION_TYPE_INFO" "10")
  )
)

;; From gtkprintoperation.h

;; Original typedef:
;; typedef enum {
;;   GTK_PRINT_STATUS_INITIAL,
;;   GTK_PRINT_STATUS_PREPARING,
;;   GTK_PRINT_STATUS_GENERATING_DATA,
;;   GTK_PRINT_STATUS_SENDING_DATA,
;;   GTK_PRINT_STATUS_PENDING,
;;   GTK_PRINT_STATUS_PENDING_ISSUE,
;;   GTK_PRINT_STATUS_PRINTING,
;;   GTK_PRINT_STATUS_FINISHED,
;;   GTK_PRINT_STATUS_FINISHED_ABORTED
;; } GtkPrintStatus;

(define-enum-extended PrintStatus
  (in-module "Gtk")
  (c-name "GtkPrintStatus")
  (values
    '("initial" "GTK_PRINT_STATUS_INITIAL" "0")
    '("preparing" "GTK_PRINT_STATUS_PREPARING" "1")
    '("generating-data" "GTK_PRINT_STATUS_GENERATING_DATA" "2")
    '("sending-data" "GTK_PRINT_STATUS_SENDING_DATA" "3")
    '("pending" "GTK_PRINT_STATUS_PENDING" "4")
    '("pending-issue" "GTK_PRINT_STATUS_PENDING_ISSUE" "5")
    '("printing" "GTK_PRINT_STATUS_PRINTING" "6")
    '("finished" "GTK_PRINT_STATUS_FINISHED" "7")
    '("finished-aborted" "GTK_PRINT_STATUS_FINISHED_ABORTED" "8")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_PRINT_OPERATION_RESULT_ERROR,
;;   GTK_PRINT_OPERATION_RESULT_APPLY,
;;   GTK_PRINT_OPERATION_RESULT_CANCEL,
;;   GTK_PRINT_OPERATION_RESULT_IN_PROGRESS
;; } GtkPrintOperationResult;

(define-enum-extended PrintOperationResult
  (in-module "Gtk")
  (c-name "GtkPrintOperationResult")
  (values
    '("error" "GTK_PRINT_OPERATION_RESULT_ERROR" "0")
    '("apply" "GTK_PRINT_OPERATION_RESULT_APPLY" "1")
    '("cancel" "GTK_PRINT_OPERATION_RESULT_CANCEL" "2")
    '("in-progress" "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS" "3")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
;;   GTK_PRINT_OPERATION_ACTION_PRINT,
;;   GTK_PRINT_OPERATION_ACTION_PREVIEW,
;;   GTK_PRINT_OPERATION_ACTION_EXPORT
;; } GtkPrintOperationAction;

(define-enum-extended PrintOperationAction
  (in-module "Gtk")
  (c-name "GtkPrintOperationAction")
  (values
    '("print-dialog" "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG" "0")
    '("print" "GTK_PRINT_OPERATION_ACTION_PRINT" "1")
    '("preview" "GTK_PRINT_OPERATION_ACTION_PREVIEW" "2")
    '("export" "GTK_PRINT_OPERATION_ACTION_EXPORT" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PRINT_ERROR_GENERAL,
;;   GTK_PRINT_ERROR_INTERNAL_ERROR,
;;   GTK_PRINT_ERROR_NOMEM,
;;   GTK_PRINT_ERROR_INVALID_FILE
;; } GtkPrintError;

(define-enum-extended PrintError
  (in-module "Gtk")
  (c-name "GtkPrintError")
  (values
    '("general" "GTK_PRINT_ERROR_GENERAL" "0")
    '("internal-error" "GTK_PRINT_ERROR_INTERNAL_ERROR" "1")
    '("nomem" "GTK_PRINT_ERROR_NOMEM" "2")
    '("invalid-file" "GTK_PRINT_ERROR_INVALID_FILE" "3")
  )
)

;; From gtkrbtree.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RBNODE_BLACK = 1 << 0,
;;   GTK_RBNODE_RED = 1 << 1,
;;   GTK_RBNODE_IS_PARENT = 1 << 2,
;;   GTK_RBNODE_IS_SELECTED = 1 << 3,
;;   GTK_RBNODE_IS_PRELIT = 1 << 4,
;;   GTK_RBNODE_INVALID = 1 << 7,
;;   GTK_RBNODE_COLUMN_INVALID = 1 << 8,
;;   GTK_RBNODE_DESCENDANTS_INVALID = 1 << 9,
;;   GTK_RBNODE_NON_COLORS = GTK_RBNODE_IS_PARENT |
;;   			  GTK_RBNODE_IS_SELECTED |
;;   			  GTK_RBNODE_IS_PRELIT |
;;                           GTK_RBNODE_INVALID |
;;                           GTK_RBNODE_COLUMN_INVALID |
;;                           GTK_RBNODE_DESCENDANTS_INVALID
;; } GtkRBNodeColor;

(define-flags-extended RBNodeColor
  (in-module "Gtk")
  (c-name "GtkRBNodeColor")
  (values
    '("black" "GTK_RBNODE_BLACK" "1 << 0")
    '("red" "GTK_RBNODE_RED" "1 << 1")
    '("is-parent" "GTK_RBNODE_IS_PARENT" "1 << 2")
    '("is-selected" "GTK_RBNODE_IS_SELECTED" "1 << 3")
    '("is-prelit" "GTK_RBNODE_IS_PRELIT" "1 << 4")
    '("invalid" "GTK_RBNODE_INVALID" "1 << 7")
    '("column-invalid" "GTK_RBNODE_COLUMN_INVALID" "1 << 8")
    '("descendants-invalid" "GTK_RBNODE_DESCENDANTS_INVALID" "1 << 9")
    '("non-colors" "GTK_RBNODE_NON_COLORS" "0x39C")
  )
)

;; From gtkrecentchooser.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RECENT_SORT_NONE = 0,
;;   GTK_RECENT_SORT_MRU,
;;   GTK_RECENT_SORT_LRU,
;;   GTK_RECENT_SORT_CUSTOM
;; } GtkRecentSortType;

(define-enum-extended RecentSortType
  (in-module "Gtk")
  (c-name "GtkRecentSortType")
  (values
    '("none" "GTK_RECENT_SORT_NONE" "0")
    '("mru" "GTK_RECENT_SORT_MRU" "1")
    '("lru" "GTK_RECENT_SORT_LRU" "2")
    '("custom" "GTK_RECENT_SORT_CUSTOM" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
;;   GTK_RECENT_CHOOSER_ERROR_INVALID_URI
;; } GtkRecentChooserError;

(define-enum-extended RecentChooserError
  (in-module "Gtk")
  (c-name "GtkRecentChooserError")
  (values
    '("not-found" "GTK_RECENT_CHOOSER_ERROR_NOT_FOUND" "0")
    '("invalid-uri" "GTK_RECENT_CHOOSER_ERROR_INVALID_URI" "1")
  )
)

;; From gtkrecentchooserutils.h

;; Original typedef:
;; typedef enum {
;;   GTK_RECENT_CHOOSER_PROP_FIRST           = 0x3000,
;;   GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER,
;;   GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE,
;;   GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND,
;;   GTK_RECENT_CHOOSER_PROP_SHOW_TIPS,
;;   GTK_RECENT_CHOOSER_PROP_SHOW_ICONS,
;;   GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE,
;;   GTK_RECENT_CHOOSER_PROP_LIMIT,
;;   GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY,
;;   GTK_RECENT_CHOOSER_PROP_SORT_TYPE,
;;   GTK_RECENT_CHOOSER_PROP_FILTER,
;;   GTK_RECENT_CHOOSER_PROP_LAST
;; } GtkRecentChooserProp;

(define-enum-extended RecentChooserProp
  (in-module "Gtk")
  (c-name "GtkRecentChooserProp")
  (values
    '("first" "GTK_RECENT_CHOOSER_PROP_FIRST" "0x3000")
    '("recent-manager" "GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER" "12289")
    '("show-private" "GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE" "12290")
    '("show-not-found" "GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND" "12291")
    '("show-tips" "GTK_RECENT_CHOOSER_PROP_SHOW_TIPS" "12292")
    '("show-icons" "GTK_RECENT_CHOOSER_PROP_SHOW_ICONS" "12293")
    '("select-multiple" "GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE" "12294")
    '("limit" "GTK_RECENT_CHOOSER_PROP_LIMIT" "12295")
    '("local-only" "GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY" "12296")
    '("sort-type" "GTK_RECENT_CHOOSER_PROP_SORT_TYPE" "12297")
    '("filter" "GTK_RECENT_CHOOSER_PROP_FILTER" "12298")
    '("last" "GTK_RECENT_CHOOSER_PROP_LAST" "12299")
  )
)

;; From gtkrecentfilter.h

;; Original typedef:
;; typedef enum {
;;   GTK_RECENT_FILTER_URI          = 1 << 0,
;;   GTK_RECENT_FILTER_DISPLAY_NAME = 1 << 1,
;;   GTK_RECENT_FILTER_MIME_TYPE    = 1 << 2,
;;   GTK_RECENT_FILTER_APPLICATION  = 1 << 3,
;;   GTK_RECENT_FILTER_GROUP        = 1 << 4,
;;   GTK_RECENT_FILTER_AGE          = 1 << 5
;; } GtkRecentFilterFlags;

(define-flags-extended RecentFilterFlags
  (in-module "Gtk")
  (c-name "GtkRecentFilterFlags")
  (values
    '("uri" "GTK_RECENT_FILTER_URI" "1 << 0")
    '("display-name" "GTK_RECENT_FILTER_DISPLAY_NAME" "1 << 1")
    '("mime-type" "GTK_RECENT_FILTER_MIME_TYPE" "1 << 2")
    '("application" "GTK_RECENT_FILTER_APPLICATION" "1 << 3")
    '("group" "GTK_RECENT_FILTER_GROUP" "1 << 4")
    '("age" "GTK_RECENT_FILTER_AGE" "1 << 5")
  )
)

;; From gtkrecentmanager.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
;;   GTK_RECENT_MANAGER_ERROR_INVALID_URI,
;;   GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
;;   GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
;;   GTK_RECENT_MANAGER_ERROR_READ,
;;   GTK_RECENT_MANAGER_ERROR_WRITE,
;;   GTK_RECENT_MANAGER_ERROR_UNKNOWN
;; } GtkRecentManagerError;

(define-enum-extended RecentManagerError
  (in-module "Gtk")
  (c-name "GtkRecentManagerError")
  (values
    '("not-found" "GTK_RECENT_MANAGER_ERROR_NOT_FOUND" "0")
    '("invalid-uri" "GTK_RECENT_MANAGER_ERROR_INVALID_URI" "1")
    '("invalid-encoding" "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING" "2")
    '("not-registered" "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED" "3")
    '("read" "GTK_RECENT_MANAGER_ERROR_READ" "4")
    '("write" "GTK_RECENT_MANAGER_ERROR_WRITE" "5")
    '("unknown" "GTK_RECENT_MANAGER_ERROR_UNKNOWN" "6")
  )
)

;; From gtkrevealer.h

;; Original typedef:
;; typedef enum {
;;   GTK_REVEALER_TRANSITION_TYPE_NONE,
;;   GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
;;   GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
;;   GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
;;   GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
;;   GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN
;; } GtkRevealerTransitionType;

(define-enum-extended RevealerTransitionType
  (in-module "Gtk")
  (c-name "GtkRevealerTransitionType")
  (values
    '("none" "GTK_REVEALER_TRANSITION_TYPE_NONE" "0")
    '("crossfade" "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE" "1")
    '("slide-right" "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT" "2")
    '("slide-left" "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT" "3")
    '("slide-up" "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP" "4")
    '("slide-down" "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN" "5")
  )
)

;; From gtkscrolledwindow.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_CORNER_TOP_LEFT,
;;   GTK_CORNER_BOTTOM_LEFT,
;;   GTK_CORNER_TOP_RIGHT,
;;   GTK_CORNER_BOTTOM_RIGHT
;; } GtkCornerType;

(define-enum-extended CornerType
  (in-module "Gtk")
  (c-name "GtkCornerType")
  (values
    '("top-left" "GTK_CORNER_TOP_LEFT" "0")
    '("bottom-left" "GTK_CORNER_BOTTOM_LEFT" "1")
    '("top-right" "GTK_CORNER_TOP_RIGHT" "2")
    '("bottom-right" "GTK_CORNER_BOTTOM_RIGHT" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_POLICY_ALWAYS,
;;   GTK_POLICY_AUTOMATIC,
;;   GTK_POLICY_NEVER,
;;   GTK_POLICY_EXTERNAL
;; } GtkPolicyType;

(define-enum-extended PolicyType
  (in-module "Gtk")
  (c-name "GtkPolicyType")
  (values
    '("always" "GTK_POLICY_ALWAYS" "0")
    '("automatic" "GTK_POLICY_AUTOMATIC" "1")
    '("never" "GTK_POLICY_NEVER" "2")
    '("external" "GTK_POLICY_EXTERNAL" "3")
  )
)

;; From gtkselection.h

;; Original typedef:
;; typedef enum {
;;   GTK_TARGET_SAME_APP = 1 << 0,    /*< nick=same-app >*/
;;   GTK_TARGET_SAME_WIDGET = 1 << 1, /*< nick=same-widget >*/
;;   GTK_TARGET_OTHER_APP = 1 << 2,   /*< nick=other-app >*/
;;   GTK_TARGET_OTHER_WIDGET = 1 << 3 /*< nick=other-widget >*/
;; } GtkTargetFlags;

(define-flags-extended TargetFlags
  (in-module "Gtk")
  (c-name "GtkTargetFlags")
  (values
    '("same-app" "GTK_TARGET_SAME_APP" "1 << 0")
    '("same-widget" "GTK_TARGET_SAME_WIDGET" "1 << 1")
    '("other-app" "GTK_TARGET_OTHER_APP" "1 << 2")
    '("other-widget" "GTK_TARGET_OTHER_WIDGET" "1 << 3")
  )
)

;; From gtkshortcutsshortcut.h

;; Original typedef:
;; typedef enum {
;;   GTK_SHORTCUT_ACCELERATOR,
;;   GTK_SHORTCUT_GESTURE_PINCH,
;;   GTK_SHORTCUT_GESTURE_STRETCH,
;;   GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
;;   GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE,
;;   GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
;;   GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
;;   GTK_SHORTCUT_GESTURE
;; } GtkShortcutType;

(define-enum-extended ShortcutType
  (in-module "Gtk")
  (c-name "GtkShortcutType")
  (values
    '("accelerator" "GTK_SHORTCUT_ACCELERATOR" "0")
    '("gesture-pinch" "GTK_SHORTCUT_GESTURE_PINCH" "1")
    '("gesture-stretch" "GTK_SHORTCUT_GESTURE_STRETCH" "2")
    '("gesture-rotate-clockwise" "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE" "3")
    '("gesture-rotate-counterclockwise" "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE" "4")
    '("gesture-two-finger-swipe-left" "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT" "5")
    '("gesture-two-finger-swipe-right" "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT" "6")
    '("gesture" "GTK_SHORTCUT_GESTURE" "7")
  )
)

;; From gtkspinbutton.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_UPDATE_ALWAYS,
;;   GTK_UPDATE_IF_VALID
;; } GtkSpinButtonUpdatePolicy;

(define-enum-extended SpinButtonUpdatePolicy
  (in-module "Gtk")
  (c-name "GtkSpinButtonUpdatePolicy")
  (values
    '("always" "GTK_UPDATE_ALWAYS" "0")
    '("if-valid" "GTK_UPDATE_IF_VALID" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_SPIN_STEP_FORWARD,
;;   GTK_SPIN_STEP_BACKWARD,
;;   GTK_SPIN_PAGE_FORWARD,
;;   GTK_SPIN_PAGE_BACKWARD,
;;   GTK_SPIN_HOME,
;;   GTK_SPIN_END,
;;   GTK_SPIN_USER_DEFINED
;; } GtkSpinType;

(define-enum-extended SpinType
  (in-module "Gtk")
  (c-name "GtkSpinType")
  (values
    '("step-forward" "GTK_SPIN_STEP_FORWARD" "0")
    '("step-backward" "GTK_SPIN_STEP_BACKWARD" "1")
    '("page-forward" "GTK_SPIN_PAGE_FORWARD" "2")
    '("page-backward" "GTK_SPIN_PAGE_BACKWARD" "3")
    '("home" "GTK_SPIN_HOME" "4")
    '("end" "GTK_SPIN_END" "5")
    '("user-defined" "GTK_SPIN_USER_DEFINED" "6")
  )
)

;; From gtkstack.h

;; Original typedef:
;; typedef enum {
;;   GTK_STACK_TRANSITION_TYPE_NONE,
;;   GTK_STACK_TRANSITION_TYPE_CROSSFADE,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
;;   GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
;;   GTK_STACK_TRANSITION_TYPE_OVER_UP,
;;   GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
;;   GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
;;   GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
;;   GTK_STACK_TRANSITION_TYPE_UNDER_UP,
;;   GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
;;   GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
;;   GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
;;   GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
;;   GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
;;   GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
;;   GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT
;; } GtkStackTransitionType;

(define-enum-extended StackTransitionType
  (in-module "Gtk")
  (c-name "GtkStackTransitionType")
  (values
    '("none" "GTK_STACK_TRANSITION_TYPE_NONE" "0")
    '("crossfade" "GTK_STACK_TRANSITION_TYPE_CROSSFADE" "1")
    '("slide-right" "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT" "2")
    '("slide-left" "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT" "3")
    '("slide-up" "GTK_STACK_TRANSITION_TYPE_SLIDE_UP" "4")
    '("slide-down" "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN" "5")
    '("slide-left-right" "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT" "6")
    '("slide-up-down" "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN" "7")
    '("over-up" "GTK_STACK_TRANSITION_TYPE_OVER_UP" "8")
    '("over-down" "GTK_STACK_TRANSITION_TYPE_OVER_DOWN" "9")
    '("over-left" "GTK_STACK_TRANSITION_TYPE_OVER_LEFT" "10")
    '("over-right" "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT" "11")
    '("under-up" "GTK_STACK_TRANSITION_TYPE_UNDER_UP" "12")
    '("under-down" "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN" "13")
    '("under-left" "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT" "14")
    '("under-right" "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT" "15")
    '("over-up-down" "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN" "16")
    '("over-down-up" "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP" "17")
    '("over-left-right" "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT" "18")
    '("over-right-left" "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT" "19")
  )
)

;; From gtkstylecontext.h

;; Original typedef:
;; typedef enum {
;;   GTK_STYLE_CONTEXT_PRINT_NONE         = 0,
;;   GTK_STYLE_CONTEXT_PRINT_RECURSE      = 1 << 0,
;;   GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE   = 1 << 1
;; } GtkStyleContextPrintFlags;

(define-flags-extended StyleContextPrintFlags
  (in-module "Gtk")
  (c-name "GtkStyleContextPrintFlags")
  (values
    '("none" "GTK_STYLE_CONTEXT_PRINT_NONE" "0x0")
    '("recurse" "GTK_STYLE_CONTEXT_PRINT_RECURSE" "1 << 0")
    '("show-style" "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE" "1 << 1")
  )
)

;; From gtktextbuffer.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS = - 1,
;;   GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT       = - 2,
;;   GTK_TEXT_BUFFER_TARGET_INFO_TEXT            = - 3
;; } GtkTextBufferTargetInfo;

(define-enum-extended TextBufferTargetInfo
  (in-module "Gtk")
  (c-name "GtkTextBufferTargetInfo")
  (values
    '("buffer-contents" "GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS" "-1")
    '("rich-text" "GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT" "-2")
    '("text" "GTK_TEXT_BUFFER_TARGET_INFO_TEXT" "-3")
  )
)

;; From gtktextiter.h

;; Original typedef:
;; typedef enum {
;;   GTK_TEXT_SEARCH_VISIBLE_ONLY     = 1 << 0,
;;   GTK_TEXT_SEARCH_TEXT_ONLY        = 1 << 1,
;;   GTK_TEXT_SEARCH_CASE_INSENSITIVE = 1 << 2
;;   /* Possible future plans: SEARCH_REGEXP */
;; } GtkTextSearchFlags;

(define-flags-extended TextSearchFlags
  (in-module "Gtk")
  (c-name "GtkTextSearchFlags")
  (values
    '("visible-only" "GTK_TEXT_SEARCH_VISIBLE_ONLY" "1 << 0")
    '("text-only" "GTK_TEXT_SEARCH_TEXT_ONLY" "1 << 1")
    '("case-insensitive" "GTK_TEXT_SEARCH_CASE_INSENSITIVE" "1 << 2")
  )
)

;; From gtktextview.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TEXT_WINDOW_PRIVATE,
;;   GTK_TEXT_WINDOW_WIDGET,
;;   GTK_TEXT_WINDOW_TEXT,
;;   GTK_TEXT_WINDOW_LEFT,
;;   GTK_TEXT_WINDOW_RIGHT,
;;   GTK_TEXT_WINDOW_TOP,
;;   GTK_TEXT_WINDOW_BOTTOM
;; } GtkTextWindowType;

(define-enum-extended TextWindowType
  (in-module "Gtk")
  (c-name "GtkTextWindowType")
  (values
    '("private" "GTK_TEXT_WINDOW_PRIVATE" "0")
    '("widget" "GTK_TEXT_WINDOW_WIDGET" "1")
    '("text" "GTK_TEXT_WINDOW_TEXT" "2")
    '("left" "GTK_TEXT_WINDOW_LEFT" "3")
    '("right" "GTK_TEXT_WINDOW_RIGHT" "4")
    '("top" "GTK_TEXT_WINDOW_TOP" "5")
    '("bottom" "GTK_TEXT_WINDOW_BOTTOM" "6")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TEXT_VIEW_LAYER_BELOW,
;;   GTK_TEXT_VIEW_LAYER_ABOVE,
;;   GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
;;   GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
;; } GtkTextViewLayer;

(define-enum-extended TextViewLayer
  (in-module "Gtk")
  (c-name "GtkTextViewLayer")
  (values
    '("below" "GTK_TEXT_VIEW_LAYER_BELOW" "0")
    '("above" "GTK_TEXT_VIEW_LAYER_ABOVE" "1")
    '("below-text" "GTK_TEXT_VIEW_LAYER_BELOW_TEXT" "2")
    '("above-text" "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT" "3")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TEXT_EXTEND_SELECTION_WORD,
;;   GTK_TEXT_EXTEND_SELECTION_LINE
;; } GtkTextExtendSelection;

(define-enum-extended TextExtendSelection
  (in-module "Gtk")
  (c-name "GtkTextExtendSelection")
  (values
    '("word" "GTK_TEXT_EXTEND_SELECTION_WORD" "0")
    '("line" "GTK_TEXT_EXTEND_SELECTION_LINE" "1")
  )
)

;; From gtktoolbar.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TOOLBAR_SPACE_EMPTY,
;;   GTK_TOOLBAR_SPACE_LINE
;; } GtkToolbarSpaceStyle;

(define-enum-extended ToolbarSpaceStyle
  (in-module "Gtk")
  (c-name "GtkToolbarSpaceStyle")
  (values
    '("empty" "GTK_TOOLBAR_SPACE_EMPTY" "0")
    '("line" "GTK_TOOLBAR_SPACE_LINE" "1")
  )
)

;; From gtktoolpalette.h

;; Original typedef:
;; typedef enum /*< flags >*/
;; {
;;   GTK_TOOL_PALETTE_DRAG_ITEMS = (1 << 0),
;;   GTK_TOOL_PALETTE_DRAG_GROUPS = (1 << 1)
;; }
;; GtkToolPaletteDragTargets;

(define-flags-extended ToolPaletteDragTargets
  (in-module "Gtk")
  (c-name "GtkToolPaletteDragTargets")
  (values
    '("items" "GTK_TOOL_PALETTE_DRAG_ITEMS" "(1 << 0)")
    '("groups" "GTK_TOOL_PALETTE_DRAG_GROUPS" "(1 << 1)")
  )
)

;; From gtktreemodel.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0,
;;   GTK_TREE_MODEL_LIST_ONLY = 1 << 1
;; } GtkTreeModelFlags;

(define-flags-extended TreeModelFlags
  (in-module "Gtk")
  (c-name "GtkTreeModelFlags")
  (values
    '("iters-persist" "GTK_TREE_MODEL_ITERS_PERSIST" "1 << 0")
    '("list-only" "GTK_TREE_MODEL_LIST_ONLY" "1 << 1")
  )
)

;; From gtktreeviewcolumn.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_TREE_VIEW_COLUMN_GROW_ONLY,
;;   GTK_TREE_VIEW_COLUMN_AUTOSIZE,
;;   GTK_TREE_VIEW_COLUMN_FIXED
;; } GtkTreeViewColumnSizing;

(define-enum-extended TreeViewColumnSizing
  (in-module "Gtk")
  (c-name "GtkTreeViewColumnSizing")
  (values
    '("grow-only" "GTK_TREE_VIEW_COLUMN_GROW_ONLY" "0")
    '("autosize" "GTK_TREE_VIEW_COLUMN_AUTOSIZE" "1")
    '("fixed" "GTK_TREE_VIEW_COLUMN_FIXED" "2")
  )
)

;; From gtktreeview.h

;; Original typedef:
;; typedef enum
;; {
;;   /* drop before/after this row */
;;   GTK_TREE_VIEW_DROP_BEFORE,
;;   GTK_TREE_VIEW_DROP_AFTER,
;;   /* drop as a child of this row (with fallback to before or after
;;    * if into is not possible)
;;    */
;;   GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
;;   GTK_TREE_VIEW_DROP_INTO_OR_AFTER
;; } GtkTreeViewDropPosition;

(define-enum-extended TreeViewDropPosition
  (in-module "Gtk")
  (c-name "GtkTreeViewDropPosition")
  (values
    '("before" "GTK_TREE_VIEW_DROP_BEFORE" "0")
    '("after" "GTK_TREE_VIEW_DROP_AFTER" "1")
    '("into-or-before" "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE" "2")
    '("into-or-after" "GTK_TREE_VIEW_DROP_INTO_OR_AFTER" "3")
  )
)

;; From gtkwidget.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_WIDGET_HELP_TOOLTIP,
;;   GTK_WIDGET_HELP_WHATS_THIS
;; } GtkWidgetHelpType;

(define-enum-extended WidgetHelpType
  (in-module "Gtk")
  (c-name "GtkWidgetHelpType")
  (values
    '("tooltip" "GTK_WIDGET_HELP_TOOLTIP" "0")
    '("whats-this" "GTK_WIDGET_HELP_WHATS_THIS" "1")
  )
)

;; From gtkwin32embed.h

;; Original typedef:
;; typedef enum {					/* send or post? */
;;   /* First those sent from the socket
;;    * to the plug
;;    */
;;   GTK_WIN32_EMBED_WINDOW_ACTIVATE,		/* post */
;;   GTK_WIN32_EMBED_WINDOW_DEACTIVATE,		/* post */
;;   GTK_WIN32_EMBED_FOCUS_IN,			/* post */
;;   GTK_WIN32_EMBED_FOCUS_OUT,			/* post */
;;   GTK_WIN32_EMBED_MODALITY_ON,			/* post */
;;   GTK_WIN32_EMBED_MODALITY_OFF,			/* post */
;;
;;   /* Then the ones sent from the plug
;;    * to the socket.
;;    */
;;   GTK_WIN32_EMBED_PARENT_NOTIFY,		/* post */
;;   GTK_WIN32_EMBED_EVENT_PLUG_MAPPED,		/* post */
;;   GTK_WIN32_EMBED_PLUG_RESIZED,			/* post */
;;   GTK_WIN32_EMBED_REQUEST_FOCUS,		/* post */
;;   GTK_WIN32_EMBED_FOCUS_NEXT,			/* post */
;;   GTK_WIN32_EMBED_FOCUS_PREV,			/* post */
;;   GTK_WIN32_EMBED_GRAB_KEY,			/* post */
;;   GTK_WIN32_EMBED_UNGRAB_KEY,			/* post */
;;   GTK_WIN32_EMBED_LAST
;; } GtkWin32EmbedMessageType;

(define-enum-extended Win32EmbedMessageType
  (in-module "Gtk")
  (c-name "GtkWin32EmbedMessageType")
  (values
    '("window-activate" "GTK_WIN32_EMBED_WINDOW_ACTIVATE" "0")
    '("window-deactivate" "GTK_WIN32_EMBED_WINDOW_DEACTIVATE" "1")
    '("focus-in" "GTK_WIN32_EMBED_FOCUS_IN" "2")
    '("focus-out" "GTK_WIN32_EMBED_FOCUS_OUT" "3")
    '("modality-on" "GTK_WIN32_EMBED_MODALITY_ON" "4")
    '("modality-off" "GTK_WIN32_EMBED_MODALITY_OFF" "5")
    '("parent-notify" "GTK_WIN32_EMBED_PARENT_NOTIFY" "6")
    '("event-plug-mapped" "GTK_WIN32_EMBED_EVENT_PLUG_MAPPED" "7")
    '("plug-resized" "GTK_WIN32_EMBED_PLUG_RESIZED" "8")
    '("request-focus" "GTK_WIN32_EMBED_REQUEST_FOCUS" "9")
    '("focus-next" "GTK_WIN32_EMBED_FOCUS_NEXT" "10")
    '("focus-prev" "GTK_WIN32_EMBED_FOCUS_PREV" "11")
    '("grab-key" "GTK_WIN32_EMBED_GRAB_KEY" "12")
    '("ungrab-key" "GTK_WIN32_EMBED_UNGRAB_KEY" "13")
    '("last" "GTK_WIN32_EMBED_LAST" "14")
  )
)

;; From gtkwindow.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_WINDOW_TOPLEVEL,
;;   GTK_WINDOW_POPUP
;; } GtkWindowType;

(define-enum-extended WindowType
  (in-module "Gtk")
  (c-name "GtkWindowType")
  (values
    '("toplevel" "GTK_WINDOW_TOPLEVEL" "0")
    '("popup" "GTK_WINDOW_POPUP" "1")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_WIN_POS_NONE,
;;   GTK_WIN_POS_CENTER,
;;   GTK_WIN_POS_MOUSE,
;;   GTK_WIN_POS_CENTER_ALWAYS,
;;   GTK_WIN_POS_CENTER_ON_PARENT
;; } GtkWindowPosition;

(define-enum-extended WindowPosition
  (in-module "Gtk")
  (c-name "GtkWindowPosition")
  (values
    '("none" "GTK_WIN_POS_NONE" "0")
    '("center" "GTK_WIN_POS_CENTER" "1")
    '("mouse" "GTK_WIN_POS_MOUSE" "2")
    '("center-always" "GTK_WIN_POS_CENTER_ALWAYS" "3")
    '("center-on-parent" "GTK_WIN_POS_CENTER_ON_PARENT" "4")
  )
)

;; From xembed.h

;; Original typedef:
;; typedef enum {
;;   XEMBED_EMBEDDED_NOTIFY        = 0,
;;   XEMBED_WINDOW_ACTIVATE        = 1,
;;   XEMBED_WINDOW_DEACTIVATE      = 2,
;;   XEMBED_REQUEST_FOCUS          = 3,
;;   XEMBED_FOCUS_IN               = 4,
;;   XEMBED_FOCUS_OUT              = 5,
;;   XEMBED_FOCUS_NEXT             = 6,
;;   XEMBED_FOCUS_PREV             = 7,
;;   XEMBED_GRAB_KEY               = 8,
;;   XEMBED_UNGRAB_KEY             = 9,
;;   XEMBED_MODALITY_ON            = 10,
;;   XEMBED_MODALITY_OFF           = 11,
;;
;; /* Non standard messages*/
;;   XEMBED_GTK_GRAB_KEY           = 108,
;;   XEMBED_GTK_UNGRAB_KEY         = 109
;; } XEmbedMessageType;

(define-enum-extended XEmbedMessageType
  (in-module "Gtk")
  (c-name "XEmbedMessageType")
  (values
    '("embedded-notify" "XEMBED_EMBEDDED_NOTIFY" "0")
    '("window-activate" "XEMBED_WINDOW_ACTIVATE" "1")
    '("window-deactivate" "XEMBED_WINDOW_DEACTIVATE" "2")
    '("request-focus" "XEMBED_REQUEST_FOCUS" "3")
    '("focus-in" "XEMBED_FOCUS_IN" "4")
    '("focus-out" "XEMBED_FOCUS_OUT" "5")
    '("focus-next" "XEMBED_FOCUS_NEXT" "6")
    '("focus-prev" "XEMBED_FOCUS_PREV" "7")
    '("grab-key" "XEMBED_GRAB_KEY" "8")
    '("ungrab-key" "XEMBED_UNGRAB_KEY" "9")
    '("modality-on" "XEMBED_MODALITY_ON" "10")
    '("modality-off" "XEMBED_MODALITY_OFF" "11")
    '("gtk-grab-key" "XEMBED_GTK_GRAB_KEY" "108")
    '("gtk-ungrab-key" "XEMBED_GTK_UNGRAB_KEY" "109")
  )
)

;; From gtkrc.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_RC_FG             = 1 << 0,
;;   GTK_RC_BG             = 1 << 1,
;;   GTK_RC_TEXT           = 1 << 2,
;;   GTK_RC_BASE           = 1 << 3
;; } GtkRcFlags;

(define-flags-extended RcFlags
  (in-module "Gtk")
  (c-name "GtkRcFlags")
  (values
    '("fg" "GTK_RC_FG" "1 << 0")
    '("bg" "GTK_RC_BG" "1 << 1")
    '("text" "GTK_RC_TEXT" "1 << 2")
    '("base" "GTK_RC_BASE" "1 << 3")
  )
)

;; Original typedef:
;; typedef enum {
;;   GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
;;   GTK_RC_TOKEN_INCLUDE,
;;   GTK_RC_TOKEN_NORMAL,
;;   GTK_RC_TOKEN_ACTIVE,
;;   GTK_RC_TOKEN_PRELIGHT,
;;   GTK_RC_TOKEN_SELECTED,
;;   GTK_RC_TOKEN_INSENSITIVE,
;;   GTK_RC_TOKEN_FG,
;;   GTK_RC_TOKEN_BG,
;;   GTK_RC_TOKEN_TEXT,
;;   GTK_RC_TOKEN_BASE,
;;   GTK_RC_TOKEN_XTHICKNESS,
;;   GTK_RC_TOKEN_YTHICKNESS,
;;   GTK_RC_TOKEN_FONT,
;;   GTK_RC_TOKEN_FONTSET,
;;   GTK_RC_TOKEN_FONT_NAME,
;;   GTK_RC_TOKEN_BG_PIXMAP,
;;   GTK_RC_TOKEN_PIXMAP_PATH,
;;   GTK_RC_TOKEN_STYLE,
;;   GTK_RC_TOKEN_BINDING,
;;   GTK_RC_TOKEN_BIND,
;;   GTK_RC_TOKEN_WIDGET,
;;   GTK_RC_TOKEN_WIDGET_CLASS,
;;   GTK_RC_TOKEN_CLASS,
;;   GTK_RC_TOKEN_LOWEST,
;;   GTK_RC_TOKEN_GTK,
;;   GTK_RC_TOKEN_APPLICATION,
;;   GTK_RC_TOKEN_THEME,
;;   GTK_RC_TOKEN_RC,
;;   GTK_RC_TOKEN_HIGHEST,
;;   GTK_RC_TOKEN_ENGINE,
;;   GTK_RC_TOKEN_MODULE_PATH,
;;   GTK_RC_TOKEN_IM_MODULE_PATH,
;;   GTK_RC_TOKEN_IM_MODULE_FILE,
;;   GTK_RC_TOKEN_STOCK,
;;   GTK_RC_TOKEN_LTR,
;;   GTK_RC_TOKEN_RTL,
;;   GTK_RC_TOKEN_COLOR,
;;   GTK_RC_TOKEN_UNBIND,
;;   GTK_RC_TOKEN_LAST
;; } GtkRcTokenType;

(define-enum-extended RcTokenType
  (in-module "Gtk")
  (c-name "GtkRcTokenType")
  (values
    '("invalid" "GTK_RC_TOKEN_INVALID" "G_TOKEN_LAST")
    '("include" "GTK_RC_TOKEN_INCLUDE" "(G_TOKEN_LAST) + 1")
    '("normal" "GTK_RC_TOKEN_NORMAL" "(G_TOKEN_LAST) + 2")
    '("active" "GTK_RC_TOKEN_ACTIVE" "(G_TOKEN_LAST) + 3")
    '("prelight" "GTK_RC_TOKEN_PRELIGHT" "(G_TOKEN_LAST) + 4")
    '("selected" "GTK_RC_TOKEN_SELECTED" "(G_TOKEN_LAST) + 5")
    '("insensitive" "GTK_RC_TOKEN_INSENSITIVE" "(G_TOKEN_LAST) + 6")
    '("fg" "GTK_RC_TOKEN_FG" "(G_TOKEN_LAST) + 7")
    '("bg" "GTK_RC_TOKEN_BG" "(G_TOKEN_LAST) + 8")
    '("text" "GTK_RC_TOKEN_TEXT" "(G_TOKEN_LAST) + 9")
    '("base" "GTK_RC_TOKEN_BASE" "(G_TOKEN_LAST) + 10")
    '("xthickness" "GTK_RC_TOKEN_XTHICKNESS" "(G_TOKEN_LAST) + 11")
    '("ythickness" "GTK_RC_TOKEN_YTHICKNESS" "(G_TOKEN_LAST) + 12")
    '("font" "GTK_RC_TOKEN_FONT" "(G_TOKEN_LAST) + 13")
    '("fontset" "GTK_RC_TOKEN_FONTSET" "(G_TOKEN_LAST) + 14")
    '("font-name" "GTK_RC_TOKEN_FONT_NAME" "(G_TOKEN_LAST) + 15")
    '("bg-pixmap" "GTK_RC_TOKEN_BG_PIXMAP" "(G_TOKEN_LAST) + 16")
    '("pixmap-path" "GTK_RC_TOKEN_PIXMAP_PATH" "(G_TOKEN_LAST) + 17")
    '("style" "GTK_RC_TOKEN_STYLE" "(G_TOKEN_LAST) + 18")
    '("binding" "GTK_RC_TOKEN_BINDING" "(G_TOKEN_LAST) + 19")
    '("bind" "GTK_RC_TOKEN_BIND" "(G_TOKEN_LAST) + 20")
    '("widget" "GTK_RC_TOKEN_WIDGET" "(G_TOKEN_LAST) + 21")
    '("widget-class" "GTK_RC_TOKEN_WIDGET_CLASS" "(G_TOKEN_LAST) + 22")
    '("class" "GTK_RC_TOKEN_CLASS" "(G_TOKEN_LAST) + 23")
    '("lowest" "GTK_RC_TOKEN_LOWEST" "(G_TOKEN_LAST) + 24")
    '("gtk" "GTK_RC_TOKEN_GTK" "(G_TOKEN_LAST) + 25")
    '("application" "GTK_RC_TOKEN_APPLICATION" "(G_TOKEN_LAST) + 26")
    '("theme" "GTK_RC_TOKEN_THEME" "(G_TOKEN_LAST) + 27")
    '("rc" "GTK_RC_TOKEN_RC" "(G_TOKEN_LAST) + 28")
    '("highest" "GTK_RC_TOKEN_HIGHEST" "(G_TOKEN_LAST) + 29")
    '("engine" "GTK_RC_TOKEN_ENGINE" "(G_TOKEN_LAST) + 30")
    '("module-path" "GTK_RC_TOKEN_MODULE_PATH" "(G_TOKEN_LAST) + 31")
    '("im-module-path" "GTK_RC_TOKEN_IM_MODULE_PATH" "(G_TOKEN_LAST) + 32")
    '("im-module-file" "GTK_RC_TOKEN_IM_MODULE_FILE" "(G_TOKEN_LAST) + 33")
    '("stock" "GTK_RC_TOKEN_STOCK" "(G_TOKEN_LAST) + 34")
    '("ltr" "GTK_RC_TOKEN_LTR" "(G_TOKEN_LAST) + 35")
    '("rtl" "GTK_RC_TOKEN_RTL" "(G_TOKEN_LAST) + 36")
    '("color" "GTK_RC_TOKEN_COLOR" "(G_TOKEN_LAST) + 37")
    '("unbind" "GTK_RC_TOKEN_UNBIND" "(G_TOKEN_LAST) + 38")
    '("last" "GTK_RC_TOKEN_LAST" "(G_TOKEN_LAST) + 39")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PATH_PRIO_LOWEST      = 0,
;;   GTK_PATH_PRIO_GTK         = 4,
;;   GTK_PATH_PRIO_APPLICATION = 8,
;;   GTK_PATH_PRIO_THEME       = 10,
;;   GTK_PATH_PRIO_RC          = 12,
;;   GTK_PATH_PRIO_HIGHEST     = 15
;; } GtkPathPriorityType;

(define-enum-extended PathPriorityType
  (in-module "Gtk")
  (c-name "GtkPathPriorityType")
  (values
    '("lowest" "GTK_PATH_PRIO_LOWEST" "0")
    '("gtk" "GTK_PATH_PRIO_GTK" "4")
    '("application" "GTK_PATH_PRIO_APPLICATION" "8")
    '("theme" "GTK_PATH_PRIO_THEME" "10")
    '("rc" "GTK_PATH_PRIO_RC" "12")
    '("highest" "GTK_PATH_PRIO_HIGHEST" "15")
  )
)

;; Original typedef:
;; typedef enum
;; {
;;   GTK_PATH_WIDGET,
;;   GTK_PATH_WIDGET_CLASS,
;;   GTK_PATH_CLASS
;; } GtkPathType;

(define-enum-extended PathType
  (in-module "Gtk")
  (c-name "GtkPathType")
  (values
    '("widget" "GTK_PATH_WIDGET" "0")
    '("widget-class" "GTK_PATH_WIDGET_CLASS" "1")
    '("class" "GTK_PATH_CLASS" "2")
  )
)

;; From gtkstyle.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_EXPANDER_COLLAPSED,
;;   GTK_EXPANDER_SEMI_COLLAPSED,
;;   GTK_EXPANDER_SEMI_EXPANDED,
;;   GTK_EXPANDER_EXPANDED
;; } GtkExpanderStyle;

(define-enum-extended ExpanderStyle
  (in-module "Gtk")
  (c-name "GtkExpanderStyle")
  (values
    '("collapsed" "GTK_EXPANDER_COLLAPSED" "0")
    '("semi-collapsed" "GTK_EXPANDER_SEMI_COLLAPSED" "1")
    '("semi-expanded" "GTK_EXPANDER_SEMI_EXPANDED" "2")
    '("expanded" "GTK_EXPANDER_EXPANDED" "3")
  )
)

;; From gtktable.h

;; Original typedef:
;; typedef enum
;; {
;;   GTK_EXPAND = 1 << 0,
;;   GTK_SHRINK = 1 << 1,
;;   GTK_FILL   = 1 << 2
;; } GtkAttachOptions;

(define-flags-extended AttachOptions
  (in-module "Gtk")
  (c-name "GtkAttachOptions")
  (values
    '("expand" "GTK_EXPAND" "1 << 0")
    '("shrink" "GTK_SHRINK" "1 << 1")
    '("fill" "GTK_FILL" "1 << 2")
  )
)

;; From gtkuimanager.h

;; Original typedef:
;; typedef enum {
;;   GTK_UI_MANAGER_AUTO              = 0,
;;   GTK_UI_MANAGER_MENUBAR           = 1 << 0,
;;   GTK_UI_MANAGER_MENU              = 1 << 1,
;;   GTK_UI_MANAGER_TOOLBAR           = 1 << 2,
;;   GTK_UI_MANAGER_PLACEHOLDER       = 1 << 3,
;;   GTK_UI_MANAGER_POPUP             = 1 << 4,
;;   GTK_UI_MANAGER_MENUITEM          = 1 << 5,
;;   GTK_UI_MANAGER_TOOLITEM          = 1 << 6,
;;   GTK_UI_MANAGER_SEPARATOR         = 1 << 7,
;;   GTK_UI_MANAGER_ACCELERATOR       = 1 << 8,
;;   GTK_UI_MANAGER_POPUP_WITH_ACCELS = 1 << 9
;; } GtkUIManagerItemType;

(define-flags-extended UIManagerItemType
  (in-module "Gtk")
  (c-name "GtkUIManagerItemType")
  (values
    '("auto" "GTK_UI_MANAGER_AUTO" "0x0")
    '("menubar" "GTK_UI_MANAGER_MENUBAR" "1 << 0")
    '("menu" "GTK_UI_MANAGER_MENU" "1 << 1")
    '("toolbar" "GTK_UI_MANAGER_TOOLBAR" "1 << 2")
    '("placeholder" "GTK_UI_MANAGER_PLACEHOLDER" "1 << 3")
    '("popup" "GTK_UI_MANAGER_POPUP" "1 << 4")
    '("menuitem" "GTK_UI_MANAGER_MENUITEM" "1 << 5")
    '("toolitem" "GTK_UI_MANAGER_TOOLITEM" "1 << 6")
    '("separator" "GTK_UI_MANAGER_SEPARATOR" "1 << 7")
    '("accelerator" "GTK_UI_MANAGER_ACCELERATOR" "1 << 8")
    '("popup-with-accels" "GTK_UI_MANAGER_POPUP_WITH_ACCELS" "1 << 9")
  )
)