
/* Generated data (by glib-mkenums) */

#include "eog-enum-types.h"

/* enumerations from "eog-debug.h" */
#include "eog-debug.h"

GType
eog_debug_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOG_DEBUG_NO_DEBUG,
			  "EOG_DEBUG_NO_DEBUG",
			  "no-debug" },
			{ EOG_DEBUG_WINDOW,
			  "EOG_DEBUG_WINDOW",
			  "window" },
			{ EOG_DEBUG_VIEW,
			  "EOG_DEBUG_VIEW",
			  "view" },
			{ EOG_DEBUG_JOBS,
			  "EOG_DEBUG_JOBS",
			  "jobs" },
			{ EOG_DEBUG_THUMBNAIL,
			  "EOG_DEBUG_THUMBNAIL",
			  "thumbnail" },
			{ EOG_DEBUG_IMAGE_DATA,
			  "EOG_DEBUG_IMAGE_DATA",
			  "image-data" },
			{ EOG_DEBUG_IMAGE_LOAD,
			  "EOG_DEBUG_IMAGE_LOAD",
			  "image-load" },
			{ EOG_DEBUG_IMAGE_SAVE,
			  "EOG_DEBUG_IMAGE_SAVE",
			  "image-save" },
			{ EOG_DEBUG_LIST_STORE,
			  "EOG_DEBUG_LIST_STORE",
			  "list-store" },
			{ EOG_DEBUG_PREFERENCES,
			  "EOG_DEBUG_PREFERENCES",
			  "preferences" },
			{ EOG_DEBUG_PRINTING,
			  "EOG_DEBUG_PRINTING",
			  "printing" },
			{ EOG_DEBUG_LCMS,
			  "EOG_DEBUG_LCMS",
			  "lcms" },
			{ EOG_DEBUG_PLUGINS,
			  "EOG_DEBUG_PLUGINS",
			  "plugins" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EogDebug"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-enums.h" */
#include "eog-enums.h"

GType
eog_image_data_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOG_IMAGE_DATA_IMAGE,
			  "EOG_IMAGE_DATA_IMAGE",
			  "image" },
			{ EOG_IMAGE_DATA_DIMENSION,
			  "EOG_IMAGE_DATA_DIMENSION",
			  "dimension" },
			{ EOG_IMAGE_DATA_EXIF,
			  "EOG_IMAGE_DATA_EXIF",
			  "exif" },
			{ EOG_IMAGE_DATA_XMP,
			  "EOG_IMAGE_DATA_XMP",
			  "xmp" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EogImageData"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-image.h" */
#include "eog-image.h"

GType
eog_image_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_IMAGE_ERROR_SAVE_NOT_LOCAL,
			  "EOG_IMAGE_ERROR_SAVE_NOT_LOCAL",
			  "save-not-local" },
			{ EOG_IMAGE_ERROR_NOT_LOADED,
			  "EOG_IMAGE_ERROR_NOT_LOADED",
			  "not-loaded" },
			{ EOG_IMAGE_ERROR_NOT_SAVED,
			  "EOG_IMAGE_ERROR_NOT_SAVED",
			  "not-saved" },
			{ EOG_IMAGE_ERROR_VFS,
			  "EOG_IMAGE_ERROR_VFS",
			  "vfs" },
			{ EOG_IMAGE_ERROR_FILE_EXISTS,
			  "EOG_IMAGE_ERROR_FILE_EXISTS",
			  "file-exists" },
			{ EOG_IMAGE_ERROR_TMP_FILE_FAILED,
			  "EOG_IMAGE_ERROR_TMP_FILE_FAILED",
			  "tmp-file-failed" },
			{ EOG_IMAGE_ERROR_GENERIC,
			  "EOG_IMAGE_ERROR_GENERIC",
			  "generic" },
			{ EOG_IMAGE_ERROR_UNKNOWN,
			  "EOG_IMAGE_ERROR_UNKNOWN",
			  "unknown" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogImageError"),
				values);
	}
	return the_type;
}

