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

#include "gth-enum-types.h"
#include "cairo-scale.h"
#include "cairo-utils.h"
#include "color-utils.h"
#include "dom.h"
#include "gfixed.h"
#include "gimp-op.h"
#include "gio-utils.h"
#include "glib-utils.h"
#include "gnome-desktop-thumbnail.h"
#include "gsignature.h"
#include "gth-accel-button.h"
#include "gth-accel-dialog.h"
#include "gth-auto-paned.h"
#include "gth-async-task.h"
#include "gth-buffer-data.h"
#include "gth-browser.h"
#include "gth-color-manager.h"
#include "gth-color-scale.h"
#include "gth-delete-task.h"
#include "gth-duplicable.h"
#include "gth-empty-list.h"
#include "gth-extensions.h"
#include "gth-file-chooser-dialog.h"
#include "gth-error.h"
#include "gth-file-data.h"
#include "gth-file-list.h"
#include "gth-file-properties.h"
#include "gth-file-selection.h"
#include "gth-file-selection-info.h"
#include "gth-file-source.h"
#include "gth-file-source-vfs.h"
#include "gth-file-store.h"
#include "gth-file-tool.h"
#include "gth-file-view.h"
#include "gth-filter.h"
#include "gth-filterbar.h"
#include "gth-filter-editor-dialog.h"
#include "gth-filter-file.h"
#include "gth-filter-grid.h"
#include "gth-folder-tree.h"
#include "gth-grid-view.h"
#include "gth-histogram.h"
#include "gth-histogram-view.h"
#include "gth-hook.h"
#include "gth-icc-profile.h"
#include "gth-icon-cache.h"
#include "gth-image.h"
#include "gth-image-dragger.h"
#include "gth-image-history.h"
#include "gth-image-list-task.h"
#include "gth-image-loader.h"
#include "gth-image-navigator.h"
#include "gth-image-overview.h"
#include "gth-image-preloader.h"
#include "gth-image-saver.h"
#include "gth-image-selector.h"
#include "gth-image-task.h"
#include "gth-image-task-chain.h"
#include "gth-image-utils.h"
#include "gth-image-viewer.h"
#include "gth-image-viewer-tool.h"
#include "gth-info-bar.h"
#include "gth-load-file-data-task.h"
#include "gth-location-bar.h"
#include "gth-location-chooser.h"
#include "gth-location-chooser-dialog.h"
#include "gth-main.h"
#include "gth-menu-manager.h"
#include "gth-metadata.h"
#include "gth-metadata-chooser.h"
#include "gth-metadata-provider.h"
#include "gth-monitor.h"
#include "gth-overwrite-dialog.h"
#include "gth-paned.h"
#include "gth-preferences.h"
#include "gth-progress-dialog.h"
#include "gth-property-view.h"
#include "gth-request-dialog.h"
#include "gth-save-file-data-task.h"
#include "gth-save-image-task.h"
#include "gth-screensaver.h"
#include "gth-shortcut.h"
#include "gth-sidebar.h"
#include "gth-sidebar-section.h"
#include "gth-statusbar.h"
#include "gth-string-list.h"
#include "gth-tags-entry.h"
#include "gth-tags-file.h"
#include "gth-template-editor-dialog.h"
#include "gth-template-selector.h"
#include "gth-task.h"
#include "gth-test.h"
#include "gth-test-aspect-ratio.h"
#include "gth-test-category.h"
#include "gth-test-chain.h"
#include "gth-test-selector.h"
#include "gth-test-simple.h"
#include "gth-thumb-loader.h"
#include "gth-time.h"
#include "gth-time-selector.h"
#include "gth-toolbox.h"
#include "gth-uri-list.h"
#include "gth-user-dir.h"
#include "gth-vfs-tree.h"
#include "gth-viewer-page.h"
#include "gth-window.h"
#include "gtk-utils.h"
#include "gvaluehash.h"
#include "pixbuf-cache.h"
#include "pixbuf-io.h"
#include "pixbuf-utils.h"
#include "str-utils.h"
#include "typedefs.h"
#include "uri-utils.h"
#include "zlib-utils.h"

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

/* enumerations from "cairo-utils.h" */

