
/* 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 "pps-document-type-builtins.h"
#include "pps-annotation.h"
#include "pps-attachment.h"
#include "pps-certificate-info.h"
#include "pps-document-annotations.h"
#include "pps-document-attachments.h"
#include "pps-document-factory.h"
#include "pps-document-find.h"
#include "pps-document-fonts.h"
#include "pps-document-forms.h"
#include "pps-document-images.h"
#include "pps-document-info.h"
#include "pps-document-layers.h"
#include "pps-document-links.h"
#include "pps-document-media.h"
#include "pps-document-misc.h"
#include "pps-document-print.h"
#include "pps-document-security.h"
#include "pps-document-signatures.h"
#include "pps-document-text.h"
#include "pps-document-transition.h"
#include "pps-document.h"
#include "pps-file-exporter.h"
#include "pps-file-helpers.h"
#include "pps-font-description.h"
#include "pps-form-field.h"
#include "pps-image.h"
#include "pps-init.h"
#include "pps-layer.h"
#include "pps-link-action.h"
#include "pps-link-dest.h"
#include "pps-link.h"
#include "pps-macros.h"
#include "pps-mapping-list.h"
#include "pps-media.h"
#include "pps-outlines.h"
#include "pps-page.h"
#include "pps-render-context.h"
#include "pps-selection.h"
#include "pps-signature.h"
#include "pps-transition-effect.h"

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

/* enumerations from "pps-annotation.h" */

