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

#include "eom-enum-types.h"

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

GType
eom_debug_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOM_DEBUG_NO_DEBUG,
			  "EOM_DEBUG_NO_DEBUG",
			  "no-debug" },
			{ EOM_DEBUG_WINDOW,
			  "EOM_DEBUG_WINDOW",
			  "window" },
			{ EOM_DEBUG_VIEW,
			  "EOM_DEBUG_VIEW",
			  "view" },
			{ EOM_DEBUG_JOBS,
			  "EOM_DEBUG_JOBS",
			  "jobs" },
			{ EOM_DEBUG_THUMBNAIL,
			  "EOM_DEBUG_THUMBNAIL",
			  "thumbnail" },
			{ EOM_DEBUG_IMAGE_DATA,
			  "EOM_DEBUG_IMAGE_DATA",
			  "image-data" },
			{ EOM_DEBUG_IMAGE_LOAD,
			  "EOM_DEBUG_IMAGE_LOAD",
			  "image-load" },
			{ EOM_DEBUG_IMAGE_SAVE,
			  "EOM_DEBUG_IMAGE_SAVE",
			  "image-save" },
			{ EOM_DEBUG_LIST_STORE,
			  "EOM_DEBUG_LIST_STORE",
			  "list-store" },
			{ EOM_DEBUG_PREFERENCES,
			  "EOM_DEBUG_PREFERENCES",
			  "preferences" },
			{ EOM_DEBUG_PRINTING,
			  "EOM_DEBUG_PRINTING",
			  "printing" },
			{ EOM_DEBUG_LCMS,
			  "EOM_DEBUG_LCMS",
			  "lcms" },
			{ EOM_DEBUG_PLUGINS,
			  "EOM_DEBUG_PLUGINS",
			  "plugins" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EomDebug"),
				values);
	}
	return the_type;
}

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

GType
eom_window_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_WINDOW_MODE_UNKNOWN,
			  "EOM_WINDOW_MODE_UNKNOWN",
			  "unknown" },
			{ EOM_WINDOW_MODE_NORMAL,
			  "EOM_WINDOW_MODE_NORMAL",
			  "normal" },
			{ EOM_WINDOW_MODE_FULLSCREEN,
			  "EOM_WINDOW_MODE_FULLSCREEN",
			  "fullscreen" },
			{ EOM_WINDOW_MODE_SLIDESHOW,
			  "EOM_WINDOW_MODE_SLIDESHOW",
			  "slideshow" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomWindowMode"),
				values);
	}
	return the_type;
}

GType
eom_window_collection_pos_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_WINDOW_COLLECTION_POS_BOTTOM,
			  "EOM_WINDOW_COLLECTION_POS_BOTTOM",
			  "bottom" },
			{ EOM_WINDOW_COLLECTION_POS_LEFT,
			  "EOM_WINDOW_COLLECTION_POS_LEFT",
			  "left" },
			{ EOM_WINDOW_COLLECTION_POS_TOP,
			  "EOM_WINDOW_COLLECTION_POS_TOP",
			  "top" },
			{ EOM_WINDOW_COLLECTION_POS_RIGHT,
			  "EOM_WINDOW_COLLECTION_POS_RIGHT",
			  "right" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomWindowCollectionPos"),
				values);
	}
	return the_type;
}

GType
eom_window_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_WINDOW_ERROR_CONTROL_NOT_FOUND,
			  "EOM_WINDOW_ERROR_CONTROL_NOT_FOUND",
			  "control-not-found" },
			{ EOM_WINDOW_ERROR_UI_NOT_FOUND,
			  "EOM_WINDOW_ERROR_UI_NOT_FOUND",
			  "ui-not-found" },
			{ EOM_WINDOW_ERROR_NO_PERSIST_FILE_INTERFACE,
			  "EOM_WINDOW_ERROR_NO_PERSIST_FILE_INTERFACE",
			  "no-persist-file-interface" },
			{ EOM_WINDOW_ERROR_IO,
			  "EOM_WINDOW_ERROR_IO",
			  "io" },
			{ EOM_WINDOW_ERROR_TRASH_NOT_FOUND,
			  "EOM_WINDOW_ERROR_TRASH_NOT_FOUND",
			  "trash-not-found" },
			{ EOM_WINDOW_ERROR_GENERIC,
			  "EOM_WINDOW_ERROR_GENERIC",
			  "generic" },
			{ EOM_WINDOW_ERROR_UNKNOWN,
			  "EOM_WINDOW_ERROR_UNKNOWN",
			  "unknown" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomWindowError"),
				values);
	}
	return the_type;
}

GType
eom_startup_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOM_STARTUP_FULLSCREEN,
			  "EOM_STARTUP_FULLSCREEN",
			  "fullscreen" },
			{ EOM_STARTUP_SLIDE_SHOW,
			  "EOM_STARTUP_SLIDE_SHOW",
			  "slide-show" },
			{ EOM_STARTUP_DISABLE_COLLECTION,
			  "EOM_STARTUP_DISABLE_COLLECTION",
			  "disable-collection" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EomStartupFlags"),
				values);
	}
	return the_type;
}

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

