#ifndef __XMP_Const_h__

#define __XMP_Const_h__ 1

// =================================================================================================

// Copyright 2002-2008 Adobe Systems Incorporated

// All Rights Reserved.

//

// NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the terms

// of the Adobe license agreement accompanying it.

// =================================================================================================

#include "XMP_Environment.h"

   #include <stddef.h>

#if XMP_MacBuild	// ! No stdint.h on Windows and some UNIXes.

    #include <stdint.h>

#endif

#if __cplusplus

extern "C" {

#endif

// =================================================================================================

/// \file XMP_Const.h

/// \brief Common C/C++ types and constants for the XMP toolkit.

// =================================================================================================

// =================================================================================================

// Basic types and constants

// =========================

// The XMP_... types are used on the off chance that the ..._t types present a problem. In that

// case only the declarations of the XMP_... types needs to change, not all of the uses. These

// types are used where fixed sizes are required in order to have a known ABI for a DLL build.

#if XMP_MacBuild

    typedef int8_t   XMP_Int8;

    typedef int16_t  XMP_Int16;

    typedef int32_t  XMP_Int32;

    typedef int64_t  XMP_Int64;

    typedef uint8_t  XMP_Uns8;

    typedef uint16_t XMP_Uns16;

    typedef uint32_t XMP_Uns32;

    typedef uint64_t XMP_Uns64;

#else

    typedef signed char XMP_Int8;

    typedef signed short XMP_Int16;

    typedef signed long XMP_Int32;

    typedef signed long long XMP_Int64;

    typedef unsigned char XMP_Uns8;

    typedef unsigned short XMP_Uns16;

    typedef unsigned long XMP_Uns32;

    typedef unsigned long long XMP_Uns64;

#endif

typedef XMP_Uns8 XMP_Bool;

/// An "ABI safe" pointer to the internal part of an XMP object. Use to pass an XMP object across

/// client DLL boundaries. See \c TXMPMeta::GetInternalRef().

typedef struct __XMPMeta__ *        XMPMetaRef;

/// An "ABI safe" pointer to the internal part of an XMP iteration object. Use to pass an XMP

/// iteration object across client DLL boundaries. See \c TXMPIterator.

typedef struct __XMPIterator__ *    XMPIteratorRef;

/// An "ABI safe" pointer to the internal part of an XMP document operations object. Use to pass an

/// XMP document operations object across client DLL boundaries. See \c TXMPDocOps.

typedef struct __XMPDocOps__ *    XMPDocOpsRef;

/// An "ABI safe" pointer to the internal part of an XMP file-handling object. Use to pass an XMP

/// file-handling object across  client DLL boundaries. See \c TXMPFiles.

typedef struct __XMPFiles__ *       XMPFilesRef;

// =================================================================================================

/// \name General scalar types and constants

/// @{

/// \typedef XMP_StringPtr

/// \brief The type for input string parameters. A <tt>const char *</tt>, a null-terminated UTF-8

/// string.

/// \typedef XMP_StringLen

/// \brief The type for string length parameters. A 32-bit unsigned integer, as big as will be

/// practically needed.

/// \typedef XMP_Index

/// \brief The type for offsets and indices. A 32-bit signed integer. It is signed to allow -1 for

/// loop termination.

/// \typedef XMP_OptionBits

/// \brief The type for a collection of 32 flag bits. Individual flags are defined as enum value bit

/// masks; see \c #kXMP_PropValueIsURI and following. A number of macros provide common set or set

/// operations, such as \c XMP_PropIsSimple. For other tests use an expression like options &

/// kXMP_<theOption>. When passing multiple option flags use the bitwise-OR operator. '|',

/// not the arithmatic plus, '+'.

typedef const char * XMP_StringPtr;  // Points to a null terminated UTF-8 string.

typedef XMP_Uns32    XMP_StringLen;

typedef XMP_Int32    XMP_Index;      // Signed, sometimes -1 is handy.

typedef XMP_Uns32    XMP_OptionBits; // Used as 32 individual bits.

/// \def kXMP_TrueStr

/// \brief The canonical true string value for Booleans in serialized XMP.

///

/// Code that converts from string to bool should be case insensitive, and also allow "1".

/// \def kXMP_FalseStr

/// \brief The canonical false string value for Booleans in serialized XMP.

///

/// Code that converts	from string to bool should be case insensitive, and also allow "0".

#define kXMP_TrueStr  "True"  // Serialized XMP spellings, not for the type bool.

#define kXMP_FalseStr "False"

/// Type for yes/no/maybe answers. The values are picked to allow Boolean-like usage. The yes and

/// values are true (non-zero), the no value is false (zero).

enum {

	/// The part or parts have definitely changed.

	kXMPTS_Yes = 1,

	/// The part or parts have definitely not changed.

	kXMPTS_No = 0,

	/// The part or parts might, or might not, have changed.

	kXMPTS_Maybe = -1

};

typedef XMP_Int8 XMP_TriState;

/// @}

// =================================================================================================

/// \struct XMP_DateTime

/// \brief The expanded type for a date and time.

///

/// Dates and time in the serialized XMP are ISO 8601 strings. The \c XMP_DateTime struct allows

/// easy conversion with other formats.

///

/// All of the fields are 32 bit, even though most could be 8 bit. This avoids overflow when doing

/// carries for arithmetic or normalization. All fields have signed values for the same reasons.

///

/// Date-time values are occasionally used with only a date or only a time component. A date without

/// a time has zeros in the \c XMP_DateTime struct for all time fields. A time without a date has

/// zeros for all date fields (year, month, and day).

///

/// \c TXMPUtils provides utility functions for manipulating date-time values.

///

/// @see \c TXMPUtils::ConvertToDate(), \c TXMPUtils::ConvertFromDate(),

/// \c TXMPUtils::CompareDateTime(), \c TXMPUtils::ConvertToLocalTime(),

/// \c TXMPUtils::ConvertToUTCTime(), \c TXMPUtils::CurrentDateTime(),

/// \c TXMPUtils::SetTimeZone()

struct XMP_DateTime {

	/// The year, can be negative.

    XMP_Int32 year;

	/// The month in the range 1..12.

    XMP_Int32 month;

	/// The day of the month in the range 1..31.

    XMP_Int32 day;

	/// The hour in the range 0..23.

    XMP_Int32 hour;

	/// The minute in the range 0..59.

    XMP_Int32 minute;

	/// The second in the range 0..59.

    XMP_Int32 second;

	/// The "sign" of the time zone, \c #kXMP_TimeIsUTC (0) means UTC, \c #kXMP_TimeWestOfUTC (-1)

	/// is west, \c #kXMP_TimeEastOfUTC (+1) is east.

    XMP_Int32 tzSign;

	/// The time zone hour in the range 0..23.

    XMP_Int32 tzHour;

	/// The time zone minute in the range 0..59.

    XMP_Int32 tzMinute;

	/// Nanoseconds within a second, often left as zero.

    XMP_Int32 nanoSecond;

};

/// Constant values for \c XMP_DateTime::tzSign field.

enum {

	/// Time zone is west of UTC.

    kXMP_TimeWestOfUTC = -1,

	/// UTC time.

    kXMP_TimeIsUTC     =  0,

	/// Time zone is east of UTC.

    kXMP_TimeEastOfUTC = +1

};

// =================================================================================================

// Standard namespace URI constants

// ================================

/// \name XML namespace constants for standard XMP schema.

/// @{

///

/// \def kXMP_NS_XMP

/// \brief The XML namespace for the XMP "basic" schema.

///

/// \def kXMP_NS_XMP_Rights

/// \brief The XML namespace for the XMP copyright schema.

///

/// \def kXMP_NS_XMP_MM

/// \brief The XML namespace for the XMP digital asset management schema.

///

/// \def kXMP_NS_XMP_BJ

/// \brief The XML namespace for the job management schema.

///

/// \def kXMP_NS_XMP_T

/// \brief The XML namespace for the XMP text document schema.

///

/// \def kXMP_NS_XMP_T_PG

/// \brief The XML namespace for the XMP paged document schema.

///

/// \def kXMP_NS_PDF

/// \brief The XML namespace for the PDF schema.

///

/// \def kXMP_NS_Photoshop

/// \brief The XML namespace for the Photoshop custom schema.

///

/// \def kXMP_NS_EXIF

/// \brief The XML namespace for Adobe's EXIF schema.

///

/// \def kXMP_NS_TIFF

/// \brief The XML namespace for Adobe's TIFF schema.

///

/// @}

#define kXMP_NS_XMP        "http://ns.adobe.com/xap/1.0/"

#define kXMP_NS_XMP_Rights "http://ns.adobe.com/xap/1.0/rights/"

#define kXMP_NS_XMP_MM     "http://ns.adobe.com/xap/1.0/mm/"

#define kXMP_NS_XMP_BJ     "http://ns.adobe.com/xap/1.0/bj/"

#define kXMP_NS_PDF        "http://ns.adobe.com/pdf/1.3/"

#define kXMP_NS_Photoshop  "http://ns.adobe.com/photoshop/1.0/"

#define kXMP_NS_PSAlbum    "http://ns.adobe.com/album/1.0/"

#define kXMP_NS_EXIF       "http://ns.adobe.com/exif/1.0/"

#define kXMP_NS_EXIF_Aux   "http://ns.adobe.com/exif/1.0/aux/"

#define kXMP_NS_TIFF       "http://ns.adobe.com/tiff/1.0/"

#define kXMP_NS_PNG        "http://ns.adobe.com/png/1.0/"

#define kXMP_NS_SWF        "http://ns.adobe.com/swf/1.0/"

#define kXMP_NS_JPEG       "http://ns.adobe.com/jpeg/1.0/"

#define kXMP_NS_JP2K       "http://ns.adobe.com/jp2k/1.0/"

#define kXMP_NS_CameraRaw  "http://ns.adobe.com/camera-raw-settings/1.0/"

#define kXMP_NS_DM         "http://ns.adobe.com/xmp/1.0/DynamicMedia/"

#define kXMP_NS_ASF        "http://ns.adobe.com/asf/1.0/"

#define kXMP_NS_WAV        "http://ns.adobe.com/xmp/wav/1.0/"

#define kXMP_NS_XMP_Note   "http://ns.adobe.com/xmp/note/"

#define kXMP_NS_AdobeStockPhoto "http://ns.adobe.com/StockPhoto/1.0/"

#define kXMP_NS_CreatorAtom "http://ns.adobe.com/creatorAtom/1.0/"

/// \name XML namespace constants for qualifiers and structured property fields.

/// @{

///

/// \def kXMP_NS_XMP_IdentifierQual

/// \brief The XML namespace for qualifiers of the xmp:Identifier property.

///

/// \def kXMP_NS_XMP_Dimensions

/// \brief The XML namespace for fields of the Dimensions type.

///

/// \def kXMP_NS_XMP_Image

/// \brief The XML namespace for fields of a graphical image. Used for the Thumbnail type.

///

/// \def kXMP_NS_XMP_ResourceEvent

/// \brief The XML namespace for fields of the ResourceEvent type.

///

/// \def kXMP_NS_XMP_ResourceRef

/// \brief The XML namespace for fields of the ResourceRef type.

///

/// \def kXMP_NS_XMP_ST_Version

/// \brief The XML namespace for fields of the Version type.

///

/// \def kXMP_NS_XMP_ST_Job

/// \brief The XML namespace for fields of the JobRef type.

///

/// @}

#define kXMP_NS_XMP_IdentifierQual "http://ns.adobe.com/xmp/Identifier/qual/1.0/"

#define kXMP_NS_XMP_Dimensions     "http://ns.adobe.com/xap/1.0/sType/Dimensions#"

#define kXMP_NS_XMP_Text           "http://ns.adobe.com/xap/1.0/t/"

#define kXMP_NS_XMP_PagedFile      "http://ns.adobe.com/xap/1.0/t/pg/"

#define kXMP_NS_XMP_Graphics       "http://ns.adobe.com/xap/1.0/g/"

#define kXMP_NS_XMP_Image          "http://ns.adobe.com/xap/1.0/g/img/"

#define kXMP_NS_XMP_Font           "http://ns.adobe.com/xap/1.0/sType/Font#"

#define kXMP_NS_XMP_ResourceEvent  "http://ns.adobe.com/xap/1.0/sType/ResourceEvent#"

#define kXMP_NS_XMP_ResourceRef    "http://ns.adobe.com/xap/1.0/sType/ResourceRef#"

#define kXMP_NS_XMP_ST_Version     "http://ns.adobe.com/xap/1.0/sType/Version#"

#define kXMP_NS_XMP_ST_Job         "http://ns.adobe.com/xap/1.0/sType/Job#"

#define kXMP_NS_XMP_ManifestItem   "http://ns.adobe.com/xap/1.0/sType/ManifestItem#"

// Deprecated XML namespace constants

#define kXMP_NS_XMP_T     "http://ns.adobe.com/xap/1.0/t/"

#define kXMP_NS_XMP_T_PG  "http://ns.adobe.com/xap/1.0/t/pg/"

#define kXMP_NS_XMP_G_IMG "http://ns.adobe.com/xap/1.0/g/img/"

/// \name XML namespace constants from outside Adobe.

/// @{

///

/// \def kXMP_NS_DC

/// \brief The XML namespace for the Dublin Core schema.

///

/// \def kXMP_NS_IPTCCore

/// \brief The XML namespace for the IPTC Core schema.

///

/// \def kXMP_NS_RDF

/// \brief The XML namespace for RDF.

///

/// \def kXMP_NS_XML

/// \brief The XML namespace for XML.

///

/// @}

#define kXMP_NS_DC              "http://purl.org/dc/elements/1.1/"

#define kXMP_NS_IPTCCore       "http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/"

#define kXMP_NS_DICOM          "http://ns.adobe.com/DICOM/"

#define kXMP_NS_PDFA_Schema    "http://www.aiim.org/pdfa/ns/schema#"

#define kXMP_NS_PDFA_Property  "http://www.aiim.org/pdfa/ns/property#"

#define kXMP_NS_PDFA_Type      "http://www.aiim.org/pdfa/ns/type#"

#define kXMP_NS_PDFA_Field     "http://www.aiim.org/pdfa/ns/field#"

#define kXMP_NS_PDFA_ID        "http://www.aiim.org/pdfa/ns/id/"

#define kXMP_NS_PDFA_Extension "http://www.aiim.org/pdfa/ns/extension/"

#define kXMP_NS_PDFX           "http://ns.adobe.com/pdfx/1.3/"

#define	kXMP_NS_PDFX_ID        "http://www.npes.org/pdfx/ns/id/"

#define kXMP_NS_RDF            "http://www.w3.org/1999/02/22-rdf-syntax-ns#"

#define kXMP_NS_XML            "http://www.w3.org/XML/1998/namespace"

// =================================================================================================

// Enums and macros used for option bits

// =====================================

/// \name Macros for standard option selections.

/// @{

///

/// \def kXMP_ArrayLastItem

/// \brief Options macro accesses last array item.

///

/// \def kXMP_UseNullTermination

/// \brief Options macro sets string style.

///

/// \def kXMP_NoOptions

/// \brief Options macro clears all property-type bits.

///

/// @}

#define kXMP_ArrayLastItem      ((XMP_Index)(-1L))

#define kXMP_UseNullTermination ((XMP_StringLen)(~0UL))

#define kXMP_NoOptions          ((XMP_OptionBits)0UL)

/// \name Macros for setting and testing general option bits.

/// @{

///

/// \def XMP_SetOption

/// \brief Macro sets an option flag bit.

///	\param var A variable storing an options flag.

/// \param opt The bit-flag constant to set.

///

/// \def XMP_ClearOption

/// \brief Macro clears an option flag bit.

///	\param var A variable storing an options flag.

/// \param opt The bit-flag constant to clear.

///

/// \def XMP_TestOption

/// \brief Macro reports whether an option flag bit is set.

///	\param var A variable storing an options flag.

/// \param opt The bit-flag constant to test.

/// \return True if the bit is set.

///

/// \def XMP_OptionIsSet

/// \brief Macro reports whether an option flag bit is set.

///	\param var A variable storing an options flag.

/// \param opt The bit-flag constant to test.

/// \return True if the bit is set.

///

/// \def XMP_OptionIsClear

/// \brief Macro reports whether an option flag bit is clear.

///	\param var A variable storing an options flag.

/// \param opt The bit-flag constant to test.

/// \return True if the bit is clear.

///

/// @}

#define XMP_SetOption(var,opt)      var |= (opt)

#define XMP_ClearOption(var,opt)    var &= ~(opt)

#define XMP_TestOption(var,opt)     (((var) & (opt)) != 0)

#define XMP_OptionIsSet(var,opt)    (((var) & (opt)) != 0)

#define XMP_OptionIsClear(var,opt)  (((var) & (opt)) == 0)

/// \name Macros for setting and testing specific option bits.

/// @{

///

/// \def XMP_PropIsSimple

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropIsStruct

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropIsArray

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_ArrayIsUnordered

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_ArrayIsOrdered

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_ArrayIsAlternate

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_ArrayIsAltText

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropHasQualifiers

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropIsQualifier

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropHasLang

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_NodeIsSchema

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// \def XMP_PropIsAlias

/// \brief Macro reports the property type specified by an options flag.

/// \param opt The options flag to check.

///

/// @}

#define XMP_PropIsSimple(opt)       (((opt) & kXMP_PropCompositeMask) == 0)

#define XMP_PropIsStruct(opt)       (((opt) & kXMP_PropValueIsStruct) != 0)

#define XMP_PropIsArray(opt)        (((opt) & kXMP_PropValueIsArray) != 0)

#define XMP_ArrayIsUnordered(opt)   (((opt) & kXMP_PropArrayIsOrdered) == 0)

#define XMP_ArrayIsOrdered(opt)     (((opt) & kXMP_PropArrayIsOrdered) != 0)

#define XMP_ArrayIsAlternate(opt)   (((opt) & kXMP_PropArrayIsAlternate) != 0)

#define XMP_ArrayIsAltText(opt)     (((opt) & kXMP_PropArrayIsAltText) != 0)

#define XMP_PropHasQualifiers(opt)  (((opt) & kXMP_PropHasQualifiers) != 0)

#define XMP_PropIsQualifier(opt)    (((opt) & kXMP_PropIsQualifier) != 0)

#define XMP_PropHasLang(opt)        (((opt) & kXMP_PropHasLang) != 0)

#define XMP_NodeIsSchema(opt)       (((opt) & kXMP_SchemaNode) != 0)

#define XMP_PropIsAlias(opt)        (((opt) & kXMP_PropIsAlias) != 0)

// -------------------------------------------------------------------------------------------------

/// Option bit flags for the \c TXMPMeta property accessor functions.

enum {

	/// The XML string form of the property value is a URI, use rdf:resource attribute. DISCOURAGED

    kXMP_PropValueIsURI       = 0x00000002UL,

	// ------------------------------------------------------

    // Options relating to qualifiers attached to a property.

	/// The property has qualifiers, includes \c rdf:type and \c xml:lang.

    kXMP_PropHasQualifiers    = 0x00000010UL,

	/// This is a qualifier for some other property, includes \c rdf:type and \c xml:lang.

	/// Qualifiers can have arbitrary structure, and can themselves have qualifiers. If the

	/// qualifier itself has a structured value, this flag is only set for the top node of the

	/// qualifier's subtree.

    kXMP_PropIsQualifier      = 0x00000020UL,

	/// Implies \c #kXMP_PropHasQualifiers, property has \c xml:lang.

    kXMP_PropHasLang          = 0x00000040UL,

	/// Implies \c #kXMP_PropHasQualifiers, property has \c rdf:type.

    kXMP_PropHasType          = 0x00000080UL,

	// --------------------------------------------

    // Options relating to the data structure form.

	/// The value is a structure with nested fields.

    kXMP_PropValueIsStruct    = 0x00000100UL,

	/// The value is an array (RDF alt/bag/seq). The "ArrayIs..." flags identify specific types

	/// of array; default is a general unordered array, serialized using an \c rdf:Bag container.

    kXMP_PropValueIsArray     = 0x00000200UL,

	/// The item order does not matter.

    kXMP_PropArrayIsUnordered = kXMP_PropValueIsArray,

	/// Implies \c #kXMP_PropValueIsArray, item order matters. It is serialized using an \c rdf:Seq container.

    kXMP_PropArrayIsOrdered   = 0x00000400UL,

	/// Implies \c #kXMP_PropArrayIsOrdered, items are alternates. It is serialized using an \c rdf:Alt container.

    kXMP_PropArrayIsAlternate = 0x00000800UL,

	// ------------------------------------

    // Additional struct and array options.

	/// Implies \c #kXMP_PropArrayIsAlternate, items are localized text.  Each array element is a

	/// simple property with an \c xml:lang attribute.

    kXMP_PropArrayIsAltText   = 0x00001000UL,

    // kXMP_InsertBeforeItem  = 0x00004000UL,  ! Used by SetXyz functions.

    // kXMP_InsertAfterItem   = 0x00008000UL,  ! Used by SetXyz functions.

	// ----------------------------

    // Other miscellaneous options.

	/// This property is an alias name for another property.  This is only returned by

	/// \c TXMPMeta::GetProperty() and then only if the property name is simple, not an path expression.

    kXMP_PropIsAlias          = 0x00010000UL,

	/// This property is the base value (actual) for a set of aliases.This is only returned by

	/// \c TXMPMeta::GetProperty() and then only if the property name is simple, not an path expression.

    kXMP_PropHasAliases       = 0x00020000UL,

	/// The value of this property is "owned" by the application, and should not generally be editable in a UI.

    kXMP_PropIsInternal       = 0x00040000UL,

	/// The value of this property is not derived from the document content.

    kXMP_PropIsStable         = 0x00100000UL,

	/// The value of this property is derived from the document content.

    kXMP_PropIsDerived        = 0x00200000UL,

    // kXMPUtil_AllowCommas   = 0x10000000UL,  ! Used by TXMPUtils::CatenateArrayItems and ::SeparateArrayItems.

    // kXMP_DeleteExisting    = 0x20000000UL,  ! Used by TXMPMeta::SetXyz functions to delete any pre-existing property.

    // kXMP_SchemaNode        = 0x80000000UL,  ! Returned by iterators - #define to avoid warnings

	// ------------------------------

    // Masks that are multiple flags.

	/// Property type bit-flag mask for all array types

    kXMP_PropArrayFormMask    = kXMP_PropValueIsArray | kXMP_PropArrayIsOrdered | kXMP_PropArrayIsAlternate | kXMP_PropArrayIsAltText,

	/// Property type bit-flag mask for composite types (array and struct)

    kXMP_PropCompositeMask    = kXMP_PropValueIsStruct | kXMP_PropArrayFormMask,

	/// Mask for bits that are reserved for transient use by the implementation.

    kXMP_ImplReservedMask     = 0x70000000L

};

#define kXMP_SchemaNode ((XMP_OptionBits)0x80000000UL)

/// Option bit flags for the \c TXMPMeta property setting functions. These option bits are shared

/// with the accessor functions:

///   \li \c #kXMP_PropValueIsURI

///   \li \c #kXMP_PropValueIsStruct

///   \li \c #kXMP_PropValueIsArray

///   \li \c #kXMP_PropArrayIsOrdered

///   \li \c #kXMP_PropArrayIsAlternate

///   \li \c #kXMP_PropArrayIsAltText

enum {

    /// Option for array item location: Insert a new item before the given index.

    kXMP_InsertBeforeItem      = 0x00004000UL,

    /// Option for array item location: Insert a new item after the given index.

    kXMP_InsertAfterItem       = 0x00008000UL,

    /// Delete any pre-existing property.

    kXMP_DeleteExisting        = 0x20000000UL,

	/// Bit-flag mask for property-value option bits

    kXMP_PropValueOptionsMask  = kXMP_PropValueIsURI,

	/// Bit-flag mask for array-item location bits

    kXMP_PropArrayLocationMask = kXMP_InsertBeforeItem | kXMP_InsertAfterItem

};

// -------------------------------------------------------------------------------------------------

/// Option bit flags for \c TXMPMeta::ParseFromBuffer().

enum {

	/// Require a surrounding \c x:xmpmeta element.

    kXMP_RequireXMPMeta   = 0x0001UL,

	/// This is the not last input buffer for this parse stream.

    kXMP_ParseMoreBuffers = 0x0002UL,

	/// Do not reconcile alias differences, throw an exception.

    kXMP_StrictAliasing   = 0x0004UL

};

/// Option bit flags for \c TXMPMeta::SerializeToBuffer().

enum {

    // *** Option to remove empty struct/array, or leaf with empty value?

	/// Omit the XML packet wrapper.

    kXMP_OmitPacketWrapper   = 0x0010UL,

	/// Default is a writeable packet.

    kXMP_ReadOnlyPacket      = 0x0020UL,

	/// Use a compact form of RDF.

    kXMP_UseCompactFormat    = 0x0040UL,

	/// Include a padding allowance for a thumbnail image.

    kXMP_IncludeThumbnailPad = 0x0100UL,

	/// The padding parameter is the overall packet length.

    kXMP_ExactPacketLength   = 0x0200UL,

	/// Show aliases as XML comments.

    kXMP_WriteAliasComments  = 0x0400UL,

	/// Omit all formatting whitespace.

    kXMP_OmitAllFormatting   = 0x0800UL,

    /// Omit the x:xmpmeta element surrounding the rdf:RDF element.

    kXMP_OmitXMPMetaElement  = 0x1000UL,

    _XMP_LittleEndian_Bit    = 0x0001UL,  // ! Don't use directly, see the combined values below!

    _XMP_UTF16_Bit           = 0x0002UL,

    _XMP_UTF32_Bit           = 0x0004UL,

	/// Bit-flag mask for encoding-type bits

    kXMP_EncodingMask        = 0x0007UL,

	/// Use UTF8 encoding

    kXMP_EncodeUTF8          = 0UL,

	/// Use UTF16 big-endian encoding

    kXMP_EncodeUTF16Big      = _XMP_UTF16_Bit,

	/// Use UTF16 little-endian encoding

    kXMP_EncodeUTF16Little   = _XMP_UTF16_Bit | _XMP_LittleEndian_Bit,

	/// Use UTF32 big-endian encoding

    kXMP_EncodeUTF32Big      = _XMP_UTF32_Bit,

	/// Use UTF13 little-endian encoding

    kXMP_EncodeUTF32Little   = _XMP_UTF32_Bit | _XMP_LittleEndian_Bit

};

// -------------------------------------------------------------------------------------------------

/// Option bit flags for \c TXMPIterator construction.

enum {

	/// The low 8 bits are an enum of what data structure to iterate.

    kXMP_IterClassMask      = 0x00FFUL,

    /// Iterate the property tree of a TXMPMeta object.

    kXMP_IterProperties     = 0x0000UL,

	/// Iterate the global alias table.

    kXMP_IterAliases        = 0x0001UL,

	/// Iterate the global namespace table.

    kXMP_IterNamespaces     = 0x0002UL,

	/// Just do the immediate children of the root, default is subtree.

    kXMP_IterJustChildren   = 0x0100UL,

	/// Just do the leaf nodes, default is all nodes in the subtree.

    kXMP_IterJustLeafNodes  = 0x0200UL,

	/// Return just the leaf part of the path, default is the full path.

    kXMP_IterJustLeafName   = 0x0400UL,

	 /// Include aliases, default is just actual properties.

    kXMP_IterIncludeAliases = 0x0800UL,

	 /// Omit all qualifiers.

    kXMP_IterOmitQualifiers = 0x1000UL

};

/// Option bit flags for \c TXMPIterator::Skip().

enum {

	/// Skip the subtree below the current node.

    kXMP_IterSkipSubtree    = 0x0001UL,

	/// Skip the subtree below and remaining siblings of the current node.

    kXMP_IterSkipSiblings   = 0x0002UL

};

// -------------------------------------------------------------------------------------------------

/// Option bit flags for \c TXMPUtils::CatenateArrayItems() and \c TXMPUtils::SeparateArrayItems().

/// These option bits are shared with the accessor functions:

///   \li \c #kXMP_PropValueIsArray,

///   \li \c #kXMP_PropArrayIsOrdered, 

///   \li \c #kXMP_PropArrayIsAlternate,

///   \li \c #kXMP_PropArrayIsAltText

enum {

	/// Allow commas in item values, default is separator.

    kXMPUtil_AllowCommas      = 0x10000000UL

};

/// Option bit flags for \c TXMPUtils::RemoveProperties() and \c TXMPUtils::AppendProperties().

enum {

	 /// Do all properties, default is just external properties.

    kXMPUtil_DoAllProperties   = 0x0001UL,

	/// Replace existing values, default is to leave them.

    kXMPUtil_ReplaceOldValues  = 0x0002UL,

	/// Delete properties if the new value is empty.

    kXMPUtil_DeleteEmptyValues = 0x0004UL,

	/// Include aliases, default is just actual properties.

    kXMPUtil_IncludeAliases    = 0x0800UL

};

// =================================================================================================

// Types and Constants for XMPFiles

// ================================

/// File format constants for use with XMPFiles.

enum {

    // ! Hex used to avoid gcc warnings. Leave the constants so the text reads big endian. There

    // ! seems to be no decent way on UNIX to determine the target endianness at compile time.

    // ! Forcing it on the client isn't acceptable.

	// --------------------

    // Public file formats.

	/// Public file format constant: 'PDF '

    kXMP_PDFFile             = 0x50444620UL,

	/// Public file format constant: 'PS  ', general PostScript following DSC conventions

    kXMP_PostScriptFile      = 0x50532020UL,

	/// Public file format constant: 'EPS ', encapsulated PostScript

    kXMP_EPSFile             = 0x45505320UL,

	/// Public file format constant: 'JPEG'

    kXMP_JPEGFile            = 0x4A504547UL,

	/// Public file format constant: 'JPX ', JPEG 2000, ISO 15444-1

    kXMP_JPEG2KFile          = 0x4A505820UL,

	/// Public file format constant: 'TIFF'

    kXMP_TIFFFile            = 0x54494646UL,

	/// Public file format constant: 'GIF '

    kXMP_GIFFile             = 0x47494620UL,

	/// Public file format constant: 'PNG '

    kXMP_PNGFile             = 0x504E4720UL,

	/// Public file format constant: 'SWF '

    kXMP_SWFFile             = 0x53574620UL,

	/// Public file format constant: 'FLA '

    kXMP_FLAFile             = 0x464C4120UL,

	/// Public file format constant: 'FLV '

    kXMP_FLVFile             = 0x464C5620UL,

	/// Public file format constant: 'MOV ', Quicktime

    kXMP_MOVFile             = 0x4D4F5620UL,

	/// Public file format constant: 'AVI '

    kXMP_AVIFile             = 0x41564920UL,

	/// Public file format constant: 'CIN ', Cineon

    kXMP_CINFile             = 0x43494E20UL,

 	/// Public file format constant: 'WAV '

    kXMP_WAVFile             = 0x57415620UL,

	/// Public file format constant: 'MP3 '

    kXMP_MP3File             = 0x4D503320UL,

	/// Public file format constant: 'SES ', Audition session

    kXMP_SESFile             = 0x53455320UL,

	/// Public file format constant: 'CEL ', Audition loop

    kXMP_CELFile             = 0x43454C20UL,

	/// Public file format constant: 'MPEG'

    kXMP_MPEGFile            = 0x4D504547UL,

	/// Public file format constant: 'MP2 '

    kXMP_MPEG2File           = 0x4D503220UL,

	/// Public file format constant: 'MP4 ', ISO 14494-12 and -14

    kXMP_MPEG4File           = 0x4D503420UL,

	/// Public file format constant: 'WMAV', Windows Media Audio and Video

    kXMP_WMAVFile            = 0x574D4156UL,

	/// Public file format constant:  'AIFF'

    kXMP_AIFFFile            = 0x41494646UL,

	/// Public file format constant:  'P2  ', a collection not really a single file

    kXMP_P2File              = 0x50322020UL,

	/// Public file format constant:  'XDCF', a collection not really a single file

    kXMP_XDCAM_FAMFile       = 0x58444346UL,

	/// Public file format constant:  'XDCS', a collection not really a single file

    kXMP_XDCAM_SAMFile       = 0x58444353UL,

	/// Public file format constant:  'XDCX', a collection not really a single file

    kXMP_XDCAM_EXFile        = 0x58444358UL,

	/// Public file format constant:  'AVHD', a collection not really a single file

    kXMP_AVCHDFile           = 0x41564844UL,

	/// Public file format constant:  'SHDV', a collection not really a single file

    kXMP_SonyHDVFile         = 0x53484456UL,

	/// Public file format constant: 'HTML'

    kXMP_HTMLFile            = 0x48544D4CUL,

	/// Public file format constant: 'XML '

    kXMP_XMLFile             = 0x584D4C20UL,

	/// Public file format constant:  'text'

    kXMP_TextFile            = 0x74657874UL,

	// -------------------------------

    // Adobe application file formats.

	/// Adobe application file format constant: 'PSD '

    kXMP_PhotoshopFile       = 0x50534420UL,

	/// Adobe application file format constant: 'AI  '

    kXMP_IllustratorFile     = 0x41492020UL,

	/// Adobe application file format constant: 'INDD'

    kXMP_InDesignFile        = 0x494E4444UL,

	/// Adobe application file format constant: 'AEP '

    kXMP_AEProjectFile       = 0x41455020UL,

	/// Adobe application file format constant: 'AET ', After Effects Project Template

    kXMP_AEProjTemplateFile  = 0x41455420UL,

	/// Adobe application file format constant: 'FFX '

    kXMP_AEFilterPresetFile  = 0x46465820UL,

	/// Adobe application file format constant: 'NCOR'

    kXMP_EncoreProjectFile   = 0x4E434F52UL,

	/// Adobe application file format constant: 'PRPJ'

    kXMP_PremiereProjectFile = 0x5052504AUL,

	/// Adobe application file format constant: 'PRTL'

    kXMP_PremiereTitleFile   = 0x5052544CUL,

	/// Adobe application file format constant: 'UCF ', Universal Container Format

	kXMP_UCFFile             = 0x55434620UL,

	// -------

    // Others.

	/// Unknown file format constant: '    '

    kXMP_UnknownFile         = 0x20202020UL

};

/// Type for file format identification constants. See \c #kXMP_PDFFile and following.

typedef XMP_Uns32 XMP_FileFormat;

// -------------------------------------------------------------------------------------------------

/// Byte-order masks, do not use directly

enum {

    kXMP_CharLittleEndianMask = 1,

    kXMP_Char16BitMask        = 2,

    kXMP_Char32BitMask        = 4

};

/// Constants to allow easy testing for 16/32 bit and big/little endian.

enum {

	/// 8-bit

    kXMP_Char8Bit        = 0,

	/// 16-bit big-endian

    kXMP_Char16BitBig    = kXMP_Char16BitMask,

	/// 16-bit little-endian