GType
pps_annotation_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_ANNOTATION_TYPE_UNKNOWN), "PPS_ANNOTATION_TYPE_UNKNOWN", "unknown" },
        { C_ENUM (PPS_ANNOTATION_TYPE_TEXT), "PPS_ANNOTATION_TYPE_TEXT", "text" },
        { C_ENUM (PPS_ANNOTATION_TYPE_FREE_TEXT), "PPS_ANNOTATION_TYPE_FREE_TEXT", "free-text" },
        { C_ENUM (PPS_ANNOTATION_TYPE_ATTACHMENT), "PPS_ANNOTATION_TYPE_ATTACHMENT", "attachment" },
        { C_ENUM (PPS_ANNOTATION_TYPE_TEXT_MARKUP), "PPS_ANNOTATION_TYPE_TEXT_MARKUP", "text-markup" },
        { C_ENUM (PPS_ANNOTATION_TYPE_STAMP), "PPS_ANNOTATION_TYPE_STAMP", "stamp" },
        { C_ENUM (PPS_ANNOTATION_TYPE_INK), "PPS_ANNOTATION_TYPE_INK", "ink" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsAnnotationType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_annotation_text_icon_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_NOTE), "PPS_ANNOTATION_TEXT_ICON_NOTE", "note" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_COMMENT), "PPS_ANNOTATION_TEXT_ICON_COMMENT", "comment" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_KEY), "PPS_ANNOTATION_TEXT_ICON_KEY", "key" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_HELP), "PPS_ANNOTATION_TEXT_ICON_HELP", "help" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_NEW_PARAGRAPH), "PPS_ANNOTATION_TEXT_ICON_NEW_PARAGRAPH", "new-paragraph" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_PARAGRAPH), "PPS_ANNOTATION_TEXT_ICON_PARAGRAPH", "paragraph" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_INSERT), "PPS_ANNOTATION_TEXT_ICON_INSERT", "insert" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_CROSS), "PPS_ANNOTATION_TEXT_ICON_CROSS", "cross" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_CIRCLE), "PPS_ANNOTATION_TEXT_ICON_CIRCLE", "circle" },
        { C_ENUM (PPS_ANNOTATION_TEXT_ICON_UNKNOWN), "PPS_ANNOTATION_TEXT_ICON_UNKNOWN", "unknown" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsAnnotationTextIcon"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_annotation_text_markup_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_ANNOTATION_TEXT_MARKUP_HIGHLIGHT), "PPS_ANNOTATION_TEXT_MARKUP_HIGHLIGHT", "highlight" },
        { C_ENUM (PPS_ANNOTATION_TEXT_MARKUP_STRIKE_OUT), "PPS_ANNOTATION_TEXT_MARKUP_STRIKE_OUT", "strike-out" },
        { C_ENUM (PPS_ANNOTATION_TEXT_MARKUP_UNDERLINE), "PPS_ANNOTATION_TEXT_MARKUP_UNDERLINE", "underline" },
        { C_ENUM (PPS_ANNOTATION_TEXT_MARKUP_SQUIGGLY), "PPS_ANNOTATION_TEXT_MARKUP_SQUIGGLY", "squiggly" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsAnnotationTextMarkupType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-certificate-info.h" */

GType
pps_certificate_status_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_CERTIFICATE_STATUS_TRUSTED), "PPS_CERTIFICATE_STATUS_TRUSTED", "trusted" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_UNTRUSTED_ISSUER), "PPS_CERTIFICATE_STATUS_UNTRUSTED_ISSUER", "untrusted-issuer" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_UNKNOWN_ISSUER), "PPS_CERTIFICATE_STATUS_UNKNOWN_ISSUER", "unknown-issuer" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_REVOKED), "PPS_CERTIFICATE_STATUS_REVOKED", "revoked" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_EXPIRED), "PPS_CERTIFICATE_STATUS_EXPIRED", "expired" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_GENERIC_ERROR), "PPS_CERTIFICATE_STATUS_GENERIC_ERROR", "generic-error" },
        { C_ENUM (PPS_CERTIFICATE_STATUS_NOT_VERIFIED), "PPS_CERTIFICATE_STATUS_NOT_VERIFIED", "not-verified" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsCertificateStatus"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-document-annotations.h" */

GType
pps_annotations_over_markup_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_ANNOTATION_OVER_MARKUP_NOT_IMPLEMENTED), "PPS_ANNOTATION_OVER_MARKUP_NOT_IMPLEMENTED", "not-implemented" },
        { C_ENUM (PPS_ANNOTATION_OVER_MARKUP_UNKNOWN), "PPS_ANNOTATION_OVER_MARKUP_UNKNOWN", "unknown" },
        { C_ENUM (PPS_ANNOTATION_OVER_MARKUP_YES), "PPS_ANNOTATION_OVER_MARKUP_YES", "yes" },
        { C_ENUM (PPS_ANNOTATION_OVER_MARKUP_NOT), "PPS_ANNOTATION_OVER_MARKUP_NOT", "not" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsAnnotationsOverMarkup"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-document-find.h" */

GType
pps_find_options_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_FIND_DEFAULT), "PPS_FIND_DEFAULT", "default" },
        { C_FLAGS (PPS_FIND_CASE_SENSITIVE), "PPS_FIND_CASE_SENSITIVE", "case-sensitive" },
        { C_FLAGS (PPS_FIND_WHOLE_WORDS_ONLY), "PPS_FIND_WHOLE_WORDS_ONLY", "whole-words-only" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsFindOptions"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-document-info.h" */

GType
pps_document_layout_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_DOCUMENT_LAYOUT_SINGLE_PAGE), "PPS_DOCUMENT_LAYOUT_SINGLE_PAGE", "single-page" },
        { C_ENUM (PPS_DOCUMENT_LAYOUT_ONE_COLUMN), "PPS_DOCUMENT_LAYOUT_ONE_COLUMN", "one-column" },
        { C_ENUM (PPS_DOCUMENT_LAYOUT_TWO_COLUMN_LEFT), "PPS_DOCUMENT_LAYOUT_TWO_COLUMN_LEFT", "two-column-left" },
        { C_ENUM (PPS_DOCUMENT_LAYOUT_TWO_COLUMN_RIGHT), "PPS_DOCUMENT_LAYOUT_TWO_COLUMN_RIGHT", "two-column-right" },
        { C_ENUM (PPS_DOCUMENT_LAYOUT_TWO_PAGE_LEFT), "PPS_DOCUMENT_LAYOUT_TWO_PAGE_LEFT", "two-page-left" },
        { C_ENUM (PPS_DOCUMENT_LAYOUT_TWO_PAGE_RIGHT), "PPS_DOCUMENT_LAYOUT_TWO_PAGE_RIGHT", "two-page-right" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsDocumentLayout"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_mode_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_DOCUMENT_MODE_NONE), "PPS_DOCUMENT_MODE_NONE", "none" },
        { C_ENUM (PPS_DOCUMENT_MODE_USE_OC), "PPS_DOCUMENT_MODE_USE_OC", "use-oc" },
        { C_ENUM (PPS_DOCUMENT_MODE_USE_THUMBS), "PPS_DOCUMENT_MODE_USE_THUMBS", "use-thumbs" },
        { C_ENUM (PPS_DOCUMENT_MODE_FULL_SCREEN), "PPS_DOCUMENT_MODE_FULL_SCREEN", "full-screen" },
        { C_ENUM (PPS_DOCUMENT_MODE_USE_ATTACHMENTS), "PPS_DOCUMENT_MODE_USE_ATTACHMENTS", "use-attachments" },
        { C_ENUM (PPS_DOCUMENT_MODE_PRESENTATION), "PPS_DOCUMENT_MODE_PRESENTATION", "presentation" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsDocumentMode"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_contains_js_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_DOCUMENT_CONTAINS_JS_UNKNOWN), "PPS_DOCUMENT_CONTAINS_JS_UNKNOWN", "unknown" },
        { C_ENUM (PPS_DOCUMENT_CONTAINS_JS_NO), "PPS_DOCUMENT_CONTAINS_JS_NO", "no" },
        { C_ENUM (PPS_DOCUMENT_CONTAINS_JS_YES), "PPS_DOCUMENT_CONTAINS_JS_YES", "yes" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsDocumentContainsJS"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_ui_hints_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_HIDE_TOOLBAR), "PPS_DOCUMENT_UI_HINT_HIDE_TOOLBAR", "hide-toolbar" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_HIDE_MENUBAR), "PPS_DOCUMENT_UI_HINT_HIDE_MENUBAR", "hide-menubar" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_HIDE_WINDOWUI), "PPS_DOCUMENT_UI_HINT_HIDE_WINDOWUI", "hide-windowui" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_FIT_WINDOW), "PPS_DOCUMENT_UI_HINT_FIT_WINDOW", "fit-window" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_CENTER_WINDOW), "PPS_DOCUMENT_UI_HINT_CENTER_WINDOW", "center-window" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_DISPLAY_DOC_TITLE), "PPS_DOCUMENT_UI_HINT_DISPLAY_DOC_TITLE", "display-doc-title" },
        { C_FLAGS (PPS_DOCUMENT_UI_HINT_DIRECTION_RTL), "PPS_DOCUMENT_UI_HINT_DIRECTION_RTL", "direction-rtl" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsDocumentUIHints"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_permissions_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_DOCUMENT_PERMISSIONS_OK_TO_PRINT), "PPS_DOCUMENT_PERMISSIONS_OK_TO_PRINT", "ok-to-print" },
        { C_FLAGS (PPS_DOCUMENT_PERMISSIONS_OK_TO_MODIFY), "PPS_DOCUMENT_PERMISSIONS_OK_TO_MODIFY", "ok-to-modify" },
        { C_FLAGS (PPS_DOCUMENT_PERMISSIONS_OK_TO_COPY), "PPS_DOCUMENT_PERMISSIONS_OK_TO_COPY", "ok-to-copy" },
        { C_FLAGS (PPS_DOCUMENT_PERMISSIONS_OK_TO_ADD_NOTES), "PPS_DOCUMENT_PERMISSIONS_OK_TO_ADD_NOTES", "ok-to-add-notes" },
        { C_FLAGS (PPS_DOCUMENT_PERMISSIONS_FULL), "PPS_DOCUMENT_PERMISSIONS_FULL", "full" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsDocumentPermissions"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_info_fields_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_DOCUMENT_INFO_TITLE), "PPS_DOCUMENT_INFO_TITLE", "title" },
        { C_FLAGS (PPS_DOCUMENT_INFO_FORMAT), "PPS_DOCUMENT_INFO_FORMAT", "format" },
        { C_FLAGS (PPS_DOCUMENT_INFO_AUTHOR), "PPS_DOCUMENT_INFO_AUTHOR", "author" },
        { C_FLAGS (PPS_DOCUMENT_INFO_SUBJECT), "PPS_DOCUMENT_INFO_SUBJECT", "subject" },
        { C_FLAGS (PPS_DOCUMENT_INFO_KEYWORDS), "PPS_DOCUMENT_INFO_KEYWORDS", "keywords" },
        { C_FLAGS (PPS_DOCUMENT_INFO_LAYOUT), "PPS_DOCUMENT_INFO_LAYOUT", "layout" },
        { C_FLAGS (PPS_DOCUMENT_INFO_CREATOR), "PPS_DOCUMENT_INFO_CREATOR", "creator" },
        { C_FLAGS (PPS_DOCUMENT_INFO_PRODUCER), "PPS_DOCUMENT_INFO_PRODUCER", "producer" },
        { C_FLAGS (PPS_DOCUMENT_INFO_CREATION_DATETIME), "PPS_DOCUMENT_INFO_CREATION_DATETIME", "creation-datetime" },
        { C_FLAGS (PPS_DOCUMENT_INFO_MOD_DATETIME), "PPS_DOCUMENT_INFO_MOD_DATETIME", "mod-datetime" },
        { C_FLAGS (PPS_DOCUMENT_INFO_LINEARIZED), "PPS_DOCUMENT_INFO_LINEARIZED", "linearized" },
        { C_FLAGS (PPS_DOCUMENT_INFO_START_MODE), "PPS_DOCUMENT_INFO_START_MODE", "start-mode" },
        { C_FLAGS (PPS_DOCUMENT_INFO_UI_HINTS), "PPS_DOCUMENT_INFO_UI_HINTS", "ui-hints" },
        { C_FLAGS (PPS_DOCUMENT_INFO_PERMISSIONS), "PPS_DOCUMENT_INFO_PERMISSIONS", "permissions" },
        { C_FLAGS (PPS_DOCUMENT_INFO_N_PAGES), "PPS_DOCUMENT_INFO_N_PAGES", "n-pages" },
        { C_FLAGS (PPS_DOCUMENT_INFO_SECURITY), "PPS_DOCUMENT_INFO_SECURITY", "security" },
        { C_FLAGS (PPS_DOCUMENT_INFO_PAPER_SIZE), "PPS_DOCUMENT_INFO_PAPER_SIZE", "paper-size" },
        { C_FLAGS (PPS_DOCUMENT_INFO_LICENSE), "PPS_DOCUMENT_INFO_LICENSE", "license" },
        { C_FLAGS (PPS_DOCUMENT_INFO_CONTAINS_JS), "PPS_DOCUMENT_INFO_CONTAINS_JS", "contains-js" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsDocumentInfoFields"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-document.h" */

GType
pps_document_load_flags_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_DOCUMENT_LOAD_FLAG_NONE), "PPS_DOCUMENT_LOAD_FLAG_NONE", "none" },
        { C_FLAGS (PPS_DOCUMENT_LOAD_FLAG_NO_CACHE), "PPS_DOCUMENT_LOAD_FLAG_NO_CACHE", "no-cache" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsDocumentLoadFlags"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_document_error_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_DOCUMENT_ERROR_INVALID), "PPS_DOCUMENT_ERROR_INVALID", "invalid" },
        { C_ENUM (PPS_DOCUMENT_ERROR_UNSUPPORTED_CONTENT), "PPS_DOCUMENT_ERROR_UNSUPPORTED_CONTENT", "unsupported-content" },
        { C_ENUM (PPS_DOCUMENT_ERROR_ENCRYPTED), "PPS_DOCUMENT_ERROR_ENCRYPTED", "encrypted" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsDocumentError"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-file-exporter.h" */

GType
pps_file_exporter_format_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_FILE_FORMAT_UNKNOWN), "PPS_FILE_FORMAT_UNKNOWN", "unknown" },
        { C_ENUM (PPS_FILE_FORMAT_PS), "PPS_FILE_FORMAT_PS", "ps" },
        { C_ENUM (PPS_FILE_FORMAT_PDF), "PPS_FILE_FORMAT_PDF", "pdf" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsFileExporterFormat"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_file_exporter_capabilities_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_PAGE_SET), "PPS_FILE_EXPORTER_CAN_PAGE_SET", "page-set" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_COPIES), "PPS_FILE_EXPORTER_CAN_COPIES", "copies" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_COLLATE), "PPS_FILE_EXPORTER_CAN_COLLATE", "collate" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_REVERSE), "PPS_FILE_EXPORTER_CAN_REVERSE", "reverse" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_SCALE), "PPS_FILE_EXPORTER_CAN_SCALE", "scale" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_GENERATE_PDF), "PPS_FILE_EXPORTER_CAN_GENERATE_PDF", "generate-pdf" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_GENERATE_PS), "PPS_FILE_EXPORTER_CAN_GENERATE_PS", "generate-ps" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_PREVIEW), "PPS_FILE_EXPORTER_CAN_PREVIEW", "preview" },
        { C_FLAGS (PPS_FILE_EXPORTER_CAN_NUMBER_UP), "PPS_FILE_EXPORTER_CAN_NUMBER_UP", "number-up" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsFileExporterCapabilities"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-file-helpers.h" */

GType
pps_compression_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_COMPRESSION_NONE), "PPS_COMPRESSION_NONE", "none" },
        { C_ENUM (PPS_COMPRESSION_BZIP2), "PPS_COMPRESSION_BZIP2", "bzip2" },
        { C_ENUM (PPS_COMPRESSION_GZIP), "PPS_COMPRESSION_GZIP", "gzip" },
        { C_ENUM (PPS_COMPRESSION_LZMA), "PPS_COMPRESSION_LZMA", "lzma" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsCompressionType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-form-field.h" */

GType
pps_form_field_text_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_FORM_FIELD_TEXT_NORMAL), "PPS_FORM_FIELD_TEXT_NORMAL", "normal" },
        { C_ENUM (PPS_FORM_FIELD_TEXT_MULTILINE), "PPS_FORM_FIELD_TEXT_MULTILINE", "multiline" },
        { C_ENUM (PPS_FORM_FIELD_TEXT_FILE_SELECT), "PPS_FORM_FIELD_TEXT_FILE_SELECT", "file-select" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsFormFieldTextType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_form_field_button_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_FORM_FIELD_BUTTON_PUSH), "PPS_FORM_FIELD_BUTTON_PUSH", "push" },
        { C_ENUM (PPS_FORM_FIELD_BUTTON_CHECK), "PPS_FORM_FIELD_BUTTON_CHECK", "check" },
        { C_ENUM (PPS_FORM_FIELD_BUTTON_RADIO), "PPS_FORM_FIELD_BUTTON_RADIO", "radio" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsFormFieldButtonType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_form_field_choice_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_FORM_FIELD_CHOICE_COMBO), "PPS_FORM_FIELD_CHOICE_COMBO", "combo" },
        { C_ENUM (PPS_FORM_FIELD_CHOICE_LIST), "PPS_FORM_FIELD_CHOICE_LIST", "list" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsFormFieldChoiceType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-link-action.h" */

GType
pps_link_action_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_LINK_ACTION_TYPE_GOTO_DEST), "PPS_LINK_ACTION_TYPE_GOTO_DEST", "goto-dest" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_GOTO_REMOTE), "PPS_LINK_ACTION_TYPE_GOTO_REMOTE", "goto-remote" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_EXTERNAL_URI), "PPS_LINK_ACTION_TYPE_EXTERNAL_URI", "external-uri" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_LAUNCH), "PPS_LINK_ACTION_TYPE_LAUNCH", "launch" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_NAMED), "PPS_LINK_ACTION_TYPE_NAMED", "named" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_LAYERS_STATE), "PPS_LINK_ACTION_TYPE_LAYERS_STATE", "layers-state" },
        { C_ENUM (PPS_LINK_ACTION_TYPE_RESET_FORM), "PPS_LINK_ACTION_TYPE_RESET_FORM", "reset-form" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsLinkActionType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-link-dest.h" */

GType
pps_link_dest_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_LINK_DEST_TYPE_PAGE), "PPS_LINK_DEST_TYPE_PAGE", "page" },
        { C_ENUM (PPS_LINK_DEST_TYPE_XYZ), "PPS_LINK_DEST_TYPE_XYZ", "xyz" },
        { C_ENUM (PPS_LINK_DEST_TYPE_FIT), "PPS_LINK_DEST_TYPE_FIT", "fit" },
        { C_ENUM (PPS_LINK_DEST_TYPE_FITH), "PPS_LINK_DEST_TYPE_FITH", "fith" },
        { C_ENUM (PPS_LINK_DEST_TYPE_FITV), "PPS_LINK_DEST_TYPE_FITV", "fitv" },
        { C_ENUM (PPS_LINK_DEST_TYPE_FITR), "PPS_LINK_DEST_TYPE_FITR", "fitr" },
        { C_ENUM (PPS_LINK_DEST_TYPE_NAMED), "PPS_LINK_DEST_TYPE_NAMED", "named" },
        { C_ENUM (PPS_LINK_DEST_TYPE_PAGE_LABEL), "PPS_LINK_DEST_TYPE_PAGE_LABEL", "page-label" },
        { C_ENUM (PPS_LINK_DEST_TYPE_UNKNOWN), "PPS_LINK_DEST_TYPE_UNKNOWN", "unknown" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsLinkDestType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-render-context.h" */

GType
pps_render_annots_flags_get_type (void)
{
    static gsize gtype_id = 0;
    static const GFlagsValue values[] = {
        { C_FLAGS (PPS_RENDER_ANNOTS_NONE), "PPS_RENDER_ANNOTS_NONE", "none" },
        { C_FLAGS (PPS_RENDER_ANNOTS_TEXT), "PPS_RENDER_ANNOTS_TEXT", "text" },
        { C_FLAGS (PPS_RENDER_ANNOTS_LINK), "PPS_RENDER_ANNOTS_LINK", "link" },
        { C_FLAGS (PPS_RENDER_ANNOTS_FREETEXT), "PPS_RENDER_ANNOTS_FREETEXT", "freetext" },
        { C_FLAGS (PPS_RENDER_ANNOTS_LINE), "PPS_RENDER_ANNOTS_LINE", "line" },
        { C_FLAGS (PPS_RENDER_ANNOTS_SQUARE), "PPS_RENDER_ANNOTS_SQUARE", "square" },
        { C_FLAGS (PPS_RENDER_ANNOTS_CIRCLE), "PPS_RENDER_ANNOTS_CIRCLE", "circle" },
        { C_FLAGS (PPS_RENDER_ANNOTS_POLYGON), "PPS_RENDER_ANNOTS_POLYGON", "polygon" },
        { C_FLAGS (PPS_RENDER_ANNOTS_POLYLINE), "PPS_RENDER_ANNOTS_POLYLINE", "polyline" },
        { C_FLAGS (PPS_RENDER_ANNOTS_HIGHLIGHT), "PPS_RENDER_ANNOTS_HIGHLIGHT", "highlight" },
        { C_FLAGS (PPS_RENDER_ANNOTS_UNDERLINE), "PPS_RENDER_ANNOTS_UNDERLINE", "underline" },
        { C_FLAGS (PPS_RENDER_ANNOTS_SQUIGGLY), "PPS_RENDER_ANNOTS_SQUIGGLY", "squiggly" },
        { C_FLAGS (PPS_RENDER_ANNOTS_STRIKEOUT), "PPS_RENDER_ANNOTS_STRIKEOUT", "strikeout" },
        { C_FLAGS (PPS_RENDER_ANNOTS_STAMP), "PPS_RENDER_ANNOTS_STAMP", "stamp" },
        { C_FLAGS (PPS_RENDER_ANNOTS_CARET), "PPS_RENDER_ANNOTS_CARET", "caret" },
        { C_FLAGS (PPS_RENDER_ANNOTS_INK), "PPS_RENDER_ANNOTS_INK", "ink" },
        { C_FLAGS (PPS_RENDER_ANNOTS_POPUP), "PPS_RENDER_ANNOTS_POPUP", "popup" },
        { C_FLAGS (PPS_RENDER_ANNOTS_FILEATTACHMENT), "PPS_RENDER_ANNOTS_FILEATTACHMENT", "fileattachment" },
        { C_FLAGS (PPS_RENDER_ANNOTS_SOUND), "PPS_RENDER_ANNOTS_SOUND", "sound" },
        { C_FLAGS (PPS_RENDER_ANNOTS_MOVIE), "PPS_RENDER_ANNOTS_MOVIE", "movie" },
        { C_FLAGS (PPS_RENDER_ANNOTS_WIDGET), "PPS_RENDER_ANNOTS_WIDGET", "widget" },
        { C_FLAGS (PPS_RENDER_ANNOTS_SCREEN), "PPS_RENDER_ANNOTS_SCREEN", "screen" },
        { C_FLAGS (PPS_RENDER_ANNOTS_PRINTERMARK), "PPS_RENDER_ANNOTS_PRINTERMARK", "printermark" },
        { C_FLAGS (PPS_RENDER_ANNOTS_TRAPNET), "PPS_RENDER_ANNOTS_TRAPNET", "trapnet" },
        { C_FLAGS (PPS_RENDER_ANNOTS_WATERMARK), "PPS_RENDER_ANNOTS_WATERMARK", "watermark" },
        { C_FLAGS (PPS_RENDER_ANNOTS_3D), "PPS_RENDER_ANNOTS_3D", "3d" },
        { C_FLAGS (PPS_RENDER_ANNOTS_RICHMEDIA), "PPS_RENDER_ANNOTS_RICHMEDIA", "richmedia" },
        { C_FLAGS (PPS_RENDER_ANNOTS_PRINT_DOCUMENT), "PPS_RENDER_ANNOTS_PRINT_DOCUMENT", "print-document" },
        { C_FLAGS (PPS_RENDER_ANNOTS_PRINT_MARKUP), "PPS_RENDER_ANNOTS_PRINT_MARKUP", "print-markup" },
        { C_FLAGS (PPS_RENDER_ANNOTS_PRINT_STAMP), "PPS_RENDER_ANNOTS_PRINT_STAMP", "print-stamp" },
        { C_FLAGS (PPS_RENDER_ANNOTS_PRINT_ALL), "PPS_RENDER_ANNOTS_PRINT_ALL", "print-all" },
        { C_FLAGS (PPS_RENDER_ANNOTS_ALL), "PPS_RENDER_ANNOTS_ALL", "all" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_flags_register_static (g_intern_static_string ("PpsRenderAnnotsFlags"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-selection.h" */

GType
pps_selection_style_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_SELECTION_STYLE_GLYPH), "PPS_SELECTION_STYLE_GLYPH", "glyph" },
        { C_ENUM (PPS_SELECTION_STYLE_WORD), "PPS_SELECTION_STYLE_WORD", "word" },
        { C_ENUM (PPS_SELECTION_STYLE_LINE), "PPS_SELECTION_STYLE_LINE", "line" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsSelectionStyle"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-signature.h" */

GType
pps_signature_status_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_SIGNATURE_STATUS_VALID), "PPS_SIGNATURE_STATUS_VALID", "valid" },
        { C_ENUM (PPS_SIGNATURE_STATUS_INVALID), "PPS_SIGNATURE_STATUS_INVALID", "invalid" },
        { C_ENUM (PPS_SIGNATURE_STATUS_DIGEST_MISMATCH), "PPS_SIGNATURE_STATUS_DIGEST_MISMATCH", "digest-mismatch" },
        { C_ENUM (PPS_SIGNATURE_STATUS_DECODING_ERROR), "PPS_SIGNATURE_STATUS_DECODING_ERROR", "decoding-error" },
        { C_ENUM (PPS_SIGNATURE_STATUS_GENERIC_ERROR), "PPS_SIGNATURE_STATUS_GENERIC_ERROR", "generic-error" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsSignatureStatus"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* enumerations from "pps-transition-effect.h" */

GType
pps_transition_effect_type_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_TRANSITION_EFFECT_REPLACE), "PPS_TRANSITION_EFFECT_REPLACE", "replace" },
        { C_ENUM (PPS_TRANSITION_EFFECT_SPLIT), "PPS_TRANSITION_EFFECT_SPLIT", "split" },
        { C_ENUM (PPS_TRANSITION_EFFECT_BLINDS), "PPS_TRANSITION_EFFECT_BLINDS", "blinds" },
        { C_ENUM (PPS_TRANSITION_EFFECT_BOX), "PPS_TRANSITION_EFFECT_BOX", "box" },
        { C_ENUM (PPS_TRANSITION_EFFECT_WIPE), "PPS_TRANSITION_EFFECT_WIPE", "wipe" },
        { C_ENUM (PPS_TRANSITION_EFFECT_DISSOLVE), "PPS_TRANSITION_EFFECT_DISSOLVE", "dissolve" },
        { C_ENUM (PPS_TRANSITION_EFFECT_GLITTER), "PPS_TRANSITION_EFFECT_GLITTER", "glitter" },
        { C_ENUM (PPS_TRANSITION_EFFECT_FLY), "PPS_TRANSITION_EFFECT_FLY", "fly" },
        { C_ENUM (PPS_TRANSITION_EFFECT_PUSH), "PPS_TRANSITION_EFFECT_PUSH", "push" },
        { C_ENUM (PPS_TRANSITION_EFFECT_COVER), "PPS_TRANSITION_EFFECT_COVER", "cover" },
        { C_ENUM (PPS_TRANSITION_EFFECT_UNCOVER), "PPS_TRANSITION_EFFECT_UNCOVER", "uncover" },
        { C_ENUM (PPS_TRANSITION_EFFECT_FADE), "PPS_TRANSITION_EFFECT_FADE", "fade" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsTransitionEffectType"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_transition_effect_alignment_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_TRANSITION_ALIGNMENT_HORIZONTAL), "PPS_TRANSITION_ALIGNMENT_HORIZONTAL", "horizontal" },
        { C_ENUM (PPS_TRANSITION_ALIGNMENT_VERTICAL), "PPS_TRANSITION_ALIGNMENT_VERTICAL", "vertical" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsTransitionEffectAlignment"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

GType
pps_transition_effect_direction_get_type (void)
{
    static gsize gtype_id = 0;
    static const GEnumValue values[] = {
        { C_ENUM (PPS_TRANSITION_DIRECTION_INWARD), "PPS_TRANSITION_DIRECTION_INWARD", "inward" },
        { C_ENUM (PPS_TRANSITION_DIRECTION_OUTWARD), "PPS_TRANSITION_DIRECTION_OUTWARD", "outward" },
        { 0, NULL, NULL }
    };
    if (g_once_init_enter (&gtype_id)) {
        GType new_type = g_enum_register_static (g_intern_static_string ("PpsTransitionEffectDirection"), values);
        g_once_init_leave (&gtype_id, new_type);
    }
    return (GType) gtype_id;
}

/* Generated data ends here */