GType
eog_image_status_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_IMAGE_STATUS_UNKNOWN,
			  "EOG_IMAGE_STATUS_UNKNOWN",
			  "unknown" },
			{ EOG_IMAGE_STATUS_LOADING,
			  "EOG_IMAGE_STATUS_LOADING",
			  "loading" },
			{ EOG_IMAGE_STATUS_LOADED,
			  "EOG_IMAGE_STATUS_LOADED",
			  "loaded" },
			{ EOG_IMAGE_STATUS_SAVING,
			  "EOG_IMAGE_STATUS_SAVING",
			  "saving" },
			{ EOG_IMAGE_STATUS_FAILED,
			  "EOG_IMAGE_STATUS_FAILED",
			  "failed" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogImageStatus"),
				values);
	}
	return the_type;
}

GType
eog_image_metadata_status_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_IMAGE_METADATA_NOT_READ,
			  "EOG_IMAGE_METADATA_NOT_READ",
			  "not-read" },
			{ EOG_IMAGE_METADATA_NOT_AVAILABLE,
			  "EOG_IMAGE_METADATA_NOT_AVAILABLE",
			  "not-available" },
			{ EOG_IMAGE_METADATA_READY,
			  "EOG_IMAGE_METADATA_READY",
			  "ready" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogImageMetadataStatus"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-job-scheduler.h" */
#include "eog-job-scheduler.h"

GType
eog_job_priority_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_JOB_PRIORITY_HIGH,
			  "EOG_JOB_PRIORITY_HIGH",
			  "priority-high" },
			{ EOG_JOB_PRIORITY_MEDIUM,
			  "EOG_JOB_PRIORITY_MEDIUM",
			  "priority-medium" },
			{ EOG_JOB_PRIORITY_LOW,
			  "EOG_JOB_PRIORITY_LOW",
			  "priority-low" },
			{ EOG_JOB_N_PRIORITIES,
			  "EOG_JOB_N_PRIORITIES",
			  "n-priorities" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogJobPriority"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-list-store.h" */
#include "eog-list-store.h"

GType
eog_list_store_column_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_LIST_STORE_THUMBNAIL,
			  "EOG_LIST_STORE_THUMBNAIL",
			  "thumbnail" },
			{ EOG_LIST_STORE_THUMB_SET,
			  "EOG_LIST_STORE_THUMB_SET",
			  "thumb-set" },
			{ EOG_LIST_STORE_EOG_IMAGE,
			  "EOG_LIST_STORE_EOG_IMAGE",
			  "eog-image" },
			{ EOG_LIST_STORE_EOG_JOB,
			  "EOG_LIST_STORE_EOG_JOB",
			  "eog-job" },
			{ EOG_LIST_STORE_NUM_COLUMNS,
			  "EOG_LIST_STORE_NUM_COLUMNS",
			  "num-columns" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogListStoreColumn"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-properties-dialog.h" */
#include "eog-properties-dialog.h"

GType
eog_properties_dialog_page_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_PROPERTIES_DIALOG_PAGE_GENERAL,
			  "EOG_PROPERTIES_DIALOG_PAGE_GENERAL",
			  "page-general" },
			{ EOG_PROPERTIES_DIALOG_PAGE_EXIF,
			  "EOG_PROPERTIES_DIALOG_PAGE_EXIF",
			  "page-exif" },
			{ EOG_PROPERTIES_DIALOG_PAGE_DETAILS,
			  "EOG_PROPERTIES_DIALOG_PAGE_DETAILS",
			  "page-details" },
			{ EOG_PROPERTIES_DIALOG_N_PAGES,
			  "EOG_PROPERTIES_DIALOG_N_PAGES",
			  "n-pages" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogPropertiesDialogPage"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-scroll-view.h" */
#include "eog-scroll-view.h"

GType
eog_transparency_style_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_TRANSP_BACKGROUND,
			  "EOG_TRANSP_BACKGROUND",
			  "background" },
			{ EOG_TRANSP_CHECKED,
			  "EOG_TRANSP_CHECKED",
			  "checked" },
			{ EOG_TRANSP_COLOR,
			  "EOG_TRANSP_COLOR",
			  "color" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogTransparencyStyle"),
				values);
	}
	return the_type;
}