GType
eom_properties_dialog_page_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_PROPERTIES_DIALOG_PAGE_GENERAL,
			  "EOM_PROPERTIES_DIALOG_PAGE_GENERAL",
			  "page-general" },
			{ EOM_PROPERTIES_DIALOG_PAGE_EXIF,
			  "EOM_PROPERTIES_DIALOG_PAGE_EXIF",
			  "page-exif" },
			{ EOM_PROPERTIES_DIALOG_PAGE_DETAILS,
			  "EOM_PROPERTIES_DIALOG_PAGE_DETAILS",
			  "page-details" },
			{ EOM_PROPERTIES_DIALOG_N_PAGES,
			  "EOM_PROPERTIES_DIALOG_N_PAGES",
			  "n-pages" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomPropertiesDialogPage"),
				values);
	}
	return the_type;
}

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

GType
eom_thumb_nav_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_THUMB_NAV_MODE_ONE_ROW,
			  "EOM_THUMB_NAV_MODE_ONE_ROW",
			  "one-row" },
			{ EOM_THUMB_NAV_MODE_ONE_COLUMN,
			  "EOM_THUMB_NAV_MODE_ONE_COLUMN",
			  "one-column" },
			{ EOM_THUMB_NAV_MODE_MULTIPLE_ROWS,
			  "EOM_THUMB_NAV_MODE_MULTIPLE_ROWS",
			  "multiple-rows" },
			{ EOM_THUMB_NAV_MODE_MULTIPLE_COLUMNS,
			  "EOM_THUMB_NAV_MODE_MULTIPLE_COLUMNS",
			  "multiple-columns" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomThumbNavMode"),
				values);
	}
	return the_type;
}

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

GType
eom_transform_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_TRANSFORM_NONE,
			  "EOM_TRANSFORM_NONE",
			  "none" },
			{ EOM_TRANSFORM_ROT_90,
			  "EOM_TRANSFORM_ROT_90",
			  "rot-90" },
			{ EOM_TRANSFORM_ROT_180,
			  "EOM_TRANSFORM_ROT_180",
			  "rot-180" },
			{ EOM_TRANSFORM_ROT_270,
			  "EOM_TRANSFORM_ROT_270",
			  "rot-270" },
			{ EOM_TRANSFORM_FLIP_HORIZONTAL,
			  "EOM_TRANSFORM_FLIP_HORIZONTAL",
			  "flip-horizontal" },
			{ EOM_TRANSFORM_FLIP_VERTICAL,
			  "EOM_TRANSFORM_FLIP_VERTICAL",
			  "flip-vertical" },
			{ EOM_TRANSFORM_TRANSPOSE,
			  "EOM_TRANSFORM_TRANSPOSE",
			  "transpose" },
			{ EOM_TRANSFORM_TRANSVERSE,
			  "EOM_TRANSFORM_TRANSVERSE",
			  "transverse" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomTransformType"),
				values);
	}
	return the_type;
}

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

GType
eom_image_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_IMAGE_ERROR_SAVE_NOT_LOCAL,
			  "EOM_IMAGE_ERROR_SAVE_NOT_LOCAL",
			  "save-not-local" },
			{ EOM_IMAGE_ERROR_NOT_LOADED,
			  "EOM_IMAGE_ERROR_NOT_LOADED",
			  "not-loaded" },
			{ EOM_IMAGE_ERROR_VFS,
			  "EOM_IMAGE_ERROR_VFS",
			  "vfs" },
			{ EOM_IMAGE_ERROR_FILE_EXISTS,
			  "EOM_IMAGE_ERROR_FILE_EXISTS",
			  "file-exists" },
			{ EOM_IMAGE_ERROR_TMP_FILE_FAILED,
			  "EOM_IMAGE_ERROR_TMP_FILE_FAILED",
			  "tmp-file-failed" },
			{ EOM_IMAGE_ERROR_GENERIC,
			  "EOM_IMAGE_ERROR_GENERIC",
			  "generic" },
			{ EOM_IMAGE_ERROR_UNKNOWN,
			  "EOM_IMAGE_ERROR_UNKNOWN",
			  "unknown" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomImageError"),
				values);
	}
	return the_type;
}

GType
eom_image_status_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_IMAGE_STATUS_UNKNOWN,
			  "EOM_IMAGE_STATUS_UNKNOWN",
			  "unknown" },
			{ EOM_IMAGE_STATUS_LOADING,
			  "EOM_IMAGE_STATUS_LOADING",
			  "loading" },
			{ EOM_IMAGE_STATUS_LOADED,
			  "EOM_IMAGE_STATUS_LOADED",
			  "loaded" },
			{ EOM_IMAGE_STATUS_SAVING,
			  "EOM_IMAGE_STATUS_SAVING",
			  "saving" },
			{ EOM_IMAGE_STATUS_FAILED,
			  "EOM_IMAGE_STATUS_FAILED",
			  "failed" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomImageStatus"),
				values);
	}
	return the_type;
}

