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