GType
eog_zoom_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_ZOOM_MODE_FREE,
			  "EOG_ZOOM_MODE_FREE",
			  "free" },
			{ EOG_ZOOM_MODE_SHRINK_TO_FIT,
			  "EOG_ZOOM_MODE_SHRINK_TO_FIT",
			  "shrink-to-fit" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogZoomMode"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-thumb-nav.h" */
#include "eog-thumb-nav.h"

GType
eog_thumb_nav_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_THUMB_NAV_MODE_ONE_ROW,
			  "EOG_THUMB_NAV_MODE_ONE_ROW",
			  "one-row" },
			{ EOG_THUMB_NAV_MODE_ONE_COLUMN,
			  "EOG_THUMB_NAV_MODE_ONE_COLUMN",
			  "one-column" },
			{ EOG_THUMB_NAV_MODE_MULTIPLE_ROWS,
			  "EOG_THUMB_NAV_MODE_MULTIPLE_ROWS",
			  "multiple-rows" },
			{ EOG_THUMB_NAV_MODE_MULTIPLE_COLUMNS,
			  "EOG_THUMB_NAV_MODE_MULTIPLE_COLUMNS",
			  "multiple-columns" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogThumbNavMode"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-thumb-view.h" */
#include "eog-thumb-view.h"

GType
eog_thumb_view_selection_change_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_THUMB_VIEW_SELECT_CURRENT,
			  "EOG_THUMB_VIEW_SELECT_CURRENT",
			  "current" },
			{ EOG_THUMB_VIEW_SELECT_LEFT,
			  "EOG_THUMB_VIEW_SELECT_LEFT",
			  "left" },
			{ EOG_THUMB_VIEW_SELECT_RIGHT,
			  "EOG_THUMB_VIEW_SELECT_RIGHT",
			  "right" },
			{ EOG_THUMB_VIEW_SELECT_FIRST,
			  "EOG_THUMB_VIEW_SELECT_FIRST",
			  "first" },
			{ EOG_THUMB_VIEW_SELECT_LAST,
			  "EOG_THUMB_VIEW_SELECT_LAST",
			  "last" },
			{ EOG_THUMB_VIEW_SELECT_RANDOM,
			  "EOG_THUMB_VIEW_SELECT_RANDOM",
			  "random" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogThumbViewSelectionChange"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-transform.h" */
#include "eog-transform.h"

GType
eog_transform_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_TRANSFORM_NONE,
			  "EOG_TRANSFORM_NONE",
			  "none" },
			{ EOG_TRANSFORM_ROT_90,
			  "EOG_TRANSFORM_ROT_90",
			  "rot-90" },
			{ EOG_TRANSFORM_ROT_180,
			  "EOG_TRANSFORM_ROT_180",
			  "rot-180" },
			{ EOG_TRANSFORM_ROT_270,
			  "EOG_TRANSFORM_ROT_270",
			  "rot-270" },
			{ EOG_TRANSFORM_FLIP_HORIZONTAL,
			  "EOG_TRANSFORM_FLIP_HORIZONTAL",
			  "flip-horizontal" },
			{ EOG_TRANSFORM_FLIP_VERTICAL,
			  "EOG_TRANSFORM_FLIP_VERTICAL",
			  "flip-vertical" },
			{ EOG_TRANSFORM_TRANSPOSE,
			  "EOG_TRANSFORM_TRANSPOSE",
			  "transpose" },
			{ EOG_TRANSFORM_TRANSVERSE,
			  "EOG_TRANSFORM_TRANSVERSE",
			  "transverse" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogTransformType"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-uri-converter.h" */
#include "eog-uri-converter.h"

GType
eog_uc_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_UC_STRING,
			  "EOG_UC_STRING",
			  "string" },
			{ EOG_UC_FILENAME,
			  "EOG_UC_FILENAME",
			  "filename" },
			{ EOG_UC_COUNTER,
			  "EOG_UC_COUNTER",
			  "counter" },
			{ EOG_UC_COMMENT,
			  "EOG_UC_COMMENT",
			  "comment" },
			{ EOG_UC_DATE,
			  "EOG_UC_DATE",
			  "date" },
			{ EOG_UC_TIME,
			  "EOG_UC_TIME",
			  "time" },
			{ EOG_UC_DAY,
			  "EOG_UC_DAY",
			  "day" },
			{ EOG_UC_MONTH,
			  "EOG_UC_MONTH",
			  "month" },
			{ EOG_UC_YEAR,
			  "EOG_UC_YEAR",
			  "year" },
			{ EOG_UC_HOUR,
			  "EOG_UC_HOUR",
			  "hour" },
			{ EOG_UC_MINUTE,
			  "EOG_UC_MINUTE",
			  "minute" },
			{ EOG_UC_SECOND,
			  "EOG_UC_SECOND",
			  "second" },
			{ EOG_UC_END,
			  "EOG_UC_END",
			  "end" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogUCType"),
				values);
	}
	return the_type;
}