GType
eom_image_metadata_status_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_IMAGE_METADATA_NOT_READ,
			  "EOM_IMAGE_METADATA_NOT_READ",
			  "not-read" },
			{ EOM_IMAGE_METADATA_NOT_AVAILABLE,
			  "EOM_IMAGE_METADATA_NOT_AVAILABLE",
			  "not-available" },
			{ EOM_IMAGE_METADATA_READY,
			  "EOM_IMAGE_METADATA_READY",
			  "ready" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomImageMetadataStatus"),
				values);
	}
	return the_type;
}

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

GType
eom_image_data_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ EOM_IMAGE_DATA_IMAGE,
			  "EOM_IMAGE_DATA_IMAGE",
			  "image" },
			{ EOM_IMAGE_DATA_DIMENSION,
			  "EOM_IMAGE_DATA_DIMENSION",
			  "dimension" },
			{ EOM_IMAGE_DATA_EXIF,
			  "EOM_IMAGE_DATA_EXIF",
			  "exif" },
			{ EOM_IMAGE_DATA_XMP,
			  "EOM_IMAGE_DATA_XMP",
			  "xmp" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("EomImageData"),
				values);
	}
	return the_type;
}

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

GType
eom_transparency_style_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_TRANSP_BACKGROUND,
			  "EOM_TRANSP_BACKGROUND",
			  "background" },
			{ EOM_TRANSP_CHECKED,
			  "EOM_TRANSP_CHECKED",
			  "checked" },
			{ EOM_TRANSP_COLOR,
			  "EOM_TRANSP_COLOR",
			  "color" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomTransparencyStyle"),
				values);
	}
	return the_type;
}

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

GType
eom_thumb_view_selection_change_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_THUMB_VIEW_SELECT_CURRENT,
			  "EOM_THUMB_VIEW_SELECT_CURRENT",
			  "current" },
			{ EOM_THUMB_VIEW_SELECT_LEFT,
			  "EOM_THUMB_VIEW_SELECT_LEFT",
			  "left" },
			{ EOM_THUMB_VIEW_SELECT_RIGHT,
			  "EOM_THUMB_VIEW_SELECT_RIGHT",
			  "right" },
			{ EOM_THUMB_VIEW_SELECT_FIRST,
			  "EOM_THUMB_VIEW_SELECT_FIRST",
			  "first" },
			{ EOM_THUMB_VIEW_SELECT_LAST,
			  "EOM_THUMB_VIEW_SELECT_LAST",
			  "last" },
			{ EOM_THUMB_VIEW_SELECT_RANDOM,
			  "EOM_THUMB_VIEW_SELECT_RANDOM",
			  "random" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomThumbViewSelectionChange"),
				values);
	}
	return the_type;
}

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

GType
eom_list_store_column_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_LIST_STORE_THUMBNAIL,
			  "EOM_LIST_STORE_THUMBNAIL",
			  "thumbnail" },
			{ EOM_LIST_STORE_THUMB_SET,
			  "EOM_LIST_STORE_THUMB_SET",
			  "thumb-set" },
			{ EOM_LIST_STORE_EOM_IMAGE,
			  "EOM_LIST_STORE_EOM_IMAGE",
			  "eom-image" },
			{ EOM_LIST_STORE_EOM_JOB,
			  "EOM_LIST_STORE_EOM_JOB",
			  "eom-job" },
			{ EOM_LIST_STORE_NUM_COLUMNS,
			  "EOM_LIST_STORE_NUM_COLUMNS",
			  "num-columns" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomListStoreColumn"),
				values);
	}
	return the_type;
}

/* enumerations from "eom-jobs.h" */
#include "eom-jobs.h"

GType
eom_job_save_response_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ EOM_SAVE_RESPONSE_NONE,
			  "EOM_SAVE_RESPONSE_NONE",
			  "none" },
			{ EOM_SAVE_RESPONSE_RETRY,
			  "EOM_SAVE_RESPONSE_RETRY",
			  "retry" },
			{ EOM_SAVE_RESPONSE_SKIP,
			  "EOM_SAVE_RESPONSE_SKIP",
			  "skip" },
			{ EOM_SAVE_RESPONSE_OVERWRITE,
			  "EOM_SAVE_RESPONSE_OVERWRITE",
			  "overwrite" },
			{ EOM_SAVE_RESPONSE_CANCEL,
			  "EOM_SAVE_RESPONSE_CANCEL",
			  "cancel" },
			{ EOM_SAVE_RESPONSE_LAST,
			  "EOM_SAVE_RESPONSE_LAST",
			  "last" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("EomJobSaveResponse"),
				values);
	}
	return the_type;
}


/* Generated data ends here */