GType
cairo_metadata_flags_t_cairo_metadata_flags_t_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(_CAIRO_METADATA_FLAG_NONE), "_CAIRO_METADATA_FLAG_NONE", "none" },
    { C_FLAGS(_CAIRO_METADATA_FLAG_HAS_ALPHA), "_CAIRO_METADATA_FLAG_HAS_ALPHA", "has-alpha" },
    { C_FLAGS(_CAIRO_METADATA_FLAG_ORIGINAL_SIZE), "_CAIRO_METADATA_FLAG_ORIGINAL_SIZE", "original-size" },
    { C_FLAGS(_CAIRO_METADATA_FLAG_THUMBNAIL_SIZE), "_CAIRO_METADATA_FLAG_THUMBNAIL_SIZE", "thumbnail-size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("cairo_metadata_flags_t"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
item_style_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(ITEM_STYLE_ICON), "ITEM_STYLE_ICON", "icon" },
    { C_ENUM(ITEM_STYLE_IMAGE), "ITEM_STYLE_IMAGE", "image" },
    { C_ENUM(ITEM_STYLE_VIDEO), "ITEM_STYLE_VIDEO", "video" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("ItemStyle"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "dom.h" */

GType
dom_error_enum_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(DOM_ERROR_FAILED), "DOM_ERROR_FAILED", "failed" },
    { C_ENUM(DOM_ERROR_INVALID_FORMAT), "DOM_ERROR_INVALID_FORMAT", "invalid-format" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("DomErrorEnum"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gio-utils.h" */

GType
gth_list_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTH_LIST_DEFAULT), "GTH_LIST_DEFAULT", "default" },
    { C_FLAGS(GTH_LIST_RECURSIVE), "GTH_LIST_RECURSIVE", "recursive" },
    { C_FLAGS(GTH_LIST_NO_FOLLOW_LINKS), "GTH_LIST_NO_FOLLOW_LINKS", "no-follow-links" },
    { C_FLAGS(GTH_LIST_NO_BACKUP_FILES), "GTH_LIST_NO_BACKUP_FILES", "no-backup-files" },
    { C_FLAGS(GTH_LIST_NO_HIDDEN_FILES), "GTH_LIST_NO_HIDDEN_FILES", "no-hidden-files" },
    { C_FLAGS(GTH_LIST_INCLUDE_SIDECARS), "GTH_LIST_INCLUDE_SIDECARS", "include-sidecars" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GthListFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gnome-desktop-thumbnail.h" */

GType
gnome_desktop_thumbnail_size_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL), "GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL", "normal" },
    { C_ENUM(GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE), "GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE", "large" },
    { C_ENUM(GNOME_DESKTOP_THUMBNAIL_SIZE_XLARGE), "GNOME_DESKTOP_THUMBNAIL_SIZE_XLARGE", "xlarge" },
    { C_ENUM(GNOME_DESKTOP_THUMBNAIL_SIZE_XXLARGE), "GNOME_DESKTOP_THUMBNAIL_SIZE_XXLARGE", "xxlarge" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GnomeDesktopThumbnailSize"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gsignature.h" */

GType
g_signature_enc_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(G_SIGNATURE_ENC_HEX), "G_SIGNATURE_ENC_HEX", "hex" },
    { C_ENUM(G_SIGNATURE_ENC_BASE64), "G_SIGNATURE_ENC_BASE64", "base64" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GSignatureEnc"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-browser.h" */

GType
gth_action_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_ACTION_GO_TO), "GTH_ACTION_GO_TO", "go-to" },
    { C_ENUM(GTH_ACTION_GO_BACK), "GTH_ACTION_GO_BACK", "go-back" },
    { C_ENUM(GTH_ACTION_GO_FORWARD), "GTH_ACTION_GO_FORWARD", "go-forward" },
    { C_ENUM(GTH_ACTION_GO_UP), "GTH_ACTION_GO_UP", "go-up" },
    { C_ENUM(GTH_ACTION_TREE_LIST_CHILDREN), "GTH_ACTION_TREE_LIST_CHILDREN", "tree-list-children" },
    { C_ENUM(GTH_ACTION_TREE_OPEN), "GTH_ACTION_TREE_OPEN", "tree-open" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthAction"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_scroll_action_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_SCROLL_ACTION_NONE), "GTH_SCROLL_ACTION_NONE", "none" },
    { C_ENUM(GTH_SCROLL_ACTION_CHANGE_FILE), "GTH_SCROLL_ACTION_CHANGE_FILE", "change-file" },
    { C_ENUM(GTH_SCROLL_ACTION_ZOOM), "GTH_SCROLL_ACTION_ZOOM", "zoom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthScrollAction"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-color-scale.h" */

GType
gth_color_scale_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_COLOR_SCALE_DEFAULT), "GTH_COLOR_SCALE_DEFAULT", "default" },
    { C_ENUM(GTH_COLOR_SCALE_WHITE_BLACK), "GTH_COLOR_SCALE_WHITE_BLACK", "white-black" },
    { C_ENUM(GTH_COLOR_SCALE_BLACK_WHITE), "GTH_COLOR_SCALE_BLACK_WHITE", "black-white" },
    { C_ENUM(GTH_COLOR_SCALE_GRAY_BLACK), "GTH_COLOR_SCALE_GRAY_BLACK", "gray-black" },
    { C_ENUM(GTH_COLOR_SCALE_GRAY_WHITE), "GTH_COLOR_SCALE_GRAY_WHITE", "gray-white" },
    { C_ENUM(GTH_COLOR_SCALE_CYAN_RED), "GTH_COLOR_SCALE_CYAN_RED", "cyan-red" },
    { C_ENUM(GTH_COLOR_SCALE_MAGENTA_GREEN), "GTH_COLOR_SCALE_MAGENTA_GREEN", "magenta-green" },
    { C_ENUM(GTH_COLOR_SCALE_YELLOW_BLUE), "GTH_COLOR_SCALE_YELLOW_BLUE", "yellow-blue" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthColorScaleType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-error.h" */

GType
gth_error_code_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_ERROR_CANCELLED), "GTH_ERROR_CANCELLED", "cancelled" },
    { C_ENUM(GTH_ERROR_GENERIC), "GTH_ERROR_GENERIC", "generic" },
    { C_ENUM(GTH_ERROR_EXTENSION_DEPENDENCY), "GTH_ERROR_EXTENSION_DEPENDENCY", "extension-dependency" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthErrorCode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-file-list.h" */

GType
gth_file_list_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_FILE_LIST_MODE_NORMAL), "GTH_FILE_LIST_MODE_NORMAL", "normal" },
    { C_ENUM(GTH_FILE_LIST_MODE_BROWSER), "GTH_FILE_LIST_MODE_BROWSER", "browser" },
    { C_ENUM(GTH_FILE_LIST_MODE_SELECTOR), "GTH_FILE_LIST_MODE_SELECTOR", "selector" },
    { C_ENUM(GTH_FILE_LIST_MODE_NO_SELECTION), "GTH_FILE_LIST_MODE_NO_SELECTION", "no-selection" },
    { C_ENUM(GTH_FILE_LIST_MODE_V_SIDEBAR), "GTH_FILE_LIST_MODE_V_SIDEBAR", "v-sidebar" },
    { C_ENUM(GTH_FILE_LIST_MODE_H_SIDEBAR), "GTH_FILE_LIST_MODE_H_SIDEBAR", "h-sidebar" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthFileListMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-file-view.h" */

GType
gth_visibility_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_VISIBILITY_NONE), "GTH_VISIBILITY_NONE", "none" },
    { C_ENUM(GTH_VISIBILITY_FULL), "GTH_VISIBILITY_FULL", "full" },
    { C_ENUM(GTH_VISIBILITY_PARTIAL), "GTH_VISIBILITY_PARTIAL", "partial" },
    { C_ENUM(GTH_VISIBILITY_PARTIAL_TOP), "GTH_VISIBILITY_PARTIAL_TOP", "partial-top" },
    { C_ENUM(GTH_VISIBILITY_PARTIAL_BOTTOM), "GTH_VISIBILITY_PARTIAL_BOTTOM", "partial-bottom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthVisibility"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_file_view_renderer_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_FILE_VIEW_RENDERER_CHECKBOX), "GTH_FILE_VIEW_RENDERER_CHECKBOX", "checkbox" },
    { C_ENUM(GTH_FILE_VIEW_RENDERER_THUMBNAIL), "GTH_FILE_VIEW_RENDERER_THUMBNAIL", "thumbnail" },
    { C_ENUM(GTH_FILE_VIEW_RENDERER_TEXT), "GTH_FILE_VIEW_RENDERER_TEXT", "text" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthFileViewRendererType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-filter.h" */

GType
gth_limit_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_LIMIT_TYPE_NONE), "GTH_LIMIT_TYPE_NONE", "none" },
    { C_ENUM(GTH_LIMIT_TYPE_FILES), "GTH_LIMIT_TYPE_FILES", "files" },
    { C_ENUM(GTH_LIMIT_TYPE_SIZE), "GTH_LIMIT_TYPE_SIZE", "size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthLimitType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-grid-view.h" */

GType
gth_cursor_movement_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_CURSOR_MOVE_UP), "GTH_CURSOR_MOVE_UP", "up" },
    { C_ENUM(GTH_CURSOR_MOVE_DOWN), "GTH_CURSOR_MOVE_DOWN", "down" },
    { C_ENUM(GTH_CURSOR_MOVE_RIGHT), "GTH_CURSOR_MOVE_RIGHT", "right" },
    { C_ENUM(GTH_CURSOR_MOVE_LEFT), "GTH_CURSOR_MOVE_LEFT", "left" },
    { C_ENUM(GTH_CURSOR_MOVE_PAGE_UP), "GTH_CURSOR_MOVE_PAGE_UP", "page-up" },
    { C_ENUM(GTH_CURSOR_MOVE_PAGE_DOWN), "GTH_CURSOR_MOVE_PAGE_DOWN", "page-down" },
    { C_ENUM(GTH_CURSOR_MOVE_BEGIN), "GTH_CURSOR_MOVE_BEGIN", "begin" },
    { C_ENUM(GTH_CURSOR_MOVE_END), "GTH_CURSOR_MOVE_END", "end" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthCursorMovement"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_drop_position_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_DROP_POSITION_NONE), "GTH_DROP_POSITION_NONE", "none" },
    { C_ENUM(GTH_DROP_POSITION_INTO), "GTH_DROP_POSITION_INTO", "into" },
    { C_ENUM(GTH_DROP_POSITION_LEFT), "GTH_DROP_POSITION_LEFT", "left" },
    { C_ENUM(GTH_DROP_POSITION_RIGHT), "GTH_DROP_POSITION_RIGHT", "right" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthDropPosition"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_selection_change_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_SELECTION_KEEP), "GTH_SELECTION_KEEP", "keep" },
    { C_ENUM(GTH_SELECTION_SET_CURSOR), "GTH_SELECTION_SET_CURSOR", "set-cursor" },
    { C_ENUM(GTH_SELECTION_SET_RANGE), "GTH_SELECTION_SET_RANGE", "set-range" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthSelectionChange"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-histogram-view.h" */

GType
gth_histogram_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_HISTOGRAM_MODE_ONE_CHANNEL), "GTH_HISTOGRAM_MODE_ONE_CHANNEL", "one-channel" },
    { C_ENUM(GTH_HISTOGRAM_MODE_ALL_CHANNELS), "GTH_HISTOGRAM_MODE_ALL_CHANNELS", "all-channels" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthHistogramMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_histogram_scale_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_HISTOGRAM_SCALE_LINEAR), "GTH_HISTOGRAM_SCALE_LINEAR", "linear" },
    { C_ENUM(GTH_HISTOGRAM_SCALE_LOGARITHMIC), "GTH_HISTOGRAM_SCALE_LOGARITHMIC", "logarithmic" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthHistogramScale"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-histogram.h" */

GType
gth_histogram_channel_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_HISTOGRAM_CHANNEL_VALUE), "GTH_HISTOGRAM_CHANNEL_VALUE", "channel-value" },
    { C_ENUM(GTH_HISTOGRAM_CHANNEL_RED), "GTH_HISTOGRAM_CHANNEL_RED", "channel-red" },
    { C_ENUM(GTH_HISTOGRAM_CHANNEL_GREEN), "GTH_HISTOGRAM_CHANNEL_GREEN", "channel-green" },
    { C_ENUM(GTH_HISTOGRAM_CHANNEL_BLUE), "GTH_HISTOGRAM_CHANNEL_BLUE", "channel-blue" },
    { C_ENUM(GTH_HISTOGRAM_CHANNEL_ALPHA), "GTH_HISTOGRAM_CHANNEL_ALPHA", "channel-alpha" },
    { C_ENUM(GTH_HISTOGRAM_N_CHANNELS), "GTH_HISTOGRAM_N_CHANNELS", "n-channels" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthHistogramChannel"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-image-selector.h" */

GType
gth_selector_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_SELECTOR_TYPE_REGION), "GTH_SELECTOR_TYPE_REGION", "region" },
    { C_ENUM(GTH_SELECTOR_TYPE_POINT), "GTH_SELECTOR_TYPE_POINT", "point" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthSelectorType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-image-viewer.h" */

GType
gth_zoom_quality_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_ZOOM_QUALITY_HIGH), "GTH_ZOOM_QUALITY_HIGH", "high" },
    { C_ENUM(GTH_ZOOM_QUALITY_LOW), "GTH_ZOOM_QUALITY_LOW", "low" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthZoomQuality"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_fit_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_FIT_NONE), "GTH_FIT_NONE", "none" },
    { C_ENUM(GTH_FIT_SIZE), "GTH_FIT_SIZE", "size" },
    { C_ENUM(GTH_FIT_SIZE_IF_LARGER), "GTH_FIT_SIZE_IF_LARGER", "size-if-larger" },
    { C_ENUM(GTH_FIT_WIDTH), "GTH_FIT_WIDTH", "width" },
    { C_ENUM(GTH_FIT_WIDTH_IF_LARGER), "GTH_FIT_WIDTH_IF_LARGER", "width-if-larger" },
    { C_ENUM(GTH_FIT_HEIGHT), "GTH_FIT_HEIGHT", "height" },
    { C_ENUM(GTH_FIT_HEIGHT_IF_LARGER), "GTH_FIT_HEIGHT_IF_LARGER", "height-if-larger" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthFit"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_zoom_change_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_ZOOM_CHANGE_ACTUAL_SIZE), "GTH_ZOOM_CHANGE_ACTUAL_SIZE", "actual-size" },
    { C_ENUM(GTH_ZOOM_CHANGE_KEEP_PREV), "GTH_ZOOM_CHANGE_KEEP_PREV", "keep-prev" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_SIZE), "GTH_ZOOM_CHANGE_FIT_SIZE", "fit-size" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_SIZE_IF_LARGER), "GTH_ZOOM_CHANGE_FIT_SIZE_IF_LARGER", "fit-size-if-larger" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_WIDTH), "GTH_ZOOM_CHANGE_FIT_WIDTH", "fit-width" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_WIDTH_IF_LARGER), "GTH_ZOOM_CHANGE_FIT_WIDTH_IF_LARGER", "fit-width-if-larger" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_HEIGHT), "GTH_ZOOM_CHANGE_FIT_HEIGHT", "fit-height" },
    { C_ENUM(GTH_ZOOM_CHANGE_FIT_HEIGHT_IF_LARGER), "GTH_ZOOM_CHANGE_FIT_HEIGHT_IF_LARGER", "fit-height-if-larger" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthZoomChange"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_transparency_style_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TRANSPARENCY_STYLE_CHECKERED), "GTH_TRANSPARENCY_STYLE_CHECKERED", "checkered" },
    { C_ENUM(GTH_TRANSPARENCY_STYLE_WHITE), "GTH_TRANSPARENCY_STYLE_WHITE", "white" },
    { C_ENUM(GTH_TRANSPARENCY_STYLE_GRAY), "GTH_TRANSPARENCY_STYLE_GRAY", "gray" },
    { C_ENUM(GTH_TRANSPARENCY_STYLE_BLACK), "GTH_TRANSPARENCY_STYLE_BLACK", "black" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTransparencyStyle"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-image.h" */

GType
gth_image_format_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_IMAGE_FORMAT_CAIRO_SURFACE), "GTH_IMAGE_FORMAT_CAIRO_SURFACE", "format-cairo-surface" },
    { C_ENUM(GTH_IMAGE_FORMAT_GDK_PIXBUF), "GTH_IMAGE_FORMAT_GDK_PIXBUF", "format-gdk-pixbuf" },
    { C_ENUM(GTH_IMAGE_FORMAT_GDK_PIXBUF_ANIMATION), "GTH_IMAGE_FORMAT_GDK_PIXBUF_ANIMATION", "format-gdk-pixbuf-animation" },
    { C_ENUM(GTH_IMAGE_N_FORMATS), "GTH_IMAGE_N_FORMATS", "n-formats" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthImageFormat"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-metadata-provider.h" */

GType
gth_metadata_write_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTH_METADATA_WRITE_DEFAULT), "GTH_METADATA_WRITE_DEFAULT", "default" },
    { C_FLAGS(GTH_METADATA_WRITE_FORCE_EMBEDDED), "GTH_METADATA_WRITE_FORCE_EMBEDDED", "force-embedded" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GthMetadataWriteFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-metadata.h" */

GType
gth_metadata_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_METADATA_TYPE_STRING), "GTH_METADATA_TYPE_STRING", "string" },
    { C_ENUM(GTH_METADATA_TYPE_STRING_LIST), "GTH_METADATA_TYPE_STRING_LIST", "string-list" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthMetadataType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_metadata_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTH_METADATA_ALLOW_NOWHERE), "GTH_METADATA_ALLOW_NOWHERE", "nowhere" },
    { C_FLAGS(GTH_METADATA_ALLOW_IN_FILE_LIST), "GTH_METADATA_ALLOW_IN_FILE_LIST", "in-file-list" },
    { C_FLAGS(GTH_METADATA_ALLOW_IN_PROPERTIES_VIEW), "GTH_METADATA_ALLOW_IN_PROPERTIES_VIEW", "in-properties-view" },
    { C_FLAGS(GTH_METADATA_ALLOW_IN_PRINT), "GTH_METADATA_ALLOW_IN_PRINT", "in-print" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GthMetadataFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-monitor.h" */

GType
gth_monitor_event_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_MONITOR_EVENT_CREATED), "GTH_MONITOR_EVENT_CREATED", "created" },
    { C_ENUM(GTH_MONITOR_EVENT_DELETED), "GTH_MONITOR_EVENT_DELETED", "deleted" },
    { C_ENUM(GTH_MONITOR_EVENT_CHANGED), "GTH_MONITOR_EVENT_CHANGED", "changed" },
    { C_ENUM(GTH_MONITOR_EVENT_REMOVED), "GTH_MONITOR_EVENT_REMOVED", "removed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthMonitorEvent"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-overwrite-dialog.h" */

GType
gth_overwrite_response_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_OVERWRITE_RESPONSE_UNSPECIFIED), "GTH_OVERWRITE_RESPONSE_UNSPECIFIED", "unspecified" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_YES), "GTH_OVERWRITE_RESPONSE_YES", "yes" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_NO), "GTH_OVERWRITE_RESPONSE_NO", "no" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_ALWAYS_YES), "GTH_OVERWRITE_RESPONSE_ALWAYS_YES", "always-yes" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_ALWAYS_NO), "GTH_OVERWRITE_RESPONSE_ALWAYS_NO", "always-no" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_RENAME), "GTH_OVERWRITE_RESPONSE_RENAME", "rename" },
    { C_ENUM(GTH_OVERWRITE_RESPONSE_CANCEL), "GTH_OVERWRITE_RESPONSE_CANCEL", "cancel" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthOverwriteResponse"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-sidebar.h" */

GType
gth_sidebar_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_SIDEBAR_STATE_HIDDEN), "GTH_SIDEBAR_STATE_HIDDEN", "hidden" },
    { C_ENUM(GTH_SIDEBAR_STATE_PROPERTIES), "GTH_SIDEBAR_STATE_PROPERTIES", "properties" },
    { C_ENUM(GTH_SIDEBAR_STATE_TOOLS), "GTH_SIDEBAR_STATE_TOOLS", "tools" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthSidebarState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-statusbar.h" */

GType
gth_statusbar_section_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_STATUSBAR_SECTION_FILE_LIST), "GTH_STATUSBAR_SECTION_FILE_LIST", "file-list" },
    { C_ENUM(GTH_STATUSBAR_SECTION_FILE), "GTH_STATUSBAR_SECTION_FILE", "file" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthStatusbarSection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-tags-entry.h" */

GType
gth_tags_entry_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TAGS_ENTRY_MODE_POPUP), "GTH_TAGS_ENTRY_MODE_POPUP", "popup" },
    { C_ENUM(GTH_TAGS_ENTRY_MODE_INLINE), "GTH_TAGS_ENTRY_MODE_INLINE", "inline" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTagsEntryMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-task.h" */

GType
gth_task_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GTH_TASK_FLAGS_SHOW_ERROR), "GTH_TASK_FLAGS_SHOW_ERROR", "show-error" },
    { C_FLAGS(GTH_TASK_FLAGS_IGNORE_ERROR), "GTH_TASK_FLAGS_IGNORE_ERROR", "ignore-error" },
    { C_FLAGS(GTH_TASK_FLAGS_FOREGROUND), "GTH_TASK_FLAGS_FOREGROUND", "foreground" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GthTaskFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_task_error_enum_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TASK_ERROR_FAILED), "GTH_TASK_ERROR_FAILED", "failed" },
    { C_ENUM(GTH_TASK_ERROR_CANCELLED), "GTH_TASK_ERROR_CANCELLED", "cancelled" },
    { C_ENUM(GTH_TASK_ERROR_SKIP_TO_NEXT_FILE), "GTH_TASK_ERROR_SKIP_TO_NEXT_FILE", "skip-to-next-file" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTaskErrorEnum"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-template-selector.h" */

GType
gth_template_code_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_SPACE), "GTH_TEMPLATE_CODE_TYPE_SPACE", "space" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_TEXT), "GTH_TEMPLATE_CODE_TYPE_TEXT", "text" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_ENUMERATOR), "GTH_TEMPLATE_CODE_TYPE_ENUMERATOR", "enumerator" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_SIMPLE), "GTH_TEMPLATE_CODE_TYPE_SIMPLE", "simple" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_DATE), "GTH_TEMPLATE_CODE_TYPE_DATE", "date" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_FILE_ATTRIBUTE), "GTH_TEMPLATE_CODE_TYPE_FILE_ATTRIBUTE", "file-attribute" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_ASK_VALUE), "GTH_TEMPLATE_CODE_TYPE_ASK_VALUE", "ask-value" },
    { C_ENUM(GTH_TEMPLATE_CODE_TYPE_QUOTED), "GTH_TEMPLATE_CODE_TYPE_QUOTED", "quoted" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTemplateCodeType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-test-chain.h" */

GType
gth_match_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_MATCH_TYPE_NONE), "GTH_MATCH_TYPE_NONE", "none" },
    { C_ENUM(GTH_MATCH_TYPE_ALL), "GTH_MATCH_TYPE_ALL", "all" },
    { C_ENUM(GTH_MATCH_TYPE_ANY), "GTH_MATCH_TYPE_ANY", "any" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthMatchType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-test-simple.h" */

GType
gth_test_data_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TEST_DATA_TYPE_NONE), "GTH_TEST_DATA_TYPE_NONE", "none" },
    { C_ENUM(GTH_TEST_DATA_TYPE_INT), "GTH_TEST_DATA_TYPE_INT", "int" },
    { C_ENUM(GTH_TEST_DATA_TYPE_SIZE), "GTH_TEST_DATA_TYPE_SIZE", "size" },
    { C_ENUM(GTH_TEST_DATA_TYPE_STRING), "GTH_TEST_DATA_TYPE_STRING", "string" },
    { C_ENUM(GTH_TEST_DATA_TYPE_DATE), "GTH_TEST_DATA_TYPE_DATE", "date" },
    { C_ENUM(GTH_TEST_DATA_TYPE_DOUBLE), "GTH_TEST_DATA_TYPE_DOUBLE", "double" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTestDataType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-test.h" */

GType
gth_match_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_MATCH_NO), "GTH_MATCH_NO", "no" },
    { C_ENUM(GTH_MATCH_YES), "GTH_MATCH_YES", "yes" },
    { C_ENUM(GTH_MATCH_LIMIT_REACHED), "GTH_MATCH_LIMIT_REACHED", "limit-reached" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthMatch"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_test_op_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TEST_OP_NONE), "GTH_TEST_OP_NONE", "none" },
    { C_ENUM(GTH_TEST_OP_EQUAL), "GTH_TEST_OP_EQUAL", "equal" },
    { C_ENUM(GTH_TEST_OP_LOWER), "GTH_TEST_OP_LOWER", "lower" },
    { C_ENUM(GTH_TEST_OP_GREATER), "GTH_TEST_OP_GREATER", "greater" },
    { C_ENUM(GTH_TEST_OP_CONTAINS), "GTH_TEST_OP_CONTAINS", "contains" },
    { C_ENUM(GTH_TEST_OP_CONTAINS_ALL), "GTH_TEST_OP_CONTAINS_ALL", "contains-all" },
    { C_ENUM(GTH_TEST_OP_CONTAINS_ONLY), "GTH_TEST_OP_CONTAINS_ONLY", "contains-only" },
    { C_ENUM(GTH_TEST_OP_STARTS_WITH), "GTH_TEST_OP_STARTS_WITH", "starts-with" },
    { C_ENUM(GTH_TEST_OP_ENDS_WITH), "GTH_TEST_OP_ENDS_WITH", "ends-with" },
    { C_ENUM(GTH_TEST_OP_MATCHES), "GTH_TEST_OP_MATCHES", "matches" },
    { C_ENUM(GTH_TEST_OP_BEFORE), "GTH_TEST_OP_BEFORE", "before" },
    { C_ENUM(GTH_TEST_OP_AFTER), "GTH_TEST_OP_AFTER", "after" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTestOp"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-toolbox.h" */

GType
gth_toolbox_section_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TOOLBOX_SECTION_FILE), "GTH_TOOLBOX_SECTION_FILE", "section-file" },
    { C_ENUM(GTH_TOOLBOX_SECTION_COLORS), "GTH_TOOLBOX_SECTION_COLORS", "section-colors" },
    { C_ENUM(GTH_TOOLBOX_SECTION_ROTATION), "GTH_TOOLBOX_SECTION_ROTATION", "section-rotation" },
    { C_ENUM(GTH_TOOLBOX_SECTION_FORMAT), "GTH_TOOLBOX_SECTION_FORMAT", "section-format" },
    { C_ENUM(GTH_TOOLBOX_N_SECTIONS), "GTH_TOOLBOX_N_SECTIONS", "n-sections" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthToolboxSection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "gth-user-dir.h" */

GType
gth_dir_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_DIR_CONFIG), "GTH_DIR_CONFIG", "config" },
    { C_ENUM(GTH_DIR_CACHE), "GTH_DIR_CACHE", "cache" },
    { C_ENUM(GTH_DIR_DATA), "GTH_DIR_DATA", "data" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthDir"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "pixbuf-cache.h" */

GType
pixbuf_cache_channel_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(PIXBUF_CACHE_CHANNEL_VALUE), "PIXBUF_CACHE_CHANNEL_VALUE", "value" },
    { C_ENUM(PIXBUF_CACHE_CHANNEL_RED), "PIXBUF_CACHE_CHANNEL_RED", "red" },
    { C_ENUM(PIXBUF_CACHE_CHANNEL_GREEN), "PIXBUF_CACHE_CHANNEL_GREEN", "green" },
    { C_ENUM(PIXBUF_CACHE_CHANNEL_BLUE), "PIXBUF_CACHE_CHANNEL_BLUE", "blue" },
    { C_ENUM(PIXBUF_CACHE_CHANNEL_ALPHA), "PIXBUF_CACHE_CHANNEL_ALPHA", "alpha" },
    { C_ENUM(PIXBUF_CACHE_CHANNEL_SIZE), "PIXBUF_CACHE_CHANNEL_SIZE", "size" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("PixbufCacheChannel"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "str-utils.h" */

GType
template_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(TEMPLATE_FLAGS_DEFAULT), "TEMPLATE_FLAGS_DEFAULT", "default" },
    { C_FLAGS(TEMPLATE_FLAGS_NO_ENUMERATOR), "TEMPLATE_FLAGS_NO_ENUMERATOR", "no-enumerator" },
    { C_FLAGS(TEMPLATE_FLAGS_PREVIEW), "TEMPLATE_FLAGS_PREVIEW", "preview" },
    { C_FLAGS(TEMPLATE_FLAGS_PARTIAL), "TEMPLATE_FLAGS_PARTIAL", "partial" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("TemplateFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "typedefs.h" */

GType
gth_click_policy_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_CLICK_POLICY_NAUTILUS), "GTH_CLICK_POLICY_NAUTILUS", "nautilus" },
    { C_ENUM(GTH_CLICK_POLICY_SINGLE), "GTH_CLICK_POLICY_SINGLE", "single" },
    { C_ENUM(GTH_CLICK_POLICY_DOUBLE), "GTH_CLICK_POLICY_DOUBLE", "double" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthClickPolicy"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_direction_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_DIRECTION_FORWARD), "GTH_DIRECTION_FORWARD", "forward" },
    { C_ENUM(GTH_DIRECTION_REVERSE), "GTH_DIRECTION_REVERSE", "reverse" },
    { C_ENUM(GTH_DIRECTION_RANDOM), "GTH_DIRECTION_RANDOM", "random" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthDirection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_transform_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_TRANSFORM_NONE), "GTH_TRANSFORM_NONE", "none" },
    { C_ENUM(GTH_TRANSFORM_FLIP_H), "GTH_TRANSFORM_FLIP_H", "flip-h" },
    { C_ENUM(GTH_TRANSFORM_ROTATE_180), "GTH_TRANSFORM_ROTATE_180", "rotate-180" },
    { C_ENUM(GTH_TRANSFORM_FLIP_V), "GTH_TRANSFORM_FLIP_V", "flip-v" },
    { C_ENUM(GTH_TRANSFORM_TRANSPOSE), "GTH_TRANSFORM_TRANSPOSE", "transpose" },
    { C_ENUM(GTH_TRANSFORM_ROTATE_90), "GTH_TRANSFORM_ROTATE_90", "rotate-90" },
    { C_ENUM(GTH_TRANSFORM_TRANSVERSE), "GTH_TRANSFORM_TRANSVERSE", "transverse" },
    { C_ENUM(GTH_TRANSFORM_ROTATE_270), "GTH_TRANSFORM_ROTATE_270", "rotate-270" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthTransform"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_unit_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_UNIT_PIXELS), "GTH_UNIT_PIXELS", "pixels" },
    { C_ENUM(GTH_UNIT_PERCENTAGE), "GTH_UNIT_PERCENTAGE", "percentage" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthUnit"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_metric_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_METRIC_PIXELS), "GTH_METRIC_PIXELS", "pixels" },
    { C_ENUM(GTH_METRIC_MILLIMETERS), "GTH_METRIC_MILLIMETERS", "millimeters" },
    { C_ENUM(GTH_METRIC_INCHES), "GTH_METRIC_INCHES", "inches" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthMetric"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_aspect_ratio_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_ASPECT_RATIO_NONE), "GTH_ASPECT_RATIO_NONE", "none" },
    { C_ENUM(GTH_ASPECT_RATIO_SQUARE), "GTH_ASPECT_RATIO_SQUARE", "square" },
    { C_ENUM(GTH_ASPECT_RATIO_IMAGE), "GTH_ASPECT_RATIO_IMAGE", "image" },
    { C_ENUM(GTH_ASPECT_RATIO_DISPLAY), "GTH_ASPECT_RATIO_DISPLAY", "display" },
    { C_ENUM(GTH_ASPECT_RATIO_5x4), "GTH_ASPECT_RATIO_5x4", "5x4" },
    { C_ENUM(GTH_ASPECT_RATIO_4x3), "GTH_ASPECT_RATIO_4x3", "4x3" },
    { C_ENUM(GTH_ASPECT_RATIO_7x5), "GTH_ASPECT_RATIO_7x5", "7x5" },
    { C_ENUM(GTH_ASPECT_RATIO_3x2), "GTH_ASPECT_RATIO_3x2", "3x2" },
    { C_ENUM(GTH_ASPECT_RATIO_16x10), "GTH_ASPECT_RATIO_16x10", "16x10" },
    { C_ENUM(GTH_ASPECT_RATIO_16x9), "GTH_ASPECT_RATIO_16x9", "16x9" },
    { C_ENUM(GTH_ASPECT_RATIO_185x100), "GTH_ASPECT_RATIO_185x100", "185x100" },
    { C_ENUM(GTH_ASPECT_RATIO_239x100), "GTH_ASPECT_RATIO_239x100", "239x100" },
    { C_ENUM(GTH_ASPECT_RATIO_CUSTOM), "GTH_ASPECT_RATIO_CUSTOM", "custom" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthAspectRatio"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_overwrite_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_OVERWRITE_SKIP), "GTH_OVERWRITE_SKIP", "skip" },
    { C_ENUM(GTH_OVERWRITE_RENAME), "GTH_OVERWRITE_RENAME", "rename" },
    { C_ENUM(GTH_OVERWRITE_ASK), "GTH_OVERWRITE_ASK", "ask" },
    { C_ENUM(GTH_OVERWRITE_OVERWRITE), "GTH_OVERWRITE_OVERWRITE", "overwrite" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthOverwriteMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_grid_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_GRID_NONE), "GTH_GRID_NONE", "none" },
    { C_ENUM(GTH_GRID_THIRDS), "GTH_GRID_THIRDS", "thirds" },
    { C_ENUM(GTH_GRID_GOLDEN), "GTH_GRID_GOLDEN", "golden" },
    { C_ENUM(GTH_GRID_CENTER), "GTH_GRID_CENTER", "center" },
    { C_ENUM(GTH_GRID_UNIFORM), "GTH_GRID_UNIFORM", "uniform" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthGridType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
gth_thumbnail_state_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GTH_THUMBNAIL_STATE_DEFAULT), "GTH_THUMBNAIL_STATE_DEFAULT", "default" },
    { C_ENUM(GTH_THUMBNAIL_STATE_CREATING), "GTH_THUMBNAIL_STATE_CREATING", "creating" },
    { C_ENUM(GTH_THUMBNAIL_STATE_CREATED), "GTH_THUMBNAIL_STATE_CREATED", "created" },
    { C_ENUM(GTH_THUMBNAIL_STATE_LOADING), "GTH_THUMBNAIL_STATE_LOADING", "loading" },
    { C_ENUM(GTH_THUMBNAIL_STATE_ERROR), "GTH_THUMBNAIL_STATE_ERROR", "error" },
    { C_ENUM(GTH_THUMBNAIL_STATE_LOADED), "GTH_THUMBNAIL_STATE_LOADED", "loaded" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GthThumbnailState"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* enumerations from "uri-utils.h" */

GType
uri_part_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(URI_PART_SCHEME), "URI_PART_SCHEME", "scheme" },
    { C_ENUM(URI_PART_USERINFO), "URI_PART_USERINFO", "userinfo" },
    { C_ENUM(URI_PART_HOST), "URI_PART_HOST", "host" },
    { C_ENUM(URI_PART_PORT), "URI_PART_PORT", "port" },
    { C_ENUM(URI_PART_PATH), "URI_PART_PATH", "path" },
    { C_ENUM(URI_PART_QUERY), "URI_PART_QUERY", "query" },
    { C_ENUM(URI_PART_FRAGMENT), "URI_PART_FRAGMENT", "fragment" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("UriPart"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* Generated data ends here */

