home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / mapix.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  27.9 KB  |  544 lines
  1. /*
  2.  *  M A P I X . H
  3.  *  
  4.  *  Definitions of objects/flags, etc used by Extended MAPI.
  5.  *  
  6.  *  Copyright 1986-1996 Microsoft Corporation. All Rights Reserved.
  7.  */
  8.  
  9. #ifndef MAPIX_H
  10. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  11. #define MAPIX_H
  12.  
  13. /* Include common MAPI header files if they haven't been already. */
  14. #ifndef MAPIDEFS_H
  15. #include <mapidefs.h>
  16. #endif
  17. #ifndef MAPICODE_H
  18. #include <mapicode.h>
  19. #endif
  20. #ifndef MAPIGUID_H
  21. #include <mapiguid.h>
  22. #endif
  23. #ifndef MAPITAGS_H
  24. #include <mapitags.h>
  25. #endif
  26.  
  27. #ifdef  __cplusplus
  28. extern "C" {
  29. #endif  
  30.  
  31. #ifndef BEGIN_INTERFACE
  32. #define BEGIN_INTERFACE
  33. #endif
  34.  
  35. /* Forward interface declarations */
  36.  
  37. DECLARE_MAPI_INTERFACE_PTR(IProfAdmin,          LPPROFADMIN);
  38. DECLARE_MAPI_INTERFACE_PTR(IMsgServiceAdmin,    LPSERVICEADMIN);
  39. DECLARE_MAPI_INTERFACE_PTR(IMAPISession,        LPMAPISESSION);
  40.  
  41. /* ------------------------------------------------------ */
  42. /* shared with simple mapi */
  43.  
  44. typedef ULONG       FLAGS;
  45.  
  46. /* MAPILogon() flags.       */
  47.  
  48. #define MAPI_LOGON_UI           0x00000001  /* Display logon UI                 */
  49. #define MAPI_NEW_SESSION        0x00000002  /* Don't use shared session         */
  50. #define MAPI_ALLOW_OTHERS       0x00000008  /* Make this a shared session       */
  51. #define MAPI_EXPLICIT_PROFILE   0x00000010  /* Don't use default profile        */
  52. #define MAPI_EXTENDED           0x00000020  /* Extended MAPI Logon              */
  53. #define MAPI_FORCE_DOWNLOAD     0x00001000  /* Get new mail before return       */
  54. #define MAPI_SERVICE_UI_ALWAYS  0x00002000  /* Do logon UI in all providers     */
  55. #define MAPI_NO_MAIL            0x00008000  /* Do not activate transports       */
  56. /* #define MAPI_NT_SERVICE          0x00010000  Allow logon from an NT service  */
  57. #ifndef MAPI_PASSWORD_UI
  58. #define MAPI_PASSWORD_UI        0x00020000  /* Display password UI only         */
  59. #endif
  60. #define MAPI_TIMEOUT_SHORT      0x00100000  /* Minimal wait for logon resources */
  61.  
  62. #define MAPI_SIMPLE_DEFAULT (MAPI_LOGON_UI | MAPI_FORCE_DOWNLOAD | MAPI_ALLOW_OTHERS)
  63. #define MAPI_SIMPLE_EXPLICIT (MAPI_NEW_SESSION | MAPI_FORCE_DOWNLOAD | MAPI_EXPLICIT_PROFILE)
  64.  
  65. /* Structure passed to MAPIInitialize(), and its ulFlags values */
  66.  
  67. typedef struct
  68. {
  69.     ULONG           ulVersion;
  70.     ULONG           ulFlags;
  71. } MAPIINIT_0, FAR *LPMAPIINIT_0;
  72.  
  73. typedef MAPIINIT_0 MAPIINIT;
  74. typedef MAPIINIT FAR *LPMAPIINIT;
  75.  
  76. #define MAPI_INIT_VERSION               0
  77.  
  78. #define MAPI_MULTITHREAD_NOTIFICATIONS  0x00000001
  79. /* Reserved for MAPI                    0x40000000 */
  80. /* #define MAPI_NT_SERVICE              0x00010000  Use from NT service */
  81.  
  82. /* MAPI base functions */
  83.  
  84. typedef HRESULT (STDAPICALLTYPE MAPIINITIALIZE)(
  85.     LPVOID          lpMapiInit
  86. );
  87. typedef MAPIINITIALIZE FAR *LPMAPIINITIALIZE;
  88.  
  89. typedef void (STDAPICALLTYPE MAPIUNINITIALIZE)(void);
  90. typedef MAPIUNINITIALIZE FAR *LPMAPIUNINITIALIZE;
  91.  
  92. MAPIINITIALIZE      MAPIInitialize;
  93. MAPIUNINITIALIZE    MAPIUninitialize;
  94.  
  95.  
  96. /*  Extended MAPI Logon function */
  97.  
  98.  
  99. typedef HRESULT (STDMETHODCALLTYPE MAPILOGONEX)(
  100.     ULONG ulUIParam,
  101.     LPTSTR lpszProfileName,
  102.     LPTSTR lpszPassword,
  103.     ULONG ulFlags,   /*  ulFlags takes all that SimpleMAPI does + MAPI_UNICODE */
  104.     LPMAPISESSION FAR * lppSession
  105. );
  106. typedef MAPILOGONEX FAR *LPMAPILOGONEX;
  107.  
  108. MAPILOGONEX MAPILogonEx;
  109.  
  110.  
  111. typedef SCODE (STDMETHODCALLTYPE MAPIALLOCATEBUFFER)(
  112.     ULONG           cbSize,
  113.     LPVOID FAR *    lppBuffer
  114. );
  115.  
  116. typedef SCODE (STDMETHODCALLTYPE MAPIALLOCATEMORE)(
  117.     ULONG           cbSize,
  118.     LPVOID          lpObject,
  119.     LPVOID FAR *    lppBuffer
  120. );
  121.  
  122. typedef ULONG (STDAPICALLTYPE MAPIFREEBUFFER)(
  123.     LPVOID          lpBuffer
  124. );
  125.  
  126. typedef MAPIALLOCATEBUFFER FAR  *LPMAPIALLOCATEBUFFER;
  127. typedef MAPIALLOCATEMORE FAR    *LPMAPIALLOCATEMORE;
  128. typedef MAPIFREEBUFFER FAR      *LPMAPIFREEBUFFER;
  129.  
  130. MAPIALLOCATEBUFFER MAPIAllocateBuffer;
  131. MAPIALLOCATEMORE MAPIAllocateMore;
  132. MAPIFREEBUFFER MAPIFreeBuffer;
  133.  
  134. typedef HRESULT (STDMETHODCALLTYPE MAPIADMINPROFILES)(
  135.     ULONG ulFlags,
  136.     LPPROFADMIN FAR *lppProfAdmin
  137. );
  138.  
  139. typedef MAPIADMINPROFILES FAR *LPMAPIADMINPROFILES;
  140.  
  141. MAPIADMINPROFILES MAPIAdminProfiles;
  142.  
  143. /* IMAPISession Interface -------------------------------------------------- */
  144.  
  145. /* Flags for OpenEntry and others */
  146.  
  147. /*#define MAPI_MODIFY               ((ULONG) 0x00000001) */
  148.  
  149. /* Flags for Logoff */
  150.  
  151. #define MAPI_LOGOFF_SHARED      0x00000001  /* Close all shared sessions    */
  152. #define MAPI_LOGOFF_UI          0x00000002  /* It's OK to present UI        */
  153.  
  154. /* Flags for SetDefaultStore. They are mutually exclusive. */
  155.  
  156. #define MAPI_DEFAULT_STORE          0x00000001  /* for incoming messages */
  157. #define MAPI_SIMPLE_STORE_TEMPORARY 0x00000002  /* for simple MAPI and CMC */
  158. #define MAPI_SIMPLE_STORE_PERMANENT 0x00000003  /* for simple MAPI and CMC */
  159. #define MAPI_PRIMARY_STORE          0x00000004  /* Used by some clients */
  160. #define MAPI_SECONDARY_STORE        0x00000005  /* Used by some clients */
  161.  
  162. /* Flags for ShowForm. */
  163.  
  164. #define MAPI_POST_MESSAGE       0x00000001  /* Selects post/send semantics */
  165. #define MAPI_NEW_MESSAGE        0x00000002  /* Governs copying during submission */
  166.  
  167. /*  MessageOptions */
  168. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  169.  
  170. /*  QueryDefaultMessageOpt */
  171. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  172.  
  173. #define MAPI_IMAPISESSION_METHODS(IPURE)                                \
  174.     MAPIMETHOD(GetLastError)                                            \
  175.         (THIS_  HRESULT                     hResult,                    \
  176.                 ULONG                       ulFlags,                    \
  177.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  178.     MAPIMETHOD(GetMsgStoresTable)                                       \
  179.         (THIS_  ULONG                       ulFlags,                    \
  180.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  181.     MAPIMETHOD(OpenMsgStore)                                            \
  182.         (THIS_  ULONG                       ulUIParam,                  \
  183.                 ULONG                       cbEntryID,                  \
  184.                 LPENTRYID                   lpEntryID,                  \
  185.                 LPCIID                      lpInterface,                \
  186.                 ULONG                       ulFlags,                    \
  187.                 LPMDB FAR *                 lppMDB) IPURE;              \
  188.     MAPIMETHOD(OpenAddressBook)                                         \
  189.         (THIS_  ULONG                       ulUIParam,                  \
  190.                 LPCIID                      lpInterface,                \
  191.                 ULONG                       ulFlags,                    \
  192.                 LPADRBOOK FAR *             lppAdrBook) IPURE;          \
  193.     MAPIMETHOD(OpenProfileSection)                                      \
  194.         (THIS_  LPMAPIUID                   lpUID,                      \
  195.                 LPCIID                      lpInterface,                \
  196.                 ULONG                       ulFlags,                    \
  197.                 LPPROFSECT FAR *            lppProfSect) IPURE;         \
  198.     MAPIMETHOD(GetStatusTable)                                          \
  199.         (THIS_  ULONG                       ulFlags,                    \
  200.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  201.     MAPIMETHOD(OpenEntry)                                               \
  202.         (THIS_  ULONG                       cbEntryID,                  \
  203.                 LPENTRYID                   lpEntryID,                  \
  204.                 LPCIID                      lpInterface,                \
  205.                 ULONG                       ulFlags,                    \
  206.                 ULONG FAR *                 lpulObjType,                \
  207.                 LPUNKNOWN FAR *             lppUnk) IPURE;  \
  208.     MAPIMETHOD(CompareEntryIDs)                                         \
  209.         (THIS_  ULONG                       cbEntryID1,                 \
  210.                 LPENTRYID                   lpEntryID1,                 \
  211.                 ULONG                       cbEntryID2,                 \
  212.                 LPENTRYID                   lpEntryID2,                 \
  213.                 ULONG                       ulFlags,                    \
  214.                 ULONG FAR *                 lpulResult) IPURE;          \
  215.     MAPIMETHOD(Advise)                                                  \
  216.         (THIS_  ULONG                       cbEntryID,                  \
  217.                 LPENTRYID                   lpEntryID,                  \
  218.                 ULONG                       ulEventMask,                \
  219.                 LPMAPIADVISESINK            lpAdviseSink,               \
  220.                 ULONG FAR *                 lpulConnection) IPURE;      \
  221.     MAPIMETHOD(Unadvise)                                                \
  222.         (THIS_  ULONG                       ulConnection) IPURE;        \
  223.     MAPIMETHOD(MessageOptions)                                          \
  224.         (THIS_  ULONG                       ulUIParam,                  \
  225.                 ULONG                       ulFlags,                    \
  226.                 LPTSTR                      lpszAdrType,                \
  227.                 LPMESSAGE                   lpMessage) IPURE;           \
  228.     MAPIMETHOD(QueryDefaultMessageOpt)                                  \
  229.         (THIS_  LPTSTR                      lpszAdrType,                \
  230.                 ULONG                       ulFlags,                    \
  231.                 ULONG FAR *                 lpcValues,                  \
  232.                 LPSPropValue FAR *          lppOptions) IPURE;          \
  233.     MAPIMETHOD(EnumAdrTypes)                                            \
  234.         (THIS_  ULONG                       ulFlags,                    \
  235.                 ULONG FAR *                 lpcAdrTypes,                \
  236.                 LPTSTR FAR * FAR *          lpppszAdrTypes) IPURE;      \
  237.     MAPIMETHOD(QueryIdentity)                                           \
  238.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  239.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  240.     MAPIMETHOD(Logoff)                                                  \
  241.         (THIS_  ULONG                       ulUIParam,                  \
  242.                 ULONG                       ulFlags,                    \
  243.                 ULONG                       ulReserved) IPURE;          \
  244.     MAPIMETHOD(SetDefaultStore)                                         \
  245.         (THIS_  ULONG                       ulFlags,                    \
  246.                 ULONG                       cbEntryID,                  \
  247.                 LPENTRYID                   lpEntryID) IPURE;           \
  248.     MAPIMETHOD(AdminServices)                                           \
  249.         (THIS_  ULONG                       ulFlags,                    \
  250.                 LPSERVICEADMIN FAR *        lppServiceAdmin) IPURE;     \
  251.     MAPIMETHOD(ShowForm)                                                \
  252.         (THIS_  ULONG                       ulUIParam,                  \
  253.                 LPMDB                       lpMsgStore,                 \
  254.                 LPMAPIFOLDER                lpParentFolder,             \
  255.                 LPCIID                      lpInterface,                \
  256.                 ULONG                       ulMessageToken,             \
  257.                 LPMESSAGE                   lpMessageSent,              \
  258.                 ULONG                       ulFlags,                    \
  259.                 ULONG                       ulMessageStatus,            \
  260.                 ULONG                       ulMessageFlags,             \
  261.                 ULONG                       ulAccess,                   \
  262.                 LPSTR                       lpszMessageClass) IPURE;    \
  263.     MAPIMETHOD(PrepareForm)                                             \
  264.         (THIS_  LPCIID                      lpInterface,                \
  265.                 LPMESSAGE                   lpMessage,                  \
  266.                 ULONG FAR *                 lpulMessageToken) IPURE;    \
  267.  
  268.  
  269. #undef       INTERFACE
  270. #define      INTERFACE  IMAPISession
  271. DECLARE_MAPI_INTERFACE_(IMAPISession, IUnknown)
  272. {
  273.     BEGIN_INTERFACE 
  274.     MAPI_IUNKNOWN_METHODS(PURE)
  275.     MAPI_IMAPISESSION_METHODS(PURE)
  276. };
  277.  
  278. /*DECLARE_MAPI_INTERFACE_PTR(IMAPISession, LPMAPISESSION);*/
  279.  
  280. /* IAddrBook Interface ----------------------------------------------------- */
  281.  
  282. /*  CreateOneOff */
  283. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  284. /****** MAPI_SEND_NO_RICH_INFO      ((ULONG) 0x00010000) */
  285.  
  286. /*  RecipOptions */
  287. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  288.  
  289. /*  QueryDefaultRecipOpt */
  290. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  291.  
  292. /*  GetSearchPath */
  293. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  294.  
  295.  
  296. #define MAPI_IADDRBOOK_METHODS(IPURE)                                   \
  297.     MAPIMETHOD(OpenEntry)                                               \
  298.         (THIS_  ULONG                       cbEntryID,                  \
  299.                 LPENTRYID                   lpEntryID,                  \
  300.                 LPCIID                      lpInterface,                \
  301.                 ULONG                       ulFlags,                    \
  302.                 ULONG FAR *                 lpulObjType,                \
  303.                 LPUNKNOWN FAR *             lppUnk) IPURE;  \
  304.     MAPIMETHOD(CompareEntryIDs)                                         \
  305.         (THIS_  ULONG                       cbEntryID1,                 \
  306.                 LPENTRYID                   lpEntryID1,                 \
  307.                 ULONG                       cbEntryID2,                 \
  308.                 LPENTRYID                   lpEntryID2,                 \
  309.                 ULONG                       ulFlags,                    \
  310.                 ULONG FAR *                 lpulResult) IPURE;          \
  311.     MAPIMETHOD(Advise)                                                  \
  312.         (THIS_  ULONG                       cbEntryID,                  \
  313.                 LPENTRYID                   lpEntryID,                  \
  314.                 ULONG                       ulEventMask,                \
  315.                 LPMAPIADVISESINK            lpAdviseSink,               \
  316.                 ULONG FAR *                 lpulConnection) IPURE;      \
  317.     MAPIMETHOD(Unadvise)                                                \
  318.         (THIS_  ULONG                       ulConnection) IPURE;        \
  319.     MAPIMETHOD(CreateOneOff)                                            \
  320.         (THIS_  LPTSTR                      lpszName,                   \
  321.                 LPTSTR                      lpszAdrType,                \
  322.                 LPTSTR                      lpszAddress,                \
  323.                 ULONG                       ulFlags,                    \
  324.                 ULONG FAR *                 lpcbEntryID,                \
  325.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  326.     MAPIMETHOD(NewEntry)                                                \
  327.         (THIS_  ULONG                       ulUIParam,                  \
  328.                 ULONG                       ulFlags,                    \
  329.                 ULONG                       cbEIDContainer,             \
  330.                 LPENTRYID                   lpEIDContainer,             \
  331.                 ULONG                       cbEIDNewEntryTpl,           \
  332.                 LPENTRYID                   lpEIDNewEntryTpl,           \
  333.                 ULONG FAR *                 lpcbEIDNewEntry,            \
  334.                 LPENTRYID FAR *             lppEIDNewEntry) IPURE;      \
  335.     MAPIMETHOD(ResolveName)                                             \
  336.         (THIS_  ULONG                       ulUIParam,                  \
  337.                 ULONG                       ulFlags,                    \
  338.                 LPTSTR                      lpszNewEntryTitle,          \
  339.                 LPADRLIST                   lpAdrList) IPURE;           \
  340.     MAPIMETHOD(Address)                                                 \
  341.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  342.                 LPADRPARM                   lpAdrParms,                 \
  343.                 LPADRLIST FAR *             lppAdrList) IPURE;          \
  344.     MAPIMETHOD(Details)                                                 \
  345.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  346.                 LPFNDISMISS                 lpfnDismiss,                \
  347.                 LPVOID                      lpvDismissContext,          \
  348.                 ULONG                       cbEntryID,                  \
  349.                 LPENTRYID                   lpEntryID,                  \
  350.                 LPFNBUTTON                  lpfButtonCallback,          \
  351.                 LPVOID                      lpvButtonContext,           \
  352.                 LPTSTR                      lpszButtonText,             \
  353.                 ULONG                       ulFlags) IPURE;             \
  354.     MAPIMETHOD(RecipOptions)                                            \
  355.         (THIS_  ULONG                       ulUIParam,                  \
  356.                 ULONG                       ulFlags,                    \
  357.                 LPADRENTRY                  lpRecip) IPURE;             \
  358.     MAPIMETHOD(QueryDefaultRecipOpt)                                    \
  359.         (THIS_  LPTSTR                      lpszAdrType,                \
  360.                 ULONG                       ulFlags,                    \
  361.                 ULONG FAR *                 lpcValues,                  \
  362.                 LPSPropValue FAR *          lppOptions) IPURE;          \
  363.     MAPIMETHOD(GetPAB)                                                  \
  364.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  365.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  366.     MAPIMETHOD(SetPAB)                                                  \
  367.         (THIS_  ULONG                       cbEntryID,                  \
  368.                 LPENTRYID                   lpEntryID) IPURE;           \
  369.     MAPIMETHOD(GetDefaultDir)                                           \
  370.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  371.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  372.     MAPIMETHOD(SetDefaultDir)                                           \
  373.         (THIS_  ULONG                       cbEntryID,                  \
  374.                 LPENTRYID                   lpEntryID) IPURE;           \
  375.     MAPIMETHOD(GetSearchPath)                                           \
  376.         (THIS_  ULONG                       ulFlags,                    \
  377.                 LPSRowSet FAR *             lppSearchPath) IPURE;       \
  378.     MAPIMETHOD(SetSearchPath)                                           \
  379.         (THIS_  ULONG                       ulFlags,                    \
  380.                 LPSRowSet                   lpSearchPath) IPURE;        \
  381.     MAPIMETHOD(PrepareRecips)                                           \
  382.         (THIS_  ULONG                       ulFlags,                    \
  383.                 LPSPropTagArray             lpPropTagArray,             \
  384.                 LPADRLIST                   lpRecipList) IPURE;         \
  385.  
  386. #undef       INTERFACE
  387. #define      INTERFACE  IAddrBook
  388. DECLARE_MAPI_INTERFACE_(IAddrBook, IMAPIProp)
  389. {
  390.     BEGIN_INTERFACE 
  391.     MAPI_IUNKNOWN_METHODS(PURE)
  392.     MAPI_IMAPIPROP_METHODS(PURE)
  393.     MAPI_IADDRBOOK_METHODS(PURE)
  394. };
  395.  
  396. DECLARE_MAPI_INTERFACE_PTR(IAddrBook, LPADRBOOK);
  397.  
  398. /* IProfAdmin Interface ---------------------------------------------------- */
  399.  
  400. /* Flags for CreateProfile */
  401. #define MAPI_DEFAULT_SERVICES           0x00000001
  402.  
  403. /* GetProfileTable */
  404. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  405.  
  406. #define MAPI_IPROFADMIN_METHODS(IPURE)                                  \
  407.     MAPIMETHOD(GetLastError)                                            \
  408.         (THIS_  HRESULT                     hResult,                    \
  409.                 ULONG                       ulFlags,                    \
  410.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  411.     MAPIMETHOD(GetProfileTable)                                         \
  412.         (THIS_  ULONG                       ulFlags,                    \
  413.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  414.     MAPIMETHOD(CreateProfile)                                           \
  415.         (THIS_  LPTSTR                      lpszProfileName,            \
  416.                 LPTSTR                      lpszPassword,               \
  417.                 ULONG                       ulUIParam,                  \
  418.                 ULONG                       ulFlags) IPURE;             \
  419.     MAPIMETHOD(DeleteProfile)                                           \
  420.         (THIS_  LPTSTR                      lpszProfileName,            \
  421.                 ULONG                       ulFlags) IPURE;             \
  422.     MAPIMETHOD(ChangeProfilePassword)                                   \
  423.         (THIS_  LPTSTR                      lpszProfileName,            \
  424.                 LPTSTR                      lpszOldPassword,            \
  425.                 LPTSTR                      lpszNewPassword,            \
  426.                 ULONG                       ulFlags) IPURE;             \
  427.     MAPIMETHOD(CopyProfile)                                             \
  428.         (THIS_  LPTSTR                      lpszOldProfileName,         \
  429.                 LPTSTR                      lpszOldPassword,            \
  430.                 LPTSTR                      lpszNewProfileName,         \
  431.                 ULONG                       ulUIParam,                  \
  432.                 ULONG                       ulFlags) IPURE;             \
  433.     MAPIMETHOD(RenameProfile)                                           \
  434.         (THIS_  LPTSTR                      lpszOldProfileName,         \
  435.                 LPTSTR                      lpszOldPassword,            \
  436.                 LPTSTR                      lpszNewProfileName,         \
  437.                 ULONG                       ulUIParam,                  \
  438.                 ULONG                       ulFlags) IPURE;             \
  439.     MAPIMETHOD(SetDefaultProfile)                                       \
  440.         (THIS_  LPTSTR                      lpszProfileName,            \
  441.                 ULONG                       ulFlags) IPURE;             \
  442.     MAPIMETHOD(AdminServices)                                           \
  443.         (THIS_  LPTSTR                      lpszProfileName,            \
  444.                 LPTSTR                      lpszPassword,               \
  445.                 ULONG                       ulUIParam,                  \
  446.                 ULONG                       ulFlags,                    \
  447.                 LPSERVICEADMIN FAR *        lppServiceAdmin) IPURE;     \
  448.  
  449.  
  450. #undef       INTERFACE
  451. #define      INTERFACE  IProfAdmin
  452. DECLARE_MAPI_INTERFACE_(IProfAdmin, IUnknown)
  453. {
  454.     BEGIN_INTERFACE 
  455.     MAPI_IUNKNOWN_METHODS(PURE)
  456.     MAPI_IPROFADMIN_METHODS(PURE)
  457. };
  458.  
  459. /* IMsgServiceAdmin Interface ---------------------------------------------- */
  460.  
  461. /* Values for PR_RESOURCE_FLAGS in message service table */
  462.  
  463. #define SERVICE_DEFAULT_STORE       0x00000001
  464. #define SERVICE_SINGLE_COPY         0x00000002
  465. #define SERVICE_CREATE_WITH_STORE   0x00000004
  466. #define SERVICE_PRIMARY_IDENTITY    0x00000008
  467. #define SERVICE_NO_PRIMARY_IDENTITY 0x00000020
  468.  
  469. /*  GetMsgServiceTable */
  470. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  471.  
  472. /*  GetProviderTable */
  473. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  474.  
  475. #define MAPI_IMSGSERVICEADMIN_METHODS(IPURE)                            \
  476.     MAPIMETHOD(GetLastError)                                            \
  477.         (THIS_  HRESULT                     hResult,                    \
  478.                 ULONG                       ulFlags,                    \
  479.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  480.     MAPIMETHOD(GetMsgServiceTable)                                      \
  481.         (THIS_  ULONG                       ulFlags,                    \
  482.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  483.     MAPIMETHOD(CreateMsgService)                                        \
  484.         (THIS_  LPTSTR                      lpszService,                \
  485.                 LPTSTR                      lpszDisplayName,            \
  486.                 ULONG                       ulUIParam,                  \
  487.                 ULONG                       ulFlags) IPURE;             \
  488.     MAPIMETHOD(DeleteMsgService)                                        \
  489.         (THIS_  LPMAPIUID                   lpUID) IPURE;               \
  490.     MAPIMETHOD(CopyMsgService)                                          \
  491.         (THIS_  LPMAPIUID                   lpUID,                      \
  492.                 LPTSTR                      lpszDisplayName,            \
  493.                 LPCIID                      lpInterfaceToCopy,          \
  494.                 LPCIID                      lpInterfaceDst,             \
  495.                 LPVOID                      lpObjectDst,                \
  496.                 ULONG                       ulUIParam,                  \
  497.                 ULONG                       ulFlags) IPURE;             \
  498.     MAPIMETHOD(RenameMsgService)                                        \
  499.         (THIS_  LPMAPIUID                   lpUID,                      \
  500.                 ULONG                       ulFlags,                    \
  501.                 LPTSTR                      lpszDisplayName) IPURE;     \
  502.     MAPIMETHOD(ConfigureMsgService)                                     \
  503.         (THIS_  LPMAPIUID                   lpUID,                      \
  504.                 ULONG                       ulUIParam,                  \
  505.                 ULONG                       ulFlags,                    \
  506.                 ULONG                       cValues,                    \
  507.                 LPSPropValue                lpProps) IPURE;             \
  508.     MAPIMETHOD(OpenProfileSection)                                      \
  509.         (THIS_  LPMAPIUID                   lpUID,                      \
  510.                 LPCIID                      lpInterface,                \
  511.                 ULONG                       ulFlags,                    \
  512.                 LPPROFSECT FAR *            lppProfSect) IPURE;         \
  513.     MAPIMETHOD(MsgServiceTransportOrder)                                \
  514.         (THIS_  ULONG                       cUID,                       \
  515.                 LPMAPIUID                   lpUIDList,                  \
  516.                 ULONG                       ulFlags) IPURE;             \
  517.     MAPIMETHOD(AdminProviders)                                          \
  518.         (THIS_  LPMAPIUID                   lpUID,                      \
  519.                 ULONG                       ulFlags,                    \
  520.                 LPPROVIDERADMIN FAR *       lppProviderAdmin) IPURE;    \
  521.     MAPIMETHOD(SetPrimaryIdentity)                                      \
  522.         (THIS_  LPMAPIUID                   lpUID,                      \
  523.                 ULONG                       ulFlags) IPURE;             \
  524.     MAPIMETHOD(GetProviderTable)                                        \
  525.         (THIS_  ULONG                       ulFlags,                    \
  526.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  527.  
  528.  
  529. #undef       INTERFACE
  530. #define      INTERFACE  IMsgServiceAdmin
  531. DECLARE_MAPI_INTERFACE_(IMsgServiceAdmin, IUnknown)
  532. {
  533.     BEGIN_INTERFACE 
  534.     MAPI_IUNKNOWN_METHODS(PURE)
  535.     MAPI_IMSGSERVICEADMIN_METHODS(PURE)
  536. };
  537.  
  538. #ifdef  __cplusplus
  539. }       /*  extern "C" */
  540. #endif  
  541.  
  542. #pragma option pop /*P_O_Pop*/
  543. #endif /* MAPIX_H */
  544.