From 11b26f05ad28a82949e75d26e77db9d35c1dc57f Mon Sep 17 00:00:00 2001 From: Jon Griffiths Date: Fri, 23 Apr 2004 23:28:04 +0000 Subject: [PATCH] Update/Add MAPI headers. --- dlls/uuid/uuid.c | 1 + include/Makefile.in | 5 + include/mapicode.h | 84 ++++- include/mapidefs.h | 878 ++++++++++++++++++++++++++++++++++++++++++-- include/mapiguid.h | 81 ++++ include/mapitags.h | 813 ++++++++++++++++++++++++++++++++++++++++ include/mapiutil.h | 216 +++++++++++ include/mapival.h | 119 ++++++ include/mapix.h | 171 +++++++++ 9 files changed, 2334 insertions(+), 34 deletions(-) create mode 100644 include/mapiguid.h create mode 100644 include/mapitags.h create mode 100644 include/mapiutil.h create mode 100644 include/mapival.h create mode 100644 include/mapix.h diff --git a/dlls/uuid/uuid.c b/dlls/uuid/uuid.c index ed0dd1284ab..8da74c2b9c8 100644 --- a/dlls/uuid/uuid.c +++ b/dlls/uuid/uuid.c @@ -51,6 +51,7 @@ DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0); #include "shldisp.h" #include "comcat.h" #include "urlmon.h" +#include "mapiguid.h" /* FIXME: cguids declares GUIDs but does not define their values */ diff --git a/include/Makefile.in b/include/Makefile.in index d00f93f92c5..fa57b08dd1c 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -121,6 +121,11 @@ WINDOWS_INCLUDES = \ mapi.h \ mapicode.h \ mapidefs.h \ + mapiguid.h \ + mapitags.h \ + mapiutil.h \ + mapival.h \ + mapix.h \ mciavi.h \ mcx.h \ mediaerr.h \ diff --git a/include/mapicode.h b/include/mapicode.h index c6b7a9dee0c..77172f52a4c 100644 --- a/include/mapicode.h +++ b/include/mapicode.h @@ -24,11 +24,87 @@ #include #define MAKE_MAPI_SCODE(sev,fac,code) \ - ( (((ULONG)(sev)<<31) | ((ULONG)(fac)<<16) | ((ULONG)(code))) ) + ((SCODE)(((ULONG)(sev)<<31)|((ULONG)(fac)<<16)|((ULONG)(code)))) -#define MAKE_MAPI_E( err ) (MAKE_MAPI_SCODE(1, FACILITY_ITF, err )) +#define MAKE_MAPI_E(e) (MAKE_MAPI_SCODE(1,FACILITY_ITF,(e))) +#define MAKE_MAPI_S(e) (MAKE_MAPI_SCODE(0,FACILITY_ITF,(e))) -#define MAPI_E_NOT_INITIALIZED MAKE_MAPI_E( 0x605) +/* Errors */ +#define MAPI_E_ACCOUNT_DISABLED ((SCODE)0x80040124) +#define MAPI_E_AMBIGUOUS_RECIP ((SCODE)0x80040700) +#define MAPI_E_BAD_CHARWIDTH ((SCODE)0x80040103) +#define MAPI_E_BAD_COLUMN ((SCODE)0x80040118) +#define MAPI_E_BAD_VALUE ((SCODE)0x80040301) +#define MAPI_E_BUSY ((SCODE)0x8004010B) +#define MAPI_E_CALL_FAILED E_FAIL +#define MAPI_E_CANCEL ((SCODE)0x80040501) +#define MAPI_E_COLLISION ((SCODE)0x80040604) +#define MAPI_E_COMPUTED ((SCODE)0x8004011A) +#define MAPI_E_CORRUPT_DATA ((SCODE)0x8004011B) +#define MAPI_E_CORRUPT_STORE ((SCODE)0x80040600) +#define MAPI_E_DECLINE_COPY ((SCODE)0x80040306) +#define MAPI_E_DISK_ERROR ((SCODE)0x80040116) +#define MAPI_E_END_OF_SESSION ((SCODE)0x80040200) +#define MAPI_E_EXTENDED_ERROR ((SCODE)0x80040119) +#define MAPI_E_FAILONEPROVIDER ((SCODE)0x8004011D) +#define MAPI_E_FOLDER_CYCLE ((SCODE)0x8004060B) +#define MAPI_E_HAS_FOLDERS ((SCODE)0x80040609) +#define MAPI_E_HAS_MESSAGES ((SCODE)0x8004060A) +#define MAPI_E_INTERFACE_NOT_SUPPORTED E_NOINTERFACE +#define MAPI_E_INVALID_ACCESS_TIME ((SCODE)0x80040123) +#define MAPI_E_INVALID_BOOKMARK ((SCODE)0x80040405) +#define MAPI_E_INVALID_ENTRYID ((SCODE)0x80040107) +#define MAPI_E_INVALID_OBJECT ((SCODE)0x80040108) +#define MAPI_E_INVALID_PARAMETER E_INVALIDARG +#define MAPI_E_INVALID_TYPE ((SCODE)0x80040302) +#define MAPI_E_INVALID_WORKSTATION_ACCOUNT ((SCODE)0x80040122) +#define MAPI_E_LOGON_FAILED ((SCODE)0x80040111) +#define MAPI_E_MISSING_REQUIRED_COLUMN ((SCODE)0x80040202) +#define MAPI_E_NETWORK_ERROR ((SCODE)0x80040115) +#define MAPI_E_NO_ACCESS E_ACCESSDENIED +#define MAPI_E_NON_STANDARD ((SCODE)0x80040606) +#define MAPI_E_NO_RECIPIENTS ((SCODE)0x80040607) +#define MAPI_E_NO_SUPPORT ((SCODE)0x80040102) +#define MAPI_E_NO_SUPPRESS ((SCODE)0x80040602) +#define MAPI_E_NOT_ENOUGH_DISK ((SCODE)0x8004010D) +#define MAPI_E_NOT_ENOUGH_MEMORY E_OUTOFMEMORY +#define MAPI_E_NOT_ENOUGH_RESOURCES ((SCODE)0x8004010E) +#define MAPI_E_NOT_FOUND ((SCODE)0x8004010F) +#define MAPI_E_NOT_INITIALIZED ((SCODE)0x80040605) +#define MAPI_E_NOT_IN_QUEUE ((SCODE)0x80040601) +#define MAPI_E_NOT_ME ((SCODE)0x80040502) +#define MAPI_E_OBJECT_CHANGED ((SCODE)0x80040109) +#define MAPI_E_OBJECT_DELETED ((SCODE)0x8004010A) +#define MAPI_E_PASSWORD_CHANGE_REQUIRED ((SCODE)0x80040120) +#define MAPI_E_PASSWORD_EXPIRED ((SCODE)0x80040121) +#define MAPI_E_SESSION_LIMIT ((SCODE)0x80040112) +#define MAPI_E_STRING_TOO_LONG ((SCODE)0x80040105) +#define MAPI_E_SUBMITTED ((SCODE)0x80040608) +#define MAPI_E_TABLE_EMPTY ((SCODE)0x80040402) +#define MAPI_E_TABLE_TOO_BIG ((SCODE)0x80040403) +#define MAPI_E_TIMEOUT ((SCODE)0x80040401) +#define MAPI_E_TOO_BIG ((SCODE)0x80040305) +#define MAPI_E_TOO_COMPLEX ((SCODE)0x80040117) +#define MAPI_E_TYPE_NO_SUPPORT ((SCODE)0x80040303) +#define MAPI_E_UNABLE_TO_ABORT ((SCODE)0x80040114) +#define MAPI_E_UNABLE_TO_COMPLETE ((SCODE)0x80040400) +#define MAPI_E_UNCONFIGURED ((SCODE)0x8004011C) +#define MAPI_E_UNEXPECTED_ID ((SCODE)0x80040307) +#define MAPI_E_UNEXPECTED_TYPE ((SCODE)0x80040304) +#define MAPI_E_UNKNOWN_CPID ((SCODE)0x8004011E) +#define MAPI_E_UNKNOWN_ENTRYID ((SCODE)0x80040201) +#define MAPI_E_UNKNOWN_FLAGS ((SCODE)0x80040106) +#define MAPI_E_UNKNOWN_LCID ((SCODE)0x8004011F) +#define MAPI_E_USER_CANCEL ((SCODE)0x80040113) +#define MAPI_E_VERSION ((SCODE)0x80040110) +#define MAPI_E_WAIT ((SCODE)0x80040500) +/* Warnings */ +#define MAPI_W_APPROX_COUNT ((SCODE)0x00040482) +#define MAPI_W_CANCEL_MESSAGE ((SCODE)0x00040580) +#define MAPI_W_ERRORS_RETURNED ((SCODE)0x00040380) +#define MAPI_W_NO_SERVICE ((SCODE)0x00040203) +#define MAPI_W_PARTIAL_COMPLETION ((SCODE)0x00040680) +#define MAPI_W_POSITION_CHANGED ((SCODE)0x00040481) -#endif +#endif /* MAPICODE_H */ diff --git a/include/mapidefs.h b/include/mapidefs.h index 55f60408562..e82c90c482d 100644 --- a/include/mapidefs.h +++ b/include/mapidefs.h @@ -16,58 +16,876 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#ifndef __WINE_MAPIDEFS_H -#define __WINE_MAPIDEFS_H +#ifndef MAPIDEFS_H +#define MAPIDEFS_H + +#ifndef __WINESRC__ +# include +#endif -#include #include #ifndef _OBJBASE_H_ #include #endif -/* Some types */ - -typedef unsigned char* LPBYTE; +/* Some types from other headers */ #ifndef __LHANDLE #define __LHANDLE -typedef unsigned long LHANDLE, *LPLHANDLE; +typedef ULONG_PTR LHANDLE, *LPLHANDLE; #endif #ifndef _tagCY_DEFINED #define _tagCY_DEFINED typedef union tagCY { - struct { + struct + { #ifdef WORDS_BIGENDIAN - LONG Hi; - ULONG Lo; + LONG Hi; + ULONG Lo; #else - ULONG Lo; - LONG Hi; + ULONG Lo; + LONG Hi; #endif - } u; - LONGLONG int64; + } DUMMYSTRUCTNAME; + LONGLONG int64; } CY; +typedef CY CURRENCY; #endif /* _tagCY_DEFINED */ -/* MAPI Recipient types */ -#ifndef MAPI_ORIG -#define MAPI_ORIG 0 /* Message originator */ -#define MAPI_TO 1 /* Primary recipient */ -#define MAPI_CC 2 /* Copy recipient */ -#define MAPI_BCC 3 /* Blind copy recipient */ -#define MAPI_P1 0x10000000 /* P1 resend recipient */ -#define MAPI_SUBMITTED 0x80000000 /* Already processed */ + +#ifndef _FILETIME_ +#define _FILETIME_ +typedef struct _FILETIME +{ + DWORD dwLowDateTime; + DWORD dwHighDateTime; +} FILETIME, *PFILETIME, *LPFILETIME; #endif -/* Bit definitions for abFlags[0] */ -#define MAPI_SHORTTERM 0x80 -#define MAPI_NOTRECIP 0x40 -#define MAPI_THISSESSION 0x20 -#define MAPI_NOW 0x10 -#define MAPI_NOTRESERVED 0x08 +/* Memory allocation routines */ +typedef SCODE (WINAPI ALLOCATEBUFFER)(ULONG,LPVOID*); +typedef SCODE (WINAPI ALLOCATEMORE)(ULONG,LPVOID,LPVOID*); +typedef ULONG (WINAPI FREEBUFFER)(LPVOID); -/* Bit definitions for abFlags[1] */ +typedef ALLOCATEBUFFER *LPALLOCATEBUFFER; +typedef ALLOCATEMORE *LPALLOCATEMORE; +typedef FREEBUFFER *LPFREEBUFFER; + +/* MAPI exposed interfaces */ +typedef const IID *LPCIID; + +typedef struct IAddrBook IAddrBook; +typedef IAddrBook *LPADRBOOK; +typedef struct IABContainer IABContainer; +typedef IABContainer *LPABCONT; +typedef struct IAttach IAttach; +typedef IAttach *LPATTACH; +typedef struct IDistList IDistList; +typedef IDistList *LPDISTLIST; +typedef struct IMailUser IMailUser; +typedef IMailUser *LPMAILUSER; +typedef struct IMAPIAdviseSink IMAPIAdviseSink; +typedef IMAPIAdviseSink *LPMAPIADVISESINK; +typedef struct IMAPIContainer IMAPIContainer; +typedef IMAPIContainer *LPMAPICONTAINER; +typedef struct IMAPIFolder IMAPIFolder; +typedef IMAPIFolder *LPMAPIFOLDER; +typedef struct IMAPIProgress IMAPIProgress; +typedef IMAPIProgress *LPMAPIPROGRESS; +typedef struct IMAPIProp IMAPIProp; +typedef IMAPIProp *LPMAPIPROP; +typedef struct IMAPIStatus IMAPIStatus; +typedef IMAPIStatus *LPMAPISTATUS; +typedef struct IMAPITable IMAPITable; +typedef IMAPITable *LPMAPITABLE; +typedef struct IMessage IMessage; +typedef IMessage *LPMESSAGE; +typedef struct IMsgStore IMsgStore; +typedef IMsgStore *LPMDB; +typedef struct IProfSect IProfSect; +typedef IProfSect *LPPROFSECT; +typedef struct IProviderAdmin IProviderAdmin; +typedef IProviderAdmin *LPPROVIDERADMIN; + +#ifndef MAPI_DIM +# define MAPI_DIM 1 /* Default to one dimension for variable length arrays */ +#endif + +/* Flags for abFlags[0] */ +#define MAPI_NOTRESERVED 0x08 +#define MAPI_NOW 0x10 +#define MAPI_THISSESSION 0x20 +#define MAPI_NOTRECIP 0x40 +#define MAPI_SHORTTERM 0x80 + +/* Flags for abFlags[1] */ #define MAPI_COMPOUND 0x80 -#endif /*__WINE_MAPIDEFS_H*/ +typedef struct _ENTRYID +{ + BYTE abFlags[4]; + BYTE ab[MAPI_DIM]; +} ENTRYID, *LPENTRYID; + +/* MAPI GUID's */ +typedef struct _MAPIUID +{ + BYTE ab[sizeof(GUID)]; +} MAPIUID, *LPMAPIUID; + +#define IsEqualMAPIUID(pl,pr) (!memcmp((pl),(pr),sizeof(MAPIUID))) + +#define MAPI_ONE_OFF_UID { 0x81,0x2b,0x1f,0xa4,0xbe,0xa3,0x10,0x19,0x9d,0x6e, \ + 0x00,0xdd,0x01,0x0f,0x54,0x02 } +#define MAPI_ONE_OFF_UNICODE 0x8000 +#define MAPI_ONE_OFF_NO_RICH_INFO 0x0001 + +/* Object types */ +#define MAPI_STORE 1U +#define MAPI_ADDRBOOK 2U +#define MAPI_FOLDER 3U +#define MAPI_ABCONT 4U +#define MAPI_MESSAGE 5U +#define MAPI_MAILUSER 6U +#define MAPI_ATTACH 7U +#define MAPI_DISTLIST 8U +#define MAPI_PROFSECT 9U +#define MAPI_STATUS 10U +#define MAPI_SESSION 11U +#define MAPI_FORMINFO 12U + +/* Flags for various calls */ +#define MAPI_MODIFY 0x00000001U /* Object can be modified */ +#define MAPI_ACCESS_MODIFY MAPI_MODIFY /* Want write access */ +#define MAPI_ACCESS_READ 0x00000002U /* Want read access */ +#define MAPI_ACCESS_DELETE 0x00000004U /* Want delete access */ +#define MAPI_ACCESS_CREATE_HIERARCHY 0x00000008U +#define MAPI_ACCESS_CREATE_CONTENTS 0x00000010U +#define MAPI_ACCESS_CREATE_ASSOCIATED 0x00000020U +#define MAPI_UNICODE 0x80000000U /* Strings in this call are Unicode */ + +#if defined (UNICODE) || defined (__WINESRC__) +#define fMapiUnicode MAPI_UNICODE +#else +#define fMapiUnicode 0U +#endif + +/* Types of message receivers */ +#ifndef MAPI_ORIG +#define MAPI_ORIG 0 /* The original author */ +#define MAPI_TO 1 /* The primary message receiver */ +#define MAPI_CC 2 /* A carbon copy receiver */ +#define MAPI_BCC 3 /* A blind carbon copy receiver */ +#define MAPI_P1 0x10000000 /* A message resend */ +#define MAPI_SUBMITTED 0x80000000 /* This message has already been sent */ +#endif + +#ifndef cchProfileNameMax +#define cchProfileNameMax 64 /* Maximum length of a profile name */ +#define cchProfilePassMax 64 /* Maximum length of a profile password */ +#endif + +/* Properties: The are the contents of cells in MAPI tables, as well as the + * values returned when object properties are queried. + */ + +/* Property types */ +#define PT_UNSPECIFIED 0U +#define PT_NULL 1U +#define PT_I2 2U +#define PT_SHORT PT_I2 +#define PT_LONG 3U +#define PT_I4 PT_LONG +#define PT_R4 4U +#define PT_FLOAT PT_R4 +#define PT_DOUBLE 5U +#define PT_R8 PT_DOUBLE +#define PT_CURRENCY 6U +#define PT_APPTIME 7U +#define PT_ERROR 10U +#define PT_BOOLEAN 11U +#define PT_OBJECT 13U +#define PT_I8 20U +#define PT_LONGLONG PT_I8 +#define PT_STRING8 30U +#define PT_UNICODE 31U +#define PT_SYSTIME 64U +#define PT_CLSID 72U +#define PT_BINARY 258U + +#define MV_FLAG 0x1000 /* This property type is multi-valued (an array) */ +#define MV_INSTANCE 0x2000 +#define MVI_FLAG (MV_FLAG|MV_INSTANCE) +#define MVI_PROP(t) ((t)|MVI_FLAG) + +#ifndef __WINESRC__ +# ifdef UNICODE +# define PT_TSTRING PT_UNICODE +# define PT_MV_TSTRING (MV_FLAG|PT_UNICODE) +# define LPSZ lpszW +# define LPPSZ lppszW +# define MVSZ MVszW +# else +# define PT_TSTRING PT_STRING8 +# define PT_MV_TSTRING (MV_FLAG|PT_STRING8) +# define LPSZ lpszA +# define LPPSZ lppszA +# define MVSZ MVszA +# endif +#endif + +#define PROP_TYPE_MASK 0xFFFFU +#define PROP_TYPE(t) ((t) & PROP_TYPE_MASK) +#define PROP_ID(t) ((t) >> 16) +#define PROP_TAG(t,id) (((id) << 16) | t) +#define PROP_ID_NULL 0 +#define PROP_ID_INVALID 0xFFFF +#define PR_NULL PROP_TAG(PT_NULL, PROP_ID_NULL) + +#define CHANGE_PROP_TYPE(t,typ) ((0xFFFF0000 & t) | typ) + +/* Multi-valued property types */ +#define PT_MV_I2 (MV_FLAG|PT_I2) +#define PT_MV_SHORT PT_MV_I2 +#define PT_MV_LONG (MV_FLAG|PT_LONG) +#define PT_MV_I4 PT_MV_LONG +#define PT_MV_R4 (MV_FLAG|PT_R4) +#define PT_MV_FLOAT PT_MV_R4 +#define PT_MV_DOUBLE (MV_FLAG|PT_DOUBLE) +#define PT_MV_R8 PT_MV_DOUBLE +#define PT_MV_CURRENCY (MV_FLAG|PT_CURRENCY) +#define PT_MV_APPTIME (MV_FLAG|PT_APPTIME) +#define PT_MV_SYSTIME (MV_FLAG|PT_SYSTIME) +#define PT_MV_STRING8 (MV_FLAG|PT_STRING8) +#define PT_MV_BINARY (MV_FLAG|PT_BINARY) +#define PT_MV_UNICODE (MV_FLAG|PT_UNICODE) +#define PT_MV_CLSID (MV_FLAG|PT_CLSID) +#define PT_MV_I8 (MV_FLAG|PT_I8) +#define PT_MV_LONGLONG PT_MV_I8 + + +/* The property tag structure. This describes a list of columns */ +typedef struct _SPropTagArray +{ + ULONG cValues; /* Number of elements in aulPropTag */ + ULONG aulPropTag[MAPI_DIM]; /* Property tags */ +} SPropTagArray, *LPSPropTagArray; + +#define CbNewSPropTagArray(c) (offsetof(SPropTagArray,aulPropTag)+(c)*sizeof(ULONG)) +#define CbSPropTagArray(p) CbNewSPropTagArray((p)->cValues) +#define SizedSPropTagArray(n,id) \ + struct _SPropTagArray_##id { ULONG cValues; ULONG aulPropTag[n]; } id + +/* Multi-valued PT_APPTIME property value */ +typedef struct _SAppTimeArray +{ + ULONG cValues; /* Number of doubles in lpat */ + double *lpat; /* Pointer to double array of length cValues */ +} SAppTimeArray; + +/* PT_BINARY property value */ +typedef struct _SBinary +{ + ULONG cb; /* Number of bytes in lpb */ + LPBYTE lpb; /* Pointer to byte array of length cb */ +} SBinary, *LPSBinary; + +/* Multi-valued PT_BINARY property value */ +typedef struct _SBinaryArray +{ + ULONG cValues; /* Number of SBinarys in lpbin */ + SBinary *lpbin; /* Pointer to SBinary array of length cValues */ +} SBinaryArray; + +typedef SBinaryArray ENTRYLIST, *LPENTRYLIST; + +/* Multi-valued PT_CY property value */ +typedef struct _SCurrencyArray +{ + ULONG cValues; /* Number of CYs in lpcu */ + CY *lpcur; /* Pointer to CY array of length cValues */ +} SCurrencyArray; + +/* Multi-valued PT_SYSTIME property value */ +typedef struct _SDateTimeArray +{ + ULONG cValues; /* Number of FILETIMEs in lpft */ + FILETIME *lpft; /* Pointer to FILETIME array of length cValues */ +} SDateTimeArray; + +/* Multi-valued PT_DOUBLE property value */ +typedef struct _SDoubleArray +{ + ULONG cValues; /* Number of doubles in lpdbl */ + double *lpdbl; /* Pointer to double array of length cValues */ +} SDoubleArray; + +/* Multi-valued PT_CLSID property value */ +typedef struct _SGuidArray +{ + ULONG cValues; /* Number of GUIDs in lpguid */ + GUID *lpguid; /* Pointer to GUID array of length cValues */ +} SGuidArray; + +/* Multi-valued PT_LONGLONG property value */ +typedef struct _SLargeIntegerArray +{ + ULONG cValues; /* Number of long64s in lpli */ + LARGE_INTEGER *lpli; /* Pointer to long64 array of length cValues */ +} SLargeIntegerArray; + +/* Multi-valued PT_LONG property value */ +typedef struct _SLongArray +{ + ULONG cValues; /* Number of longs in lpl */ + LONG *lpl; /* Pointer to long array of length cValues */ +} SLongArray; + +/* Multi-valued PT_STRING8 property value */ +typedef struct _SLPSTRArray +{ + ULONG cValues; /* Number of Ascii strings in lppszA */ + LPSTR *lppszA; /* Pointer to Ascii string array of length cValues */ +} SLPSTRArray; + +/* Multi-valued PT_FLOAT property value */ +typedef struct _SRealArray +{ + ULONG cValues; /* Number of floats in lpflt */ + float *lpflt; /* Pointer to float array of length cValues */ +} SRealArray; + +/* Multi-valued PT_SHORT property value */ +typedef struct _SShortArray +{ + ULONG cValues; /* Number of shorts in lpb */ + short int *lpi; /* Pointer to short array of length cValues */ +} SShortArray; + +/* Multi-valued PT_UNICODE property value */ +typedef struct _SWStringArray +{ + ULONG cValues; /* Number of Unicode strings in lppszW */ + LPWSTR *lppszW; /* Pointer to Unicode string array of length cValues */ +} SWStringArray; + +/* A property value */ +typedef union _PV +{ + short int i; + LONG l; + ULONG ul; + float flt; + double dbl; + unsigned short b; + CY cur; + double at; + FILETIME ft; + LPSTR lpszA; + SBinary bin; + LPWSTR lpszW; + LPGUID lpguid; + LARGE_INTEGER li; + SShortArray MVi; + SLongArray MVl; + SRealArray MVflt; + SDoubleArray MVdbl; + SCurrencyArray MVcur; + SAppTimeArray MVat; + SDateTimeArray MVft; + SBinaryArray MVbin; + SLPSTRArray MVszA; + SWStringArray MVszW; + SGuidArray MVguid; + SLargeIntegerArray MVli; + SCODE err; + LONG x; +} __UPV; + +/* Property value structure. This is essentially a mini-Variant */ +typedef struct _SPropValue +{ + ULONG ulPropTag; /* The property type */ + ULONG dwAlignPad; /* Alignment, treat as reserved */ + union _PV Value; /* The property value */ +} SPropValue, *LPSPropValue; + +/* Structure describing a table row (a collection of property values) */ +typedef struct _SRow +{ + ULONG ulAdrEntryPad; /* Padding, treat as reserved */ + ULONG cValues; /* Count of property values in lpProbs */ + LPSPropValue lpProps; /* Pointer to an array of property values of length cValues */ +} SRow, *LPSRow; + +/* Structure describing a set of table rows */ +typedef struct _SRowSet +{ + ULONG cRows; /* Count of rows in aRow */ + SRow aRow[MAPI_DIM]; /* Array of rows of length cRows */ +} SRowSet, *LPSRowSet; + +#define CbNewSRowSet(c) (offsetof(SRowSet,aRow)+(c)*sizeof(SRow)) +#define CbSRowSet(p) CbNewSRowSet((p)->cRows) +#define SizedSRowSet(n,id) \ + struct _SRowSet_##id { ULONG cRows; SRow aRow[n]; } id + +/* Structure describing a problem with a property */ +typedef struct _SPropProblem +{ + ULONG ulIndex; /* Index of the property */ + ULONG ulPropTag; /* Proprty tag of the property */ + SCODE scode; /* Error code of the problem */ +} SPropProblem, *LPSPropProblem; + +/* A collection of property problems */ +typedef struct _SPropProblemArray +{ + ULONG cProblem; /* Number of problems in aProblem */ + SPropProblem aProblem[MAPI_DIM]; /* Array of problems of length cProblem */ +} SPropProblemArray, *LPSPropProblemArray; + +/* FPropContainsProp flags */ +#define FL_FULLSTRING 0x00000ul /* Exact string match */ +#define FL_SUBSTRING 0x00001ul /* Substring match */ +#define FL_PREFIX 0x00002ul /* Prefix match */ +#define FL_IGNORECASE 0x10000ul /* Case insensitive */ +#define FL_IGNORENONSPACE 0x20000ul /* Ignore non spacing characters */ +#define FL_LOOSE 0x40000ul /* Try very hard to match */ + + +/* Table types returned by IMAPITable_GetStatus() */ +#define TBLTYPE_SNAPSHOT 0U /* Table is fixed at creation time and contents do not change */ +#define TBLTYPE_KEYSET 1U /* Table has a fixed number of rows, but row values may change */ +#define TBLTYPE_DYNAMIC 2U /* Table values and the number of rows may change */ + +/* Table status returned by IMAPITable_GetStatus() */ +#define TBLSTAT_COMPLETE 0U /* All operations have completed (normal status) */ +#define TBLSTAT_QCHANGED 7U /* Table data has changed as expected */ +#define TBLSTAT_SORTING 9U /* Table is being asynchronously sorted */ +#define TBLSTAT_SORT_ERROR 10U /* An error occurred while sorting the table */ +#define TBLSTAT_SETTING_COLS 11U /* Table columns are being asynchronously changed */ +#define TBLSTAT_SETCOL_ERROR 13U /* An error occurred during column changing */ +#define TBLSTAT_RESTRICTING 14U /* Table rows are being asynchronously restricted */ +#define TBLSTAT_RESTRICT_ERROR 15U /* An error occurred during row restriction */ + +/* Flags for IMAPITable operations that can be asynchronous */ +#define TBL_NOWAIT 1U /* Perform the operation asynchronously */ +#define TBL_BATCH 2U /* Perform the operation when the results are needed */ +#define TBL_ASYNC TBL_NOWAIT /* Synonym for TBL_NOWAIT */ + +/* Flags for IMAPITable_FindRow() */ +#define DIR_BACKWARD 1U /* Read rows backwards from the start bookmark */ + +/* Table bookmarks */ +typedef ULONG BOOKMARK; + +#define BOOKMARK_BEGINNING ((BOOKMARK)0) /* The first row */ +#define BOOKMARK_CURRENT ((BOOKMARK)1) /* The curent table row */ +#define BOOKMARK_END ((BOOKMARK)2) /* The last row */ + +/* Row restrictions */ +typedef struct _SRestriction* LPSRestriction; + +typedef struct _SAndRestriction +{ + ULONG cRes; + LPSRestriction lpRes; +} SAndRestriction; + +typedef struct _SBitMaskRestriction +{ + ULONG relBMR; + ULONG ulPropTag; + ULONG ulMask; +} SBitMaskRestriction; + +typedef struct _SCommentRestriction +{ + ULONG cValues; + LPSRestriction lpRes; + LPSPropValue lpProp; +} SCommentRestriction; + +#define RELOP_LT 0U +#define RELOP_LE 1U +#define RELOP_GT 2U +#define RELOP_GE 3U +#define RELOP_EQ 4U +#define RELOP_NE 5U +#define RELOP_RE 6U + +typedef struct _SComparePropsRestriction +{ + ULONG relop; + ULONG ulPropTag1; + ULONG ulPropTag2; +} SComparePropsRestriction; + +typedef struct _SContentRestriction +{ + ULONG ulFuzzyLevel; + ULONG ulPropTag; + LPSPropValue lpProp; +} SContentRestriction; + +typedef struct _SExistRestriction +{ + ULONG ulReserved1; + ULONG ulPropTag; + ULONG ulReserved2; +} SExistRestriction; + +typedef struct _SNotRestriction +{ + ULONG ulReserved; + LPSRestriction lpRes; +} SNotRestriction; + +typedef struct _SOrRestriction +{ + ULONG cRes; + LPSRestriction lpRes; +} SOrRestriction; + +typedef struct _SPropertyRestriction +{ + ULONG relop; + ULONG ulPropTag; + LPSPropValue lpProp; +} SPropertyRestriction; + +typedef struct _SSizeRestriction +{ + ULONG relop; + ULONG ulPropTag; + ULONG cb; +} SSizeRestriction; + +typedef struct _SSubRestriction +{ + ULONG ulSubObject; + LPSRestriction lpRes; +} SSubRestriction; + +/* Restriction types */ +#define RES_AND 0U +#define RES_OR 1U +#define RES_NOT 2U +#define RES_CONTENT 3U +#define RES_PROPERTY 4U +#define RES_COMPAREPROPS 5U +#define RES_BITMASK 6U +#define RES_SIZE 7U +#define RES_EXIST 8U +#define RES_SUBRESTRICTION 9U +#define RES_COMMENT 10U + +typedef struct _SRestriction +{ + ULONG rt; + union + { + SAndRestriction resAnd; + SBitMaskRestriction resBitMask; + SCommentRestriction resComment; + SComparePropsRestriction resCompareProps; + SContentRestriction resContent; + SExistRestriction resExist; + SNotRestriction resNot; + SOrRestriction resOr; + SPropertyRestriction resProperty; + SSizeRestriction resSize; + SSubRestriction resSub; + } res; +} SRestriction; + +/* Errors */ +typedef struct _MAPIERROR +{ + ULONG ulVersion; /* Mapi version */ +#if defined (UNICODE) || defined (__WINESRC__) + LPWSTR lpszError; /* Error and component strings. These are Ascii */ + LPWSTR lpszComponent; /* unless the MAPI_UNICODE flag is passed in */ +#else + LPSTR lpszError; + LPSTR lpszComponent; +#endif + ULONG ulLowLevelError; + ULONG ulContext; +} MAPIERROR, *LPMAPIERROR; + +/* Sorting */ +#define TABLE_SORT_ASCEND 0U +#define TABLE_SORT_DESCEND 1U +#define TABLE_SORT_COMBINE 2U + +typedef struct _SSortOrder +{ + ULONG ulPropTag; + ULONG ulOrder; +} SSortOrder, *LPSSortOrder; + +typedef struct _SSortOrderSet +{ + ULONG cSorts; + ULONG cCategories; + ULONG cExpanded; + SSortOrder aSort[MAPI_DIM]; +} SSortOrderSet, * LPSSortOrderSet; + +#define MNID_ID 0 +#define MNID_STRING 1 + +typedef struct _MAPINAMEID +{ + LPGUID lpguid; + ULONG ulKind; + union + { + LONG lID; + LPWSTR lpwstrName; + } Kind; +} MAPINAMEID, *LPMAPINAMEID; + +/* Desired notification types (bitflags) */ +#define fnevCriticalError 0x00000001UL +#define fnevNewMail 0x00000002UL +#define fnevObjectCreated 0x00000004UL +#define fnevObjectDeleted 0x00000008UL +#define fnevObjectModified 0x00000010UL +#define fnevObjectMoved 0x00000020UL +#define fnevObjectCopied 0x00000040UL +#define fnevSearchComplete 0x00000080UL +#define fnevTableModified 0x00000100UL +#define fnevStatusObjectModified 0x00000200UL +#define fnevReservedForMapi 0x40000000UL +#define fnevExtended 0x80000000UL + +/* Type of notification event */ +#define TABLE_CHANGED 1U +#define TABLE_ERROR 2U +#define TABLE_ROW_ADDED 3U +#define TABLE_ROW_DELETED 4U +#define TABLE_ROW_MODIFIED 5U +#define TABLE_SORT_DONE 6U +#define TABLE_RESTRICT_DONE 7U +#define TABLE_SETCOL_DONE 8U +#define TABLE_RELOAD 9U + +/* fnevCriticalError notification */ +typedef struct _ERROR_NOTIFICATION +{ + ULONG cbEntryID; + LPENTRYID lpEntryID; + SCODE scode; + ULONG ulFlags; + LPMAPIERROR lpMAPIError; +} ERROR_NOTIFICATION; + +/* fnevNewMail notification */ +typedef struct _NEWMAIL_NOTIFICATION +{ + ULONG cbEntryID; + LPENTRYID lpEntryID; + ULONG cbParentID; + LPENTRYID lpParentID; + ULONG ulFlags; +#if defined (UNICODE) || defined (__WINESRC__) + LPWSTR lpszMessageClass; +#else + LPSTR lpszMessageClass; +#endif + ULONG ulMessageFlags; +} NEWMAIL_NOTIFICATION; + +/* fnevObjectCreated/Deleted/Modified/Moved/Copied notification */ +typedef struct _OBJECT_NOTIFICATION +{ + ULONG cbEntryID; + LPENTRYID lpEntryID; + ULONG ulObjType; + ULONG cbParentID; + LPENTRYID lpParentID; + ULONG cbOldID; + LPENTRYID lpOldID; + ULONG cbOldParentID; + LPENTRYID lpOldParentID; + LPSPropTagArray lpPropTagArray; +} OBJECT_NOTIFICATION; + +/* fnevTableModified notification */ +typedef struct _TABLE_NOTIFICATION +{ + ULONG ulTableEvent; + HRESULT hResult; + SPropValue propIndex; + SPropValue propPrior; + SRow row; + ULONG ulPad; +} TABLE_NOTIFICATION; + +/* fnevExtended notification */ +typedef struct _EXTENDED_NOTIFICATION +{ + ULONG ulEvent; + ULONG cb; + LPBYTE pbEventParameters; +} EXTENDED_NOTIFICATION; + +/* fnevStatusObjectModified notification */ +typedef struct +{ + ULONG cbEntryID; + LPENTRYID lpEntryID; + ULONG cValues; + LPSPropValue lpPropVals; +} STATUS_OBJECT_NOTIFICATION; + +/* The notification structure passed to advise sinks */ +typedef struct _NOTIFICATION +{ + ULONG ulEventType; + ULONG ulAlignPad; + union + { + ERROR_NOTIFICATION err; + NEWMAIL_NOTIFICATION newmail; + OBJECT_NOTIFICATION obj; + TABLE_NOTIFICATION tab; + EXTENDED_NOTIFICATION ext; + STATUS_OBJECT_NOTIFICATION statobj; + } info; +} NOTIFICATION, *LPNOTIFICATION; + +typedef LONG (WINAPI NOTIFCALLBACK)(LPVOID,ULONG,LPNOTIFICATION); +typedef NOTIFCALLBACK *LPNOTIFCALLBACK; + +/***************************************************************************** + * IMAPITable interface + * + * This is the read-only 'view' over an I(MAPI)TableData object. + */ +#define INTERFACE IMAPITable +#define IMAPITable_METHODS \ + IUnknown_METHODS \ + STDMETHOD(GetLastError)(THIS_ HRESULT hRes, ULONG ulFlags, LPMAPIERROR *lppError) PURE; \ + STDMETHOD(Advise)(THIS_ ULONG ulMask, LPMAPIADVISESINK lpSink, ULONG *lpCxn) PURE; \ + STDMETHOD(Unadvise)(THIS_ ULONG ulCxn) PURE; \ + STDMETHOD(GetStatus)(THIS_ ULONG *lpStatus, ULONG *lpType) PURE; \ + STDMETHOD(SetColumns)(THIS_ LPSPropTagArray lpProps, ULONG ulFlags) PURE; \ + STDMETHOD(QueryColumns)(THIS_ ULONG ulFlags, LPSPropTagArray *lpCols) PURE; \ + STDMETHOD(GetRowCount)(THIS_ ULONG ulFlags, ULONG *lpCount) PURE; \ + STDMETHOD(SeekRow)(THIS_ BOOKMARK lpStart, LONG lRows, LONG *lpSeeked) PURE; \ + STDMETHOD(SeekRowApprox)(THIS_ ULONG ulNum, ULONG ulDenom) PURE; \ + STDMETHOD(QueryPosition)(THIS_ ULONG *lpRow, ULONG *lpNum, ULONG *lpDenom) PURE; \ + STDMETHOD(FindRow)(THIS_ LPSRestriction lpRestrict, BOOKMARK lpOrigin, ULONG ulFlags) PURE; \ + STDMETHOD(Restrict)(THIS_ LPSRestriction lpRestrict, ULONG ulFlags) PURE; \ + STDMETHOD(CreateBookmark)(THIS_ BOOKMARK *lppPos) PURE; \ + STDMETHOD(FreeBookmark)(THIS_ BOOKMARK lpPos) PURE; \ + STDMETHOD(SortTable)(THIS_ LPSSortOrderSet lpSortOpts, ULONG ulFlags) PURE; \ + STDMETHOD(QuerySortOrder)(THIS_ LPSSortOrderSet *lppSortOpts) PURE; \ + STDMETHOD(QueryRows)(THIS_ LONG lRows, ULONG ulFlags, LPSRowSet *lppRows) PURE; \ + STDMETHOD(Abort) (THIS) PURE; \ + STDMETHOD(ExpandRow)(THIS_ ULONG cbKey, LPBYTE lpKey, ULONG ulRows, \ + ULONG ulFlags, LPSRowSet *lppRows, ULONG *lpMore) PURE; \ + STDMETHOD(CollapseRow)(THIS_ ULONG cbKey, LPBYTE lpKey, ULONG ulFlags, ULONG *lpRows) PURE; \ + STDMETHOD(WaitForCompletion)(THIS_ ULONG ulFlags, ULONG ulTime, ULONG *lpState) PURE; \ + STDMETHOD(GetCollapseState)(THIS_ ULONG ulFlags, ULONG cbKey, LPBYTE lpKey, \ + ULONG *lpStateLen, LPBYTE *lpState) PURE; \ + STDMETHOD(SetCollapseState)(THIS_ ULONG ulFlags, ULONG ulLen, \ + LPBYTE lpStart, BOOKMARK *lppWhere) PURE; +ICOM_DEFINE(IMAPITable,IUnknown) +#undef INTERFACE + +#ifdef COBJMACROS + /*** IUnknown methods ***/ +#define IMAPITable_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMAPITable_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMAPITable_Release(p) (p)->lpVtbl->Release(p) + /*** IMAPITable methods ***/ +#define IMAPITable_GetLastError(p,a,b,c) (p)->lpVtbl->GetLastError(p,a,b,c) +#define IMAPITable_Advise(p,a,b,c) (p)->lpVtbl->Advise(p,a,b,c) +#define IMAPITable_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#define IMAPITable_GetStatus(p,a,b) (p)->lpVtbl->GetStatus(p,a,b) +#define IMAPITable_SetColumns(p,a,b) (p)->lpVtbl->SetColumns(p,a,b) +#define IMAPITable_QueryColumns(p,a,b) (p)->lpVtbl->QueryColumns(p,a,b) +#define IMAPITable_GetRowCount(p,a,b) (p)->lpVtbl->GetRowCount(p,a,b) +#define IMAPITable_SeekRow(p,a,b) (p)->lpVtbl->SeekRow(p,a,b) +#define IMAPITable_SeekRowApprox(p,a,b) (p)->lpVtbl->SeekRowApprox(p,a,b) +#define IMAPITable_QueryPosition(p,a,b) (p)->lpVtbl->QueryPosition(p,a,b) +#define IMAPITable_FindRow(p,a,b,c) (p)->lpVtbl->FindRow(p,a,b,c) +#define IMAPITable_Restrict(p,a,b) (p)->lpVtbl->Recstrict(p,a,b) +#define IMAPITable_CreateBookmark(p,a) (p)->lpVtbl->CreateBookmark(p,a) +#define IMAPITable_FreeBookmark(p,a) (p)->lpVtbl->FreeBookmark(p,a) +#define IMAPITable_SortTable(p,a,b) (p)->lpVtbl->SortTable(p,a,b) +#define IMAPITable_QuerySortOrder(p,a) (p)->lpVtbl->QuerySortOrder(p,a) +#define IMAPITable_QueryRows(p,a,b,c) (p)->lpVtbl->QueryRows(p,a,b,c) +#define IMAPITable_Abort(p) (p)->lpVtbl->Abort(p) +#define IMAPITable_ExpandRow(p,a,b,c,d,e,f) (p)->lpVtbl->ExpandRow(p,a,b,c,d,e,f) +#define IMAPITable_CollapseRow(p,a,b,c,d) (p)->lpVtbl->CollapseRow(p,a,b,c,d) +#define IMAPITable_WaitForCompletion(p,a,b,c) (p)->lpVtbl->WaitForCompletion(p,a,b,c) +#define IMAPITable_GetCollapseState(p,a,b,c,d,e) (p)->lpVtbl->GetCollapseState(p,a,b,c,d,e) +#define IMAPITable_SetCollapseState(p,a,b,c,d) (p)->lpVtbl->SetCollapseState(p,a,b,c,d) +#endif + +/***************************************************************************** + * IMAPIAdviseSink interface + */ +#define INTERFACE IMAPIAdviseSink +#define IMAPIAdviseSink_METHODS \ + IUnknown_METHODS \ + STDMETHOD(OnNotify)(THIS_ ULONG NumNotif, LPNOTIFICATION lpNotif) PURE; +ICOM_DEFINE(IMAPIAdviseSink,IUnknown) +#undef INTERFACE + +#ifdef COBJMACROS + /*** IUnknown methods ***/ +#define IMAPIAdviseSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMAPIAdviseSink_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMAPIAdviseSink_Release(p) (p)->lpVtbl->Release(p) + /*** IMAPIAdviseSink methods ***/ +#define IMAPIAdviseSink_OnNotify(p,a,b) (p)->lpVtbl->OnNotify(p,a,b) +#endif + +typedef struct +{ + ULONG cb; + BYTE abEntry[MAPI_DIM]; +} FLATENTRY, *LPFLATENTRY; + +typedef struct +{ + ULONG cEntries; + ULONG cbEntries; + BYTE abEntries[MAPI_DIM]; +} FLATENTRYLIST, *LPFLATENTRYLIST; + +typedef struct +{ + ULONG cb; + BYTE ab[MAPI_DIM]; +} MTSID, *LPMTSID; + +typedef struct +{ + ULONG cMTSIDs; + ULONG cbMTSIDs; + BYTE abMTSIDs[MAPI_DIM]; +} FLATMTSIDLIST, *LPFLATMTSIDLIST; + +typedef struct _ADRENTRY +{ + ULONG ulReserved1; + ULONG cValues; + LPSPropValue rgPropVals; +} ADRENTRY, *LPADRENTRY; + +typedef struct _ADRLIST +{ + ULONG cEntries; + ADRENTRY aEntries[MAPI_DIM]; +} ADRLIST, *LPADRLIST; + +#endif /*MAPIDEFS_H*/ diff --git a/include/mapiguid.h b/include/mapiguid.h new file mode 100644 index 00000000000..2c8e34a94fc --- /dev/null +++ b/include/mapiguid.h @@ -0,0 +1,81 @@ +/* + * Copyright 2004 Jon Griffiths + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef MAPIGUID_H +#define MAPIGUID_H + +#define DEFINE_MAPIGUID(n,l,w1,w2) DEFINE_OLEGUID(n,l,w1,w2) + +DEFINE_MAPIGUID(IID_IABContainer,0x2030D,0,0); +DEFINE_MAPIGUID(IID_IABLogon,0x20314,0,0); +DEFINE_MAPIGUID(IID_IABProvider,0x20311,0,0); +DEFINE_MAPIGUID(IID_IAddrBook,0x20309,0,0); +DEFINE_MAPIGUID(IID_IAttachment,0x20308,0,0); +DEFINE_MAPIGUID(IID_IDistList,0x2030E,0,0); +DEFINE_MAPIGUID(IID_IEnumMAPIFormProp,0x20323,0,0); +DEFINE_MAPIGUID(IID_IMailUser,0x2030A,0,0); +DEFINE_MAPIGUID(IID_IMAPIAdviseSink,0x20302,0,0); +DEFINE_MAPIGUID(IID_IMAPIContainer,0x2030B,0,0); +DEFINE_MAPIGUID(IID_IMAPIControl,0x2031B,0,0); +DEFINE_MAPIGUID(IID_IMAPIFolder,0x2030C,0,0); +DEFINE_MAPIGUID(IID_IMAPIForm,0x20327,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormAdviseSink,0x2032F,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormContainer,0x2032E,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormFactory,0x20350,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormInfo,0x20324,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormMgr,0x20322,0,0); +DEFINE_MAPIGUID(IID_IMAPIFormProp,0x2032D,0,0); +DEFINE_MAPIGUID(IID_IMAPIMessageSite,0x20370,0,0); +DEFINE_MAPIGUID(IID_IMAPIProgress,0x2031F,0,0); +DEFINE_MAPIGUID(IID_IMAPIProp,0x20303,0,0); +DEFINE_MAPIGUID(IID_IMAPIPropData,0x2031A,0,0); +DEFINE_MAPIGUID(IID_IMAPISession,0x20300,0,0); +DEFINE_MAPIGUID(IID_IMAPISpoolerInit,0x20317,0,0); +DEFINE_MAPIGUID(IID_IMAPISpoolerService,0x2031E,0,0); +DEFINE_MAPIGUID(IID_IMAPISpoolerSession,0x20318,0,0); +DEFINE_MAPIGUID(IID_IMAPIStatus,0x20305,0,0); +DEFINE_MAPIGUID(IID_IMAPISup,0x2030F,0,0); +DEFINE_MAPIGUID(IID_IMAPITable,0x20301,0,0); +DEFINE_MAPIGUID(IID_IMAPITableData,0x20316,0,0); +DEFINE_MAPIGUID(IID_IMAPIViewAdviseSink,0x2032B,0,0); +DEFINE_MAPIGUID(IID_IMAPIViewContext,0x20321,0,0); +DEFINE_MAPIGUID(IID_IMessage,0x20307,0,0); +DEFINE_MAPIGUID(IID_IMsgServiceAdmin,0x2031D,0,0); +DEFINE_MAPIGUID(IID_IMsgStore,0x20306,0,0); +DEFINE_MAPIGUID(IID_IMSLogon,0x20313,0,0); +DEFINE_MAPIGUID(IID_IMSProvider,0x20310,0,0); +DEFINE_MAPIGUID(IID_IPersistMessage,0x2032A,0,0); +DEFINE_MAPIGUID(IID_IProfAdmin,0x2031C,0,0); +DEFINE_MAPIGUID(IID_IProfSect,0x20304,0,0); +DEFINE_MAPIGUID(IID_IProviderAdmin,0x20325,0,0); +DEFINE_MAPIGUID(IID_ISpoolerHook,0x20320,0,0); +DEFINE_MAPIGUID(IID_IStreamDocfile,0x2032C,0,0); +DEFINE_MAPIGUID(IID_IStreamTnef,0x20330,0,0); +DEFINE_MAPIGUID(IID_ITNEF,0x20319,0,0); +DEFINE_MAPIGUID(IID_IXPLogon,0x20315,0,0); +DEFINE_MAPIGUID(IID_IXPProvider,0x20312,0,0); +DEFINE_MAPIGUID(MUID_PROFILE_INSTANCE,0x20385,0,0); +DEFINE_MAPIGUID(PS_MAPI,0x20328,0,0); +DEFINE_MAPIGUID(PS_PUBLIC_STRINGS,0x20329,0,0); +DEFINE_MAPIGUID(PS_ROUTING_ADDRTYPE,0x20381,0,0); +DEFINE_MAPIGUID(PS_ROUTING_DISPLAY_NAME,0x20382,0,0); +DEFINE_MAPIGUID(PS_ROUTING_EMAIL_ADDRESSES,0x20380,0,0); +DEFINE_MAPIGUID(PS_ROUTING_ENTRYID,0x20383,0,0); +DEFINE_MAPIGUID(PS_ROUTING_SEARCH_KEY,0x20384,0,0); + +#endif/* MAPIGUID_H */ diff --git a/include/mapitags.h b/include/mapitags.h new file mode 100644 index 00000000000..e73b81b5458 --- /dev/null +++ b/include/mapitags.h @@ -0,0 +1,813 @@ +/* + * MAPI property tag declarations + * + * Copyright 2004 Jon Griffiths + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License,or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not,write to the Free Software + * Foundation,Inc.,59 Temple Place,Suite 330,Boston,MA 02111-1307 USA + */ +#ifndef MAPITAGS_H +#define MAPITAGS_H + +#define FIsTransmittable(t) (PROP_ID(t) < 0x0E00 || PROP_ID(t) >= 0x8000 || \ + (PROP_ID(t) >= 0x1000 && PROP_ID(t) < 0x6000) || \ + (PROP_ID(t) >= 0x6800 && PROP_ID(t) < 0x7C00)) + +#define PR_ACKNOWLEDGEMENT_MODE PROP_TAG(PT_I4,0x01) +#define PR_ALTERNATE_RECIPIENT_ALLOWED PROP_TAG(PT_BOOLEAN,0x02) +#define PR_AUTHORIZING_USERS PROP_TAG(PT_BINARY,0x03) +/* Comment on an automatically forwarded message */ +#define PR_AUTO_FORWARD_COMMENT_W PROP_TAG(PT_UNICODE,0x04) +#define PR_AUTO_FORWARD_COMMENT_A PROP_TAG(PT_STRING8,0x04) +#define PR_AUTO_FORWARD_COMMENT WINELIB_NAME_AW(PR_AUTO_FORWARD_COMMENT_) +/* Whether a message has been automatically forwarded */ +#define PR_AUTO_FORWARDED PROP_TAG(PT_BOOLEAN,0x05) +#define PR_CONTENT_CONFIDENTIALITY_ALGORITHM_ID PROP_TAG(PT_BINARY,0x06) +#define PR_CONTENT_CORRELATOR PROP_TAG(PT_BINARY,0x07) +#define PR_CONTENT_IDENTIFIER_W PROP_TAG(PT_UNICODE,0x08) +#define PR_CONTENT_IDENTIFIER_A PROP_TAG(PT_STRING8,0x08) +#define PR_CONTENT_IDENTIFIER WINELIB_NAME_AW(PR_CONTENT_IDENTIFIER_) +/* MIME content length */ +#define PR_CONTENT_LENGTH PROP_TAG(PT_I4,0x09) +#define PR_CONTENT_RETURN_REQUESTED PROP_TAG(PT_BOOLEAN,0x0A) +#define PR_CONVERSATION_KEY PROP_TAG(PT_BINARY,0x0B) +#define PR_CONVERSION_EITS PROP_TAG(PT_BINARY,0x0C) +#define PR_CONVERSION_WITH_LOSS_PROHIBITED PROP_TAG(PT_BOOLEAN,0x0D) +#define PR_CONVERTED_EITS PROP_TAG(PT_BINARY,0x0E) +/* Time to deliver for delayed delivery messages */ +#define PR_DEFERRED_DELIVERY_TIME PROP_TAG(PT_SYSTIME,0x0F) +#define PR_DELIVER_TIME PROP_TAG(PT_SYSTIME,0x10) +/* Reason a message was discarded */ +#define PR_DISCARD_REASON PROP_TAG(PT_I4,0x11) +#define PR_DISCLOSURE_OF_RECIPIENTS PROP_TAG(PT_BOOLEAN,0x12) +#define PR_DL_EXPANSION_HISTORY PROP_TAG(PT_BINARY,0x13) +#define PR_DL_EXPANSION_PROHIBITED PROP_TAG(PT_BOOLEAN,0x14) +#define PR_EXPIRY_TIME PROP_TAG(PT_SYSTIME,0x15) +#define PR_IMPLICIT_CONVERSION_PROHIBITED PROP_TAG(PT_BOOLEAN,0x16) +/* Message importance */ +#define PR_IMPORTANCE PROP_TAG(PT_I4,0x17) +#define PR_IPM_ID PROP_TAG(PT_BINARY,0x18) +#define PR_LATEST_DELIVERY_TIME PROP_TAG(PT_SYSTIME,0x19) +#define PR_MESSAGE_CLASS_W PROP_TAG(PT_UNICODE,0x1A) +#define PR_MESSAGE_CLASS_A PROP_TAG(PT_STRING8,0x1A) +#define PR_MESSAGE_CLASS WINELIB_NAME_AW(PR_MESSAGE_CLASS_) +#define PR_MESSAGE_DELIVERY_ID PROP_TAG(PT_BINARY,0x1B) +#define PR_MESSAGE_SECURITY_LABEL PROP_TAG(PT_BINARY,0x1E) +#define PR_OBSOLETED_IPMS PROP_TAG(PT_BINARY,0x1F) +/* Person a message was originally for */ +#define PR_ORIGINALLY_INTENDED_RECIPIENT_NAME PROP_TAG(PT_BINARY,0x20) +#define PR_ORIGINAL_EITS PROP_TAG(PT_BINARY,0x21) +#define PR_ORIGINATOR_CERTIFICATE PROP_TAG(PT_BINARY,0x22) +#define PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED PROP_TAG(PT_BOOLEAN,0x23) +/* Address of the message sender */ +#define PR_ORIGINATOR_RETURN_ADDRESS PROP_TAG(PT_BINARY,0x24) +#define PR_PARENT_KEY PROP_TAG(PT_BINARY,0x25) +#define PR_PRIORITY PROP_TAG(PT_I4,0x26) +#define PR_ORIGIN_CHECK PROP_TAG(PT_BINARY,0x27) +#define PR_PROOF_OF_SUBMISSION_REQUESTED PROP_TAG(PT_BOOLEAN,0x28) +/* Whether a read reciept is desired */ +#define PR_READ_RECEIPT_REQUESTED PROP_TAG(PT_BOOLEAN,0x29) +/* Time a message was received */ +#define PR_RECEIPT_TIME PROP_TAG(PT_SYSTIME,0x2A) +#define PR_RECIPIENT_REASSIGNMENT_PROHIBITED PROP_TAG(PT_BOOLEAN,0x2B) +#define PR_REDIRECTION_HISTORY PROP_TAG(PT_BINARY,0x2C) +#define PR_RELATED_IPMS PROP_TAG(PT_BINARY,0x2D) +/* Sensitivity of the original message */ +#define PR_ORIGINAL_SENSITIVITY PROP_TAG(PT_I4,0x2E) +#define PR_LANGUAGES_W PROP_TAG(PT_UNICODE,0x2F) +#define PR_LANGUAGES_A PROP_TAG(PT_STRING8,0x2F) +#define PR_LANGUAGES WINELIB_NAME_AW(PR_LANGUAGES_) +#define PR_REPLY_TIME PROP_TAG(PT_SYSTIME,0x30) +#define PR_REPORT_TAG PROP_TAG(PT_BINARY,0x31) +#define PR_REPORT_TIME PROP_TAG(PT_SYSTIME,0x32) +#define PR_RETURNED_IPM PROP_TAG(PT_BOOLEAN,0x33) +#define PR_SECURITY PROP_TAG(PT_I4,0x34) +#define PR_INCOMPLETE_COPY PROP_TAG(PT_BOOLEAN,0x35) +#define PR_SENSITIVITY PROP_TAG(PT_I4,0x36) +/* The message subject */ +#define PR_SUBJECT_W PROP_TAG(PT_UNICODE,0x37) +#define PR_SUBJECT_A PROP_TAG(PT_STRING8,0x37) +#define PR_SUBJECT WINELIB_NAME_AW(PR_SUBJECT_) +#define PR_SUBJECT_IPM PROP_TAG(PT_BINARY,0x38) +#define PR_CLIENT_SUBMIT_TIME PROP_TAG(PT_SYSTIME,0x39) +#define PR_REPORT_NAME_W PROP_TAG(PT_UNICODE,0x3A) +#define PR_REPORT_NAME_A PROP_TAG(PT_STRING8,0x3A) +#define PR_REPORT_NAME WINELIB_NAME_AW(PR_REPORT_NAME_) +#define PR_SENT_REPRESENTING_SEARCH_KEY PROP_TAG(PT_BINARY,0x3B) +#define PR_X400_CONTENT_TYPE PROP_TAG(PT_BINARY,0x3C) +#define PR_SUBJECT_PREFIX_W PROP_TAG(PT_UNICODE,0x3D) +#define PR_SUBJECT_PREFIX_A PROP_TAG(PT_STRING8,0x3D) +#define PR_SUBJECT_PREFIX WINELIB_NAME_AW(PR_SUBJECT_PREFIX_) +#define PR_NON_RECEIPT_REASON PROP_TAG(PT_I4,0x3E) +#define PR_RECEIVED_BY_ENTRYID PROP_TAG(PT_BINARY,0x3F) +/* Recieved by: entry */ +#define PR_RECEIVED_BY_NAME_W PROP_TAG(PT_UNICODE,0x40) +#define PR_RECEIVED_BY_NAME_A PROP_TAG(PT_STRING8,0x40) +#define PR_RECEIVED_BY_NAME WINELIB_NAME_AW(PR_RECEIVED_BY_NAME_) +#define PR_SENT_REPRESENTING_ENTRYID PROP_TAG(PT_BINARY,0x41) +#define PR_SENT_REPRESENTING_NAME_W PROP_TAG(PT_UNICODE,0x42) +#define PR_SENT_REPRESENTING_NAME_A PROP_TAG(PT_STRING8,0x42) +#define PR_SENT_REPRESENTING_NAME WINELIB_NAME_AW(PR_SENT_REPRESENTING_NAME_) +#define PR_RCVD_REPRESENTING_ENTRYID PROP_TAG(PT_BINARY,0x43) +#define PR_RCVD_REPRESENTING_NAME_W PROP_TAG(PT_UNICODE,0x44) +#define PR_RCVD_REPRESENTING_NAME_A PROP_TAG(PT_STRING8,0x44) +#define PR_RCVD_REPRESENTING_NAME WINELIB_NAME_AW(PR_RCVD_REPRESENTING_NAME_) +#define PR_REPORT_ENTRYID PROP_TAG(PT_BINARY,0x45) +#define PR_READ_RECEIPT_ENTRYID PROP_TAG(PT_BINARY,0x46) +#define PR_MESSAGE_SUBMISSION_ID PROP_TAG(PT_BINARY,0x47) +#define PR_PROVIDER_SUBMIT_TIME PROP_TAG(PT_SYSTIME,0x48) +/* Subject of the original message */ +#define PR_ORIGINAL_SUBJECT_W PROP_TAG(PT_UNICODE,0x49) +#define PR_ORIGINAL_SUBJECT_A PROP_TAG(PT_STRING8,0x49) +#define PR_ORIGINAL_SUBJECT WINELIB_NAME_AW(PR_ORIGINAL_SUBJECT_) +#define PR_DISC_VAL PROP_TAG(PT_BOOLEAN,0x4A) +#define PR_ORIG_MESSAGE_CLASS_W PROP_TAG(PT_UNICODE,0x4B) +#define PR_ORIG_MESSAGE_CLASS_A PROP_TAG(PT_STRING8,0x4B) +#define PR_ORIG_MESSAGE_CLASS WINELIB_NAME_AW(PR_ORIG_MESSAGE_CLASS_) +#define PR_ORIGINAL_AUTHOR_ENTRYID PROP_TAG(PT_BINARY,0x4C) +/* Author of the original message */ +#define PR_ORIGINAL_AUTHOR_NAME_W PROP_TAG(PT_UNICODE,0x4D) +#define PR_ORIGINAL_AUTHOR_NAME_A PROP_TAG(PT_STRING8,0x4D) +#define PR_ORIGINAL_AUTHOR_NAME WINELIB_NAME_AW(PR_ORIGINAL_AUTHOR_NAME_) +/* Time the original message was submitted */ +#define PR_ORIGINAL_SUBMIT_TIME PROP_TAG(PT_SYSTIME,0x4E) +#define PR_REPLY_RECIPIENT_ENTRIES PROP_TAG(PT_BINARY,0x4F) +#define PR_REPLY_RECIPIENT_NAMES_W PROP_TAG(PT_UNICODE,0x50) +#define PR_REPLY_RECIPIENT_NAMES_A PROP_TAG(PT_STRING8,0x50) +#define PR_REPLY_RECIPIENT_NAMES WINELIB_NAME_AW(PR_REPLY_RECIPIENT_NAMES_) +#define PR_RECEIVED_BY_SEARCH_KEY PROP_TAG(PT_BINARY,0x51) +#define PR_RCVD_REPRESENTING_SEARCH_KEY PROP_TAG(PT_BINARY,0x52) +#define PR_READ_RECEIPT_SEARCH_KEY PROP_TAG(PT_BINARY,0x53) +#define PR_REPORT_SEARCH_KEY PROP_TAG(PT_BINARY,0x54) +#define PR_ORIGINAL_DELIVERY_TIME PROP_TAG(PT_SYSTIME,0x55) +#define PR_ORIGINAL_AUTHOR_SEARCH_KEY PROP_TAG(PT_BINARY,0x56) +#define PR_MESSAGE_TO_ME PROP_TAG(PT_BOOLEAN,0x57) +#define PR_MESSAGE_CC_ME PROP_TAG(PT_BOOLEAN,0x58) +#define PR_MESSAGE_RECIP_ME PROP_TAG(PT_BOOLEAN,0x59) +/* Sender of the original message */ +#define PR_ORIGINAL_SENDER_NAME_W PROP_TAG(PT_UNICODE,0x5A) +#define PR_ORIGINAL_SENDER_NAME_A PROP_TAG(PT_STRING8,0x5A) +#define PR_ORIGINAL_SENDER_NAME WINELIB_NAME_AW(PR_ORIGINAL_SENDER_NAME_) +#define PR_ORIGINAL_SENDER_ENTRYID PROP_TAG(PT_BINARY,0x5B) +#define PR_ORIGINAL_SENDER_SEARCH_KEY PROP_TAG(PT_BINARY,0x5C) +#define PR_ORIGINAL_SENT_REPRESENTING_NAME_W PROP_TAG(PT_UNICODE,0x5D) +#define PR_ORIGINAL_SENT_REPRESENTING_NAME_A PROP_TAG(PT_STRING8,0x5D) +#define PR_ORIGINAL_SENT_REPRESENTING_NAME WINELIB_NAME_AW(PR_ORIGINAL_SENT_REPRESENTING_NAME_) +#define PR_ORIGINAL_SENT_REPRESENTING_ENTRYID PROP_TAG(PT_BINARY,0x5E) +#define PR_ORIGINAL_SENT_REPRESENTING_SEARCH_KEY PROP_TAG(PT_BINARY,0x5F) +#define PR_START_DATE PROP_TAG(PT_SYSTIME,0x60) +#define PR_END_DATE PROP_TAG(PT_SYSTIME,0x61) +#define PR_OWNER_APPT_ID PROP_TAG(PT_I4,0x62) +/* Whether a response to the message is desired */ +#define PR_RESPONSE_REQUESTED PROP_TAG(PT_BOOLEAN,0x63) +#define PR_SENT_REPRESENTING_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x64) +#define PR_SENT_REPRESENTING_ADDRTYPE_A PROP_TAG(PT_STRING8,0x64) +#define PR_SENT_REPRESENTING_ADDRTYPE WINELIB_NAME_AW(PR_SENT_REPRESENTING_ADDRTYPE_) +#define PR_SENT_REPRESENTING_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x65) +#define PR_SENT_REPRESENTING_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x65) +#define PR_SENT_REPRESENTING_EMAIL_ADDRESS WINELIB_NAME_AW(PR_SENT_REPRESENTING_EMAIL_ADDRESS_) +#define PR_ORIGINAL_SENDER_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x66) +#define PR_ORIGINAL_SENDER_ADDRTYPE_A PROP_TAG(PT_STRING8,0x66) +#define PR_ORIGINAL_SENDER_ADDRTYPE WINELIB_NAME_AW(PR_ORIGINAL_SENDER_ADDRTYPE_) +/* Email of the original message sender */ +#define PR_ORIGINAL_SENDER_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x67) +#define PR_ORIGINAL_SENDER_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x67) +#define PR_ORIGINAL_SENDER_EMAIL_ADDRESS WINELIB_NAME_AW(PR_ORIGINAL_SENDER_EMAIL_ADDRESS_) +#define PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x68) +#define PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_A PROP_TAG(PT_STRING8,0x68) +#define PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE WINELIB_NAME_AW(PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_) +#define PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x69) +#define PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x69) +#define PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS WINELIB_NAME_AW(PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_) +#define PR_CONVERSATION_TOPIC_W PROP_TAG(PT_UNICODE,0x70) +#define PR_CONVERSATION_TOPIC_A PROP_TAG(PT_STRING8,0x70) +#define PR_CONVERSATION_TOPIC WINELIB_NAME_AW(PR_CONVERSATION_TOPIC_) +#define PR_CONVERSATION_INDEX PROP_TAG(PT_BINARY,0x71) +#define PR_ORIGINAL_DISPLAY_BCC_W PROP_TAG(PT_UNICODE,0x72) +#define PR_ORIGINAL_DISPLAY_BCC_A PROP_TAG(PT_STRING8,0x72) +#define PR_ORIGINAL_DISPLAY_BCC WINELIB_NAME_AW(PR_ORIGINAL_DISPLAY_BCC_) +#define PR_ORIGINAL_DISPLAY_CC_W PROP_TAG(PT_UNICODE,0x73) +#define PR_ORIGINAL_DISPLAY_CC_A PROP_TAG(PT_STRING8,0x73) +#define PR_ORIGINAL_DISPLAY_CC WINELIB_NAME_AW(PR_ORIGINAL_DISPLAY_CC_) +#define PR_ORIGINAL_DISPLAY_TO_W PROP_TAG(PT_UNICODE,0x74) +#define PR_ORIGINAL_DISPLAY_TO_A PROP_TAG(PT_STRING8,0x74) +#define PR_ORIGINAL_DISPLAY_TO WINELIB_NAME_AW(PR_ORIGINAL_DISPLAY_TO_) +#define PR_RECEIVED_BY_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x75) +#define PR_RECEIVED_BY_ADDRTYPE_A PROP_TAG(PT_STRING8,0x75) +#define PR_RECEIVED_BY_ADDRTYPE WINELIB_NAME_AW(PR_RECEIVED_BY_ADDRTYPE_) +#define PR_RECEIVED_BY_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x76) +#define PR_RECEIVED_BY_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x76) +#define PR_RECEIVED_BY_EMAIL_ADDRESS WINELIB_NAME_AW(PR_RECEIVED_BY_EMAIL_ADDRESS_) +#define PR_RCVD_REPRESENTING_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x77) +#define PR_RCVD_REPRESENTING_ADDRTYPE_A PROP_TAG(PT_STRING8,0x77) +#define PR_RCVD_REPRESENTING_ADDRTYPE WINELIB_NAME_AW(PR_RCVD_REPRESENTING_ADDRTYPE_) +#define PR_RCVD_REPRESENTING_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x78) +#define PR_RCVD_REPRESENTING_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x78) +#define PR_RCVD_REPRESENTING_EMAIL_ADDRESS WINELIB_NAME_AW(PR_RCVD_REPRESENTING_EMAIL_ADDRESS_) +#define PR_ORIGINAL_AUTHOR_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x79) +#define PR_ORIGINAL_AUTHOR_ADDRTYPE_A PROP_TAG(PT_STRING8,0x79) +#define PR_ORIGINAL_AUTHOR_ADDRTYPE WINELIB_NAME_AW(PR_ORIGINAL_AUTHOR_ADDRTYPE_) +#define PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x7A) +#define PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x7A) +#define PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS WINELIB_NAME_AW(PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_) +#define PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x7B) +#define PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_A PROP_TAG(PT_STRING8,0x7B) +#define PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE WINELIB_NAME_AW(PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_) +#define PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x7C) +#define PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x7C) +#define PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS WINELIB_NAME_AW(PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_) +#define PR_TRANSPORT_MESSAGE_HEADERS_W PROP_TAG(PT_UNICODE,0x7D) +#define PR_TRANSPORT_MESSAGE_HEADERS_A PROP_TAG(PT_STRING8,0x7D) +#define PR_TRANSPORT_MESSAGE_HEADERS WINELIB_NAME_AW(PR_TRANSPORT_MESSAGE_HEADERS_) +#define PR_DELEGATION PROP_TAG(PT_BINARY,0x7E) +#define PR_TNEF_CORRELATION_KEY PROP_TAG(PT_BINARY,0x7F) +#define PR_BODY_W PROP_TAG(PT_UNICODE,0x1000) +#define PR_BODY_A PROP_TAG(PT_STRING8,0x1000) +#define PR_BODY WINELIB_NAME_AW(PR_BODY_) +#define PR_REPORT_TEXT_W PROP_TAG(PT_UNICODE,0x1001) +#define PR_REPORT_TEXT_A PROP_TAG(PT_STRING8,0x1001) +#define PR_REPORT_TEXT WINELIB_NAME_AW(PR_REPORT_TEXT_) +#define PR_ORIGINATOR_AND_DL_EXPANSION_HISTORY PROP_TAG(PT_BINARY,0x1002) +#define PR_REPORTING_DL_NAME PROP_TAG(PT_BINARY,0x1003) +#define PR_REPORTING_MTA_CERTIFICATE PROP_TAG(PT_BINARY,0x1004) +#define PR_RTF_SYNC_BODY_CRC PROP_TAG(PT_I4,0x1006) +#define PR_RTF_SYNC_BODY_COUNT PROP_TAG(PT_I4,0x1007) +#define PR_RTF_SYNC_BODY_TAG_W PROP_TAG(PT_UNICODE,0x1008) +#define PR_RTF_SYNC_BODY_TAG_A PROP_TAG(PT_STRING8,0x1008) +#define PR_RTF_SYNC_BODY_TAG WINELIB_NAME_AW(PR_RTF_SYNC_BODY_TAG_) +#define PR_RTF_COMPRESSED PROP_TAG(PT_BINARY,0x1009) +#define PR_RTF_SYNC_PREFIX_COUNT PROP_TAG(PT_I4,0x1010) +#define PR_RTF_SYNC_TRAILING_COUNT PROP_TAG(PT_I4,0x1011) +#define PR_ORIGINALLY_INTENDED_RECIP_ENTRYID PROP_TAG(PT_BINARY,0x1012) +#define PR_CONTENT_INTEGRITY_CHECK PROP_TAG(PT_BINARY,0x0C00) +#define PR_EXPLICIT_CONVERSION PROP_TAG(PT_I4,0x0C01) +#define PR_IPM_RETURN_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C02) +#define PR_MESSAGE_TOKEN PROP_TAG(PT_BINARY,0x0C03) +#define PR_NDR_REASON_CODE PROP_TAG(PT_I4,0x0C04) +#define PR_NDR_DIAG_CODE PROP_TAG(PT_I4,0x0C05) +#define PR_NON_RECEIPT_NOTIFICATION_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C06) +#define PR_DELIVERY_POINT PROP_TAG(PT_I4,0x0C07) +#define PR_ORIGINATOR_NON_DELIVERY_REPORT_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C08) +#define PR_ORIGINATOR_REQUESTED_ALTERNATE_RECIPIENT PROP_TAG(PT_BINARY,0x0C09) +#define PR_PHYSICAL_DELIVERY_BUREAU_FAX_DELIVERY PROP_TAG(PT_BOOLEAN,0x0C0A) +#define PR_PHYSICAL_DELIVERY_MODE PROP_TAG(PT_I4,0x0C0B) +#define PR_PHYSICAL_DELIVERY_REPORT_REQUEST PROP_TAG(PT_I4,0x0C0C) +#define PR_PHYSICAL_FORWARDING_ADDRESS PROP_TAG(PT_BINARY,0x0C0D) +#define PR_PHYSICAL_FORWARDING_ADDRESS_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C0E) +#define PR_PHYSICAL_FORWARDING_PROHIBITED PROP_TAG(PT_BOOLEAN,0x0C0F) +#define PR_PHYSICAL_RENDITION_ATTRIBUTES PROP_TAG(PT_BINARY,0x0C10) +#define PR_PROOF_OF_DELIVERY PROP_TAG(PT_BINARY,0x0C11) +#define PR_PROOF_OF_DELIVERY_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C12) +#define PR_RECIPIENT_CERTIFICATE PROP_TAG(PT_BINARY,0x0C13) +#define PR_RECIPIENT_NUMBER_FOR_ADVICE_W PROP_TAG(PT_UNICODE,0x0C14) +#define PR_RECIPIENT_NUMBER_FOR_ADVICE_A PROP_TAG(PT_STRING8,0x0C14) +#define PR_RECIPIENT_NUMBER_FOR_ADVICE WINELIB_NAME_AW(PR_RECIPIENT_NUMBER_FOR_ADVICE_) +#define PR_RECIPIENT_TYPE PROP_TAG(PT_I4,0x0C15) +#define PR_REGISTERED_MAIL_TYPE PROP_TAG(PT_I4,0x0C16) +#define PR_REPLY_REQUESTED PROP_TAG(PT_BOOLEAN,0x0C17) +#define PR_REQUESTED_DELIVERY_METHOD PROP_TAG(PT_I4,0x0C18) +#define PR_SENDER_ENTRYID PROP_TAG(PT_BINARY,0x0C19) +#define PR_SENDER_NAME_W PROP_TAG(PT_UNICODE,0x0C1A) +#define PR_SENDER_NAME_A PROP_TAG(PT_STRING8,0x0C1A) +#define PR_SENDER_NAME WINELIB_NAME_AW(PR_SENDER_NAME_) +#define PR_SUPPLEMENTARY_INFO_W PROP_TAG(PT_UNICODE,0x0C1B) +#define PR_SUPPLEMENTARY_INFO_A PROP_TAG(PT_STRING8,0x0C1B) +#define PR_SUPPLEMENTARY_INFO WINELIB_NAME_AW(PR_SUPPLEMENTARY_INFO_) +#define PR_TYPE_OF_MTS_USER PROP_TAG(PT_I4,0x0C1C) +#define PR_SENDER_SEARCH_KEY PROP_TAG(PT_BINARY,0x0C1D) +#define PR_SENDER_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x0C1E) +#define PR_SENDER_ADDRTYPE_A PROP_TAG(PT_STRING8,0x0C1E) +#define PR_SENDER_ADDRTYPE WINELIB_NAME_AW(PR_SENDER_ADDRTYPE_) +#define PR_SENDER_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x0C1F) +#define PR_SENDER_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x0C1F) +#define PR_SENDER_EMAIL_ADDRESS WINELIB_NAME_AW(PR_SENDER_EMAIL_ADDRESS_) +#define PR_CURRENT_VERSION PROP_TAG(PT_I8,0x0E00) +#define PR_DELETE_AFTER_SUBMIT PROP_TAG(PT_BOOLEAN,0x0E01) +#define PR_DISPLAY_BCC_W PROP_TAG(PT_UNICODE,0x0E02) +#define PR_DISPLAY_BCC_A PROP_TAG(PT_STRING8,0x0E02) +#define PR_DISPLAY_BCC WINELIB_NAME_AW(PR_DISPLAY_BCC_) +#define PR_DISPLAY_CC_W PROP_TAG(PT_UNICODE,0x0E03) +#define PR_DISPLAY_CC_A PROP_TAG(PT_STRING8,0x0E03) +#define PR_DISPLAY_CC WINELIB_NAME_AW(PR_DISPLAY_CC_) +#define PR_DISPLAY_TO_W PROP_TAG(PT_UNICODE,0x0E04) +#define PR_DISPLAY_TO_A PROP_TAG(PT_STRING8,0x0E04) +#define PR_DISPLAY_TO WINELIB_NAME_AW(PR_DISPLAY_TO_) +#define PR_PARENT_DISPLAY_W PROP_TAG(PT_UNICODE,0x0E05) +#define PR_PARENT_DISPLAY_A PROP_TAG(PT_STRING8,0x0E05) +#define PR_PARENT_DISPLAY WINELIB_NAME_AW(PR_PARENT_DISPLAY_) +#define PR_MESSAGE_DELIVERY_TIME PROP_TAG(PT_SYSTIME,0x0E06) +#define PR_MESSAGE_FLAGS PROP_TAG(PT_I4,0x0E07) +#define PR_MESSAGE_SIZE PROP_TAG(PT_I4,0x0E08) +#define PR_PARENT_ENTRYID PROP_TAG(PT_BINARY,0x0E09) +#define PR_SENTMAIL_ENTRYID PROP_TAG(PT_BINARY,0x0E0A) +#define PR_CORRELATE PROP_TAG(PT_BOOLEAN,0x0E0C) +#define PR_CORRELATE_MTSID PROP_TAG(PT_BINARY,0x0E0D) +#define PR_DISCRETE_VALUES PROP_TAG(PT_BOOLEAN,0x0E0E) +#define PR_RESPONSIBILITY PROP_TAG(PT_BOOLEAN,0x0E0F) +#define PR_SPOOLER_STATUS PROP_TAG(PT_I4,0x0E10) +#define PR_TRANSPORT_STATUS PROP_TAG(PT_I4,0x0E11) +#define PR_MESSAGE_RECIPIENTS PROP_TAG(PT_OBJECT,0x0E12) +#define PR_MESSAGE_ATTACHMENTS PROP_TAG(PT_OBJECT,0x0E13) +#define PR_SUBMIT_FLAGS PROP_TAG(PT_I4,0x0E14) +#define PR_RECIPIENT_STATUS PROP_TAG(PT_I4,0x0E15) +#define PR_TRANSPORT_KEY PROP_TAG(PT_I4,0x0E16) +#define PR_MSG_STATUS PROP_TAG(PT_I4,0x0E17) +#define PR_MESSAGE_DOWNLOAD_TIME PROP_TAG(PT_I4,0x0E18) +#define PR_CREATION_VERSION PROP_TAG(PT_I8,0x0E19) +#define PR_MODIFY_VERSION PROP_TAG(PT_I8,0x0E1A) +#define PR_HASATTACH PROP_TAG(PT_BOOLEAN,0x0E1B) +#define PR_BODY_CRC PROP_TAG(PT_I4, 0x0E1C) +#define PR_NORMALIZED_SUBJECT_W PROP_TAG(PT_UNICODE,0x0E1D) +#define PR_NORMALIZED_SUBJECT_A PROP_TAG(PT_STRING8,0x0E1D) +#define PR_NORMALIZED_SUBJECT WINELIB_NAME_AW(PR_NORMALIZED_SUBJECT_) +#define PR_RTF_IN_SYNC PROP_TAG(PT_BOOLEAN,0x0E1F) +#define PR_ATTACH_SIZE PROP_TAG(PT_I4,0x0E20) +#define PR_ATTACH_NUM PROP_TAG(PT_I4,0x0E21) +#define PR_PREPROCESS PROP_TAG(PT_BOOLEAN,0x0E22) +#define PR_ORIGINATING_MTA_CERTIFICATE PROP_TAG(PT_BINARY,0x0E25) +#define PR_PROOF_OF_SUBMISSION PROP_TAG(PT_BINARY,0x0E26) +/* A unique identifier for editing the properties of a MAPI object */ +#define PR_ENTRYID PROP_TAG(PT_BINARY,0x0FFF) +/* The type of an object */ +#define PR_OBJECT_TYPE PROP_TAG(PT_I4,0x0FFE) +#define PR_ICON PROP_TAG(PT_BINARY,0x0FFD) +#define PR_MINI_ICON PROP_TAG(PT_BINARY,0x0FFC) +#define PR_STORE_ENTRYID PROP_TAG(PT_BINARY,0x0FFB) +#define PR_STORE_RECORD_KEY PROP_TAG(PT_BINARY,0x0FFA) +/* Binary identifer for an individual object */ +#define PR_RECORD_KEY PROP_TAG(PT_BINARY,0x0FF9) +#define PR_MAPPING_SIGNATURE PROP_TAG(PT_BINARY,0x0FF8) +#define PR_ACCESS_LEVEL PROP_TAG(PT_I4,0x0FF7) +/* The primary key of a column in a table */ +#define PR_INSTANCE_KEY PROP_TAG(PT_BINARY,0x0FF6) +#define PR_ROW_TYPE PROP_TAG(PT_I4,0x0FF5) +#define PR_ACCESS PROP_TAG(PT_I4,0x0FF4) +#define PR_ROWID PROP_TAG(PT_I4,0x3000) +/* The name to display for a given MAPI object */ +#define PR_DISPLAY_NAME_W PROP_TAG(PT_UNICODE,0x3001) +#define PR_DISPLAY_NAME_A PROP_TAG(PT_STRING8,0x3001) +#define PR_DISPLAY_NAME WINELIB_NAME_AW(PR_DISPLAY_NAME_) +#define PR_ADDRTYPE_W PROP_TAG(PT_UNICODE,0x3002) +#define PR_ADDRTYPE_A PROP_TAG(PT_STRING8,0x3002) +#define PR_ADDRTYPE WINELIB_NAME_AW(PR_ADDRTYPE_) +/* An email address */ +#define PR_EMAIL_ADDRESS_W PROP_TAG(PT_UNICODE,0x3003) +#define PR_EMAIL_ADDRESS_A PROP_TAG(PT_STRING8,0x3003) +#define PR_EMAIL_ADDRESS WINELIB_NAME_AW(PR_EMAIL_ADDRESS_) +/* A comment field */ +#define PR_COMMENT_W PROP_TAG(PT_UNICODE,0x3004) +#define PR_COMMENT_A PROP_TAG(PT_STRING8,0x3004) +#define PR_COMMENT WINELIB_NAME_AW(PR_COMMENT_) +#define PR_DEPTH PROP_TAG(PT_I4,0x3005) +/* Provider-defined display name for a service provider */ +#define PR_PROVIDER_DISPLAY_W PROP_TAG(PT_UNICODE,0x3006) +#define PR_PROVIDER_DISPLAY_A PROP_TAG(PT_STRING8,0x3006) +#define PR_PROVIDER_DISPLAY WINELIB_NAME_AW(PR_PROVIDER_DISPLAY_) +/* The time an object was created */ +#define PR_CREATION_TIME PROP_TAG(PT_SYSTIME,0x3007) +/* The time an object was last modified */ +#define PR_LAST_MODIFICATION_TIME PROP_TAG(PT_SYSTIME,0x3008) +/* Flags describing a service provider, message service, or status object */ +#define PR_RESOURCE_FLAGS PROP_TAG(PT_I4,0x3009) +/* The name of a provider dll, minus any "32" suffix and ".dll" */ +#define PR_PROVIDER_DLL_NAME_W PROP_TAG(PT_UNICODE,0x300A) +#define PR_PROVIDER_DLL_NAME_A PROP_TAG(PT_STRING8,0x300A) +#define PR_PROVIDER_DLL_NAME WINELIB_NAME_AW(PR_PROVIDER_DLL_NAME_) +#define PR_SEARCH_KEY PROP_TAG(PT_BINARY,0x300B) +#define PR_PROVIDER_UID PROP_TAG(PT_BINARY,0x300C) +#define PR_PROVIDER_ORDINAL PROP_TAG(PT_I4,0x300D) +#define PR_FORM_VERSION_W PROP_TAG(PT_UNICODE,0x3301) +#define PR_FORM_VERSION_A PROP_TAG(PT_STRING8,0x3301) +#define PR_FORM_VERSION WINELIB_NAME_AW(PR_FORM_VERSION_) +#define PR_FORM_CLSID PROP_TAG(PT_CLSID,0x3302) +#define PR_FORM_CONTACT_NAME_W PROP_TAG(PT_UNICODE,0x3303) +#define PR_FORM_CONTACT_NAME_A PROP_TAG(PT_STRING8,0x3303) +#define PR_FORM_CONTACT_NAME WINELIB_NAME_AW(PR_FORM_CONTACT_NAME_) +#define PR_FORM_CATEGORY_W PROP_TAG(PT_UNICODE,0x3304) +#define PR_FORM_CATEGORY_A PROP_TAG(PT_STRING8,0x3304) +#define PR_FORM_CATEGORY WINELIB_NAME_AW(PR_FORM_CATEGORY_) +#define PR_FORM_CATEGORY_SUB_W PROP_TAG(PT_UNICODE,0x3305) +#define PR_FORM_CATEGORY_SUB_A PROP_TAG(PT_STRING8,0x3305) +#define PR_FORM_CATEGORY_SUB WINELIB_NAME_AW(PR_FORM_CATEGORY_SUB_) +#define PR_FORM_HOST_MAP PROP_TAG(PT_MV_LONG,0x3306) +#define PR_FORM_HIDDEN PROP_TAG(PT_BOOLEAN,0x3307) +#define PR_FORM_DESIGNER_NAME_W PROP_TAG(PT_UNICODE,0x3308) +#define PR_FORM_DESIGNER_NAME_A PROP_TAG(PT_STRING8,0x3308) +#define PR_FORM_DESIGNER_NAME WINELIB_NAME_AW(PR_FORM_DESIGNER_NAME_) +#define PR_FORM_DESIGNER_GUID PROP_TAG(PT_CLSID,0x3309) +#define PR_FORM_MESSAGE_BEHAVIOR PROP_TAG(PT_I4,0x330A) +/* Is this row the default message store? */ +#define PR_DEFAULT_STORE PROP_TAG(PT_BOOLEAN,0x3400) +#define PR_STORE_SUPPORT_MASK PROP_TAG(PT_I4,0x340D) +#define PR_STORE_STATE PROP_TAG(PT_I4,0x340E) +#define PR_IPM_SUBTREE_SEARCH_KEY PROP_TAG(PT_BINARY,0x3410) +#define PR_IPM_OUTBOX_SEARCH_KEY PROP_TAG(PT_BINARY,0x3411) +#define PR_IPM_WASTEBASKET_SEARCH_KEY PROP_TAG(PT_BINARY,0x3412) +#define PR_IPM_SENTMAIL_SEARCH_KEY PROP_TAG(PT_BINARY,0x3413) +/* Provder-defined message store type */ +#define PR_MDB_PROVIDER PROP_TAG(PT_BINARY,0x3414) +#define PR_RECEIVE_FOLDER_SETTINGS PROP_TAG(PT_OBJECT,0x3415) +#define PR_VALID_FOLDER_MASK PROP_TAG(PT_I4,0x35DF) +#define PR_IPM_SUBTREE_ENTRYID PROP_TAG(PT_BINARY,0x35E0) +#define PR_IPM_OUTBOX_ENTRYID PROP_TAG(PT_BINARY,0x35E2) +#define PR_IPM_WASTEBASKET_ENTRYID PROP_TAG(PT_BINARY,0x35E3) +#define PR_IPM_SENTMAIL_ENTRYID PROP_TAG(PT_BINARY,0x35E4) +#define PR_VIEWS_ENTRYID PROP_TAG(PT_BINARY,0x35E5) +#define PR_COMMON_VIEWS_ENTRYID PROP_TAG(PT_BINARY,0x35E6) +#define PR_FINDER_ENTRYID PROP_TAG(PT_BINARY,0x35E7) +#define PR_CONTAINER_FLAGS PROP_TAG(PT_I4,0x3600) +#define PR_FOLDER_TYPE PROP_TAG(PT_I4,0x3601) +#define PR_CONTENT_COUNT PROP_TAG(PT_I4,0x3602) +#define PR_CONTENT_UNREAD PROP_TAG(PT_I4,0x3603) +#define PR_CREATE_TEMPLATES PROP_TAG(PT_OBJECT,0x3604) +#define PR_DETAILS_TABLE PROP_TAG(PT_OBJECT,0x3605) +#define PR_SEARCH PROP_TAG(PT_OBJECT,0x3607) +#define PR_SELECTABLE PROP_TAG(PT_BOOLEAN,0x3609) +#define PR_SUBFOLDERS PROP_TAG(PT_BOOLEAN,0x360A) +#define PR_STATUS PROP_TAG(PT_I4,0x360B) +#define PR_ANR_W PROP_TAG(PT_UNICODE,0x360C) +#define PR_ANR_A PROP_TAG(PT_STRING8,0x360C) +#define PR_ANR WINELIB_NAME_AW(PR_ANR_) +#define PR_CONTENTS_SORT_ORDER PROP_TAG(PT_MV_LONG,0x360D) +#define PR_CONTAINER_HIERARCHY PROP_TAG(PT_OBJECT,0x360E) +#define PR_CONTAINER_CONTENTS PROP_TAG(PT_OBJECT,0x360F) +#define PR_FOLDER_ASSOCIATED_CONTENTS PROP_TAG(PT_OBJECT,0x3610) +#define PR_DEF_CREATE_DL PROP_TAG(PT_BINARY,0x3611) +#define PR_DEF_CREATE_MAILUSER PROP_TAG(PT_BINARY,0x3612) +#define PR_CONTAINER_CLASS_W PROP_TAG(PT_UNICODE,0x3613) +#define PR_CONTAINER_CLASS_A PROP_TAG(PT_STRING8,0x3613) +#define PR_CONTAINER_CLASS WINELIB_NAME_AW(PR_CONTAINER_CLASS_) +#define PR_CONTAINER_MODIFY_VERSION PROP_TAG(PT_I8,0x3614) +#define PR_AB_PROVIDER_ID PROP_TAG(PT_BINARY,0x3615) +#define PR_DEFAULT_VIEW_ENTRYID PROP_TAG(PT_BINARY,0x3616) +#define PR_ASSOC_CONTENT_COUNT PROP_TAG(PT_I4,0x3617) +#define PR_ATTACHMENT_X400_PARAMETERS PROP_TAG(PT_BINARY,0x3700) +#define PR_ATTACH_DATA_OBJ PROP_TAG(PT_OBJECT,0x3701) +#define PR_ATTACH_DATA_BIN PROP_TAG(PT_BINARY,0x3701) +#define PR_ATTACH_ENCODING PROP_TAG(PT_BINARY,0x3702) +#define PR_ATTACH_EXTENSION_W PROP_TAG(PT_UNICODE,0x3703) +#define PR_ATTACH_EXTENSION_A PROP_TAG(PT_STRING8,0x3703) +#define PR_ATTACH_EXTENSION WINELIB_NAME_AW(PR_ATTACH_EXTENSION_) +#define PR_ATTACH_FILENAME_W PROP_TAG(PT_UNICODE,0x3704) +#define PR_ATTACH_FILENAME_A PROP_TAG(PT_STRING8,0x3704) +#define PR_ATTACH_FILENAME WINELIB_NAME_AW(PR_ATTACH_FILENAME_) +#define PR_ATTACH_METHOD PROP_TAG(PT_I4,0x3705) +#define PR_ATTACH_LONG_FILENAME_W PROP_TAG(PT_UNICODE,0x3707) +#define PR_ATTACH_LONG_FILENAME_A PROP_TAG(PT_STRING8,0x3707) +#define PR_ATTACH_LONG_FILENAME WINELIB_NAME_AW(PR_ATTACH_LONG_FILENAME_) +#define PR_ATTACH_PATHNAME_W PROP_TAG(PT_UNICODE,0x3708) +#define PR_ATTACH_PATHNAME_A PROP_TAG(PT_STRING8,0x3708) +#define PR_ATTACH_PATHNAME WINELIB_NAME_AW(PR_ATTACH_PATHNAME_) +#define PR_ATTACH_RENDERING PROP_TAG(PT_BINARY, 0x3709) +#define PR_ATTACH_TAG PROP_TAG(PT_BINARY,0x370A) +#define PR_RENDERING_POSITION PROP_TAG(PT_I4,0x370B) +#define PR_ATTACH_TRANSPORT_NAME_W PROP_TAG(PT_UNICODE,0x370C) +#define PR_ATTACH_TRANSPORT_NAME_A PROP_TAG(PT_STRING8,0x370C) +#define PR_ATTACH_TRANSPORT_NAME WINELIB_NAME_AW(PR_ATTACH_TRANSPORT_NAME_) +#define PR_ATTACH_LONG_PATHNAME_W PROP_TAG(PT_UNICODE,0x370D) +#define PR_ATTACH_LONG_PATHNAME_A PROP_TAG(PT_STRING8,0x370D) +#define PR_ATTACH_LONG_PATHNAME WINELIB_NAME_AW(PR_ATTACH_LONG_PATHNAME_) +#define PR_ATTACH_MIME_TAG_W PROP_TAG(PT_UNICODE,0x370E) +#define PR_ATTACH_MIME_TAG_A PROP_TAG(PT_STRING8,0x370E) +#define PR_ATTACH_MIME_TAG WINELIB_NAME_AW(PR_ATTACH_MIME_TAG_) +#define PR_ATTACH_ADDITIONAL_INFO PROP_TAG(PT_BINARY,0x370F) +#define PR_DISPLAY_TYPE PROP_TAG(PT_I4,0x3900) +#define PR_TEMPLATEID PROP_TAG(PT_BINARY,0x3902) +#define PR_PRIMARY_CAPABILITY PROP_TAG(PT_BINARY,0x3904) +#define PR_7BIT_DISPLAY_NAME PROP_TAG(PT_STRING8,0x39FF) +#define PR_ACCOUNT_W PROP_TAG(PT_UNICODE,0x3A00) +#define PR_ACCOUNT_A PROP_TAG(PT_STRING8,0x3A00) +#define PR_ACCOUNT WINELIB_NAME_AW(PR_ACCOUNT_) +#define PR_ALTERNATE_RECIPIENT PROP_TAG(PT_BINARY,0x3A01) +#define PR_CALLBACK_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A02) +#define PR_CALLBACK_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A02) +#define PR_CALLBACK_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_CALLBACK_TELEPHONE_NUMBER_) +#define PR_CONVERSION_PROHIBITED PROP_TAG(PT_BOOLEAN,0x3A03) +#define PR_DISCLOSE_RECIPIENTS PROP_TAG(PT_BOOLEAN,0x3A04) +#define PR_GENERATION_W PROP_TAG(PT_UNICODE,0x3A05) +#define PR_GENERATION_A PROP_TAG(PT_STRING8,0x3A05) +#define PR_GENERATION WINELIB_NAME_AW(PR_GENERATION_) +#define PR_GIVEN_NAME_W PROP_TAG(PT_UNICODE,0x3A06) +#define PR_GIVEN_NAME_A PROP_TAG(PT_STRING8,0x3A06) +#define PR_GIVEN_NAME WINELIB_NAME_AW(PR_GIVEN_NAME_) +#define PR_GOVERNMENT_ID_NUMBER_W PROP_TAG(PT_UNICODE,0x3A07) +#define PR_GOVERNMENT_ID_NUMBER_A PROP_TAG(PT_STRING8,0x3A07) +#define PR_GOVERNMENT_ID_NUMBER WINELIB_NAME_AW(PR_GOVERNMENT_ID_NUMBER_) +#define PR_BUSINESS_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A08) +#define PR_BUSINESS_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A08) +#define PR_BUSINESS_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_BUSINESS_TELEPHONE_NUMBER_) +#define PR_OFFICE_TELEPHONE_NUMBER_W PR_BUSINESS_TELEPHONE_NUMBER_W +#define PR_OFFICE_TELEPHONE_NUMBER_A PR_BUSINESS_TELEPHONE_NUMBER_A +#define PR_OFFICE_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_OFFICE_TELEPHONE_NUMBER_) +#define PR_HOME_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A09) +#define PR_HOME_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A09) +#define PR_HOME_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_HOME_TELEPHONE_NUMBER_) +#define PR_INITIALS_W PROP_TAG(PT_UNICODE,0x3A0A) +#define PR_INITIALS_A PROP_TAG(PT_STRING8,0x3A0A) +#define PR_INITIALS WINELIB_NAME_AW(PR_INITIALS_) +#define PR_KEYWORD_W PROP_TAG(PT_UNICODE,0x3A0B) +#define PR_KEYWORD_A PROP_TAG(PT_STRING8,0x3A0B) +#define PR_KEYWORD WINELIB_NAME_AW(PR_KEYWORD_) +#define PR_LANGUAGE_W PROP_TAG(PT_UNICODE,0x3A0C) +#define PR_LANGUAGE_A PROP_TAG(PT_STRING8,0x3A0C) +#define PR_LANGUAGE WINELIB_NAME_AW(PR_LANGUAGE_) +#define PR_LOCATION_W PROP_TAG(PT_UNICODE,0x3A0D) +#define PR_LOCATION_A PROP_TAG(PT_STRING8,0x3A0D) +#define PR_LOCATION WINELIB_NAME_AW(PR_LOCATION_) +#define PR_MAIL_PERMISSION PROP_TAG(PT_BOOLEAN,0x3A0E) +#define PR_MHS_COMMON_NAME_W PROP_TAG(PT_UNICODE,0x3A0F) +#define PR_MHS_COMMON_NAME_A PROP_TAG(PT_STRING8,0x3A0F) +#define PR_MHS_COMMON_NAME WINELIB_NAME_AW(PR_MHS_COMMON_NAME_) +#define PR_ORGANIZATIONAL_ID_NUMBER_W PROP_TAG(PT_UNICODE,0x3A10) +#define PR_ORGANIZATIONAL_ID_NUMBER_A PROP_TAG(PT_STRING8,0x3A10) +#define PR_ORGANIZATIONAL_ID_NUMBER WINELIB_NAME_AW(PR_ORGANIZATIONAL_ID_NUMBER_) +#define PR_SURNAME_W PROP_TAG(PT_UNICODE,0x3A11) +#define PR_SURNAME_A PROP_TAG(PT_STRING8,0x3A11) +#define PR_SURNAME WINELIB_NAME_AW(PR_SURNAME_) +#define PR_ORIGINAL_ENTRYID PROP_TAG(PT_BINARY,0x3A12) +#define PR_ORIGINAL_DISPLAY_NAME_W PROP_TAG(PT_UNICODE,0x3A13) +#define PR_ORIGINAL_DISPLAY_NAME_A PROP_TAG(PT_STRING8,0x3A13) +#define PR_ORIGINAL_DISPLAY_NAME WINELIB_NAME_AW(PR_ORIGINAL_DISPLAY_NAME_) +#define PR_ORIGINAL_SEARCH_KEY PROP_TAG(PT_BINARY,0x3A14) +#define PR_POSTAL_ADDRESS_W PROP_TAG(PT_UNICODE,0x3A15) +#define PR_POSTAL_ADDRESS_A PROP_TAG(PT_STRING8,0x3A15) +#define PR_POSTAL_ADDRESS WINELIB_NAME_AW(PR_POSTAL_ADDRESS_) +#define PR_COMPANY_NAME_W PROP_TAG(PT_UNICODE,0x3A16) +#define PR_COMPANY_NAME_A PROP_TAG(PT_STRING8,0x3A16) +#define PR_COMPANY_NAME WINELIB_NAME_AW(PR_COMPANY_NAME_) +#define PR_TITLE_W PROP_TAG(PT_UNICODE,0x3A17) +#define PR_TITLE_A PROP_TAG(PT_STRING8,0x3A17) +#define PR_TITLE WINELIB_NAME_AW(PR_TITLE_) +#define PR_DEPARTMENT_NAME_W PROP_TAG(PT_UNICODE,0x3A18) +#define PR_DEPARTMENT_NAME_A PROP_TAG(PT_STRING8,0x3A18) +#define PR_DEPARTMENT_NAME WINELIB_NAME_AW(PR_DEPARTMENT_NAME_) +#define PR_OFFICE_LOCATION_W PROP_TAG(PT_UNICODE,0x3A19) +#define PR_OFFICE_LOCATION_A PROP_TAG(PT_STRING8,0x3A19) +#define PR_OFFICE_LOCATION WINELIB_NAME_AW(PR_OFFICE_LOCATION_) +#define PR_PRIMARY_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1A) +#define PR_PRIMARY_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1A) +#define PR_PRIMARY_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_PRIMARY_TELEPHONE_NUMBER_) +#define PR_BUSINESS2_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1B) +#define PR_BUSINESS2_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1B) +#define PR_BUSINESS2_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_BUSINESS2_TELEPHONE_NUMBER_) +#define PR_OFFICE2_TELEPHONE_NUMBER_W PR_BUSINESS2_TELEPHONE_NUMBER_W +#define PR_OFFICE2_TELEPHONE_NUMBER_A PR_BUSINESS2_TELEPHONE_NUMBER_A +#define PR_OFFICE2_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_OFFICE2_TELEPHONE_NUMBER_) +#define PR_MOBILE_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1C) +#define PR_MOBILE_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1C) +#define PR_MOBILE_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_MOBILE_TELEPHONE_NUMBER_) +#define PR_CELLULAR_TELEPHONE_NUMBER_W PR_MOBILE_TELEPHONE_NUMBER_W +#define PR_CELLULAR_TELEPHONE_NUMBER_A PR_MOBILE_TELEPHONE_NUMBER_A +#define PR_CELLULAR_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_CELLULAR_TELEPHONE_NUMBER_) +#define PR_RADIO_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1D) +#define PR_RADIO_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1D) +#define PR_RADIO_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_RADIO_TELEPHONE_NUMBER_) +#define PR_CAR_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1E) +#define PR_CAR_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1E) +#define PR_CAR_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_CAR_TELEPHONE_NUMBER_) +#define PR_OTHER_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A1F) +#define PR_OTHER_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A1F) +#define PR_OTHER_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_OTHER_TELEPHONE_NUMBER_) +#define PR_TRANSMITABLE_DISPLAY_NAME_W PROP_TAG(PT_UNICODE,0x3A20) +#define PR_TRANSMITABLE_DISPLAY_NAME_A PROP_TAG(PT_STRING8,0x3A20) +#define PR_TRANSMITABLE_DISPLAY_NAME WINELIB_NAME_AW(PR_TRANSMITABLE_DISPLAY_NAME_) +#define PR_PAGER_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A21) +#define PR_PAGER_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A21) +#define PR_PAGER_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_PAGER_TELEPHONE_NUMBER_) +#define PR_BEEPER_TELEPHONE_NUMBER_W PR_PAGER_TELEPHONE_NUMBER_W +#define PR_BEEPER_TELEPHONE_NUMBER_A PR_PAGER_TELEPHONE_NUMBER_A +#define PR_BEEPER_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_BEEPER_TELEPHONE_NUMBER_) +#define PR_USER_CERTIFICATE PROP_TAG(PT_BINARY,0x3A22) +#define PR_PRIMARY_FAX_NUMBER_W PROP_TAG(PT_UNICODE,0x3A23) +#define PR_PRIMARY_FAX_NUMBER_A PROP_TAG(PT_STRING8,0x3A23) +#define PR_PRIMARY_FAX_NUMBER WINELIB_NAME_AW(PR_PRIMARY_FAX_NUMBER_) +#define PR_BUSINESS_FAX_NUMBER_W PROP_TAG(PT_UNICODE,0x3A24) +#define PR_BUSINESS_FAX_NUMBER_A PROP_TAG(PT_STRING8,0x3A24) +#define PR_BUSINESS_FAX_NUMBER WINELIB_NAME_AW(PR_BUSINESS_FAX_NUMBER_) +#define PR_HOME_FAX_NUMBER_W PROP_TAG(PT_UNICODE,0x3A25) +#define PR_HOME_FAX_NUMBER_A PROP_TAG(PT_STRING8,0x3A25) +#define PR_HOME_FAX_NUMBER WINELIB_NAME_AW(PR_HOME_FAX_NUMBER_) +#define PR_COUNTRY_W PROP_TAG(PT_UNICODE,0x3A26) +#define PR_COUNTRY_A PROP_TAG(PT_STRING8,0x3A26) +#define PR_COUNTRY WINELIB_NAME_AW(PR_COUNTRY_) +#define PR_BUSINESS_ADDRESS_COUNTRY_W PR_COUNTRY_W +#define PR_BUSINESS_ADDRESS_COUNTRY_A PR_COUNTRY_A +#define PR_BUSINESS_ADDRESS_COUNTRY WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_COUNTRY_) +#define PR_LOCALITY_W PROP_TAG(PT_UNICODE,0x3A27) +#define PR_LOCALITY_A PROP_TAG(PT_STRING8,0x3A27) +#define PR_LOCALITY WINELIB_NAME_AW(PR_LOCALITY_) +#define PR_BUSINESS_ADDRESS_CITY_W PR_LOCALITY_W +#define PR_BUSINESS_ADDRESS_CITY_A PR_LOCALITY_A +#define PR_BUSINESS_ADDRESS_CITY WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_CITY_) +#define PR_STATE_OR_PROVINCE_W PROP_TAG(PT_UNICODE,0x3A28) +#define PR_STATE_OR_PROVINCE_A PROP_TAG(PT_STRING8,0x3A28) +#define PR_STATE_OR_PROVINCE WINELIB_NAME_AW(PR_STATE_OR_PROVINCE_) +#define PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_W PR_STATE_OR_PROVINCE_W +#define PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_A PR_STATE_OR_PROVINCE_A +#define PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_) +#define PR_STREET_ADDRESS_W PROP_TAG(PT_UNICODE,0x3A29) +#define PR_STREET_ADDRESS_A PROP_TAG(PT_STRING8,0x3A29) +#define PR_STREET_ADDRESS WINELIB_NAME_AW(PR_STREET_ADDRESS_) +#define PR_BUSINESS_ADDRESS_STREET_W PR_STREET_ADDRESS_W +#define PR_BUSINESS_ADDRESS_STREET_A PR_STREET_ADDRESS_A +#define PR_BUSINESS_ADDRESS_STREET WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_STREET_) +#define PR_POSTAL_CODE_W PROP_TAG(PT_UNICODE,0x3A2A) +#define PR_POSTAL_CODE_A PROP_TAG(PT_STRING8,0x3A2A) +#define PR_POSTAL_CODE WINELIB_NAME_AW(PR_POSTAL_CODE_) +#define PR_BUSINESS_ADDRESS_POSTAL_CODE_W PR_POSTAL_CODE_W +#define PR_BUSINESS_ADDRESS_POSTAL_CODE_A PR_POSTAL_CODE_A +#define PR_BUSINESS_ADDRESS_POSTAL_CODE WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_POSTAL_CODE_) +#define PR_POST_OFFICE_BOX_W PROP_TAG(PT_UNICODE,0x3A2B) +#define PR_POST_OFFICE_BOX_A PROP_TAG(PT_STRING8,0x3A2B) +#define PR_POST_OFFICE_BOX WINELIB_NAME_AW(PR_POST_OFFICE_BOX_) +#define PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_W PR_POST_OFFICE_BOX_W +#define PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_A PR_POST_OFFICE_BOX_A +#define PR_BUSINESS_ADDRESS_POST_OFFICE_BOX WINELIB_NAME_AW(PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_) +#define PR_TELEX_NUMBER_W PROP_TAG(PT_UNICODE,0x3A2C) +#define PR_TELEX_NUMBER_A PROP_TAG(PT_STRING8,0x3A2C) +#define PR_TELEX_NUMBER WINELIB_NAME_AW(PR_TELEX_NUMBER_) +#define PR_ISDN_NUMBER_W PROP_TAG(PT_UNICODE,0x3A2D) +#define PR_ISDN_NUMBER_A PROP_TAG(PT_STRING8,0x3A2D) +#define PR_ISDN_NUMBER WINELIB_NAME_AW(PR_ISDN_NUMBER_) +#define PR_ASSISTANT_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A2E) +#define PR_ASSISTANT_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A2E) +#define PR_ASSISTANT_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_ASSISTANT_TELEPHONE_NUMBER_) +#define PR_HOME2_TELEPHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A2F) +#define PR_HOME2_TELEPHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A2F) +#define PR_HOME2_TELEPHONE_NUMBER WINELIB_NAME_AW(PR_HOME2_TELEPHONE_NUMBER_) +#define PR_ASSISTANT_W PROP_TAG(PT_UNICODE,0x3A30) +#define PR_ASSISTANT_A PROP_TAG(PT_STRING8,0x3A30) +#define PR_ASSISTANT WINELIB_NAME_AW(PR_ASSISTANT_) +#define PR_SEND_RICH_INFO PROP_TAG(PT_BOOLEAN,0x3A40) +#define PR_WEDDING_ANNIVERSARY PROP_TAG(PT_SYSTIME,0x3A41) +#define PR_BIRTHDAY PROP_TAG(PT_SYSTIME,0x3A42) +#define PR_HOBBIES_W PROP_TAG(PT_UNICODE,0x3A43) +#define PR_HOBBIES_A PROP_TAG(PT_STRING8,0x3A43) +#define PR_HOBBIES WINELIB_NAME_AW(PR_HOBBIES_) +#define PR_MIDDLE_NAME_W PROP_TAG(PT_UNICODE,0x3A44) +#define PR_MIDDLE_NAME_A PROP_TAG(PT_STRING8,0x3A44) +#define PR_MIDDLE_NAME WINELIB_NAME_AW(PR_MIDDLE_NAME_) +#define PR_DISPLAY_NAME_PREFIX_W PROP_TAG(PT_UNICODE,0x3A45) +#define PR_DISPLAY_NAME_PREFIX_A PROP_TAG(PT_STRING8,0x3A45) +#define PR_DISPLAY_NAME_PREFIX WINELIB_NAME_AW(PR_DISPLAY_NAME_PREFIX_) +#define PR_PROFESSION_W PROP_TAG(PT_UNICODE,0x3A46) +#define PR_PROFESSION_A PROP_TAG(PT_STRING8,0x3A46) +#define PR_PROFESSION WINELIB_NAME_AW(PR_PROFESSION_) +#define PR_PREFERRED_BY_NAME_W PROP_TAG(PT_UNICODE,0x3A47) +#define PR_PREFERRED_BY_NAME_A PROP_TAG(PT_STRING8,0x3A47) +#define PR_PREFERRED_BY_NAME WINELIB_NAME_AW(PR_PREFERRED_BY_NAME_) +#define PR_SPOUSE_NAME_W PROP_TAG(PT_UNICODE,0x3A48) +#define PR_SPOUSE_NAME_A PROP_TAG(PT_STRING8,0x3A48) +#define PR_SPOUSE_NAME WINELIB_NAME_AW(PR_SPOUSE_NAME_) +#define PR_COMPUTER_NETWORK_NAME_W PROP_TAG(PT_UNICODE,0x3A49) +#define PR_COMPUTER_NETWORK_NAME_A PROP_TAG(PT_STRING8,0x3A49) +#define PR_COMPUTER_NETWORK_NAME WINELIB_NAME_AW(PR_COMPUTER_NETWORK_NAME_) +#define PR_CUSTOMER_ID_W PROP_TAG(PT_UNICODE,0x3A4A) +#define PR_CUSTOMER_ID_A PROP_TAG(PT_STRING8,0x3A4A) +#define PR_CUSTOMER_ID WINELIB_NAME_AW(PR_CUSTOMER_ID_) +#define PR_TTYTDD_PHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A4B) +#define PR_TTYTDD_PHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A4B) +#define PR_TTYTDD_PHONE_NUMBER WINELIB_NAME_AW(PR_TTYTDD_PHONE_NUMBER_) +#define PR_FTP_SITE_W PROP_TAG(PT_UNICODE,0x3A4C) +#define PR_FTP_SITE_A PROP_TAG(PT_STRING8,0x3A4C) +#define PR_FTP_SITE WINELIB_NAME_AW(PR_FTP_SITE_) +#define PR_GENDER PROP_TAG(PT_I2,0x3A4D) +#define PR_MANAGER_NAME_W PROP_TAG(PT_UNICODE,0x3A4E) +#define PR_MANAGER_NAME_A PROP_TAG(PT_STRING8,0x3A4E) +#define PR_MANAGER_NAME WINELIB_NAME_AW(PR_MANAGER_NAME_) +#define PR_NICKNAME_W PROP_TAG(PT_UNICODE,0x3A4F) +#define PR_NICKNAME_A PROP_TAG(PT_STRING8,0x3A4F) +#define PR_NICKNAME WINELIB_NAME_AW(PR_NICKNAME_) +#define PR_PERSONAL_HOME_PAGE_W PROP_TAG(PT_UNICODE,0x3A50) +#define PR_PERSONAL_HOME_PAGE_A PROP_TAG(PT_STRING8,0x3A50) +#define PR_PERSONAL_HOME_PAGE WINELIB_NAME_AW(PR_PERSONAL_HOME_PAGE_) +#define PR_BUSINESS_HOME_PAGE_W PROP_TAG(PT_UNICODE,0x3A51) +#define PR_BUSINESS_HOME_PAGE_A PROP_TAG(PT_STRING8,0x3A51) +#define PR_BUSINESS_HOME_PAGE WINELIB_NAME_AW(PR_BUSINESS_HOME_PAGE_) +#define PR_CONTACT_VERSION PROP_TAG(PT_CLSID,0x3A52) +#define PR_CONTACT_ENTRYIDS PROP_TAG(PT_MV_BINARY,0x3A53) +#define PR_CONTACT_ADDRTYPES_W PROP_TAG(PT_MV_UNICODE,0x3A54) +#define PR_CONTACT_ADDRTYPES_A PROP_TAG(PT_MV_STRING8,0x3A54) +#define PR_CONTACT_ADDRTYPES WINELIB_NAME_AW(PR_CONTACT_ADDRTYPES_) +#define PR_CONTACT_DEFAULT_ADDRESS_INDEX PROP_TAG(PT_I4,0x3A55) +#define PR_CONTACT_EMAIL_ADDRESSES_W PROP_TAG(PT_MV_UNICODE,0x3A56) +#define PR_CONTACT_EMAIL_ADDRESSES_A PROP_TAG(PT_MV_STRING8,0x3A56) +#define PR_CONTACT_EMAIL_ADDRESSES WINELIB_NAME_AW(PR_CONTACT_EMAIL_ADDRESSES_) +#define PR_COMPANY_MAIN_PHONE_NUMBER_W PROP_TAG(PT_UNICODE,0x3A57) +#define PR_COMPANY_MAIN_PHONE_NUMBER_A PROP_TAG(PT_STRING8,0x3A57) +#define PR_COMPANY_MAIN_PHONE_NUMBER WINELIB_NAME_AW(PR_COMPANY_MAIN_PHONE_NUMBER_) +#define PR_CHILDRENS_NAMES_W PROP_TAG(PT_MV_UNICODE,0x3A58) +#define PR_CHILDRENS_NAMES_A PROP_TAG(PT_MV_STRING8,0x3A58) +#define PR_CHILDRENS_NAMES WINELIB_NAME_AW(PR_CHILDRENS_NAMES_) +#define PR_HOME_ADDRESS_CITY_W PROP_TAG(PT_UNICODE,0x3A59) +#define PR_HOME_ADDRESS_CITY_A PROP_TAG(PT_STRING8,0x3A59) +#define PR_HOME_ADDRESS_CITY WINELIB_NAME_AW(PR_HOME_ADDRESS_CITY_) +#define PR_HOME_ADDRESS_COUNTRY_W PROP_TAG(PT_UNICODE,0x3A5A) +#define PR_HOME_ADDRESS_COUNTRY_A PROP_TAG(PT_STRING8,0x3A5A) +#define PR_HOME_ADDRESS_COUNTRY WINELIB_NAME_AW(PR_HOME_ADDRESS_COUNTRY_) +#define PR_HOME_ADDRESS_POSTAL_CODE_W PROP_TAG(PT_UNICODE,0x3A5B) +#define PR_HOME_ADDRESS_POSTAL_CODE_A PROP_TAG(PT_STRING8,0x3A5B) +#define PR_HOME_ADDRESS_POSTAL_CODE WINELIB_NAME_AW(PR_HOME_ADDRESS_POSTAL_CODE_) +#define PR_HOME_ADDRESS_STATE_OR_PROVINCE_W PROP_TAG(PT_UNICODE,0x3A5C) +#define PR_HOME_ADDRESS_STATE_OR_PROVINCE_A PROP_TAG(PT_STRING8,0x3A5C) +#define PR_HOME_ADDRESS_STATE_OR_PROVINCE WINELIB_NAME_AW(PR_HOME_ADDRESS_STATE_OR_PROVINCE_) +#define PR_HOME_ADDRESS_STREET_W PROP_TAG(PT_UNICODE,0x3A5D) +#define PR_HOME_ADDRESS_STREET_A PROP_TAG(PT_STRING8,0x3A5D) +#define PR_HOME_ADDRESS_STREET WINELIB_NAME_AW(PR_HOME_ADDRESS_STREET_) +#define PR_HOME_ADDRESS_POST_OFFICE_BOX_W PROP_TAG(PT_UNICODE,0x3A5E) +#define PR_HOME_ADDRESS_POST_OFFICE_BOX_A PROP_TAG(PT_STRING8,0x3A5E) +#define PR_HOME_ADDRESS_POST_OFFICE_BOX WINELIB_NAME_AW(PR_HOME_ADDRESS_POST_OFFICE_BOX_) +#define PR_OTHER_ADDRESS_CITY_W PROP_TAG(PT_UNICODE,0x3A5F) +#define PR_OTHER_ADDRESS_CITY_A PROP_TAG(PT_STRING8,0x3A5F) +#define PR_OTHER_ADDRESS_CITY WINELIB_NAME_AW(PR_OTHER_ADDRESS_CITY_) +#define PR_OTHER_ADDRESS_COUNTRY_W PROP_TAG(PT_UNICODE,0x3A60) +#define PR_OTHER_ADDRESS_COUNTRY_A PROP_TAG(PT_STRING8,0x3A60) +#define PR_OTHER_ADDRESS_COUNTRY WINELIB_NAME_AW(PR_OTHER_ADDRESS_COUNTRY_) +#define PR_OTHER_ADDRESS_POSTAL_CODE_W PROP_TAG(PT_UNICODE,0x3A61) +#define PR_OTHER_ADDRESS_POSTAL_CODE_A PROP_TAG(PT_STRING8,0x3A61) +#define PR_OTHER_ADDRESS_POSTAL_CODE WINELIB_NAME_AW(PR_OTHER_ADDRESS_POSTAL_CODE_) +#define PR_OTHER_ADDRESS_STATE_OR_PROVINCE_W PROP_TAG(PT_UNICODE,0x3A62) +#define PR_OTHER_ADDRESS_STATE_OR_PROVINCE_A PROP_TAG(PT_STRING8,0x3A62) +#define PR_OTHER_ADDRESS_STATE_OR_PROVINCE WINELIB_NAME_AW(PR_OTHER_ADDRESS_STATE_OR_PROVINCE_) +#define PR_OTHER_ADDRESS_STREET_W PROP_TAG(PT_UNICODE,0x3A63) +#define PR_OTHER_ADDRESS_STREET_A PROP_TAG(PT_STRING8,0x3A63) +#define PR_OTHER_ADDRESS_STREET WINELIB_NAME_AW(PR_OTHER_ADDRESS_STREET_) +#define PR_OTHER_ADDRESS_POST_OFFICE_BOX_W PROP_TAG(PT_UNICODE,0x3A64) +#define PR_OTHER_ADDRESS_POST_OFFICE_BOX_A PROP_TAG(PT_STRING8,0x3A64) +#define PR_OTHER_ADDRESS_POST_OFFICE_BOX WINELIB_NAME_AW(PR_OTHER_ADDRESS_POST_OFFICE_BOX_) +#define PR_STORE_PROVIDERS PROP_TAG(PT_BINARY,0x3D00) +#define PR_AB_PROVIDERS PROP_TAG(PT_BINARY,0x3D01) +#define PR_TRANSPORT_PROVIDERS PROP_TAG(PT_BINARY,0x3D02) +#define PR_DEFAULT_PROFILE PROP_TAG(PT_BOOLEAN,0x3D04) +#define PR_AB_SEARCH_PATH PROP_TAG(PT_MV_BINARY,0x3D05) +#define PR_AB_DEFAULT_DIR PROP_TAG(PT_BINARY,0x3D06) +#define PR_AB_DEFAULT_PAB PROP_TAG(PT_BINARY,0x3D07) +#define PR_FILTERING_HOOKS PROP_TAG(PT_BINARY, 0x3D08) +#define PR_SERVICE_NAME_W PROP_TAG(PT_UNICODE,0x3D09) +#define PR_SERVICE_NAME_A PROP_TAG(PT_STRING8,0x3D09) +#define PR_SERVICE_NAME WINELIB_NAME_AW(PR_SERVICE_NAME_) +#define PR_SERVICE_DLL_NAME_W PROP_TAG(PT_UNICODE,0x3D0A) +#define PR_SERVICE_DLL_NAME_A PROP_TAG(PT_STRING8,0x3D0A) +#define PR_SERVICE_DLL_NAME WINELIB_NAME_AW(PR_SERVICE_DLL_NAME_) +#define PR_SERVICE_ENTRY_NAME PROP_TAG(PT_STRING8,0x3D0B) +#define PR_SERVICE_UID PROP_TAG(PT_BINARY,0x3D0C) +#define PR_SERVICE_EXTRA_UIDS PROP_TAG(PT_BINARY,0x3D0D) +#define PR_SERVICES PROP_TAG(PT_BINARY,0x3D0E) +#define PR_SERVICE_SUPPORT_FILES_W PROP_TAG(PT_MV_UNICODE,0x3D0F) +#define PR_SERVICE_SUPPORT_FILES_A PROP_TAG(PT_MV_STRING8,0x3D0F) +#define PR_SERVICE_SUPPORT_FILES WINELIB_NAME_AW(PR_SERVICE_SUPPORT_FILES_) +#define PR_SERVICE_DELETE_FILES_W PROP_TAG(PT_MV_UNICODE,0x3D10) +#define PR_SERVICE_DELETE_FILES_A PROP_TAG(PT_MV_STRING8,0x3D10) +#define PR_SERVICE_DELETE_FILES WINELIB_NAME_AW(PR_SERVICE_DELETE_FILES_) +#define PR_AB_SEARCH_PATH_UPDATE PROP_TAG(PT_BINARY,0x3D11) +#define PR_PROFILE_NAME_A PROP_TAG(PT_STRING8,0x3D12) +#define PR_PROFILE_NAME_W PROP_TAG(PT_UNICODE,0x3D12) +#define PR_PROFILE_NAME WINELIB_NAME_AW(PR_PROFILE_NAME_) +#define PR_IDENTITY_DISPLAY_W PROP_TAG(PT_UNICODE,0x3E00) +#define PR_IDENTITY_DISPLAY_A PROP_TAG(PT_STRING8,0x3E00) +#define PR_IDENTITY_DISPLAY WINELIB_NAME_AW(PR_IDENTITY_DISPLAY_) +#define PR_IDENTITY_ENTRYID PROP_TAG(PT_BINARY,0x3E01) +#define PR_RESOURCE_METHODS PROP_TAG(PT_I4,0x3E02) +/* Service provider type */ +#define PR_RESOURCE_TYPE PROP_TAG(PT_I4,0x3E03) +#define PR_STATUS_CODE PROP_TAG(PT_I4,0x3E04) +#define PR_IDENTITY_SEARCH_KEY PROP_TAG(PT_BINARY,0x3E05) +#define PR_OWN_STORE_ENTRYID PROP_TAG(PT_BINARY,0x3E06) +#define PR_RESOURCE_PATH_W PROP_TAG(PT_UNICODE,0x3E07) +#define PR_RESOURCE_PATH_A PROP_TAG(PT_STRING8,0x3E07) +#define PR_RESOURCE_PATH WINELIB_NAME_AW(PR_RESOURCE_PATH_) +#define PR_STATUS_STRING_W PROP_TAG(PT_UNICODE,0x3E08) +#define PR_STATUS_STRING_A PROP_TAG(PT_STRING8,0x3E08) +#define PR_STATUS_STRING WINELIB_NAME_AW(PR_STATUS_STRING_) +#define PR_X400_DEFERRED_DELIVERY_CANCEL PROP_TAG(PT_BOOLEAN,0x3E09) +#define PR_HEADER_FOLDER_ENTRYID PROP_TAG(PT_BINARY,0x3E0A) +#define PR_REMOTE_PROGRESS PROP_TAG(PT_I4,0x3E0B) +#define PR_REMOTE_PROGRESS_TEXT_W PROP_TAG(PT_UNICODE,0x3E0C) +#define PR_REMOTE_PROGRESS_TEXT_A PROP_TAG(PT_STRING8,0x3E0C) +#define PR_REMOTE_PROGRESS_TEXT WINELIB_NAME_AW(PR_REMOTE_PROGRESS_TEXT_) +#define PR_REMOTE_VALIDATE_OK PROP_TAG(PT_BOOLEAN,0x3E0D) +#define PR_CONTROL_FLAGS PROP_TAG(PT_I4,0x3F00) +#define PR_CONTROL_STRUCTURE PROP_TAG(PT_BINARY,0x3F01) +#define PR_CONTROL_TYPE PROP_TAG(PT_I4,0x3F02) +#define PR_DELTAX PROP_TAG(PT_I4,0x3F03) +#define PR_DELTAY PROP_TAG(PT_I4,0x3F04) +#define PR_XPOS PROP_TAG(PT_I4,0x3F05) +#define PR_YPOS PROP_TAG(PT_I4,0x3F06) +#define PR_CONTROL_ID PROP_TAG(PT_BINARY,0x3F07) +#define PR_INITIAL_DETAILS_PANE PROP_TAG(PT_I4,0x3F08) + +#define PROP_ID_SECURE_MIN 0x67F0 +#define PROP_ID_SECURE_MAX 0x67FF + +#endif /* MAPITAGS_H */ diff --git a/include/mapiutil.h b/include/mapiutil.h new file mode 100644 index 00000000000..836cb1aea94 --- /dev/null +++ b/include/mapiutil.h @@ -0,0 +1,216 @@ +/* + * Copyright 2004 Jon Griffiths + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef MAPIUTIL_H_ +#define MAPIUTIL_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define TAD_ALL_ROWS 1 /* Delete all rows */ + +LPMALLOC WINAPI MAPIGetDefaultMalloc(void); + +#define SOF_UNIQUEFILENAME 0x80000000U /* Create a unique (temporary) filename */ + +#if defined (UNICODE) || defined (__WINESRC__) +typedef HRESULT (WINAPI * LPOPENSTREAMONFILE)(LPALLOCATEBUFFER,LPFREEBUFFER, + ULONG,LPWSTR,LPWSTR,LPSTREAM*); +HRESULT WINAPI OpenStreamOnFile(LPALLOCATEBUFFER,LPFREEBUFFER, + ULONG,LPWSTR,LPWSTR,LPSTREAM*); +#else +typedef HRESULT (WINAPI * LPOPENSTREAMONFILE)(LPALLOCATEBUFFER,LPFREEBUFFER, + ULONG,LPSTR,LPSTR,LPSTREAM*); +HRESULT WINAPI OpenStreamOnFile(LPALLOCATEBUFFER,LPFREEBUFFER, + ULONG,LPSTR,LPSTR,LPSTREAM*); +#endif +#define OPENSTREAMONFILE "OpenStreamOnFile" + +BOOL WINAPI FEqualNames(LPMAPINAMEID,LPMAPINAMEID); + +typedef struct IPropData IPropData; +typedef IPropData *LPPROPDATA; + +#define IPROP_READONLY 0x00001U +#define IPROP_READWRITE 0x00002U +#define IPROP_CLEAN 0x10000U +#define IPROP_DIRTY 0x20000U + +SCODE WINAPI CreateIProp(LPCIID,ALLOCATEBUFFER*,ALLOCATEMORE*,FREEBUFFER*, + LPVOID,LPPROPDATA*); +SCODE WINAPI PropCopyMore(LPSPropValue,LPSPropValue,ALLOCATEMORE*,LPVOID); +ULONG WINAPI UlPropSize(LPSPropValue); +VOID WINAPI GetInstance(LPSPropValue,LPSPropValue,ULONG); +BOOL WINAPI FPropContainsProp(LPSPropValue,LPSPropValue,ULONG); +BOOL WINAPI FPropCompareProp(LPSPropValue,ULONG,LPSPropValue); +LONG WINAPI LPropCompareProp(LPSPropValue,LPSPropValue); + +HRESULT WINAPI HrAddColumns(LPMAPITABLE,LPSPropTagArray,LPALLOCATEBUFFER,LPFREEBUFFER); +HRESULT WINAPI HrAddColumnsEx(LPMAPITABLE,LPSPropTagArray,LPALLOCATEBUFFER, + LPFREEBUFFER,void (*)(LPSPropTagArray)); +HRESULT WINAPI HrAllocAdviseSink(LPNOTIFCALLBACK,LPVOID,LPMAPIADVISESINK*); +HRESULT WINAPI HrThisThreadAdviseSink(LPMAPIADVISESINK,LPMAPIADVISESINK*); +HRESULT WINAPI HrDispatchNotifications (ULONG); + +ULONG WINAPI UlAddRef(void*); +ULONG WINAPI UlRelease(void*); + +HRESULT WINAPI HrGetOneProp(LPMAPIPROP,ULONG,LPSPropValue*); +HRESULT WINAPI HrSetOneProp(LPMAPIPROP,LPSPropValue); +BOOL WINAPI FPropExists(LPMAPIPROP,ULONG); +void WINAPI FreePadrlist(LPADRLIST); +void WINAPI FreeProws(LPSRowSet); +HRESULT WINAPI HrQueryAllRows(LPMAPITABLE,LPSPropTagArray,LPSRestriction, + LPSSortOrderSet,LONG,LPSRowSet*); +LPSPropValue WINAPI PpropFindProp(LPSPropValue,ULONG,ULONG); + +#if defined (UNICODE) || defined (__WINESRC__) +BOOL WINAPI FBinFromHex(LPWSTR,LPBYTE); +SCODE WINAPI ScBinFromHexBounded(LPWSTR,LPBYTE,ULONG); +void WINAPI HexFromBin(LPBYTE,int,LPWSTR); +ULONG WINAPI UlFromSzHex(LPCWSTR); +LPWSTR WINAPI SzFindCh(LPCWSTR,USHORT); +LPWSTR WINAPI SzFindLastCh(LPCWSTR,USHORT); +LPWSTR WINAPI SzFindSz(LPCWSTR,LPCWSTR); +UINT WINAPI UFromSz(LPCSTR); +#else +BOOL WINAPI FBinFromHex(LPSTR,LPBYTE); +SCODE WINAPI ScBinFromHexBounded(LPSTR,LPBYTE,ULONG); +void WINAPI HexFromBin(LPBYTE,int,LPSTR); +ULONG WINAPI UlFromSzHex(LPCSTR); +LPSTR WINAPI SzFindCh(LPCSTR,USHORT); +LPSTR WINAPI SzFindLastCh(LPCSTR,USHORT); +LPSTR WINAPI SzFindSz(LPCSTR,LPCSTR); +UINT WINAPI UFromSz(LPCSTR); +#endif + +SCODE WINAPI ScInitMapiUtil(ULONG); +void WINAPI DeinitMapiUtil(void); + +#define szHrDispatchNotifications "_HrDispatchNotifications@4" +#define szScCreateConversationIndex "_ScCreateConversationIndex@16" + +typedef HRESULT (WINAPI DISPATCHNOTIFICATIONS)(ULONG); +typedef DISPATCHNOTIFICATIONS *LPDISPATCHNOTIFICATIONS; +typedef SCODE (WINAPI CREATECONVERSATIONINDEX)(ULONG,LPBYTE,ULONG*,LPBYTE*); +typedef CREATECONVERSATIONINDEX *LPCREATECONVERSATIONINDEX; + +typedef struct ITableData ITableData; +typedef ITableData *LPTABLEDATA; + +typedef void (WINAPI CALLERRELEASE)(ULONG,LPTABLEDATA,LPMAPITABLE); + +/***************************************************************************** + * ITableData interface + * + * The underlying table data structure for IMAPITable. + */ +#define INTERFACE ITableData +#define ITableData_METHODS \ + IUnknown_METHODS \ + STDMETHOD(HrGetView)(THIS_ LPSSortOrderSet lpSort, CALLERRELEASE *lpRel, \ + ULONG ulData, LPMAPITABLE *lppTable) PURE; \ + STDMETHOD(HrModifyRow)(THIS_ LPSRow lpRow) PURE; \ + STDMETHOD(HrDeleteRow)(THIS_ LPSPropValue lpKey) PURE; \ + STDMETHOD(HrQueryRow)(THIS_ LPSPropValue lpKey, LPSRow *lppRow, ULONG *lpRowNum) PURE; \ + STDMETHOD(HrEnumRow)(THIS_ ULONG ulRowNum, LPSRow *lppRow) PURE; \ + STDMETHOD(HrNotify)(THIS_ ULONG ulFlags, ULONG cValues, LPSPropValue lpValues) PURE; \ + STDMETHOD(HrInsertRow)(THIS_ ULONG ulRow, LPSRow lpRow) PURE; \ + STDMETHOD(HrModifyRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows) PURE; \ + STDMETHOD(HrDeleteRows)(THIS_ ULONG ulFlags, LPSRowSet lpRows, ULONG *lpCount) PURE; +ICOM_DEFINE(ITableData,IUnknown) +#undef INTERFACE + +#ifdef COBJMACROS + /*** IUnknown methods ***/ +#define ITableData_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ITableData_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ITableData_Release(p) (p)->lpVtbl->Release(p) + /*** ITableData methods ***/ +#define ITableData_HrGetView(p,a,b,c,d) (p)->lpVtbl->HrGetView(p,a,b,c,d) +#define ITableData_HrModifyRow(p,a) (p)->lpVtbl->HrModifyRow(p,a) +#define ITableData_HrDeleteRow(p,a) (p)->lpVtbl->HrDeleteRow(p,a) +#define ITableData_HrQueryRow(p,a,b,c) (p)->lpVtbl->HrQueryRow(p,a,b,c) +#define ITableData_HrEnumRow(p,a,b) (p)->lpVtbl->HrEnumRow(p,a,b) +#define ITableData_HrNotify(p,a,b,c) (p)->lpVtbl->HrNotify(p,a,b,c) +#define ITableData_HrInsertRow(p,a,b) (p)->lpVtbl->HrInsertRow(p,a,b) +#define ITableData_HrModifyRows(p,a,b) (p)->lpVtbl->HrModifyRows(p,a,b) +#define ITableData_HrDeleteRows(p,a,b,c) (p)->lpVtbl->HrDeleteRows(p,a,b,c) +#endif + +SCODE WINAPI CreateTable(LPCIID,ALLOCATEBUFFER*,ALLOCATEMORE*,FREEBUFFER*, + LPVOID,ULONG,ULONG,LPSPropTagArray,LPTABLEDATA*); + +SCODE WINAPI ScCountNotifications(int,LPNOTIFICATION,ULONG*); +SCODE WINAPI ScCountProps(int,LPSPropValue,ULONG*); +SCODE WINAPI ScCopyNotifications(int,LPNOTIFICATION,LPVOID,ULONG*); +SCODE WINAPI ScCopyProps(int,LPSPropValue,LPVOID,ULONG*); +SCODE WINAPI ScDupPropset(int,LPSPropValue,LPALLOCATEBUFFER,LPSPropValue*); +SCODE WINAPI ScRelocNotifications(int,LPNOTIFICATION,LPVOID,LPVOID,ULONG*); +SCODE WINAPI ScRelocProps(int,LPSPropValue,LPVOID,LPVOID,ULONG*); + +LPSPropValue WINAPI LpValFindProp(ULONG,ULONG,LPSPropValue); + +static inline FILETIME FtAddFt(FILETIME ftLeft, FILETIME ftRight) +{ + LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight; + union { FILETIME ft; LONG64 ll; } ftmap; + ftmap.ll = *pl + *pr; + return ftmap.ft; +} + +static inline FILETIME FtSubFt(FILETIME ftLeft, FILETIME ftRight) +{ + LONG64 *pl = (LONG64*)&ftLeft, *pr = (LONG64*)&ftRight; + union { FILETIME ft; LONG64 ll; } ftmap; + ftmap.ll = *pl - *pr; + return ftmap.ft; +} + +static inline FILETIME FtNegFt(FILETIME ftLeft) +{ + LONG64 *p = (LONG64*)&ftLeft; + union { FILETIME ft; LONG64 ll; } ftmap; + ftmap.ll = -*p; + return ftmap.ft; +} + +static inline FILETIME FtMulDw(DWORD dwLeft, FILETIME ftRight) +{ + LONG64 l = (LONG64)dwLeft, *pr = (LONG64*)&ftRight; + union { FILETIME ft; LONG64 ll; } ftmap; + ftmap.ll = l * (*pr); + return ftmap.ft; +} + +static inline FILETIME FtMulDwDw(DWORD dwLeft, DWORD dwRight) +{ + LONG64 l = (LONG64)dwLeft, r = (LONG64)dwRight; + union { FILETIME ft; LONG64 ll; } ftmap; + ftmap.ll = l * r; + return ftmap.ft; +} + +#ifdef __cplusplus +} +#endif + +#endif /* MAPIUTIL_H_ */ diff --git a/include/mapival.h b/include/mapival.h new file mode 100644 index 00000000000..465f9e4a7a8 --- /dev/null +++ b/include/mapival.h @@ -0,0 +1,119 @@ +/* + * Copyright 2004 Jon Griffiths + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef MAPIVAL_H +#define MAPIVAL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +BOOL WINAPI FBadRglpszW(LPWSTR*,ULONG); +BOOL WINAPI FBadRowSet(LPSRowSet); +BOOL WINAPI FBadRglpNameID(LPMAPINAMEID*,ULONG); +BOOL WINAPI FBadEntryList(LPENTRYLIST); +ULONG WINAPI FBadRestriction(LPSRestriction); +ULONG WINAPI FBadPropTag(ULONG); +ULONG WINAPI FBadRow(LPSRow); +ULONG WINAPI FBadProp(LPSPropValue); +ULONG WINAPI FBadSortOrderSet(LPSSortOrderSet); +ULONG WINAPI FBadColumnSet(LPSPropTagArray); + +#define FBadRgPropVal(p,n) FAILED(ScCountProps((n),(p),NULL)) +#define FBadPropVal(p) FBadRgPropVal(1,(p)) +#define FBadAdrList(p) FBadRowSet((LPSRowSet)(p)) + +#define BAD_STANDARD_OBJ(a,b,c,d) FALSE +#define FBadUnknown(a) FALSE +#define FBadQueryInterface(a,b,c) FALSE +#define FBadAddRef(a) FALSE +#define FBadRelease(a) FALSE +#define FBadGetLastError(a,b,c,d) FALSE +#define FBadSaveChanges(a,b) FALSE +#define FBadGetProps(a,b,c,d) FALSE +#define FBadGetPropList(a,b) FALSE +#define FBadOpenProperty(a,b,c,d,e,f) FALSE +#define FBadSetProps(a,b,c,d) FALSE +#define FBadDeleteProps(a,b,c) FALSE +#define FBadCopyTo(a,b,c,d,e,f,g,h,i,j) FALSE +#define FBadCopyProps(a,b,c,d,e,f,g,h) FALSE +#define FBadGetNamesFromIDs(a,b,c,d,e,f) FALSE +#define FBadGetIDsFromNames(a,b,c,d,e) FALSE + +#define ValidateParms(x) do { } while(0) +#define UlValidateParms(x) do { } while(0) +#define CheckParms(x) do { } while(0) + +#define ValidateParameters1(a,b) do { } while(0) +#define ValidateParameters2(a,b,c) do { } while(0) +#define ValidateParameters3(a,b,c,d) do { } while(0) +#define ValidateParameters4(a,b,c,d,e) do { } while(0) +#define ValidateParameters5(a,b,c,d,e,f) do { } while(0) +#define ValidateParameters6(a,b,c,d,e,f,g) do { } while(0) +#define ValidateParameters7(a,b,c,d,e,f,g,h) do { } while(0) +#define ValidateParameters8(a,b,c,d,e,f,g,h,i) do { } while(0) +#define ValidateParameters9(a,b,c,d,e,f,g,h,i,j) do { } while(0) +#define ValidateParameters10(a,b,c,d,e,f,g,h,i,j,k) do { } while(0) +#define ValidateParameters11(a,b,c,d,e,f,g,h,i,j,k,l) do { } while(0) +#define ValidateParameters12(a,b,c,d,e,f,g,h,i,j,k,l,m) do { } while(0) +#define ValidateParameters13(a,b,c,d,e,f,g,h,i,j,k,l,m,n) do { } while(0) +#define ValidateParameters14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) do { } while(0) +#define ValidateParameters15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) do { } while(0) +#define ValidateParameters16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) do { } while(0) + +#define UlValidateParameters1(a,b) do { } while(0) +#define UlValidateParameters2(a,b,c) do { } while(0) +#define UlValidateParameters3(a,b,c,d) do { } while(0) +#define UlValidateParameters4(a,b,c,d,e) do { } while(0) +#define UlValidateParameters5(a,b,c,d,e,f) do { } while(0) +#define UlValidateParameters6(a,b,c,d,e,f,g) do { } while(0) +#define UlValidateParameters7(a,b,c,d,e,f,g,h) do { } while(0) +#define UlValidateParameters8(a,b,c,d,e,f,g,h,i) do { } while(0) +#define UlValidateParameters9(a,b,c,d,e,f,g,h,i,j) do { } while(0) +#define UlValidateParameters10(a,b,c,d,e,f,g,h,i,j,k) do { } while(0) +#define UlValidateParameters11(a,b,c,d,e,f,g,h,i,j,k,l) do { } while(0) +#define UlValidateParameters12(a,b,c,d,e,f,g,h,i,j,k,l,m) do { } while(0) +#define UlValidateParameters13(a,b,c,d,e,f,g,h,i,j,k,l,m,n) do { } while(0) +#define UlValidateParameters14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) do { } while(0) +#define UlValidateParameters15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) do { } while(0) +#define UlValidateParameters16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) do { } while(0) + +#define CheckParameters1(a,b) do { } while(0) +#define CheckParameters2(a,b,c) do { } while(0) +#define CheckParameters3(a,b,c,d) do { } while(0) +#define CheckParameters4(a,b,c,d,e) do { } while(0) +#define CheckParameters5(a,b,c,d,e,f) do { } while(0) +#define CheckParameters6(a,b,c,d,e,f,g) do { } while(0) +#define CheckParameters7(a,b,c,d,e,f,g,h) do { } while(0) +#define CheckParameters8(a,b,c,d,e,f,g,h,i) do { } while(0) +#define CheckParameters9(a,b,c,d,e,f,g,h,i,j) do { } while(0) +#define CheckParameters10(a,b,c,d,e,f,g,h,i,j,k) do { } while(0) +#define CheckParameters11(a,b,c,d,e,f,g,h,i,j,k,l) do { } while(0) +#define CheckParameters12(a,b,c,d,e,f,g,h,i,j,k,l,m) do { } while(0) +#define CheckParameters13(a,b,c,d,e,f,g,h,i,j,k,l,m,n) do { } while(0) +#define CheckParameters14(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) do { } while(0) +#define CheckParameters15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) do { } while(0) +#define CheckParameters16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) do { } while(0) + +#ifdef __cplusplus +} +#endif + +#endif /* MAPIVAL_H */ diff --git a/include/mapix.h b/include/mapix.h new file mode 100644 index 00000000000..4d086934084 --- /dev/null +++ b/include/mapix.h @@ -0,0 +1,171 @@ +/* + * Copyright 2004 Jon Griffiths + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef MAPIX_H +#define MAPIX_H + +#ifndef MAPIDEFS_H +#include +#endif +#ifndef MAPICODE_H +#include +#endif +#ifndef MAPIGUID_H +#include +#endif +#ifndef MAPITAGS_H +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct IProfAdmin IProfAdmin; +typedef IProfAdmin *LPPROFADMIN; +typedef struct IMsgServiceAdmin IMsgServiceAdmin; +typedef IMsgServiceAdmin *LPSERVICEADMIN; +typedef struct IMAPISession IMAPISession; +typedef IMAPISession *LPMAPISESSION; + +typedef unsigned long FLAGS; + +/* Flags for MAPILogon and MAPILogonEx */ +#define MAPI_LOGON_UI 0x000001 +#define MAPI_NEW_SESSION 0x000002 +#define MAPI_EXTENDED 0x000020 +#define MAPI_FORCE_DOWNLOAD 0x001000 +#define MAPI_PASSWORD_UI 0x020000 +#define MAPI_ALLOW_OTHERS 0x000008 +#define MAPI_EXPLICIT_PROFILE 0x000010 +#define MAPI_SERVICE_UI_ALWAYS 0x002000 +#define MAPI_NO_MAIL 0x008000 +#define MAPI_NT_SERVICE 0x010000 +#define MAPI_TIMEOUT_SHORT 0x100000 + +#define MAPI_SIMPLE_DEFAULT (MAPI_LOGON_UI|MAPI_ALLOW_OTHERS|MAPI_FORCE_DOWNLOAD) +#define MAPI_SIMPLE_EXPLICIT (MAPI_NEW_SESSION|MAPI_EXPLICIT_PROFILE|MAPI_FORCE_DOWNLOAD) + +typedef struct tagMAPIINIT_0 +{ + ULONG ulVersion; + ULONG ulFlags; +} MAPIINIT_0, *LPMAPIINIT_0; + +typedef MAPIINIT_0 MAPIINIT, *LPMAPIINIT; + +#define MAPI_INIT_VERSION 0U + +typedef HRESULT (WINAPI MAPIINITIALIZE)(void*); +typedef MAPIINITIALIZE *LPMAPIINITIALIZE; +MAPIINITIALIZE MAPIInitialize; + +typedef void (WINAPI MAPIUNINITIALIZE)(void); +typedef MAPIUNINITIALIZE *LPMAPIUNINITIALIZE; +MAPIUNINITIALIZE MAPIUninitialize; + +#if defined (UNICODE) || defined (__WINESRC__) +typedef HRESULT (STDMETHODCALLTYPE MAPILOGONEX)(ULONG_PTR,LPWSTR,LPWSTR,ULONG,LPMAPISESSION*); +#else +typedef HRESULT (STDMETHODCALLTYPE MAPILOGONEX)(ULONG_PTR,LPSTR,LPSTR,ULONG,LPMAPISESSION *); +#endif +typedef MAPILOGONEX *LPMAPILOGONEX; +MAPILOGONEX MAPILogonEx; + +typedef SCODE (WINAPI MAPIALLOCATEBUFFER)(ULONG,LPVOID*); +typedef MAPIALLOCATEBUFFER *LPMAPIALLOCATEBUFFER; +MAPIALLOCATEBUFFER MAPIAllocateBuffer; + +typedef SCODE (WINAPI MAPIALLOCATEMORE)(ULONG,LPVOID,LPVOID*); +typedef MAPIALLOCATEMORE *LPMAPIALLOCATEMORE; +MAPIALLOCATEMORE MAPIAllocateMore; + +typedef ULONG (WINAPI MAPIFREEBUFFER)(LPVOID); +typedef MAPIFREEBUFFER *LPMAPIFREEBUFFER; +MAPIFREEBUFFER MAPIFreeBuffer; + +/***************************************************************************** + * IMAPISession interface + */ +#define INTERFACE IMAPISession +#define IMAPISession_METHODS \ + IUnknown_METHODS \ + STDMETHOD(GetLastError)(THIS_ HRESULT hResult, ULONG ulFlags, LPMAPIERROR *lppMAPIError) PURE; \ + STDMETHOD(GetMsgStoresTable)(THIS_ ULONG ulFlags, LPMAPITABLE *lppTable) PURE; \ + STDMETHOD(OpenMsgStore)(THIS_ ULONG_PTR ulUIParam, ULONG cbId, \ + LPENTRYID lpId, LPCIID lpIFace, ULONG ulFlags, LPMDB *lppMDB) PURE; \ + STDMETHOD(OpenAddressBook)(THIS_ ULONG_PTR ulUIParam, LPCIID iid, ULONG ulFlags, LPADRBOOK *lppAdrBook) PURE; \ + STDMETHOD(OpenProfileSection)(THIS_ LPMAPIUID lpUID, LPCIID iid, ULONG ulFlags, LPPROFSECT *lppProf) PURE; \ + STDMETHOD(GetStatusTable)(THIS_ ULONG ulFlags, LPMAPITABLE *lppTable) PURE; \ + STDMETHOD(OpenEntry)(THIS_ ULONG cbId, LPENTRYID lpId, LPCIID iid, \ + ULONG ulFlags, ULONG *lpType, LPUNKNOWN *lppUnk) PURE; \ + STDMETHOD(CompareEntryIDs)(THIS_ ULONG cbLID, LPENTRYID lpLID, ULONG cbRID, \ + LPENTRYID lpRID, ULONG ulFlags, ULONG *lpRes) PURE; \ + STDMETHOD(Advise)(THIS_ ULONG cbId, LPENTRYID lpId, ULONG ulMask, \ + LPMAPIADVISESINK lpSink, ULONG *lpCxn) PURE;\ + STDMETHOD(Unadvise)(THIS_ ULONG ulConnection) PURE;\ + STDMETHOD(MessageOptions)(THIS_ ULONG_PTR ulUIParam, ULONG ulFlags, LPSTR lpszAddr, LPMESSAGE lpMsg) PURE; \ + STDMETHOD(QueryDefaultMessageOpt)(THIS_ LPSTR lpszAddr, ULONG ulFlags, \ + ULONG *lpcVals, LPSPropValue *lppOpts) PURE; \ + STDMETHOD(EnumAdrTypes)(THIS_ ULONG ulFlags, ULONG *lpcTypes, LPSTR **lpppszTypes) PURE; \ + STDMETHOD(QueryIdentity)(THIS_ ULONG *lpcbId, LPENTRYID *lppEntryID) PURE; \ + STDMETHOD(Logoff)(THIS_ ULONG_PTR ulUIParam, ULONG ulFlags, ULONG ulReserved) PURE; \ + STDMETHOD(SetDefaultStore)(THIS_ ULONG ulFlags, ULONG cbId, LPENTRYID lpId) PURE; \ + STDMETHOD(AdminServices)(THIS_ ULONG ulFlags, LPSERVICEADMIN *lppAdmin) PURE; \ + STDMETHOD(ShowForm)(THIS_ ULONG_PTR ulUIParam, LPMDB lpStore, \ + LPMAPIFOLDER lpParent, LPCIID iid, ULONG ulToken, \ + LPMESSAGE lpSent, ULONG ulFlags, ULONG ulStatus, \ + ULONG ulMsgFlags, ULONG ulAccess, LPSTR lpszClass) PURE; \ + STDMETHOD(PrepareForm)(THIS_ LPCIID lpIFace, LPMESSAGE lpMsg, ULONG *lpToken) PURE; +ICOM_DEFINE(IMAPISession,IUnknown) +#undef INTERFACE + +#ifdef COBJMACROS + /*** IUnknown methods ***/ +#define IMAPISession_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMAPISession_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMAPISession_Release(p) (p)->lpVtbl->Release(p) + /*** IMAPISession methods ***/ +#define IMAPISession_GetLastError(p,a,b,c) (p)->lpVtbl->GetLastError(p,a,b,c) +#define IMAPISession_GetMsgStoresTable(p,a,b) (p)->lpVtbl->GetMsgStoresTable(p,a,b) +#define IMAPISession_OpenMsgStore(p,a,b,c,d,e,f) (p)->lpVtbl->OpenMsgStore(p,a,b,c,d,e,f) +#define IMAPISession_OpenAddressBook(p,a,b,c,d) (p)->lpVtbl->OpenAddressBook(p,a,b,c,d) +#define IMAPISession_OpenProfileSection(p,a,b,c,d) (p)->lpVtbl->OpenProfileSection(p,a,b,c,d) +#define IMAPISession_GetStatusTable(p,a,b) (p)->lpVtbl->GetStatusTable(p,a,b) +#define IMAPISession_OpenEntry(p,a,b,c,d,e,f) (p)->lpVtbl->OpenEntry(p,a,b,c,d,e,f) +#define IMAPISession_CompareEntryIDs(p,a,b,c,d,e,f) (p)->lpVtbl->CompareEntryIDs(p,a,b,c,d,e,f) +#define IMAPISession_Advise(p,a,b,c,d,e) (p)->lpVtbl->Advise(p,a,b,c,d,e) +#define IMAPISession_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#define IMAPISession_MessageOptions(p,a,b,c,d) (p)->lpVtbl->MessageOptions)(p,a,b,c,d) +#define IMAPISession_QueryDefaultMessageOpt(p,a,b,c,d) \ + (p)->lpVtbl->QueryDefaultMessageOpt(p,a,b,c,d) +#define IMAPISession_EnumAdrTypes(p,a,b,c) (p)->lpVtbl->EnumAdrTypes(p,a,b,c) +#define IMAPISession_QueryIdentity(p,a,b) (p)->lpVtbl->QueryIdentity(p,a,b) +#define IMAPISession_Logoff(p,a,b,c) (p)->lpVtbl->Logoff(p,a,b,c) +#define IMAPISession_SetDefaultStore(p,a,b,c) (p)->lpVtbl->SetDefaultStore(p,a,b,c) +#define IMAPISession_AdminServices(p,a,b) (p)->lpVtbl->AdminServices(p,a,b) +#define IMAPISession_ShowForm(p,a,b,c,d,e,f,g,h,i,j,k) \ + (p)->lpVtbl->ShowForm(p,a,b,c,d,e,f,g,h,i,j,k) +#define IMAPISession_PrepareForm(p,a,b,c) (p)->lpVtbl->PrepareForm(p,a,b,c) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* MAPIX_H */