GType
eog_uc_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_UC_ERROR_INVALID_UNICODE,
			  "EOG_UC_ERROR_INVALID_UNICODE",
			  "invalid-unicode" },
			{ EOG_UC_ERROR_INVALID_CHARACTER,
			  "EOG_UC_ERROR_INVALID_CHARACTER",
			  "invalid-character" },
			{ EOG_UC_ERROR_EQUAL_FILENAMES,
			  "EOG_UC_ERROR_EQUAL_FILENAMES",
			  "equal-filenames" },
			{ EOG_UC_ERROR_UNKNOWN,
			  "EOG_UC_ERROR_UNKNOWN",
			  "unknown" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogUCError"),
				values);
	}
	return the_type;
}

/* enumerations from "eog-window.h" */
#include "eog-window.h"

GType
eog_window_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_WINDOW_MODE_UNKNOWN,
			  "EOG_WINDOW_MODE_UNKNOWN",
			  "unknown" },
			{ EOG_WINDOW_MODE_NORMAL,
			  "EOG_WINDOW_MODE_NORMAL",
			  "normal" },
			{ EOG_WINDOW_MODE_FULLSCREEN,
			  "EOG_WINDOW_MODE_FULLSCREEN",
			  "fullscreen" },
			{ EOG_WINDOW_MODE_SLIDESHOW,
			  "EOG_WINDOW_MODE_SLIDESHOW",
			  "slideshow" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogWindowMode"),
				values);
	}
	return the_type;
}

GType
eog_window_gallery_pos_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_WINDOW_GALLERY_POS_BOTTOM,
			  "EOG_WINDOW_GALLERY_POS_BOTTOM",
			  "bottom" },
			{ EOG_WINDOW_GALLERY_POS_LEFT,
			  "EOG_WINDOW_GALLERY_POS_LEFT",
			  "left" },
			{ EOG_WINDOW_GALLERY_POS_TOP,
			  "EOG_WINDOW_GALLERY_POS_TOP",
			  "top" },
			{ EOG_WINDOW_GALLERY_POS_RIGHT,
			  "EOG_WINDOW_GALLERY_POS_RIGHT",
			  "right" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogWindowGalleryPos"),
				values);
	}
	return the_type;
}

GType
eog_window_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOG_WINDOW_ERROR_CONTROL_NOT_FOUND,
			  "EOG_WINDOW_ERROR_CONTROL_NOT_FOUND",
			  "control-not-found" },
			{ EOG_WINDOW_ERROR_UI_NOT_FOUND,
			  "EOG_WINDOW_ERROR_UI_NOT_FOUND",
			  "ui-not-found" },
			{ EOG_WINDOW_ERROR_NO_PERSIST_FILE_INTERFACE,
			  "EOG_WINDOW_ERROR_NO_PERSIST_FILE_INTERFACE",
			  "no-persist-file-interface" },
			{ EOG_WINDOW_ERROR_IO,
			  "EOG_WINDOW_ERROR_IO",
			  "io" },
			{ EOG_WINDOW_ERROR_TRASH_NOT_FOUND,
			  "EOG_WINDOW_ERROR_TRASH_NOT_FOUND",
			  "trash-not-found" },
			{ EOG_WINDOW_ERROR_GENERIC,
			  "EOG_WINDOW_ERROR_GENERIC",
			  "generic" },
			{ EOG_WINDOW_ERROR_UNKNOWN,
			  "EOG_WINDOW_ERROR_UNKNOWN",
			  "unknown" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EogWindowError"),
				values);
	}
	return the_type;
}

GType
eog_startup_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOG_STARTUP_FULLSCREEN,
			  "EOG_STARTUP_FULLSCREEN",
			  "fullscreen" },
			{ EOG_STARTUP_SLIDE_SHOW,
			  "EOG_STARTUP_SLIDE_SHOW",
			  "slide-show" },
			{ EOG_STARTUP_DISABLE_GALLERY,
			  "EOG_STARTUP_DISABLE_GALLERY",
			  "disable-gallery" },
			{ EOG_STARTUP_SINGLE_WINDOW,
			  "EOG_STARTUP_SINGLE_WINDOW",
			  "single-window" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EogStartupFlags"),
				values);
	}
	return the_type;
}


/* Generated data ends here */

