#![allow(
non_snake_case,
non_upper_case_globals,
non_camel_case_types,
dead_code,
clippy::all
)]
#[inline]
pub unsafe fn BuildDisplayTable<P3>(
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
lpmalloc: P3,
hinstance: windows::Win32::Foundation::HINSTANCE,
cpages: u32,
lppage: *mut DTPAGE,
ulflags: u32,
lpptable: *mut Option<IMAPITable>,
lpptbldata: *mut Option<ITableData>,
) -> windows_core::Result<()>
where
P3: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
crate::link!("mapi32" "system" fn BuildDisplayTable(lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpmalloc : * mut core::ffi::c_void, hinstance : windows::Win32::Foundation:: HINSTANCE, cpages : u32, lppage : *mut DTPAGE, ulflags : u32, lpptable : *mut * mut core::ffi::c_void, lpptbldata : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
BuildDisplayTable(
lpallocatebuffer,
lpallocatemore,
lpfreebuffer,
lpmalloc.param().abi(),
hinstance,
cpages,
lppage as _,
ulflags,
core::mem::transmute(lpptable),
core::mem::transmute(lpptbldata),
)
.ok()
}
}
#[inline]
pub unsafe fn ChangeIdleRoutine(
ftg: *mut core::ffi::c_void,
lpfnidle: PFNIDLE,
lpvidleparam: *mut core::ffi::c_void,
priidle: i16,
csecidle: u32,
iroidle: u16,
ircidle: u16,
) {
crate::link!("mapi32" "system" fn ChangeIdleRoutine(ftg : *mut core::ffi::c_void, lpfnidle : PFNIDLE, lpvidleparam : *mut core::ffi::c_void, priidle : i16, csecidle : u32, iroidle : u16, ircidle : u16));
unsafe {
ChangeIdleRoutine(
ftg as _,
lpfnidle,
lpvidleparam as _,
priidle,
csecidle,
iroidle,
ircidle,
)
}
}
#[inline]
pub unsafe fn CloseIMsgSession(lpmsgsess: windows::Win32::Storage::Imapi::LPMSGSESS) {
crate::link!("mapi32" "system" fn CloseIMsgSession(lpmsgsess : windows::Win32::Storage::Imapi:: LPMSGSESS));
unsafe { CloseIMsgSession(lpmsgsess) }
}
#[inline]
pub unsafe fn CreateIProp(
lpinterface: *mut windows_core::GUID,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
lpvreserved: *mut core::ffi::c_void,
lpppropdata: *mut Option<IPropData>,
) -> i32 {
crate::link!("mapi32" "system" fn CreateIProp(lpinterface : *mut windows_core::GUID, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpvreserved : *mut core::ffi::c_void, lpppropdata : *mut * mut core::ffi::c_void) -> i32);
unsafe {
CreateIProp(
lpinterface as _,
lpallocatebuffer,
lpallocatemore,
lpfreebuffer,
lpvreserved as _,
core::mem::transmute(lpppropdata),
)
}
}
#[inline]
pub unsafe fn CreateTable(
lpinterface: *mut windows_core::GUID,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
lpvreserved: *mut core::ffi::c_void,
ultabletype: u32,
ulproptagindexcolumn: u32,
lpsproptagarraycolumns: *mut SPropTagArray,
lpptabledata: *mut Option<ITableData>,
) -> i32 {
crate::link!("mapi32" "system" fn CreateTable(lpinterface : *mut windows_core::GUID, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpvreserved : *mut core::ffi::c_void, ultabletype : u32, ulproptagindexcolumn : u32, lpsproptagarraycolumns : *mut SPropTagArray, lpptabledata : *mut * mut core::ffi::c_void) -> i32);
unsafe {
CreateTable(
lpinterface as _,
lpallocatebuffer,
lpallocatemore,
lpfreebuffer,
lpvreserved as _,
ultabletype,
ulproptagindexcolumn,
lpsproptagarraycolumns as _,
core::mem::transmute(lpptabledata),
)
}
}
#[inline]
pub unsafe fn DeinitMapiUtil() {
crate::link!("mapi32" "system" fn DeinitMapiUtil());
unsafe { DeinitMapiUtil() }
}
#[inline]
pub unsafe fn DeregisterIdleRoutine(ftg: *mut core::ffi::c_void) {
crate::link!("mapi32" "system" fn DeregisterIdleRoutine(ftg : *mut core::ffi::c_void));
unsafe { DeregisterIdleRoutine(ftg as _) }
}
#[inline]
pub unsafe fn EnableIdleRoutine(ftg: *mut core::ffi::c_void, fenable: bool) {
crate::link!("mapi32" "system" fn EnableIdleRoutine(ftg : *mut core::ffi::c_void, fenable : windows::Win32::Foundation:: BOOL));
unsafe { EnableIdleRoutine(ftg as _, fenable.into()) }
}
#[inline]
pub unsafe fn FBadColumnSet(lpptacols: *mut SPropTagArray) -> u32 {
crate::link!("mapi32" "system" fn FBadColumnSet(lpptacols : *mut SPropTagArray) -> u32);
unsafe { FBadColumnSet(lpptacols as _) }
}
#[inline]
pub unsafe fn FBadEntryList(lpentrylist: *mut SBinaryArray) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FBadEntryList(lpentrylist : *mut SBinaryArray) -> windows::Win32::Foundation:: BOOL);
unsafe { FBadEntryList(lpentrylist as _) }
}
#[inline]
pub unsafe fn FBadProp(lpprop: *mut SPropValue) -> u32 {
crate::link!("mapi32" "system" fn FBadProp(lpprop : *mut SPropValue) -> u32);
unsafe { FBadProp(lpprop as _) }
}
#[inline]
pub unsafe fn FBadPropTag(ulproptag: u32) -> u32 {
crate::link!("mapi32" "system" fn FBadPropTag(ulproptag : u32) -> u32);
unsafe { FBadPropTag(ulproptag) }
}
#[inline]
pub unsafe fn FBadRestriction(lpres: *mut SRestriction) -> u32 {
crate::link!("mapi32" "system" fn FBadRestriction(lpres : *mut SRestriction) -> u32);
unsafe { FBadRestriction(lpres as _) }
}
#[inline]
pub unsafe fn FBadRglpNameID(
lppnameid: *mut *mut MAPINAMEID,
cnames: u32,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FBadRglpNameID(lppnameid : *mut *mut MAPINAMEID, cnames : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { FBadRglpNameID(lppnameid as _, cnames) }
}
#[inline]
pub unsafe fn FBadRglpszW(
lppszw: *const windows_core::PCWSTR,
cstrings: u32,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FBadRglpszW(lppszw : *const windows_core::PCWSTR, cstrings : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { FBadRglpszW(lppszw, cstrings) }
}
#[inline]
pub unsafe fn FBadRow(lprow: *mut SRow) -> u32 {
crate::link!("mapi32" "system" fn FBadRow(lprow : *mut SRow) -> u32);
unsafe { FBadRow(lprow as _) }
}
#[inline]
pub unsafe fn FBadRowSet(lprowset: *mut SRowSet) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FBadRowSet(lprowset : *mut SRowSet) -> windows::Win32::Foundation:: BOOL);
unsafe { FBadRowSet(lprowset as _) }
}
#[inline]
pub unsafe fn FBadSortOrderSet(lpsos: *mut SSortOrderSet) -> u32 {
crate::link!("mapi32" "system" fn FBadSortOrderSet(lpsos : *mut SSortOrderSet) -> u32);
unsafe { FBadSortOrderSet(lpsos as _) }
}
#[inline]
pub unsafe fn FBinFromHex(lpsz: *const i8, lpb: *mut u8) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FBinFromHex(lpsz : *const i8, lpb : *mut u8) -> windows::Win32::Foundation:: BOOL);
unsafe { FBinFromHex(lpsz, lpb as _) }
}
#[inline]
pub unsafe fn FEqualNames(
lpname1: *mut MAPINAMEID,
lpname2: *mut MAPINAMEID,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FEqualNames(lpname1 : *mut MAPINAMEID, lpname2 : *mut MAPINAMEID) -> windows::Win32::Foundation:: BOOL);
unsafe { FEqualNames(lpname1 as _, lpname2 as _) }
}
#[inline]
pub unsafe fn FPropCompareProp(
lpspropvalue1: *mut SPropValue,
ulrelop: u32,
lpspropvalue2: *mut SPropValue,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FPropCompareProp(lpspropvalue1 : *mut SPropValue, ulrelop : u32, lpspropvalue2 : *mut SPropValue) -> windows::Win32::Foundation:: BOOL);
unsafe { FPropCompareProp(lpspropvalue1 as _, ulrelop, lpspropvalue2 as _) }
}
#[inline]
pub unsafe fn FPropContainsProp(
lpspropvaluedst: *mut SPropValue,
lpspropvaluesrc: *mut SPropValue,
ulfuzzylevel: u32,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn FPropContainsProp(lpspropvaluedst : *mut SPropValue, lpspropvaluesrc : *mut SPropValue, ulfuzzylevel : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { FPropContainsProp(lpspropvaluedst as _, lpspropvaluesrc as _, ulfuzzylevel) }
}
#[inline]
pub unsafe fn FPropExists<P0>(lpmapiprop: P0, ulproptag: u32) -> windows::Win32::Foundation::BOOL
where
P0: windows_core::Param<IMAPIProp>,
{
crate::link!("mapi32" "system" fn FPropExists(lpmapiprop : * mut core::ffi::c_void, ulproptag : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { FPropExists(lpmapiprop.param().abi(), ulproptag) }
}
#[inline]
pub unsafe fn FreePadrlist(lpadrlist: *mut ADRLIST) {
crate::link!("mapi32" "system" fn FreePadrlist(lpadrlist : *mut ADRLIST));
unsafe { FreePadrlist(lpadrlist as _) }
}
#[inline]
pub unsafe fn FreeProws(lprows: *mut SRowSet) {
crate::link!("mapi32" "system" fn FreeProws(lprows : *mut SRowSet));
unsafe { FreeProws(lprows as _) }
}
#[inline]
pub unsafe fn FtAddFt(
ftaddend1: windows::Win32::Foundation::FILETIME,
ftaddend2: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
crate::link!("mapi32" "system" fn FtAddFt(ftaddend1 : windows::Win32::Foundation:: FILETIME, ftaddend2 : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
unsafe {
FtAddFt(
core::mem::transmute(ftaddend1),
core::mem::transmute(ftaddend2),
)
}
}
#[inline]
pub unsafe fn FtMulDw(
ftmultiplier: u32,
ftmultiplicand: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
crate::link!("mapi32" "system" fn FtMulDw(ftmultiplier : u32, ftmultiplicand : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
unsafe { FtMulDw(ftmultiplier, core::mem::transmute(ftmultiplicand)) }
}
#[inline]
pub unsafe fn FtMulDwDw(
ftmultiplicand: u32,
ftmultiplier: u32,
) -> windows::Win32::Foundation::FILETIME {
crate::link!("mapi32" "system" fn FtMulDwDw(ftmultiplicand : u32, ftmultiplier : u32) -> windows::Win32::Foundation:: FILETIME);
unsafe { FtMulDwDw(ftmultiplicand, ftmultiplier) }
}
#[inline]
pub unsafe fn FtNegFt(
ft: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
crate::link!("mapi32" "system" fn FtNegFt(ft : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
unsafe { FtNegFt(core::mem::transmute(ft)) }
}
#[inline]
pub unsafe fn FtSubFt(
ftminuend: windows::Win32::Foundation::FILETIME,
ftsubtrahend: windows::Win32::Foundation::FILETIME,
) -> windows::Win32::Foundation::FILETIME {
crate::link!("mapi32" "system" fn FtSubFt(ftminuend : windows::Win32::Foundation:: FILETIME, ftsubtrahend : windows::Win32::Foundation:: FILETIME) -> windows::Win32::Foundation:: FILETIME);
unsafe {
FtSubFt(
core::mem::transmute(ftminuend),
core::mem::transmute(ftsubtrahend),
)
}
}
#[inline]
pub unsafe fn FtgRegisterIdleRoutine(
lpfnidle: PFNIDLE,
lpvidleparam: *mut core::ffi::c_void,
priidle: i16,
csecidle: u32,
iroidle: u16,
) -> *mut core::ffi::c_void {
crate::link!("mapi32" "system" fn FtgRegisterIdleRoutine(lpfnidle : PFNIDLE, lpvidleparam : *mut core::ffi::c_void, priidle : i16, csecidle : u32, iroidle : u16) -> *mut core::ffi::c_void);
unsafe { FtgRegisterIdleRoutine(lpfnidle, lpvidleparam as _, priidle, csecidle, iroidle) }
}
#[inline]
pub unsafe fn GetAttribIMsgOnIStg(
lpobject: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
lpppropattrarray: *mut *mut SPropAttrArray,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn GetAttribIMsgOnIStg(lpobject : *mut core::ffi::c_void, lpproptagarray : *mut SPropTagArray, lpppropattrarray : *mut *mut SPropAttrArray) -> windows_core::HRESULT);
unsafe { GetAttribIMsgOnIStg(lpobject as _, lpproptagarray as _, lpppropattrarray as _).ok() }
}
#[inline]
pub unsafe fn HexFromBin(lpb: *mut u8, cb: i32, lpsz: *const i8) {
crate::link!("mapi32" "system" fn HexFromBin(lpb : *mut u8, cb : i32, lpsz : *const i8));
unsafe { HexFromBin(lpb as _, cb, lpsz) }
}
#[inline]
pub unsafe fn HrAddColumns<P0>(
lptbl: P0,
lpproptagcolumnsnew: *mut SPropTagArray,
lpallocatebuffer: LPALLOCATEBUFFER,
lpfreebuffer: LPFREEBUFFER,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPITable>,
{
crate::link!("mapi32" "system" fn HrAddColumns(lptbl : * mut core::ffi::c_void, lpproptagcolumnsnew : *mut SPropTagArray, lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER) -> windows_core::HRESULT);
unsafe {
HrAddColumns(
lptbl.param().abi(),
lpproptagcolumnsnew as _,
lpallocatebuffer,
lpfreebuffer,
)
.ok()
}
}
#[inline]
pub unsafe fn HrAddColumnsEx<P0>(
lptbl: P0,
lpproptagcolumnsnew: *mut SPropTagArray,
lpallocatebuffer: LPALLOCATEBUFFER,
lpfreebuffer: LPFREEBUFFER,
lpfnfiltercolumns: isize,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPITable>,
{
crate::link!("mapi32" "system" fn HrAddColumnsEx(lptbl : * mut core::ffi::c_void, lpproptagcolumnsnew : *mut SPropTagArray, lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER, lpfnfiltercolumns : isize) -> windows_core::HRESULT);
unsafe {
HrAddColumnsEx(
lptbl.param().abi(),
lpproptagcolumnsnew as _,
lpallocatebuffer,
lpfreebuffer,
lpfnfiltercolumns,
)
.ok()
}
}
#[inline]
pub unsafe fn HrAllocAdviseSink(
lpfncallback: LPNOTIFCALLBACK,
lpvcontext: *mut core::ffi::c_void,
lppadvisesink: *mut Option<IMAPIAdviseSink>,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn HrAllocAdviseSink(lpfncallback : LPNOTIFCALLBACK, lpvcontext : *mut core::ffi::c_void, lppadvisesink : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrAllocAdviseSink(
lpfncallback,
lpvcontext as _,
core::mem::transmute(lppadvisesink),
)
.ok()
}
}
#[inline]
pub unsafe fn HrCompareABEntryIDsWithExchangeContext<P0, P2>(
pmsess: P0,
pemsmdbuid: *const MAPIUID,
paddrbook: P2,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
P2: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrCompareABEntryIDsWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid1 : u32, lpentryid1 : *mut ENTRYID, cbentryid2 : u32, lpentryid2 : *mut ENTRYID, ulflags : u32, lpulresult : *mut u32) -> windows_core::HRESULT);
unsafe {
HrCompareABEntryIDsWithExchangeContext(
pmsess.param().abi(),
pemsmdbuid,
paddrbook.param().abi(),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrComposeEID<P0>(
lpsession: P0,
cbstorerecordkey: u32,
lpstorerecordkey: *mut u8,
cbmsgentryid: u32,
lpmsgentryid: *mut ENTRYID,
lpcbeid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
{
crate::link!("mapi32" "system" fn HrComposeEID(lpsession : * mut core::ffi::c_void, cbstorerecordkey : u32, lpstorerecordkey : *mut u8, cbmsgentryid : u32, lpmsgentryid : *mut ENTRYID, lpcbeid : *mut u32, lppentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe {
HrComposeEID(
lpsession.param().abi(),
cbstorerecordkey,
lpstorerecordkey as _,
cbmsgentryid,
lpmsgentryid as _,
lpcbeid as _,
lppentryid as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrComposeMsgID<P0>(
lpsession: P0,
cbstoresearchkey: u32,
pstoresearchkey: *mut u8,
cbmsgentryid: u32,
lpmsgentryid: *mut ENTRYID,
lpszmsgid: *const *const i8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
{
crate::link!("mapi32" "system" fn HrComposeMsgID(lpsession : * mut core::ffi::c_void, cbstoresearchkey : u32, pstoresearchkey : *mut u8, cbmsgentryid : u32, lpmsgentryid : *mut ENTRYID, lpszmsgid : *const *const i8) -> windows_core::HRESULT);
unsafe {
HrComposeMsgID(
lpsession.param().abi(),
cbstoresearchkey,
pstoresearchkey as _,
cbmsgentryid,
lpmsgentryid as _,
lpszmsgid,
)
.ok()
}
}
#[inline]
pub unsafe fn HrDecomposeEID<P0>(
lpsession: P0,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpcbstoreentryid: *mut u32,
lppstoreentryid: *mut *mut ENTRYID,
lpcbmsgentryid: *mut u32,
lppmsgentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
{
crate::link!("mapi32" "system" fn HrDecomposeEID(lpsession : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpcbstoreentryid : *mut u32, lppstoreentryid : *mut *mut ENTRYID, lpcbmsgentryid : *mut u32, lppmsgentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe {
HrDecomposeEID(
lpsession.param().abi(),
cbentryid,
lpentryid as _,
lpcbstoreentryid as _,
lppstoreentryid as _,
lpcbmsgentryid as _,
lppmsgentryid as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrDecomposeMsgID<P0>(
lpsession: P0,
lpszmsgid: *const i8,
lpcbstoreentryid: *mut u32,
lppstoreentryid: *mut *mut ENTRYID,
lppcbmsgentryid: *mut u32,
lppmsgentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
{
crate::link!("mapi32" "system" fn HrDecomposeMsgID(lpsession : * mut core::ffi::c_void, lpszmsgid : *const i8, lpcbstoreentryid : *mut u32, lppstoreentryid : *mut *mut ENTRYID, lppcbmsgentryid : *mut u32, lppmsgentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe {
HrDecomposeMsgID(
lpsession.param().abi(),
lpszmsgid,
lpcbstoreentryid as _,
lppstoreentryid as _,
lppcbmsgentryid as _,
lppmsgentryid as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrDispatchNotifications(ulflags: u32) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn HrDispatchNotifications(ulflags : u32) -> windows_core::HRESULT);
unsafe { HrDispatchNotifications(ulflags).ok() }
}
#[inline]
pub unsafe fn HrDoABDetailsWithExchangeContext<P0, P2>(
pmsess: P0,
pemsmdbuid: *const MAPIUID,
paddrbook: P2,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
P2: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrDoABDetailsWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, lpuluiparam : *mut usize, lpfndismiss : LPFNDISMISS, lpvdismisscontext : *mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpfbuttoncallback : windows::Win32::System::AddressBook:: LPFNBUTTON, lpvbuttoncontext : *mut core::ffi::c_void, lpszbuttontext : *mut i8, ulflags : u32) -> windows_core::HRESULT);
unsafe {
HrDoABDetailsWithExchangeContext(
pmsess.param().abi(),
pemsmdbuid,
paddrbook.param().abi(),
lpuluiparam as _,
lpfndismiss,
lpvdismisscontext as _,
cbentryid,
lpentryid as _,
lpfbuttoncallback,
lpvbuttoncontext as _,
lpszbuttontext as _,
ulflags,
)
.ok()
}
}
#[inline]
pub unsafe fn HrDoABDetailsWithProviderUID<P1>(
pemsabpuid: *const MAPIUID,
paddrbook: P1,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrDoABDetailsWithProviderUID(pemsabpuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, lpuluiparam : *mut usize, lpfndismiss : LPFNDISMISS, lpvdismisscontext : *mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpfbuttoncallback : windows::Win32::System::AddressBook:: LPFNBUTTON, lpvbuttoncontext : *mut core::ffi::c_void, lpszbuttontext : *mut i8, ulflags : u32) -> windows_core::HRESULT);
unsafe {
HrDoABDetailsWithProviderUID(
pemsabpuid,
paddrbook.param().abi(),
lpuluiparam as _,
lpfndismiss,
lpvdismisscontext as _,
cbentryid,
lpentryid as _,
lpfbuttoncallback,
lpvbuttoncontext as _,
lpszbuttontext as _,
ulflags,
)
.ok()
}
}
#[inline]
pub unsafe fn HrEntryIDFromSz(
lpsz: *const i8,
lpcb: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn HrEntryIDFromSz(lpsz : *const i8, lpcb : *mut u32, lppentryid : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe { HrEntryIDFromSz(lpsz, lpcb as _, lppentryid as _).ok() }
}
#[inline]
pub unsafe fn HrGetGALFromEmsmdbUID<P0, P1>(
psess: P0,
lpadrbook: P1,
pemsmdbuid: *const MAPIUID,
lpcbeid: *mut u32,
lppeid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
P1: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrGetGALFromEmsmdbUID(psess : * mut core::ffi::c_void, lpadrbook : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, lpcbeid : *mut u32, lppeid : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe {
HrGetGALFromEmsmdbUID(
psess.param().abi(),
lpadrbook.param().abi(),
pemsmdbuid,
lpcbeid as _,
lppeid as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrGetOneProp<P0>(
lpmapiprop: P0,
ulproptag: u32,
lppprop: *mut *mut SPropValue,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIProp>,
{
crate::link!("mapi32" "system" fn HrGetOneProp(lpmapiprop : * mut core::ffi::c_void, ulproptag : u32, lppprop : *mut *mut SPropValue) -> windows_core::HRESULT);
unsafe { HrGetOneProp(lpmapiprop.param().abi(), ulproptag, lppprop as _).ok() }
}
#[inline]
pub unsafe fn HrIStorageFromStream<P0>(
lpunkin: P0,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppstorageout: *mut Option<windows::Win32::System::Com::StructuredStorage::IStorage>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::IUnknown>,
{
crate::link!("mapi32" "system" fn HrIStorageFromStream(lpunkin : * mut core::ffi::c_void, lpinterface : *mut windows_core::GUID, ulflags : u32, lppstorageout : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrIStorageFromStream(
lpunkin.param().abi(),
lpinterface as _,
ulflags,
core::mem::transmute(lppstorageout),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryUsingDefaultContext<P0, P1>(
pmsess: P0,
paddrbook: P1,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
P1: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryUsingDefaultContext(pmsess : * mut core::ffi::c_void, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryUsingDefaultContext(
pmsess.param().abi(),
paddrbook.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryWithExchangeContext<P0, P2>(
pmsess: P0,
pemsmdbuid: *const MAPIUID,
paddrbook: P2,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISession>,
P2: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryWithExchangeContext(pmsess : * mut core::ffi::c_void, pemsmdbuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryWithExchangeContext(
pmsess.param().abi(),
pemsmdbuid,
paddrbook.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryWithProviderUID<P1>(
pemsabpuid: *const MAPIUID,
paddrbook: P1,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryWithProviderUID(pemsabpuid : *const MAPIUID, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryWithProviderUID(
pemsabpuid,
paddrbook.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryWithProviderUIDSupport<P1>(
pemsabpuid: *const MAPIUID,
lpsup: P1,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMAPISupport>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryWithProviderUIDSupport(pemsabpuid : *const MAPIUID, lpsup : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryWithProviderUIDSupport(
pemsabpuid,
lpsup.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryWithResolvedRow<P1>(
prwresolved: *mut SRow,
paddrbook: P1,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IAddrBook>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryWithResolvedRow(prwresolved : *mut SRow, paddrbook : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryWithResolvedRow(
prwresolved as _,
paddrbook.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrOpenABEntryWithSupport<P0>(
lpsup: P0,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISupport>,
{
crate::link!("olmapi32" "system" fn HrOpenABEntryWithSupport(lpsup : * mut core::ffi::c_void, cbentryid : u32, lpentryid : *mut ENTRYID, lpinterface : *mut windows_core::GUID, ulflags : u32, lpulobjtype : *mut u32, lppunk : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
HrOpenABEntryWithSupport(
lpsup.param().abi(),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
#[inline]
pub unsafe fn HrQueryAllRows<P0>(
lptable: P0,
lpproptags: *mut SPropTagArray,
lprestriction: *mut SRestriction,
lpsortorderset: *mut SSortOrderSet,
crowsmax: i32,
lpprows: *mut *mut SRowSet,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPITable>,
{
crate::link!("mapi32" "system" fn HrQueryAllRows(lptable : * mut core::ffi::c_void, lpproptags : *mut SPropTagArray, lprestriction : *mut SRestriction, lpsortorderset : *mut SSortOrderSet, crowsmax : i32, lpprows : *mut *mut SRowSet) -> windows_core::HRESULT);
unsafe {
HrQueryAllRows(
lptable.param().abi(),
lpproptags as _,
lprestriction as _,
lpsortorderset as _,
crowsmax,
lpprows as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrSetOneProp<P0>(lpmapiprop: P0, lpprop: *mut SPropValue) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIProp>,
{
crate::link!("mapi32" "system" fn HrSetOneProp(lpmapiprop : * mut core::ffi::c_void, lpprop : *mut SPropValue) -> windows_core::HRESULT);
unsafe { HrSetOneProp(lpmapiprop.param().abi(), lpprop as _).ok() }
}
#[inline]
pub unsafe fn HrSzFromEntryID(
cb: u32,
lpentryid: *mut ENTRYID,
lpsz: *const *const i8,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn HrSzFromEntryID(cb : u32, lpentryid : *mut ENTRYID, lpsz : *const *const i8) -> windows_core::HRESULT);
unsafe { HrSzFromEntryID(cb, lpentryid as _, lpsz).ok() }
}
#[inline]
pub unsafe fn HrThisThreadAdviseSink<P0>(lpadvisesink: P0) -> windows_core::Result<IMAPIAdviseSink>
where
P0: windows_core::Param<IMAPIAdviseSink>,
{
crate::link!("mapi32" "system" fn HrThisThreadAdviseSink(lpadvisesink : * mut core::ffi::c_void, lppadvisesink : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
HrThisThreadAdviseSink(lpadvisesink.param().abi(), &mut result__)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn HrValidateIPMSubtree<P0>(
lpmdb: P0,
ulflags: u32,
lpcvalues: *mut u32,
lppvalues: *mut *mut SPropValue,
lpperr: *mut *mut MAPIERROR,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMsgStore>,
{
crate::link!("mapi32" "system" fn HrValidateIPMSubtree(lpmdb : * mut core::ffi::c_void, ulflags : u32, lpcvalues : *mut u32, lppvalues : *mut *mut SPropValue, lpperr : *mut *mut MAPIERROR) -> windows_core::HRESULT);
unsafe {
HrValidateIPMSubtree(
lpmdb.param().abi(),
ulflags,
lpcvalues as _,
lppvalues as _,
lpperr as _,
)
.ok()
}
}
#[inline]
pub unsafe fn HrValidateParameters(
emethod: METHODS,
ppfirstarg: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
crate::link!("olmapi32" "system" fn HrValidateParameters(emethod : METHODS, ppfirstarg : *mut *mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe { HrValidateParameters(emethod, ppfirstarg as _).ok() }
}
#[inline]
pub unsafe fn IsBadBoundedStringPtr(
lpsz: *const core::ffi::c_void,
cchmax: u32,
) -> windows::Win32::Foundation::BOOL {
crate::link!("mapi32" "system" fn IsBadBoundedStringPtr(lpsz : *const core::ffi::c_void, cchmax : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { IsBadBoundedStringPtr(lpsz, cchmax) }
}
#[inline]
pub unsafe fn LPropCompareProp(
lpspropvaluea: *mut SPropValue,
lpspropvalueb: *mut SPropValue,
) -> i32 {
crate::link!("mapi32" "system" fn LPropCompareProp(lpspropvaluea : *mut SPropValue, lpspropvalueb : *mut SPropValue) -> i32);
unsafe { LPropCompareProp(lpspropvaluea as _, lpspropvalueb as _) }
}
#[inline]
pub unsafe fn LpValFindProp(
ulproptag: u32,
cvalues: u32,
lpproparray: *mut SPropValue,
) -> *mut SPropValue {
crate::link!("mapi32" "system" fn LpValFindProp(ulproptag : u32, cvalues : u32, lpproparray : *mut SPropValue) -> *mut SPropValue);
unsafe { LpValFindProp(ulproptag, cvalues, lpproparray as _) }
}
#[inline]
pub unsafe fn MAPIAddress<P2, P4>(
param0: usize,
param1: usize,
param2: P2,
param3: u32,
param4: P4,
param5: u32,
param6: *mut MapiRecipDesc,
param7: u32,
param8: u32,
param9: *mut u32,
param10: *mut *mut MapiRecipDesc,
) -> u32
where
P2: windows_core::Param<windows_core::PCSTR>,
P4: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPIAddress(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : windows_core::PCSTR, param5 : u32, param6 : *mut MapiRecipDesc, param7 : u32, param8 : u32, param9 : *mut u32, param10 : *mut *mut MapiRecipDesc) -> u32);
unsafe {
MAPIAddress(
param0,
param1,
param2.param().abi(),
param3,
param4.param().abi(),
param5,
param6 as _,
param7,
param8,
param9 as _,
param10 as _,
)
}
}
#[inline]
pub unsafe fn MAPIAdminProfiles(param0: u32) -> windows_core::Result<IProfAdmin> {
crate::link!("mapi32" "system" fn MAPIAdminProfiles(param0 : u32, param1 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
MAPIAdminProfiles(param0, &mut result__).and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn MAPIAllocateBuffer(param0: u32, param1: *mut *mut core::ffi::c_void) -> i32 {
crate::link!("mapi32" "system" fn MAPIAllocateBuffer(param0 : u32, param1 : *mut *mut core::ffi::c_void) -> i32);
unsafe { MAPIAllocateBuffer(param0, param1 as _) }
}
#[inline]
pub unsafe fn MAPIAllocateMore(
param0: u32,
param1: *mut core::ffi::c_void,
param2: *mut *mut core::ffi::c_void,
) -> i32 {
crate::link!("mapi32" "system" fn MAPIAllocateMore(param0 : u32, param1 : *mut core::ffi::c_void, param2 : *mut *mut core::ffi::c_void) -> i32);
unsafe { MAPIAllocateMore(param0, param1 as _, param2 as _) }
}
#[inline]
pub unsafe fn MAPIDeinitIdle() {
crate::link!("mapi32" "system" fn MAPIDeinitIdle());
unsafe { MAPIDeinitIdle() }
}
#[inline]
pub unsafe fn MAPIDeleteMail<P2>(
param0: usize,
param1: usize,
param2: P2,
param3: u32,
param4: u32,
) -> u32
where
P2: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPIDeleteMail(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32) -> u32);
unsafe { MAPIDeleteMail(param0, param1, param2.param().abi(), param3, param4) }
}
#[inline]
pub unsafe fn MAPIDetails(
param0: usize,
param1: usize,
param2: *mut MapiRecipDesc,
param3: u32,
param4: u32,
) -> u32 {
crate::link!("mapi32" "system" fn MAPIDetails(param0 : usize, param1 : usize, param2 : *mut MapiRecipDesc, param3 : u32, param4 : u32) -> u32);
unsafe { MAPIDetails(param0, param1, param2 as _, param3, param4) }
}
#[inline]
pub unsafe fn MAPIFindNext<P2, P3, P6>(
param0: usize,
param1: usize,
param2: P2,
param3: P3,
param4: u32,
param5: u32,
param6: P6,
) -> u32
where
P2: windows_core::Param<windows_core::PCSTR>,
P3: windows_core::Param<windows_core::PCSTR>,
P6: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPIFindNext(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : windows_core::PCSTR, param4 : u32, param5 : u32, param6 : windows_core::PCSTR) -> u32);
unsafe {
MAPIFindNext(
param0,
param1,
param2.param().abi(),
param3.param().abi(),
param4,
param5,
param6.param().abi(),
)
}
}
#[inline]
pub unsafe fn MAPIFreeBuffer(param0: *mut core::ffi::c_void) -> u32 {
crate::link!("mapi32" "system" fn MAPIFreeBuffer(param0 : *mut core::ffi::c_void) -> u32);
unsafe { MAPIFreeBuffer(param0 as _) }
}
#[inline]
pub unsafe fn MAPIGetDefaultMalloc() -> Option<windows::Win32::System::Com::IMalloc> {
crate::link!("mapi32" "system" fn MAPIGetDefaultMalloc() -> Option < windows::Win32::System::Com:: IMalloc >);
unsafe { MAPIGetDefaultMalloc() }
}
#[inline]
pub unsafe fn MAPIInitIdle(lpvreserved: *mut core::ffi::c_void) -> i32 {
crate::link!("mapi32" "system" fn MAPIInitIdle(lpvreserved : *mut core::ffi::c_void) -> i32);
unsafe { MAPIInitIdle(lpvreserved as _) }
}
#[inline]
pub unsafe fn MAPIInitialize(param0: *mut core::ffi::c_void) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn MAPIInitialize(param0 : *mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe { MAPIInitialize(param0 as _).ok() }
}
#[inline]
pub unsafe fn MAPILogoff(param0: usize, param1: usize, param2: u32, param3: u32) -> u32 {
crate::link!("mapi32" "system" fn MAPILogoff(param0 : usize, param1 : usize, param2 : u32, param3 : u32) -> u32);
unsafe { MAPILogoff(param0, param1, param2, param3) }
}
#[inline]
pub unsafe fn MAPILogon<P1, P2>(
param0: usize,
param1: P1,
param2: P2,
param3: u32,
param4: u32,
param5: *mut usize,
) -> u32
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPILogon(param0 : usize, param1 : windows_core::PCSTR, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut usize) -> u32);
unsafe {
MAPILogon(
param0,
param1.param().abi(),
param2.param().abi(),
param3,
param4,
param5 as _,
)
}
}
#[inline]
pub unsafe fn MAPILogonEx(
param0: usize,
param1: *mut i8,
param2: *mut i8,
param3: u32,
param4: *mut Option<IMAPISession>,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn MAPILogonEx(param0 : usize, param1 : *mut i8, param2 : *mut i8, param3 : u32, param4 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
MAPILogonEx(
param0,
param1 as _,
param2 as _,
param3,
core::mem::transmute(param4),
)
.ok()
}
}
#[inline]
pub unsafe fn MAPIOpenFormMgr<P0>(psession: P0) -> windows_core::Result<IMAPIFormMgr>
where
P0: windows_core::Param<IMAPISession>,
{
crate::link!("mapi32" "system" fn MAPIOpenFormMgr(psession : * mut core::ffi::c_void, ppmgr : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
MAPIOpenFormMgr(psession.param().abi(), &mut result__)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn MAPIOpenLocalFormContainer() -> windows_core::Result<IMAPIFormContainer> {
crate::link!("mapi32" "system" fn MAPIOpenLocalFormContainer(ppfcnt : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
MAPIOpenLocalFormContainer(&mut result__)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn MAPIReadMail<P2>(
param0: usize,
param1: usize,
param2: P2,
param3: u32,
param4: u32,
param5: *mut *mut MapiMessage,
) -> u32
where
P2: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPIReadMail(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut *mut MapiMessage) -> u32);
unsafe {
MAPIReadMail(
param0,
param1,
param2.param().abi(),
param3,
param4,
param5 as _,
)
}
}
#[inline]
pub unsafe fn MAPIResolveName<P2>(
param0: usize,
param1: usize,
param2: P2,
param3: u32,
param4: u32,
param5: *mut *mut MapiRecipDesc,
) -> u32
where
P2: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPIResolveName(param0 : usize, param1 : usize, param2 : windows_core::PCSTR, param3 : u32, param4 : u32, param5 : *mut *mut MapiRecipDesc) -> u32);
unsafe {
MAPIResolveName(
param0,
param1,
param2.param().abi(),
param3,
param4,
param5 as _,
)
}
}
#[inline]
pub unsafe fn MAPISaveMail<P5>(
param0: usize,
param1: usize,
param2: *mut MapiMessage,
param3: u32,
param4: u32,
param5: P5,
) -> u32
where
P5: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPISaveMail(param0 : usize, param1 : usize, param2 : *mut MapiMessage, param3 : u32, param4 : u32, param5 : windows_core::PCSTR) -> u32);
unsafe {
MAPISaveMail(
param0,
param1,
param2 as _,
param3,
param4,
param5.param().abi(),
)
}
}
#[inline]
pub unsafe fn MAPISendDocuments<P1, P2, P3>(
param0: usize,
param1: P1,
param2: P2,
param3: P3,
param4: u32,
) -> u32
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
P3: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MAPISendDocuments(param0 : usize, param1 : windows_core::PCSTR, param2 : windows_core::PCSTR, param3 : windows_core::PCSTR, param4 : u32) -> u32);
unsafe {
MAPISendDocuments(
param0,
param1.param().abi(),
param2.param().abi(),
param3.param().abi(),
param4,
)
}
}
#[inline]
pub unsafe fn MAPISendMail(
param0: usize,
param1: usize,
param2: *mut MapiMessage,
param3: u32,
param4: u32,
) -> u32 {
crate::link!("mapi32" "system" fn MAPISendMail(param0 : usize, param1 : usize, param2 : *mut MapiMessage, param3 : u32, param4 : u32) -> u32);
unsafe { MAPISendMail(param0, param1, param2 as _, param3, param4) }
}
#[inline]
pub unsafe fn MAPIUninitialize() {
crate::link!("mapi32" "system" fn MAPIUninitialize());
unsafe { MAPIUninitialize() }
}
#[inline]
pub unsafe fn MNLS_CompareStringW<P2, P4>(
locale: u32,
dwcmpflags: u32,
lpstring1: P2,
cchcount1: i32,
lpstring2: P4,
cchcount2: i32,
) -> i32
where
P2: windows_core::Param<windows_core::PCWSTR>,
P4: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_CompareStringW(locale : u32, dwcmpflags : u32, lpstring1 : windows_core::PCWSTR, cchcount1 : i32, lpstring2 : windows_core::PCWSTR, cchcount2 : i32) -> i32);
unsafe {
MNLS_CompareStringW(
locale,
dwcmpflags,
lpstring1.param().abi(),
cchcount1,
lpstring2.param().abi(),
cchcount2,
)
}
}
#[inline]
pub unsafe fn MNLS_IsBadStringPtrW<P0>(lpsz: P0, ucchmax: u32) -> windows::Win32::Foundation::BOOL
where
P0: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_IsBadStringPtrW(lpsz : windows_core::PCWSTR, ucchmax : u32) -> windows::Win32::Foundation:: BOOL);
unsafe { MNLS_IsBadStringPtrW(lpsz.param().abi(), ucchmax) }
}
#[inline]
pub unsafe fn MNLS_MultiByteToWideChar<P2, P4>(
ucodepage: u32,
dwflags: u32,
lpmultibytestr: P2,
cchmultibyte: i32,
lpwidecharstr: P4,
cchwidechar: i32,
) -> i32
where
P2: windows_core::Param<windows_core::PCSTR>,
P4: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_MultiByteToWideChar(ucodepage : u32, dwflags : u32, lpmultibytestr : windows_core::PCSTR, cchmultibyte : i32, lpwidecharstr : windows_core::PCWSTR, cchwidechar : i32) -> i32);
unsafe {
MNLS_MultiByteToWideChar(
ucodepage,
dwflags,
lpmultibytestr.param().abi(),
cchmultibyte,
lpwidecharstr.param().abi(),
cchwidechar,
)
}
}
#[inline]
pub unsafe fn MNLS_WideCharToMultiByte<P2, P4, P6>(
ucodepage: u32,
dwflags: u32,
lpwidecharstr: P2,
cchwidechar: i32,
lpmultibytestr: P4,
cchmultibyte: i32,
lpdefaultchar: P6,
lpfuseddefaultchar: *mut windows::Win32::Foundation::BOOL,
) -> i32
where
P2: windows_core::Param<windows_core::PCWSTR>,
P4: windows_core::Param<windows_core::PCSTR>,
P6: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn MNLS_WideCharToMultiByte(ucodepage : u32, dwflags : u32, lpwidecharstr : windows_core::PCWSTR, cchwidechar : i32, lpmultibytestr : windows_core::PCSTR, cchmultibyte : i32, lpdefaultchar : windows_core::PCSTR, lpfuseddefaultchar : *mut windows::Win32::Foundation:: BOOL) -> i32);
unsafe {
MNLS_WideCharToMultiByte(
ucodepage,
dwflags,
lpwidecharstr.param().abi(),
cchwidechar,
lpmultibytestr.param().abi(),
cchmultibyte,
lpdefaultchar.param().abi(),
lpfuseddefaultchar as _,
)
}
}
#[inline]
pub unsafe fn MNLS_lstrcmpW<P0, P1>(lpstring1: P0, lpstring2: P1) -> i32
where
P0: windows_core::Param<windows_core::PCWSTR>,
P1: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_lstrcmpW(lpstring1 : windows_core::PCWSTR, lpstring2 : windows_core::PCWSTR) -> i32);
unsafe { MNLS_lstrcmpW(lpstring1.param().abi(), lpstring2.param().abi()) }
}
#[inline]
pub unsafe fn MNLS_lstrcpyW<P0, P1>(lpstring1: P0, lpstring2: P1) -> windows_core::PWSTR
where
P0: windows_core::Param<windows_core::PCWSTR>,
P1: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_lstrcpyW(lpstring1 : windows_core::PCWSTR, lpstring2 : windows_core::PCWSTR) -> windows_core::PWSTR);
unsafe { MNLS_lstrcpyW(lpstring1.param().abi(), lpstring2.param().abi()) }
}
#[inline]
pub unsafe fn MNLS_lstrlenW<P0>(lpstring: P0) -> i32
where
P0: windows_core::Param<windows_core::PCWSTR>,
{
crate::link!("mapi32" "system" fn MNLS_lstrlenW(lpstring : windows_core::PCWSTR) -> i32);
unsafe { MNLS_lstrlenW(lpstring.param().abi()) }
}
#[inline]
pub unsafe fn MSProviderInit<P1>(
param0: windows::Win32::Foundation::HINSTANCE,
param1: P1,
param2: LPALLOCATEBUFFER,
param3: LPALLOCATEMORE,
param4: LPFREEBUFFER,
param5: u32,
param6: u32,
param7: *mut u32,
param8: *mut Option<IMSProvider>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
crate::link!("olmapi32" "cdecl" fn MSProviderInit(param0 : windows::Win32::Foundation:: HINSTANCE, param1 : * mut core::ffi::c_void, param2 : LPALLOCATEBUFFER, param3 : LPALLOCATEMORE, param4 : LPFREEBUFFER, param5 : u32, param6 : u32, param7 : *mut u32, param8 : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
MSProviderInit(
param0,
param1.param().abi(),
param2,
param3,
param4,
param5,
param6,
param7 as _,
core::mem::transmute(param8),
)
.ok()
}
}
#[inline]
pub unsafe fn MapStorageSCode(stgscode: i32) -> i32 {
crate::link!("mapi32" "system" fn MapStorageSCode(stgscode : i32) -> i32);
unsafe { MapStorageSCode(stgscode) }
}
#[inline]
pub unsafe fn OpenIMsgOnIStg<P4, P6>(
lpmsgsess: windows::Win32::Storage::Imapi::LPMSGSESS,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
lpmalloc: P4,
lpmapisup: *mut core::ffi::c_void,
lpstg: P6,
lpfmsgcallrelease: *mut windows::Win32::Storage::Imapi::MSGCALLRELEASE,
ulcallerdata: u32,
ulflags: u32,
lppmsg: *mut Option<IMessage>,
) -> i32
where
P4: windows_core::Param<windows::Win32::System::Com::IMalloc>,
P6: windows_core::Param<windows::Win32::System::Com::StructuredStorage::IStorage>,
{
crate::link!("mapi32" "system" fn OpenIMsgOnIStg(lpmsgsess : windows::Win32::Storage::Imapi:: LPMSGSESS, lpallocatebuffer : LPALLOCATEBUFFER, lpallocatemore : LPALLOCATEMORE, lpfreebuffer : LPFREEBUFFER, lpmalloc : * mut core::ffi::c_void, lpmapisup : *mut core::ffi::c_void, lpstg : * mut core::ffi::c_void, lpfmsgcallrelease : *mut windows::Win32::Storage::Imapi:: MSGCALLRELEASE, ulcallerdata : u32, ulflags : u32, lppmsg : *mut * mut core::ffi::c_void) -> i32);
unsafe {
OpenIMsgOnIStg(
lpmsgsess,
lpallocatebuffer,
lpallocatemore,
lpfreebuffer,
lpmalloc.param().abi(),
lpmapisup as _,
lpstg.param().abi(),
lpfmsgcallrelease as _,
ulcallerdata,
ulflags,
core::mem::transmute(lppmsg),
)
}
}
#[inline]
pub unsafe fn OpenIMsgSession<P0>(
lpmalloc: P0,
ulflags: u32,
lppmsgsess: *mut windows::Win32::Storage::Imapi::LPMSGSESS,
) -> i32
where
P0: windows_core::Param<windows::Win32::System::Com::IMalloc>,
{
crate::link!("mapi32" "system" fn OpenIMsgSession(lpmalloc : * mut core::ffi::c_void, ulflags : u32, lppmsgsess : *mut windows::Win32::Storage::Imapi:: LPMSGSESS) -> i32);
unsafe { OpenIMsgSession(lpmalloc.param().abi(), ulflags, lppmsgsess as _) }
}
#[inline]
pub unsafe fn OpenStreamOnFile(
lpallocatebuffer: LPALLOCATEBUFFER,
lpfreebuffer: LPFREEBUFFER,
ulflags: u32,
lpszfilename: *const i8,
lpszprefix: Option<*const i8>,
) -> windows_core::Result<windows::Win32::System::Com::IStream> {
crate::link!("mapi32" "system" fn OpenStreamOnFile(lpallocatebuffer : LPALLOCATEBUFFER, lpfreebuffer : LPFREEBUFFER, ulflags : u32, lpszfilename : *const i8, lpszprefix : *const i8, lppstream : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
OpenStreamOnFile(
lpallocatebuffer,
lpfreebuffer,
ulflags,
lpszfilename,
lpszprefix.unwrap_or(core::mem::zeroed()) as _,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn PpropFindProp(
lpproparray: *mut SPropValue,
cvalues: u32,
ulproptag: u32,
) -> *mut SPropValue {
crate::link!("mapi32" "system" fn PpropFindProp(lpproparray : *mut SPropValue, cvalues : u32, ulproptag : u32) -> *mut SPropValue);
unsafe { PpropFindProp(lpproparray as _, cvalues, ulproptag) }
}
#[inline]
pub unsafe fn PropCopyMore(
lpspropvaluedest: *mut SPropValue,
lpspropvaluesrc: *mut SPropValue,
lpfallocmore: LPALLOCATEMORE,
lpvobject: *mut core::ffi::c_void,
) -> i32 {
crate::link!("mapi32" "system" fn PropCopyMore(lpspropvaluedest : *mut SPropValue, lpspropvaluesrc : *mut SPropValue, lpfallocmore : LPALLOCATEMORE, lpvobject : *mut core::ffi::c_void) -> i32);
unsafe {
PropCopyMore(
lpspropvaluedest as _,
lpspropvaluesrc as _,
lpfallocmore,
lpvobject as _,
)
}
}
#[inline]
pub unsafe fn RTFSync<P0>(
lpmessage: P0,
ulflags: u32,
) -> windows_core::Result<windows::Win32::Foundation::BOOL>
where
P0: windows_core::Param<IMessage>,
{
crate::link!("mapi32" "system" fn RTFSync(lpmessage : * mut core::ffi::c_void, ulflags : u32, lpfmessageupdated : *mut windows::Win32::Foundation:: BOOL) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
RTFSync(lpmessage.param().abi(), ulflags, &mut result__)
.map(|| core::mem::transmute(result__))
}
}
#[inline]
pub unsafe fn ScBinFromHexBounded(lpsz: *const i8, lpb: *mut u8, cb: u32) -> i32 {
crate::link!("mapi32" "system" fn ScBinFromHexBounded(lpsz : *const i8, lpb : *mut u8, cb : u32) -> i32);
unsafe { ScBinFromHexBounded(lpsz, lpb as _, cb) }
}
#[inline]
pub unsafe fn ScCopyNotifications(
cnotification: i32,
lpnotifications: *mut NOTIFICATION,
lpvdst: *mut core::ffi::c_void,
lpcb: *mut u32,
) -> i32 {
crate::link!("mapi32" "system" fn ScCopyNotifications(cnotification : i32, lpnotifications : *mut NOTIFICATION, lpvdst : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
unsafe { ScCopyNotifications(cnotification, lpnotifications as _, lpvdst as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCopyProps(
cvalues: i32,
lpproparray: *mut SPropValue,
lpvdst: *mut core::ffi::c_void,
lpcb: *mut u32,
) -> i32 {
crate::link!("mapi32" "system" fn ScCopyProps(cvalues : i32, lpproparray : *mut SPropValue, lpvdst : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
unsafe { ScCopyProps(cvalues, lpproparray as _, lpvdst as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCountNotifications(
cnotifications: i32,
lpnotifications: *mut NOTIFICATION,
lpcb: *mut u32,
) -> i32 {
crate::link!("mapi32" "system" fn ScCountNotifications(cnotifications : i32, lpnotifications : *mut NOTIFICATION, lpcb : *mut u32) -> i32);
unsafe { ScCountNotifications(cnotifications, lpnotifications as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCountProps(cvalues: i32, lpproparray: *mut SPropValue, lpcb: *mut u32) -> i32 {
crate::link!("mapi32" "system" fn ScCountProps(cvalues : i32, lpproparray : *mut SPropValue, lpcb : *mut u32) -> i32);
unsafe { ScCountProps(cvalues, lpproparray as _, lpcb as _) }
}
#[inline]
pub unsafe fn ScCreateConversationIndex(
cbparent: u32,
lpbparent: *mut u8,
lpcbconvindex: *mut u32,
lppbconvindex: *mut *mut u8,
) -> i32 {
crate::link!("mapi32" "system" fn ScCreateConversationIndex(cbparent : u32, lpbparent : *mut u8, lpcbconvindex : *mut u32, lppbconvindex : *mut *mut u8) -> i32);
unsafe {
ScCreateConversationIndex(
cbparent,
lpbparent as _,
lpcbconvindex as _,
lppbconvindex as _,
)
}
}
#[inline]
pub unsafe fn ScDupPropset(
cvalues: i32,
lpproparray: *mut SPropValue,
lpallocatebuffer: LPALLOCATEBUFFER,
lppproparray: *mut *mut SPropValue,
) -> i32 {
crate::link!("mapi32" "system" fn ScDupPropset(cvalues : i32, lpproparray : *mut SPropValue, lpallocatebuffer : LPALLOCATEBUFFER, lppproparray : *mut *mut SPropValue) -> i32);
unsafe {
ScDupPropset(
cvalues,
lpproparray as _,
lpallocatebuffer,
lppproparray as _,
)
}
}
#[inline]
pub unsafe fn ScInitMapiUtil(ulflags: u32) -> i32 {
crate::link!("mapi32" "system" fn ScInitMapiUtil(ulflags : u32) -> i32);
unsafe { ScInitMapiUtil(ulflags) }
}
#[inline]
pub unsafe fn ScLocalPathFromUNC<P0, P1>(lpszunc: P0, lpszlocal: P1, cchlocal: u32) -> i32
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn ScLocalPathFromUNC(lpszunc : windows_core::PCSTR, lpszlocal : windows_core::PCSTR, cchlocal : u32) -> i32);
unsafe { ScLocalPathFromUNC(lpszunc.param().abi(), lpszlocal.param().abi(), cchlocal) }
}
#[inline]
pub unsafe fn ScMAPIXFromSMAPI(
lhsimplesession: usize,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
lppmapisession: *mut Option<IMAPISession>,
) -> i32 {
crate::link!("mapi32" "system" fn ScMAPIXFromSMAPI(lhsimplesession : usize, ulflags : u32, lpinterface : *mut windows_core::GUID, lppmapisession : *mut * mut core::ffi::c_void) -> i32);
unsafe {
ScMAPIXFromSMAPI(
lhsimplesession,
ulflags,
lpinterface as _,
core::mem::transmute(lppmapisession),
)
}
}
#[inline]
pub unsafe fn ScRelocNotifications(
cnotification: i32,
lpnotifications: *mut NOTIFICATION,
lpvbaseold: *mut core::ffi::c_void,
lpvbasenew: *mut core::ffi::c_void,
lpcb: *mut u32,
) -> i32 {
crate::link!("mapi32" "system" fn ScRelocNotifications(cnotification : i32, lpnotifications : *mut NOTIFICATION, lpvbaseold : *mut core::ffi::c_void, lpvbasenew : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
unsafe {
ScRelocNotifications(
cnotification,
lpnotifications as _,
lpvbaseold as _,
lpvbasenew as _,
lpcb as _,
)
}
}
#[inline]
pub unsafe fn ScRelocProps(
cvalues: i32,
lpproparray: *mut SPropValue,
lpvbaseold: *mut core::ffi::c_void,
lpvbasenew: *mut core::ffi::c_void,
lpcb: *mut u32,
) -> i32 {
crate::link!("mapi32" "system" fn ScRelocProps(cvalues : i32, lpproparray : *mut SPropValue, lpvbaseold : *mut core::ffi::c_void, lpvbasenew : *mut core::ffi::c_void, lpcb : *mut u32) -> i32);
unsafe {
ScRelocProps(
cvalues,
lpproparray as _,
lpvbaseold as _,
lpvbasenew as _,
lpcb as _,
)
}
}
#[inline]
pub unsafe fn ScUNCFromLocalPath<P0, P1>(lpszlocal: P0, lpszunc: P1, cchunc: u32) -> i32
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
crate::link!("mapi32" "system" fn ScUNCFromLocalPath(lpszlocal : windows_core::PCSTR, lpszunc : windows_core::PCSTR, cchunc : u32) -> i32);
unsafe { ScUNCFromLocalPath(lpszlocal.param().abi(), lpszunc.param().abi(), cchunc) }
}
#[inline]
pub unsafe fn SetAttribIMsgOnIStg(
lpobject: *mut core::ffi::c_void,
lpproptags: *mut SPropTagArray,
lppropattrs: *mut SPropAttrArray,
lpppropproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn SetAttribIMsgOnIStg(lpobject : *mut core::ffi::c_void, lpproptags : *mut SPropTagArray, lppropattrs : *mut SPropAttrArray, lpppropproblems : *mut *mut SPropProblemArray) -> windows_core::HRESULT);
unsafe {
SetAttribIMsgOnIStg(
lpobject as _,
lpproptags as _,
lppropattrs as _,
lpppropproblems as _,
)
.ok()
}
}
#[inline]
pub unsafe fn SzFindCh(lpsz: *mut i8, ch: u16) -> *mut i8 {
crate::link!("mapi32" "system" fn SzFindCh(lpsz : *mut i8, ch : u16) -> *mut i8);
unsafe { SzFindCh(lpsz as _, ch) }
}
#[inline]
pub unsafe fn SzFindLastCh(lpsz: *mut i8, ch: u16) -> *mut i8 {
crate::link!("mapi32" "system" fn SzFindLastCh(lpsz : *mut i8, ch : u16) -> *mut i8);
unsafe { SzFindLastCh(lpsz as _, ch) }
}
#[inline]
pub unsafe fn SzFindSz(lpsz: *mut i8, lpszkey: *mut i8) -> *mut i8 {
crate::link!("mapi32" "system" fn SzFindSz(lpsz : *mut i8, lpszkey : *mut i8) -> *mut i8);
unsafe { SzFindSz(lpsz as _, lpszkey as _) }
}
#[inline]
pub unsafe fn UFromSz(lpsz: *mut i8) -> u32 {
crate::link!("mapi32" "system" fn UFromSz(lpsz : *mut i8) -> u32);
unsafe { UFromSz(lpsz as _) }
}
#[inline]
pub unsafe fn UlAddRef(lpunk: *mut core::ffi::c_void) -> u32 {
crate::link!("mapi32" "system" fn UlAddRef(lpunk : *mut core::ffi::c_void) -> u32);
unsafe { UlAddRef(lpunk as _) }
}
#[inline]
pub unsafe fn UlFromSzHex(lpsz: *mut i8) -> u32 {
crate::link!("mapi32" "system" fn UlFromSzHex(lpsz : *mut i8) -> u32);
unsafe { UlFromSzHex(lpsz as _) }
}
#[inline]
pub unsafe fn UlPropSize(lpspropvalue: *mut SPropValue) -> u32 {
crate::link!("mapi32" "system" fn UlPropSize(lpspropvalue : *mut SPropValue) -> u32);
unsafe { UlPropSize(lpspropvalue as _) }
}
#[inline]
pub unsafe fn UlRelease(lpunk: *mut core::ffi::c_void) -> u32 {
crate::link!("mapi32" "system" fn UlRelease(lpunk : *mut core::ffi::c_void) -> u32);
unsafe { UlRelease(lpunk as _) }
}
#[inline]
pub unsafe fn WrapCompressedRTFStream<P0>(
lpcompressedrtfstream: P0,
ulflags: u32,
) -> windows_core::Result<windows::Win32::System::Com::IStream>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
crate::link!("mapi32" "system" fn WrapCompressedRTFStream(lpcompressedrtfstream : * mut core::ffi::c_void, ulflags : u32, lpuncompressedrtfstream : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe {
let mut result__ = core::mem::zeroed();
WrapCompressedRTFStream(lpcompressedrtfstream.param().abi(), ulflags, &mut result__)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
#[inline]
pub unsafe fn WrapStoreEntryID(
ulflags: u32,
lpszdllname: *const i8,
cborigentry: u32,
lporigentry: *mut ENTRYID,
lpcbwrappedentry: *mut u32,
lppwrappedentry: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn WrapStoreEntryID(ulflags : u32, lpszdllname : *const i8, cborigentry : u32, lporigentry : *mut ENTRYID, lpcbwrappedentry : *mut u32, lppwrappedentry : *mut *mut ENTRYID) -> windows_core::HRESULT);
unsafe {
WrapStoreEntryID(
ulflags,
lpszdllname,
cborigentry,
lporigentry as _,
lpcbwrappedentry as _,
lppwrappedentry as _,
)
.ok()
}
}
#[inline]
pub unsafe fn __CPPValidateParameters(
emethod: METHODS,
ppfirst: *const core::ffi::c_void,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn __CPPValidateParameters(emethod : METHODS, ppfirst : *const core::ffi::c_void) -> windows_core::HRESULT);
unsafe { __CPPValidateParameters(emethod, ppfirst).ok() }
}
#[inline]
pub unsafe fn __ValidateParameters(
emethod: METHODS,
ppthis: *mut core::ffi::c_void,
) -> windows_core::Result<()> {
crate::link!("mapi32" "system" fn __ValidateParameters(emethod : METHODS, ppthis : *mut core::ffi::c_void) -> windows_core::HRESULT);
unsafe { __ValidateParameters(emethod, ppthis as _).ok() }
}
pub const ABORT_XP_HEADER_OPERATION: u32 = 2097152u32;
pub type ABPROVIDERINIT = Option<
unsafe extern "system" fn(
hinstance: windows::Win32::Foundation::HINSTANCE,
lpmalloc: Option<windows::Win32::System::Com::IMalloc>,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
ulflags: u32,
ulmapiver: u32,
lpulproviderver: *mut u32,
lppabprovider: *mut Option<IABProvider>,
) -> windows_core::HRESULT,
>;
pub const AB_FIND_ON_OPEN: u32 = 16u32;
pub const AB_MODIFIABLE: u32 = 4u32;
pub const AB_NOT_DEFAULT: u32 = 32u32;
pub const AB_NO_DIALOG: u32 = 1u32;
pub const AB_RECIPIENTS: u32 = 1u32;
pub const AB_RESOLVE: u32 = 32u32;
pub const AB_SELECTONLY: u32 = 16u32;
pub const AB_SHOW_OTHERS: u32 = 4u32;
pub const AB_SHOW_PHANTOMS: u32 = 2u32;
pub const AB_SUBCONTAINERS: u32 = 2u32;
pub const AB_UNICODEUI: u32 = 64u32;
pub const AB_UNMODIFIABLE: u32 = 8u32;
pub const ACCTUI_NO_WARNING: u32 = 256u32;
pub const ACCTUI_SHOW_ACCTWIZARD: u32 = 1024u32;
pub const ACCTUI_SHOW_DATA_TAB: u32 = 512u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACCT_BIN {
pub cb: u32,
pub pb: *mut u8,
}
impl Default for ACCT_BIN {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ACCT_INIT_NOSYNCH_MAPI_ACCTS: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ACCT_VARIANT {
pub dwType: u32,
pub Val: ACCT_VARIANT_0,
}
impl Default for ACCT_VARIANT {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union ACCT_VARIANT_0 {
pub dw: u32,
pub pwsz: windows_core::PWSTR,
pub bin: ACCT_BIN,
}
impl Default for ACCT_VARIANT_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ACLTABLE_FREEBUSY: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct ACTION {
pub acttype: ACTTYPE,
pub ulActionFlavor: u32,
pub lpRes: *mut SRestriction,
pub lpPropTagArray: *mut SPropTagArray,
pub ulFlags: u32,
pub dwAlignPad: u32,
pub Anonymous: ACTION_0,
}
impl Default for ACTION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union ACTION_0 {
pub actMoveCopy: ACTION_0_0,
pub actReply: ACTION_0_1,
pub actDeferAction: ACTION_0_2,
pub scBounceCode: i32,
pub lpadrlist: *mut ADRLIST,
pub propTag: SPropValue,
}
impl Default for ACTION_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_2 {
pub cbData: u32,
pub pbData: *mut u8,
}
impl Default for ACTION_0_2 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_0 {
pub cbStoreEntryId: u32,
pub lpStoreEntryId: *mut ENTRYID,
pub cbFldEntryId: u32,
pub lpFldEntryId: *mut ENTRYID,
}
impl Default for ACTION_0_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTION_0_1 {
pub cbEntryId: u32,
pub lpEntryId: *mut ENTRYID,
pub guidReplyTemplate: windows_core::GUID,
}
impl Default for ACTION_0_1 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ACTIONS {
pub ulVersion: u32,
pub cActions: u32,
pub lpAction: *mut ACTION,
}
impl Default for ACTIONS {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ACTTYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ADDRESSFORMAT(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADDRESSLIST {
pub cAdrs: u32,
pub prgAdr: *mut ADDRESSPROPS,
}
impl Default for ADDRESSLIST {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADDRESSPROPS {
pub dwProps: u32,
pub hAddress: *mut HADDRESS__,
pub ietFriendly: ENCODINGTYPE,
pub hCharset: *mut HCHARSET__,
pub dwAdrType: u32,
pub pszFriendly: windows_core::PSTR,
pub pwszReserved: windows_core::PWSTR,
pub pszEmail: windows_core::PSTR,
pub certstate: CERTSTATE,
pub tbSigning: windows::Win32::System::Com::BLOB,
pub tbEncryption: windows::Win32::System::Com::BLOB,
pub dwCookie: u32,
pub dwReserved1: u32,
pub dwReserved2: u32,
}
impl Default for ADDRESSPROPS {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ADDRESS_ONE: u32 = 8u32;
pub const ADMN_PAD: u32 = 3u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRENTRY {
pub ulReserved1: u32,
pub cValues: u32,
pub rgPropVals: *mut SPropValue,
}
impl Default for ADRENTRY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRLIST {
pub cEntries: u32,
pub aEntries: [ADRENTRY; 1],
}
impl Default for ADRLIST {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ADRPARM {
pub cbABContEntryID: u32,
pub lpABContEntryID: *mut ENTRYID,
pub ulFlags: u32,
pub lpReserved: *mut core::ffi::c_void,
pub ulHelpContext: u32,
pub lpszHelpFileName: *mut i8,
pub lpfnABSDI: LPFNABSDI,
pub lpfnDismiss: LPFNDISMISS,
pub lpvDismissContext: *mut core::ffi::c_void,
pub lpszCaption: *mut i8,
pub lpszNewEntryTitle: *mut i8,
pub lpszDestWellsTitle: *mut i8,
pub cDestFields: u32,
pub nDestFieldFocus: u32,
pub lppszDestTitles: *mut *mut i8,
pub lpulDestComps: *mut u32,
pub lpContRestriction: *mut SRestriction,
pub lpHierRestriction: *mut SRestriction,
}
impl Default for ADRPARM {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ADRPARM_HELP_CTX: u32 = 0u32;
pub const AFT_DISPLAY_BOTH: ADDRESSFORMAT = ADDRESSFORMAT(2i32);
pub const AFT_DISPLAY_EMAIL: ADDRESSFORMAT = ADDRESSFORMAT(1i32);
pub const AFT_DISPLAY_FRIENDLY: ADDRESSFORMAT = ADDRESSFORMAT(0i32);
pub const AFT_RFC822_DECODED: ADDRESSFORMAT = ADDRESSFORMAT(3i32);
pub const AFT_RFC822_ENCODED: ADDRESSFORMAT = ADDRESSFORMAT(4i32);
pub const AFT_RFC822_TRANSMIT: ADDRESSFORMAT = ADDRESSFORMAT(5i32);
pub const AG_DAYS: u32 = 2u32;
pub const AG_MONTHS: u32 = 0u32;
pub const AG_WEEKS: u32 = 1u32;
pub const ANTIVIRUS_SCAN_NO_VIRUS: u32 = 0u32;
pub const ANTIVIRUS_SCAN_VIRUS_CLEANED: u32 = 2u32;
pub const ANTIVIRUS_SCAN_VIRUS_DELETED: u32 = 3u32;
pub const ANTIVIRUS_SCAN_VIRUS_PRESENT: u32 = 1u32;
pub const ATTACH_BY_REFERENCE: u32 = 2u32;
pub const ATTACH_BY_REF_ONLY: u32 = 4u32;
pub const ATTACH_BY_REF_RESOLVE: u32 = 3u32;
pub const ATTACH_BY_VALUE: u32 = 1u32;
pub const ATTACH_BY_WEBREFERENCE: u32 = 7u32;
pub const ATTACH_DIALOG: u32 = 1u32;
pub const ATTACH_EMBEDDED_MSG: u32 = 5u32;
pub const ATTACH_OLE: u32 = 6u32;
pub const AUTO_RESPONSE_SUPPRESS_AUTO_REPLY: u32 = 32u32;
pub const AUTO_RESPONSE_SUPPRESS_DR: u32 = 1u32;
pub const AUTO_RESPONSE_SUPPRESS_NDR: u32 = 2u32;
pub const AUTO_RESPONSE_SUPPRESS_NORFC821FROM: u32 = 64u32;
pub const AUTO_RESPONSE_SUPPRESS_NRN: u32 = 8u32;
pub const AUTO_RESPONSE_SUPPRESS_OOF: u32 = 16u32;
pub const AUTO_RESPONSE_SUPPRESS_RN: u32 = 4u32;
pub const BACKGROUND_SEARCH: u32 = 32u32;
pub const BEGIN_DEFERRED: u32 = 1u32;
pub const BMR_EQZ: u32 = 0u32;
pub const BMR_NEZ: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct BODYLOCATION(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BODYOFFSETS {
pub cbBoundaryStart: u32,
pub cbHeaderStart: u32,
pub cbBodyStart: u32,
pub cbBodyEnd: u32,
}
impl Default for BODYOFFSETS {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const BOOKMARK_BEGINNING: u32 = 0u32;
pub const BOOKMARK_CURRENT: u32 = 1u32;
pub const BOOKMARK_END: u32 = 2u32;
pub const CALLBACK_DISCONTINUE: u32 = 2147483648u32;
pub type CALLERRELEASE = Option<
unsafe extern "system" fn(
ulcallerdata: usize,
lptbldata: Option<ITableData>,
lpvue: Option<IMAPITable>,
),
>;
pub const CB_OID_1: u32 = 9u32;
pub const CB_OID_2: u32 = 10u32;
pub const CB_OID_3: u32 = 11u32;
pub const CB_OID_4: u32 = 12u32;
pub const CB_OID_MAC_BINARY: u32 = 9u32;
pub const CB_OID_MIMETAG: u32 = 9u32;
pub const CB_OID_OLE: u32 = 9u32;
pub const CB_OID_OLE1: u32 = 10u32;
pub const CB_OID_OLE1_STORAGE: u32 = 11u32;
pub const CB_OID_OLE2: u32 = 10u32;
pub const CB_OID_OLE2_STORAGE: u32 = 11u32;
pub const CB_OID_TNEF: u32 = 9u32;
pub const CCHMAX_CID: u32 = 255u32;
pub const CCHMAX_CSET_NAME: u32 = 128u32;
pub const CCHMAX_FACE_NAME: u32 = 128u32;
pub const CCHMAX_HEADER_LINE: u32 = 1000u32;
pub const CCHMAX_INTERNET_DATE: u32 = 50u32;
pub const CCHMAX_LANG_NAME: u32 = 128u32;
pub const CCHMAX_MID: u32 = 255u32;
pub const CDID_EMAIL: CERTDATAID = CERTDATAID(0i32);
pub const CDID_MAX: CERTDATAID = CERTDATAID(1i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTDATAID(pub i32);
pub const CERTIFICATE_CHAIN_TOO_LONG: CERTSTATE = CERTSTATE(3i32);
pub const CERTIFICATE_CRL_LISTED: CERTSTATE = CERTSTATE(5i32);
pub const CERTIFICATE_ERROR: CERTSTATE = CERTSTATE(8i32);
pub const CERTIFICATE_EXPIRED: CERTSTATE = CERTSTATE(2i32);
pub const CERTIFICATE_INVALID: CERTSTATE = CERTSTATE(7i32);
pub const CERTIFICATE_MISSING_ISSUER: CERTSTATE = CERTSTATE(4i32);
pub const CERTIFICATE_NOPRINT: CERTSTATE = CERTSTATE(9i32);
pub const CERTIFICATE_NOT_PRESENT: CERTSTATE = CERTSTATE(1i32);
pub const CERTIFICATE_NOT_TRUSTED: CERTSTATE = CERTSTATE(6i32);
pub const CERTIFICATE_OK: CERTSTATE = CERTSTATE(0i32);
pub const CERTIFICATE_UNKNOWN: CERTSTATE = CERTSTATE(10i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTNAMETYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CERTSTATE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CHARSETTYPE(pub i32);
pub const CHARSET_BODY: CHARSETTYPE = CHARSETTYPE(0i32);
pub const CHARSET_HEADER: CHARSETTYPE = CHARSETTYPE(1i32);
pub const CHARSET_WEB: CHARSETTYPE = CHARSETTYPE(2i32);
pub const CHECK_SENDER: u32 = 1u32;
pub const CLEAR_NRN_PENDING: u32 = 64u32;
pub const CLEAR_READ_FLAG: u32 = 4u32;
pub const CLEAR_RN_PENDING: u32 = 32u32;
pub const CLSID_IMimeHtmlProtocol: windows_core::GUID =
windows_core::GUID::from_u128(0x05300401_bcbc_11d0_85e3_00c04fd85ab4);
pub const CLSID_IVirtualStream: windows_core::GUID =
windows_core::GUID::from_u128(0xfd853cdf_7f86_11d0_8252_00c04fd85ab4);
pub const CLSID_MimeEdit: windows_core::GUID =
windows_core::GUID::from_u128(0x1c82ead9_508e_11d1_8dcf_00c04fb951f9);
pub const CLSID_OlkAccountManager: windows_core::GUID =
windows_core::GUID::from_u128(0xed475410_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkAddressBook: windows_core::GUID =
windows_core::GUID::from_u128(0xed475419_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkHotmailAccount: windows_core::GUID =
windows_core::GUID::from_u128(0x4db5cbf0_3b77_4852_bc8e_bb81908861f3);
pub const CLSID_OlkIMAP4Account: windows_core::GUID =
windows_core::GUID::from_u128(0xed475412_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkLDAPAccount: windows_core::GUID =
windows_core::GUID::from_u128(0x4db5cbf2_3b77_4852_bc8e_bb81908861f3);
pub const CLSID_OlkMAPIAccount: windows_core::GUID =
windows_core::GUID::from_u128(0xed475414_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkMail: windows_core::GUID =
windows_core::GUID::from_u128(0xed475418_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkPOP3Account: windows_core::GUID =
windows_core::GUID::from_u128(0xed475411_b0d6_11d2_8c3b_00104b2a6676);
pub const CLSID_OlkStore: windows_core::GUID =
windows_core::GUID::from_u128(0xed475420_b0d6_11d2_8c3b_00104b2a6676);
pub const CMDSETID_MimeEdit: windows_core::GUID =
windows_core::GUID::from_u128(0x1c82eada_508e_11d1_8dcf_00c04fb951f9);
pub const CMDSETID_MimeEditHost: windows_core::GUID =
windows_core::GUID::from_u128(0x1c82eadb_508e_11d1_8dcf_00c04fb951f9);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CODEPAGEINFO {
pub dwMask: u32,
pub cpiCodePage: u32,
pub fIsValidCodePage: windows::Win32::Foundation::BOOL,
pub ulMaxCharSize: u32,
pub fInternetCP: windows::Win32::Foundation::BOOL,
pub cpiFamily: u32,
pub szName: [i8; 128],
pub szBodyCset: [i8; 128],
pub szHeaderCset: [i8; 128],
pub szWebCset: [i8; 128],
pub szFixedFont: [i8; 128],
pub szVariableFont: [i8; 128],
pub ietNewsDefault: ENCODINGTYPE,
pub ietMailDefault: ENCODINGTYPE,
pub dwReserved1: u32,
}
impl Default for CODEPAGEINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const COMMIT_ONLYIFDIRTY: u32 = 1u32;
pub const COMMIT_REUSESTORAGE: u32 = 2u32;
pub const COMMIT_SMIMETRANSFERENCODE: u32 = 4u32;
pub const CONFIG_CHANGED: u32 = 1048576u32;
pub const CONFIG_NO_AUTO_DETECT: u32 = 16u32;
pub const CONFIG_OST_CACHE_ONLY: u32 = 32u32;
pub const CONFIG_PROMPT_FOR_CREDENTIALS: u32 = 8u32;
pub const CONFIG_SERVICE: u32 = 1u32;
pub const CONFIG_SHOW_CONNECT_UI: u32 = 4u32;
pub const CONFIG_SHOW_STARTUP_UI: u32 = 2u32;
pub const CONNECT_ANONYMOUS_ACCESS: u32 = 16u32;
pub const CONNECT_NO_ADDRESS_RESOLUTION: u32 = 64u32;
pub const CONNECT_NO_NOTIFICATIONS: u32 = 32u32;
pub const CONNECT_NO_RPC_ENCRYPTION: u32 = 2u32;
pub const CONNECT_NO_TABLE_NOTIFICATIONS: u32 = 32u32;
pub const CONNECT_NO_UNDER_COVER_CONNECTION: u32 = 8u32;
pub const CONNECT_RESTORE_DATABASE: u32 = 128u32;
pub const CONNECT_USE_ADMIN_PRIVILEGE: u32 = 1u32;
pub const CONNECT_USE_SEPARATE_CONNECTION: u32 = 4u32;
pub const CONVENIENT_DEPTH: u32 = 1u32;
pub const COPY_SUBFOLDERS: u32 = 16u32;
pub const COUNTRY_PAD: u32 = 0u32;
pub const CP_ACP: u32 = 0u32;
pub const CP_ISO2022JPESC: u32 = 50221u32;
pub const CP_ISO2022JPSIO: u32 = 50222u32;
pub const CP_JAUTODETECT: u32 = 50932u32;
pub const CP_KAUTODETECT: u32 = 50949u32;
pub const CP_OEMCP: u32 = 1u32;
pub const CP_UNICODE: u32 = 1200u32;
pub const CP_USASCII: u32 = 1252u32;
pub const CREATE_ALWAYS: u32 = 2u32;
pub const CREATE_CHECK_DUP_LOOSE: u32 = 2u32;
pub const CREATE_CHECK_DUP_STRICT: u32 = 1u32;
pub const CREATE_NEW: u32 = 1u32;
pub const CREATE_REPLACE: u32 = 4u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CSETAPPLYTYPE(pub i32);
pub const CSET_APPLY_ALL: CSETAPPLYTYPE = CSETAPPLYTYPE(1i32);
pub const CSET_APPLY_TAG_ALL: CSETAPPLYTYPE = CSETAPPLYTYPE(2i32);
pub const CSET_APPLY_UNTAGGED: CSETAPPLYTYPE = CSETAPPLYTYPE(0i32);
pub const CURRENT_SPI_VERSION: i32 = 65552i32;
pub const DEF_ALLOW_8BIT_HEADER: u32 = 0u32;
pub const DEF_BODY_REMOVE_NBSP: u32 = 1u32;
pub const DEF_CAN_INLINE_TEXT_BODIES: u32 = 0u32;
pub const DEF_CBMAX_BODY_LINE: u32 = 74u32;
pub const DEF_CBMAX_HEADER_LINE: u32 = 1000u32;
pub const DEF_CLEANUP_TREE_ON_SAVE: u32 = 1u32;
pub const DEF_DBCS_ESCAPE_IS_8BIT: u32 = 0u32;
pub const DEF_DECODE_RFC1154: u32 = 0u32;
pub const DEF_ENCRYPTION_ALG_ID: u32 = 26114u32;
pub const DEF_GENERATE_MESSAGE_ID: u32 = 0u32;
pub const DEF_HANDSOFF_ONSAVE: u32 = 0u32;
pub const DEF_HASH_ALG_ID: u32 = 32772u32;
pub const DEF_HIDE_TNEF_ATTACHMENTS: u32 = 1u32;
pub const DEF_INCLUDE_SENDER_CERT: u32 = 0u32;
pub const DEF_LOAD_USE_BIND_FILE: u32 = 0u32;
pub const DEF_NO_DEFAULT_CNTTYPE: u32 = 0u32;
pub const DEF_SAVEBODY_KEEPBOUNDARY: u32 = 0u32;
pub const DEF_SECURITY_IGNOREMASK: u32 = 0u32;
pub const DEF_SHOW_MACBINARY: u32 = 0u32;
pub const DEF_SUPPORT_EXTERNAL_BODY: u32 = 0u32;
pub const DEF_WRAP_BODY_TEXT: u32 = 1u32;
pub const DEINIT_HURRY: u32 = 2147483648u32;
pub const DEINIT_NORMAL: u32 = 1u32;
pub const DELETE_CHILDREN_ONLY: u32 = 2u32;
pub const DELETE_HARD_DELETE: u32 = 16u32;
pub const DELETE_PROMOTE_CHILDREN: u32 = 1u32;
pub const DEL_ASSOCIATED: u32 = 8u32;
pub const DEL_FOLDERS: u32 = 4u32;
pub const DEL_MESSAGES: u32 = 1u32;
pub const DIALOG_ALLOW_CANCEL: u32 = 128u32;
pub const DIALOG_ATTACH: u32 = 8u32;
pub const DIALOG_CONFIRM_CANCEL: u32 = 256u32;
pub const DIALOG_COPY: u32 = 32u32;
pub const DIALOG_DELETE: u32 = 64u32;
pub const DIALOG_FOLDER: u32 = 1u32;
pub const DIALOG_MESSAGE: u32 = 2u32;
pub const DIALOG_MODAL: u32 = 1u32;
pub const DIALOG_MOVE: u32 = 16u32;
pub const DIALOG_OPTIONS: u32 = 4u32;
pub const DIALOG_PROP: u32 = 4u32;
pub const DIALOG_SDI: u32 = 2u32;
pub const DIR_BACKWARD: u32 = 1u32;
pub const DO_NOT_SEND_TO_ORIGINATOR: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLBUTTON {
pub ulbLpszLabel: u32,
pub ulFlags: u32,
pub ulPRControl: u32,
}
impl Default for DTBLBUTTON {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLCHECKBOX {
pub ulbLpszLabel: u32,
pub ulFlags: u32,
pub ulPRPropertyName: u32,
}
impl Default for DTBLCHECKBOX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLCOMBOBOX {
pub ulbLpszCharsAllowed: u32,
pub ulFlags: u32,
pub ulNumCharsAllowed: u32,
pub ulPRPropertyName: u32,
pub ulPRTableName: u32,
}
impl Default for DTBLCOMBOBOX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLDDLBX {
pub ulFlags: u32,
pub ulPRDisplayProperty: u32,
pub ulPRSetProperty: u32,
pub ulPRTableName: u32,
}
impl Default for DTBLDDLBX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLEDIT {
pub ulbLpszCharsAllowed: u32,
pub ulFlags: u32,
pub ulNumCharsAllowed: u32,
pub ulPropTag: u32,
}
impl Default for DTBLEDIT {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLGROUPBOX {
pub ulbLpszLabel: u32,
pub ulFlags: u32,
}
impl Default for DTBLGROUPBOX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLLABEL {
pub ulbLpszLabelName: u32,
pub ulFlags: u32,
}
impl Default for DTBLLABEL {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLLBX {
pub ulFlags: u32,
pub ulPRSetProperty: u32,
pub ulPRTableName: u32,
}
impl Default for DTBLLBX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLMVDDLBX {
pub ulFlags: u32,
pub ulMVPropTag: u32,
}
impl Default for DTBLMVDDLBX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLMVLISTBOX {
pub ulFlags: u32,
pub ulMVPropTag: u32,
}
impl Default for DTBLMVLISTBOX {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLPAGE {
pub ulbLpszLabel: u32,
pub ulFlags: u32,
pub ulbLpszComponent: u32,
pub ulContext: u32,
}
impl Default for DTBLPAGE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DTBLRADIOBUTTON {
pub ulbLpszLabel: u32,
pub ulFlags: u32,
pub ulcButtons: u32,
pub ulPropTag: u32,
pub lReturnValue: i32,
}
impl Default for DTBLRADIOBUTTON {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct DTCTL {
pub ulCtlType: u32,
pub ulCtlFlags: u32,
pub lpbNotif: *mut u8,
pub cbNotif: u32,
pub lpszFilter: *mut i8,
pub ulItemID: u32,
pub ctl: DTCTL_0,
}
impl Default for DTCTL {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union DTCTL_0 {
pub lpv: *mut core::ffi::c_void,
pub lplabel: *mut DTBLLABEL,
pub lpedit: *mut DTBLEDIT,
pub lplbx: *mut DTBLLBX,
pub lpcombobox: *mut DTBLCOMBOBOX,
pub lpddlbx: *mut DTBLDDLBX,
pub lpcheckbox: *mut DTBLCHECKBOX,
pub lpgroupbox: *mut DTBLGROUPBOX,
pub lpbutton: *mut DTBLBUTTON,
pub lpradiobutton: *mut DTBLRADIOBUTTON,
pub lpmvlbx: *mut DTBLMVLISTBOX,
pub lpmvddlbx: *mut DTBLMVDDLBX,
pub lppage: *mut DTBLPAGE,
}
impl Default for DTCTL_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const DTCT_BUTTON: u32 = 7u32;
pub const DTCT_CHECKBOX: u32 = 5u32;
pub const DTCT_COMBOBOX: u32 = 3u32;
pub const DTCT_DDLBX: u32 = 4u32;
pub const DTCT_EDIT: u32 = 1u32;
pub const DTCT_GROUPBOX: u32 = 6u32;
pub const DTCT_LABEL: u32 = 0u32;
pub const DTCT_LBX: u32 = 2u32;
pub const DTCT_MVDDLBX: u32 = 12u32;
pub const DTCT_MVLISTBOX: u32 = 11u32;
pub const DTCT_PAGE: u32 = 8u32;
pub const DTCT_RADIOBUTTON: u32 = 9u32;
pub const DTE_FLAG_ACL_CAPABLE: u32 = 1073741824u32;
pub const DTE_FLAG_REMOTE_VALID: u32 = 2147483648u32;
pub const DTE_MASK_LOCAL: u32 = 255u32;
pub const DTE_MASK_REMOTE: u32 = 65280u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct DTPAGE {
pub cctl: u32,
pub lpszResourceName: *mut i8,
pub Anonymous: DTPAGE_0,
pub lpctl: *mut DTCTL,
}
impl Default for DTPAGE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union DTPAGE_0 {
pub lpszComponent: *mut i8,
pub ulItemID: u32,
}
impl Default for DTPAGE_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const DT_ACCEPT_DBCS: u32 = 32u32;
pub const DT_AGENT: u32 = 3u32;
pub const DT_DISTLIST: u32 = 1u32;
pub const DT_EDITABLE: u32 = 2u32;
pub const DT_EQUIPMENT: u32 = 8u32;
pub const DT_FOLDER: u32 = 16777216u32;
pub const DT_FOLDER_LINK: u32 = 33554432u32;
pub const DT_FOLDER_SPECIAL: u32 = 67108864u32;
pub const DT_FORUM: u32 = 2u32;
pub const DT_GLOBAL: u32 = 131072u32;
pub const DT_LOCAL: u32 = 196608u32;
pub const DT_MAILUSER: u32 = 0u32;
pub const DT_MODIFIABLE: u32 = 65536u32;
pub const DT_MULTILINE: u32 = 1u32;
pub const DT_NOT_SPECIFIC: u32 = 327680u32;
pub const DT_ORGANIZATION: u32 = 4u32;
pub const DT_PASSWORD_EDIT: u32 = 16u32;
pub const DT_PRIVATE_DISTLIST: u32 = 5u32;
pub const DT_REMOTE_MAILUSER: u32 = 6u32;
pub const DT_REQUIRED: u32 = 4u32;
pub const DT_ROOM: u32 = 7u32;
pub const DT_SEC_DISTLIST: u32 = 9u32;
pub const DT_SET_IMMEDIATE: u32 = 8u32;
pub const DT_SET_SELECTION: u32 = 64u32;
pub const DT_WAN: u32 = 262144u32;
pub const EBF_COMMITIFDIRTY: u32 = 131072u32;
pub const EBF_MASK: u32 = 4294901760u32;
pub const EBF_RECURSE: u32 = 65536u32;
pub const EDITOR_FORMAT_DONTKNOW: u32 = 0u32;
pub const EDITOR_FORMAT_HTML: u32 = 2u32;
pub const EDITOR_FORMAT_PLAINTEXT: u32 = 1u32;
pub const EDITOR_FORMAT_RTF: u32 = 3u32;
pub const EDK_RULES_VERSION: u32 = 1u32;
pub const EMS_AB_ADDRESS_LOOKUP: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct ENCODINGTYPE(pub i32);
pub const END_DONT_RESEND: u32 = 262144u32;
pub const END_RESEND_LATER: u32 = 131072u32;
pub const END_RESEND_NOW: u32 = 65536u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENTRYID {
pub abFlags: [u8; 4],
pub ab: [u8; 1],
}
impl Default for ENTRYID {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENUMHEADERROW {
pub hRow: *mut HHEADERROW__,
pub pszHeader: windows_core::PSTR,
pub pszData: windows_core::PSTR,
pub cchData: u32,
pub dwReserved: u32,
}
impl Default for ENUMHEADERROW {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ENUMPROPERTY {
pub pszName: windows_core::PSTR,
pub hRow: *mut HHEADERROW__,
pub dwPropId: u32,
}
impl Default for ENUMPROPERTY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ENV_BLANK: u32 = 0u32;
pub const ENV_MSG_EXT: u32 = 2u32;
pub const ENV_RECIP_EXT: u32 = 4u32;
pub const ENV_RECIP_NUM: u32 = 1u32;
pub const EPF_NONAME: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ERROR_NOTIFICATION {
pub cbEntryID: u32,
pub lpEntryID: *mut ENTRYID,
pub scode: i32,
pub ulFlags: u32,
pub lpMAPIError: *mut MAPIERROR,
}
impl Default for ERROR_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const EXCHANGE_RM_SET_EXPLICIT_SD: u32 = 1u32;
pub const EXCHIVERB_FORWARD: u32 = 104u32;
pub const EXCHIVERB_OPEN: u32 = 0u32;
pub const EXCHIVERB_PRINT: u32 = 105u32;
pub const EXCHIVERB_REPLYTOALL: u32 = 103u32;
pub const EXCHIVERB_REPLYTOFOLDER: u32 = 108u32;
pub const EXCHIVERB_REPLYTOSENDER: u32 = 102u32;
pub const EXCHIVERB_RESERVED_COMPOSE: u32 = 100u32;
pub const EXCHIVERB_RESERVED_DELIVERY: u32 = 107u32;
pub const EXCHIVERB_RESERVED_OPEN: u32 = 101u32;
pub const EXCHIVERB_SAVEAS: u32 = 106u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct EXTENDED_NOTIFICATION {
pub ulEvent: u32,
pub cb: u32,
pub pbEventParameters: *mut u8,
}
impl Default for EXTENDED_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const E_ACCT_NOT_FOUND: u32 = 2148303105u32;
pub const E_ACCT_WRONG_SORT_ORDER: u32 = 2148303109u32;
pub const E_OLK_ALREADY_INITIALIZED: u32 = 2148302850u32;
pub const E_OLK_NOT_INITIALIZED: u32 = 2148302853u32;
pub const E_OLK_PARAM_NOT_SUPPORTED: u32 = 2148302851u32;
pub const E_OLK_PROP_READ_ONLY: u32 = 2148302861u32;
pub const E_OLK_REGISTRY: u32 = 2148302850u32;
pub const FACILITY_INTERNET: u32 = 12u32;
pub type FGETCOMPONENTPATH = Option<
unsafe extern "system" fn(
szcomponent: *mut i8,
szqualifier: *mut i8,
szdllpath: *mut i8,
cchbuffersize: u32,
finstall: windows::Win32::Foundation::BOOL,
) -> windows::Win32::Foundation::BOOL,
>;
pub const FILE_ATTRIBUTE_ARCHIVE: u32 = 32u32;
pub const FILE_ATTRIBUTE_DIRECTORY: u32 = 16u32;
pub const FILE_ATTRIBUTE_HIDDEN: u32 = 2u32;
pub const FILE_ATTRIBUTE_NORMAL: u32 = 128u32;
pub const FILE_ATTRIBUTE_READONLY: u32 = 1u32;
pub const FILE_ATTRIBUTE_SYSTEM: u32 = 4u32;
pub const FILE_ATTRIBUTE_TEMPORARY: u32 = 256u32;
pub const FILE_FLAG_RANDOM_ACCESS: u32 = 268435456u32;
pub const FILE_FLAG_SEQUENTIAL_SCAN: u32 = 134217728u32;
pub const FILE_FLAG_WRITE_THROUGH: u32 = 2147483648u32;
pub const FILL_ENTRY: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FINDBODY {
pub pszPriType: windows_core::PSTR,
pub pszSubType: windows_core::PSTR,
pub dwReserved: u32,
}
impl Default for FINDBODY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FINDHEADER {
pub pszHeader: windows_core::PCSTR,
pub dwReserved: u32,
}
impl Default for FINDHEADER {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATENTRY {
pub cb: u32,
pub abEntry: [u8; 1],
}
impl Default for FLATENTRY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATENTRYLIST {
pub cEntries: u32,
pub cbEntries: u32,
pub abEntries: [u8; 1],
}
impl Default for FLATENTRYLIST {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FLATMTSIDLIST {
pub cMTSIDs: u32,
pub cbMTSIDs: u32,
pub abMTSIDs: [u8; 1],
}
impl Default for FLATMTSIDLIST {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const FLDSTATUS_DELMARKED: u32 = 8u32;
pub const FLDSTATUS_HIDDEN: u32 = 4u32;
pub const FLDSTATUS_HIGHLIGHTED: u32 = 1u32;
pub const FLDSTATUS_TAGGED: u32 = 2u32;
pub const FLUSH_ASYNC_OK: u32 = 32u32;
pub const FLUSH_DOWNLOAD: u32 = 4u32;
pub const FLUSH_FORCE: u32 = 8u32;
pub const FLUSH_NO_UI: u32 = 16u32;
pub const FLUSH_UPLOAD: u32 = 2u32;
pub const FL_FULLSTRING: u32 = 0u32;
pub const FL_IGNORECASE: u32 = 65536u32;
pub const FL_IGNORENONSPACE: u32 = 131072u32;
pub const FL_LOOSE: u32 = 262144u32;
pub const FL_PREFIX: u32 = 2u32;
pub const FL_SUBSTRING: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct FNTSYSTYPE(pub i32);
pub const FNT_SYS_ICON: FNTSYSTYPE = FNTSYSTYPE(0i32);
pub const FNT_SYS_ICON_BOLD: FNTSYSTYPE = FNTSYSTYPE(1i32);
pub const FNT_SYS_ICON_STRIKEOUT: FNTSYSTYPE = FNTSYSTYPE(3i32);
pub const FNT_SYS_LAST: FNTSYSTYPE = FNTSYSTYPE(4i32);
pub const FNT_SYS_MENU: FNTSYSTYPE = FNTSYSTYPE(2i32);
pub const FOLDER_COMMON_VIEWS_VALID: u32 = 64u32;
pub const FOLDER_DIALOG: u32 = 2u32;
pub const FOLDER_FINDER_VALID: u32 = 128u32;
pub const FOLDER_GENERIC: u32 = 1u32;
pub const FOLDER_IPM_INBOX_VALID: u32 = 2u32;
pub const FOLDER_IPM_OUTBOX_VALID: u32 = 4u32;
pub const FOLDER_IPM_SENTMAIL_VALID: u32 = 16u32;
pub const FOLDER_IPM_SUBTREE_VALID: u32 = 1u32;
pub const FOLDER_IPM_WASTEBASKET_VALID: u32 = 8u32;
pub const FOLDER_MOVE: u32 = 1u32;
pub const FOLDER_ROOT: u32 = 0u32;
pub const FOLDER_SEARCH: u32 = 2u32;
pub const FOLDER_VIEWS_VALID: u32 = 32u32;
pub const FORCE_SAVE: u32 = 4u32;
pub const FORCE_SUBMIT: u32 = 1u32;
pub const FORCE_XP_CONNECT: u32 = 262144u32;
pub const FORCE_XP_DISCONNECT: u32 = 524288u32;
pub const FOREGROUND_SEARCH: u32 = 16u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FORMPRINTSETUP {
pub ulFlags: u32,
pub hDevMode: windows::Win32::Foundation::HGLOBAL,
pub hDevNames: windows::Win32::Foundation::HGLOBAL,
pub ulFirstPageNumber: u32,
pub fPrintAttachments: u32,
}
impl Default for FORMPRINTSETUP {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const FORMPROPSET_INTERSECTION: u32 = 1u32;
pub const FORMPROPSET_UNION: u32 = 0u32;
pub const FPST_ENUM_PROP: u32 = 1u32;
pub const FPST_VANILLA: u32 = 0u32;
pub const FWD_AS_ATTACHMENT: u32 = 4u32;
pub const FWD_DO_NOT_MUNGE_MSG: u32 = 2u32;
pub const FWD_PRESERVE_SENDER: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct FlagList {
pub cFlags: u32,
pub ulFlag: [u32; 1],
}
impl Default for FlagList {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const GENERATE_RECEIPT_ONLY: u32 = 16u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HADDRESS__ {
pub unused: u32,
}
impl Default for HADDRESS__ {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HBODY__ {
pub unused: u32,
}
impl Default for HBODY__ {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HCHARSET__ {
pub unused: u32,
}
impl Default for HCHARSET__ {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HEADERROWINFO {
pub dwRowNumber: u32,
pub cboffStart: u32,
pub cboffColon: u32,
pub cboffEnd: u32,
}
impl Default for HEADERROWINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct HEADERTABLEFLAGS(pub i32);
pub const HFRMREG_DEFAULT: u32 = 0u32;
pub const HFRMREG_FOLDER: u32 = 3u32;
pub const HFRMREG_LOCAL: u32 = 1u32;
pub const HFRMREG_PERSONAL: u32 = 2u32;
pub const HF_NO_DUPLICATES: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct HHEADERROW__ {
pub unused: u32,
}
impl Default for HHEADERROW__ {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const HOOK_CANCEL: u32 = 2u32;
pub const HOOK_DELETE: u32 = 1u32;
pub const HOOK_INBOUND: u32 = 512u32;
pub const HOOK_OUTBOUND: u32 = 1024u32;
pub type HPPROVIDERINIT = Option<
unsafe extern "system" fn(
lpsession: Option<IMAPISession>,
hinstance: windows::Win32::Foundation::HINSTANCE,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
lpsectionuid: *mut MAPIUID,
ulflags: u32,
lppspoolerhook: *mut Option<ISpoolerHook>,
) -> windows_core::HRESULT,
>;
pub const HTF_ENUMHANDLESONLY: HEADERTABLEFLAGS = HEADERTABLEFLAGS(2i32);
pub const HTF_NAMEINDATA: HEADERTABLEFLAGS = HEADERTABLEFLAGS(1i32);
windows_core::imp::define_interface!(
IABContainer,
IABContainer_Vtbl,
0x0002030d_0000_0000_c000_000000000046
);
impl core::ops::Deref for IABContainer {
type Target = IMAPIContainer;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IABContainer,
windows_core::IUnknown,
IMAPIProp,
IMAPIContainer
);
impl IABContainer {
pub unsafe fn CreateEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: *mut Option<IMAPIProp>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
ulcreateflags,
core::mem::transmute(lppmapipropentry),
)
.ok()
}
}
pub unsafe fn CopyEntries<P2>(
&self,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyEntries)(
windows_core::Interface::as_raw(self),
lpentries as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteEntries(
&self,
lpentries: *mut SBinaryArray,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteEntries)(
windows_core::Interface::as_raw(self),
lpentries as _,
ulflags,
)
.ok()
}
}
pub unsafe fn ResolveNames(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ResolveNames)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
ulflags,
lpadrlist as _,
lpflaglist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IABContainer_Vtbl {
pub base__: IMAPIContainer_Vtbl,
pub CreateEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CopyEntries: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DeleteEntries: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
u32,
) -> windows_core::HRESULT,
pub ResolveNames: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
u32,
*mut ADRLIST,
*mut FlagList,
) -> windows_core::HRESULT,
}
pub trait IABContainer_Impl: IMAPIContainer_Impl {
fn CreateEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: windows_core::OutRef<'_, IMAPIProp>,
) -> windows_core::Result<()>;
fn CopyEntries(
&self,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteEntries(&self, lpentries: *mut SBinaryArray, ulflags: u32)
-> windows_core::Result<()>;
fn ResolveNames(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::Result<()>;
}
impl IABContainer_Vtbl {
pub const fn new<Identity: IABContainer_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateEntry<Identity: IABContainer_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABContainer_Impl::CreateEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulcreateflags),
core::mem::transmute_copy(&lppmapipropentry),
)
.into()
}
}
unsafe extern "system" fn CopyEntries<Identity: IABContainer_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABContainer_Impl::CopyEntries(
this,
core::mem::transmute_copy(&lpentries),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteEntries<
Identity: IABContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpentries: *mut SBinaryArray,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABContainer_Impl::DeleteEntries(
this,
core::mem::transmute_copy(&lpentries),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn ResolveNames<Identity: IABContainer_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABContainer_Impl::ResolveNames(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpadrlist),
core::mem::transmute_copy(&lpflaglist),
)
.into()
}
}
Self {
base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
CreateEntry: CreateEntry::<Identity, OFFSET>,
CopyEntries: CopyEntries::<Identity, OFFSET>,
DeleteEntries: DeleteEntries::<Identity, OFFSET>,
ResolveNames: ResolveNames::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IABContainer as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
|| iid == &<IMAPIContainer as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IABContainer {}
pub const IABContainer_CopyEntries: METHODS = METHODS(43i32);
pub const IABContainer_CreateEntry: METHODS = METHODS(42i32);
pub const IABContainer_DeleteEntries: METHODS = METHODS(44i32);
pub const IABContainer_ResolveNames: METHODS = METHODS(45i32);
windows_core::imp::define_interface!(
IABLogon,
IABLogon_Vtbl,
0x00020314_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IABLogon, windows_core::IUnknown);
impl IABLogon {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Logoff(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Logoff)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn Advise<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut Option<IMAPIStatus>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenStatusEntry)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppentry),
)
.ok()
}
}
pub unsafe fn OpenTemplateID<P3, P6>(
&self,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: P3,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: *mut Option<IMAPIProp>,
lpmapipropsibling: P6,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIProp>,
P6: windows_core::Param<IMAPIProp>,
{
unsafe {
(windows_core::Interface::vtable(self).OpenTemplateID)(
windows_core::Interface::as_raw(self),
cbtemplateid,
lptemplateid as _,
ultemplateflags,
lpmapipropdata.param().abi(),
lpinterface as _,
core::mem::transmute(lppmapipropnew),
lpmapipropsibling.param().abi(),
)
.ok()
}
}
pub unsafe fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetOneOffTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn PrepareRecips(
&self,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PrepareRecips)(
windows_core::Interface::as_raw(self),
ulflags,
lpproptagarray as _,
lpreciplist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IABLogon_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Logoff: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub OpenStatusEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenTemplateID: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut *mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetOneOffTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub PrepareRecips: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropTagArray,
*mut ADRLIST,
) -> windows_core::HRESULT,
}
pub trait IABLogon_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Logoff(&self, ulflags: u32) -> windows_core::Result<()>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn Advise(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: windows_core::OutRef<'_, IMAPIStatus>,
) -> windows_core::Result<()>;
fn OpenTemplateID(
&self,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: windows_core::Ref<'_, IMAPIProp>,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: windows_core::OutRef<'_, IMAPIProp>,
lpmapipropsibling: windows_core::Ref<'_, IMAPIProp>,
) -> windows_core::Result<()>;
fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn PrepareRecips(
&self,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()>;
}
impl IABLogon_Vtbl {
pub const fn new<Identity: IABLogon_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Logoff<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::Logoff(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn OpenEntry<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn CompareEntryIDs<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::Advise(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn OpenStatusEntry<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::OpenStatusEntry(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppentry),
)
.into()
}
}
unsafe extern "system" fn OpenTemplateID<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: *mut *mut core::ffi::c_void,
lpmapipropsibling: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::OpenTemplateID(
this,
core::mem::transmute_copy(&cbtemplateid),
core::mem::transmute_copy(&lptemplateid),
core::mem::transmute_copy(&ultemplateflags),
core::mem::transmute_copy(&lpmapipropdata),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lppmapipropnew),
core::mem::transmute_copy(&lpmapipropsibling),
)
.into()
}
}
unsafe extern "system" fn GetOneOffTable<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IABLogon_Impl::GetOneOffTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn PrepareRecips<Identity: IABLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABLogon_Impl::PrepareRecips(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&lpreciplist),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Logoff: Logoff::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
OpenTemplateID: OpenTemplateID::<Identity, OFFSET>,
GetOneOffTable: GetOneOffTable::<Identity, OFFSET>,
PrepareRecips: PrepareRecips::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IABLogon as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IABLogon {}
pub const IABLogon_Advise: METHODS = METHODS(88i32);
pub const IABLogon_CompareEntryIDs: METHODS = METHODS(87i32);
pub const IABLogon_GetLastError: METHODS = METHODS(84i32);
pub const IABLogon_GetOneOffTable: METHODS = METHODS(92i32);
pub const IABLogon_Logoff: METHODS = METHODS(85i32);
pub const IABLogon_OpenEntry: METHODS = METHODS(86i32);
pub const IABLogon_OpenStatusEntry: METHODS = METHODS(90i32);
pub const IABLogon_OpenTemplateID: METHODS = METHODS(91i32);
pub const IABLogon_PrepareRecips: METHODS = METHODS(93i32);
pub const IABLogon_Unadvise: METHODS = METHODS(89i32);
windows_core::imp::define_interface!(
IABProvider,
IABProvider_Vtbl,
0x00020311_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IABProvider, windows_core::IUnknown);
impl IABProvider {
pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Shutdown)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn Logon<P0>(
&self,
lpmapisup: P0,
uluiparam: usize,
lpszprofilename: *mut i8,
ulflags: u32,
lpulpcbsecurity: *mut u32,
lppbsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppablogon: *mut Option<IABLogon>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISupport>,
{
unsafe {
(windows_core::Interface::vtable(self).Logon)(
windows_core::Interface::as_raw(self),
lpmapisup.param().abi(),
uluiparam,
lpszprofilename as _,
ulflags,
lpulpcbsecurity as _,
lppbsecurity as _,
lppmapierror as _,
core::mem::transmute(lppablogon),
)
.ok()
}
}
}
#[repr(C)]
pub struct IABProvider_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Shutdown:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub Logon: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
usize,
*mut i8,
u32,
*mut u32,
*mut *mut u8,
*mut *mut MAPIERROR,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IABProvider_Impl: windows_core::IUnknownImpl {
fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn Logon(
&self,
lpmapisup: windows_core::Ref<'_, IMAPISupport>,
uluiparam: usize,
lpszprofilename: *mut i8,
ulflags: u32,
lpulpcbsecurity: *mut u32,
lppbsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppablogon: windows_core::OutRef<'_, IABLogon>,
) -> windows_core::Result<()>;
}
impl IABProvider_Vtbl {
pub const fn new<Identity: IABProvider_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Shutdown<Identity: IABProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn Logon<Identity: IABProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmapisup: *mut core::ffi::c_void,
uluiparam: usize,
lpszprofilename: *mut i8,
ulflags: u32,
lpulpcbsecurity: *mut u32,
lppbsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppablogon: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IABProvider_Impl::Logon(
this,
core::mem::transmute_copy(&lpmapisup),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulpcbsecurity),
core::mem::transmute_copy(&lppbsecurity),
core::mem::transmute_copy(&lppmapierror),
core::mem::transmute_copy(&lppablogon),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Shutdown: Shutdown::<Identity, OFFSET>,
Logon: Logon::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IABProvider as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IABProvider {}
pub const IABProvider_Logon: METHODS = METHODS(83i32);
pub const IABProvider_Shutdown: METHODS = METHODS(82i32);
pub const IAP_ADRTYPE: u32 = 4u32;
pub const IAP_ALL: u32 = 4294967295u32;
pub const IAP_CERTSTATE: u32 = 256u32;
pub const IAP_CHARSET: u32 = 1u32;
pub const IAP_COOKIE: u32 = 4096u32;
pub const IAP_EMAIL: u32 = 32u32;
pub const IAP_ENCODING: u32 = 2048u32;
pub const IAP_ENCRYPTION_PRINT: u32 = 1024u32;
pub const IAP_FRIENDLY: u32 = 8u32;
pub const IAP_HANDLE: u32 = 2u32;
pub const IAP_SIGNING_PRINT: u32 = 512u32;
pub const IAT_ALL: u32 = 4294967295u32;
pub const IAT_APPARTO: u32 = 512u32;
pub const IAT_BCC: u32 = 16u32;
pub const IAT_CC: u32 = 8u32;
pub const IAT_FROM: u32 = 1u32;
pub const IAT_REPLYTO: u32 = 32u32;
pub const IAT_RETRCPTTO: u32 = 128u32;
pub const IAT_RETURNPATH: u32 = 64u32;
pub const IAT_RR: u32 = 256u32;
pub const IAT_SENDER: u32 = 2u32;
pub const IAT_TO: u32 = 4u32;
pub const IAT_UNKNOWN: u32 = 0u32;
windows_core::imp::define_interface!(
IAddrBook,
IAddrBook_Vtbl,
0x00020309_0000_0000_c000_000000000046
);
impl core::ops::Deref for IAddrBook {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IAddrBook, windows_core::IUnknown, IMAPIProp);
impl IAddrBook {
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn Advise<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn CreateOneOff(
&self,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateOneOff)(
windows_core::Interface::as_raw(self),
lpszname as _,
lpszadrtype as _,
lpszaddress as _,
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn NewEntry(
&self,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NewEntry)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
cbeidcontainer,
lpeidcontainer as _,
cbeidnewentrytpl,
lpeidnewentrytpl as _,
lpcbeidnewentry as _,
lppeidnewentry as _,
)
.ok()
}
}
pub unsafe fn ResolveName(
&self,
uluiparam: usize,
ulflags: u32,
lpsznewentrytitle: *mut i8,
lpadrlist: *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ResolveName)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
lpsznewentrytitle as _,
lpadrlist as _,
)
.ok()
}
}
pub unsafe fn Address(
&self,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Address)(
windows_core::Interface::as_raw(self),
lpuluiparam as _,
lpadrparms as _,
lppadrlist as _,
)
.ok()
}
}
pub unsafe fn Details(
&self,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Details)(
windows_core::Interface::as_raw(self),
lpuluiparam as _,
lpfndismiss,
lpvdismisscontext as _,
cbentryid,
lpentryid as _,
lpfbuttoncallback,
lpvbuttoncontext as _,
lpszbuttontext as _,
ulflags,
)
.ok()
}
}
pub unsafe fn RecipOptions(
&self,
uluiparam: usize,
ulflags: u32,
lprecip: *mut ADRENTRY,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RecipOptions)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
lprecip as _,
)
.ok()
}
}
pub unsafe fn QueryDefaultRecipOpt(
&self,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryDefaultRecipOpt)(
windows_core::Interface::as_raw(self),
lpszadrtype as _,
ulflags,
lpcvalues as _,
lppoptions as _,
)
.ok()
}
}
pub unsafe fn GetPAB(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetPAB)(
windows_core::Interface::as_raw(self),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn SetPAB(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetPAB)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn GetDefaultDir(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetDefaultDir)(
windows_core::Interface::as_raw(self),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn SetDefaultDir(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetDefaultDir)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn GetSearchPath(
&self,
ulflags: u32,
lppsearchpath: *mut *mut SRowSet,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSearchPath)(
windows_core::Interface::as_raw(self),
ulflags,
lppsearchpath as _,
)
.ok()
}
}
pub unsafe fn SetSearchPath(
&self,
ulflags: u32,
lpsearchpath: *mut SRowSet,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetSearchPath)(
windows_core::Interface::as_raw(self),
ulflags,
lpsearchpath as _,
)
.ok()
}
}
pub unsafe fn PrepareRecips(
&self,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PrepareRecips)(
windows_core::Interface::as_raw(self),
ulflags,
lpproptagarray as _,
lpreciplist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IAddrBook_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub CreateOneOff: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
*mut i8,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub NewEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub ResolveName: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
*mut ADRLIST,
) -> windows_core::HRESULT,
pub Address: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut usize,
*mut ADRPARM,
*mut *mut ADRLIST,
) -> windows_core::HRESULT,
pub Details: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut usize,
LPFNDISMISS,
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
windows::Win32::System::AddressBook::LPFNBUTTON,
*mut core::ffi::c_void,
*mut i8,
u32,
) -> windows_core::HRESULT,
pub RecipOptions: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut ADRENTRY,
) -> windows_core::HRESULT,
pub QueryDefaultRecipOpt: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
u32,
*mut u32,
*mut *mut SPropValue,
) -> windows_core::HRESULT,
pub GetPAB: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub SetPAB: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub GetDefaultDir: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub SetDefaultDir: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub GetSearchPath: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SRowSet,
) -> windows_core::HRESULT,
pub SetSearchPath: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SRowSet,
) -> windows_core::HRESULT,
pub PrepareRecips: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropTagArray,
*mut ADRLIST,
) -> windows_core::HRESULT,
}
pub trait IAddrBook_Impl: IMAPIProp_Impl {
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn Advise(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn CreateOneOff(
&self,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn NewEntry(
&self,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn ResolveName(
&self,
uluiparam: usize,
ulflags: u32,
lpsznewentrytitle: *mut i8,
lpadrlist: *mut ADRLIST,
) -> windows_core::Result<()>;
fn Address(
&self,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::Result<()>;
fn Details(
&self,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>;
fn RecipOptions(
&self,
uluiparam: usize,
ulflags: u32,
lprecip: *mut ADRENTRY,
) -> windows_core::Result<()>;
fn QueryDefaultRecipOpt(
&self,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::Result<()>;
fn GetPAB(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn SetPAB(&self, cbentryid: u32, lpentryid: *mut ENTRYID) -> windows_core::Result<()>;
fn GetDefaultDir(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn SetDefaultDir(&self, cbentryid: u32, lpentryid: *mut ENTRYID) -> windows_core::Result<()>;
fn GetSearchPath(
&self,
ulflags: u32,
lppsearchpath: *mut *mut SRowSet,
) -> windows_core::Result<()>;
fn SetSearchPath(&self, ulflags: u32, lpsearchpath: *mut SRowSet) -> windows_core::Result<()>;
fn PrepareRecips(
&self,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()>;
}
impl IAddrBook_Vtbl {
pub const fn new<Identity: IAddrBook_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OpenEntry<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn CompareEntryIDs<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::Advise(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn CreateOneOff<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::CreateOneOff(
this,
core::mem::transmute_copy(&lpszname),
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&lpszaddress),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn NewEntry<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::NewEntry(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbeidcontainer),
core::mem::transmute_copy(&lpeidcontainer),
core::mem::transmute_copy(&cbeidnewentrytpl),
core::mem::transmute_copy(&lpeidnewentrytpl),
core::mem::transmute_copy(&lpcbeidnewentry),
core::mem::transmute_copy(&lppeidnewentry),
)
.into()
}
}
unsafe extern "system" fn ResolveName<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lpsznewentrytitle: *mut i8,
lpadrlist: *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::ResolveName(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsznewentrytitle),
core::mem::transmute_copy(&lpadrlist),
)
.into()
}
}
unsafe extern "system" fn Address<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::Address(
this,
core::mem::transmute_copy(&lpuluiparam),
core::mem::transmute_copy(&lpadrparms),
core::mem::transmute_copy(&lppadrlist),
)
.into()
}
}
unsafe extern "system" fn Details<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::Details(
this,
core::mem::transmute_copy(&lpuluiparam),
core::mem::transmute_copy(&lpfndismiss),
core::mem::transmute_copy(&lpvdismisscontext),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpfbuttoncallback),
core::mem::transmute_copy(&lpvbuttoncontext),
core::mem::transmute_copy(&lpszbuttontext),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn RecipOptions<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lprecip: *mut ADRENTRY,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::RecipOptions(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lprecip),
)
.into()
}
}
unsafe extern "system" fn QueryDefaultRecipOpt<
Identity: IAddrBook_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::QueryDefaultRecipOpt(
this,
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcvalues),
core::mem::transmute_copy(&lppoptions),
)
.into()
}
}
unsafe extern "system" fn GetPAB<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::GetPAB(
this,
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn SetPAB<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::SetPAB(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn GetDefaultDir<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::GetDefaultDir(
this,
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn SetDefaultDir<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::SetDefaultDir(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn GetSearchPath<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lppsearchpath: *mut *mut SRowSet,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::GetSearchPath(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppsearchpath),
)
.into()
}
}
unsafe extern "system" fn SetSearchPath<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpsearchpath: *mut SRowSet,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::SetSearchPath(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsearchpath),
)
.into()
}
}
unsafe extern "system" fn PrepareRecips<Identity: IAddrBook_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpproptagarray: *mut SPropTagArray,
lpreciplist: *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IAddrBook_Impl::PrepareRecips(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&lpreciplist),
)
.into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
OpenEntry: OpenEntry::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
CreateOneOff: CreateOneOff::<Identity, OFFSET>,
NewEntry: NewEntry::<Identity, OFFSET>,
ResolveName: ResolveName::<Identity, OFFSET>,
Address: Address::<Identity, OFFSET>,
Details: Details::<Identity, OFFSET>,
RecipOptions: RecipOptions::<Identity, OFFSET>,
QueryDefaultRecipOpt: QueryDefaultRecipOpt::<Identity, OFFSET>,
GetPAB: GetPAB::<Identity, OFFSET>,
SetPAB: SetPAB::<Identity, OFFSET>,
GetDefaultDir: GetDefaultDir::<Identity, OFFSET>,
SetDefaultDir: SetDefaultDir::<Identity, OFFSET>,
GetSearchPath: GetSearchPath::<Identity, OFFSET>,
SetSearchPath: SetSearchPath::<Identity, OFFSET>,
PrepareRecips: PrepareRecips::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IAddrBook as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IAddrBook {}
windows_core::imp::define_interface!(IAttach, IAttach_Vtbl, 0);
impl core::ops::Deref for IAttach {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IAttach, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IAttach_Vtbl {
pub base__: IMAPIProp_Vtbl,
}
pub trait IAttach_Impl: IMAPIProp_Impl {}
impl IAttach_Vtbl {
pub const fn new<Identity: IAttach_Impl, const OFFSET: isize>() -> Self {
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IAttach as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IAttach {}
pub const IBL_FIRST: BODYLOCATION = BODYLOCATION(2i32);
pub const IBL_LAST: BODYLOCATION = BODYLOCATION(3i32);
pub const IBL_NEXT: BODYLOCATION = BODYLOCATION(4i32);
pub const IBL_PARENT: BODYLOCATION = BODYLOCATION(1i32);
pub const IBL_PREVIOUS: BODYLOCATION = BODYLOCATION(5i32);
pub const IBL_ROOT: BODYLOCATION = BODYLOCATION(0i32);
pub const IBT_ATTACHMENT: IMSGBODYTYPE = IMSGBODYTYPE(1i32);
pub const IBT_AUTOATTACH: IMSGBODYTYPE = IMSGBODYTYPE(4i32);
pub const IBT_CSETTAGGED: IMSGBODYTYPE = IMSGBODYTYPE(3i32);
pub const IBT_EMPTY: IMSGBODYTYPE = IMSGBODYTYPE(2i32);
pub const IBT_SECURE: IMSGBODYTYPE = IMSGBODYTYPE(0i32);
pub const ICON_INDEX_ACCEPT: u32 = 1029u32;
pub const ICON_INDEX_ASSIGNEE_TASK: u32 = 1282u32;
pub const ICON_INDEX_ASSIGNER_TASK: u32 = 1283u32;
pub const ICON_INDEX_CANCELATION: u32 = 1032u32;
pub const ICON_INDEX_CONTACT: u32 = 512u32;
pub const ICON_INDEX_DECLINE: u32 = 1030u32;
pub const ICON_INDEX_DELIVERY_MAIL: u32 = 264u32;
pub const ICON_INDEX_DISTRIBUTION_LIST: u32 = 514u32;
pub const ICON_INDEX_FORWARDED_MAIL: u32 = 262u32;
pub const ICON_INDEX_INFORMATIONAL_UPDATE: u32 = 1033u32;
pub const ICON_INDEX_IRM_COMPOSE_MAIL: u32 = 309u32;
pub const ICON_INDEX_IRM_FORWARDED_MAIL: u32 = 307u32;
pub const ICON_INDEX_IRM_READ_MAIL: u32 = 305u32;
pub const ICON_INDEX_IRM_REPLIED_MAIL: u32 = 308u32;
pub const ICON_INDEX_IRM_UNREAD_MAIL: u32 = 306u32;
pub const ICON_INDEX_JOURNAL_CONVERSATION: u32 = 1537u32;
pub const ICON_INDEX_JOURNAL_DOCUMENT: u32 = 1554u32;
pub const ICON_INDEX_JOURNAL_EMAIL_MESSAGE: u32 = 1538u32;
pub const ICON_INDEX_JOURNAL_FAX: u32 = 1545u32;
pub const ICON_INDEX_JOURNAL_LETTER: u32 = 1548u32;
pub const ICON_INDEX_JOURNAL_MEETING: u32 = 1555u32;
pub const ICON_INDEX_JOURNAL_MEETING_CANCELLATION: u32 = 1556u32;
pub const ICON_INDEX_JOURNAL_MEETING_REQUEST: u32 = 1539u32;
pub const ICON_INDEX_JOURNAL_MEETING_RESPONSE: u32 = 1540u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_ACCESS: u32 = 1552u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_EXCEL: u32 = 1550u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_POWER_POINT: u32 = 1551u32;
pub const ICON_INDEX_JOURNAL_MICROSOFT_OFFICE_WORD: u32 = 1549u32;
pub const ICON_INDEX_JOURNAL_NOTE: u32 = 1544u32;
pub const ICON_INDEX_JOURNAL_PHONE_CALL: u32 = 1546u32;
pub const ICON_INDEX_JOURNAL_REMOTE_SESSION: u32 = 1557u32;
pub const ICON_INDEX_JOURNAL_TASK_REQUEST: u32 = 1542u32;
pub const ICON_INDEX_JOURNAL_TASK_RESPONSE: u32 = 1543u32;
pub const ICON_INDEX_MAIL_ENCRYPTED: u32 = 272u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_FORWARDED: u32 = 277u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_READ: u32 = 279u32;
pub const ICON_INDEX_MAIL_ENCRYPTED_REPLIED: u32 = 275u32;
pub const ICON_INDEX_MAIL_SIGNED: u32 = 271u32;
pub const ICON_INDEX_MAIL_SMIME_RECEIPT: u32 = 274u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED: u32 = 273u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_FORWARDED: u32 = 278u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_READ: u32 = 280u32;
pub const ICON_INDEX_MAIL_SMIME_SIGNED_REPLIED: u32 = 276u32;
pub const ICON_INDEX_MEETING_REQUEST: u32 = 1028u32;
pub const ICON_INDEX_NEW_MAIL: u32 = 4294967295u32;
pub const ICON_INDEX_NONDELIVERY_MAIL: u32 = 266u32;
pub const ICON_INDEX_NONREAD_MAIL: u32 = 267u32;
pub const ICON_INDEX_OTHER: u32 = 3u32;
pub const ICON_INDEX_OUT_OF_OFFICE_MAIL: u32 = 283u32;
pub const ICON_INDEX_POST: u32 = 1u32;
pub const ICON_INDEX_READ_MAIL: u32 = 256u32;
pub const ICON_INDEX_READ_RECEIPT_MAIL: u32 = 265u32;
pub const ICON_INDEX_RECALL_F_MAIL: u32 = 269u32;
pub const ICON_INDEX_RECALL_MAIL: u32 = 284u32;
pub const ICON_INDEX_RECALL_S_MAIL: u32 = 268u32;
pub const ICON_INDEX_RECEIPT_MAIL: u32 = 260u32;
pub const ICON_INDEX_RECURRING_APPOINTMENT: u32 = 1025u32;
pub const ICON_INDEX_RECURRING_MEETING: u32 = 1027u32;
pub const ICON_INDEX_REMOTE_MAIL: u32 = 263u32;
pub const ICON_INDEX_REPLIED_MAIL: u32 = 261u32;
pub const ICON_INDEX_SINGLE_INSTANCE_APPOINTMENT: u32 = 1024u32;
pub const ICON_INDEX_SINGLE_INSTANCE_MEETING: u32 = 1026u32;
pub const ICON_INDEX_STICKY_NOTE_BLUE: u32 = 768u32;
pub const ICON_INDEX_STICKY_NOTE_GREEN: u32 = 769u32;
pub const ICON_INDEX_STICKY_NOTE_PINK: u32 = 770u32;
pub const ICON_INDEX_STICKY_NOTE_WHITE: u32 = 772u32;
pub const ICON_INDEX_STICKY_NOTE_YELLOW: u32 = 771u32;
pub const ICON_INDEX_SUBMITTED_MAIL: u32 = 258u32;
pub const ICON_INDEX_TASK: u32 = 1280u32;
pub const ICON_INDEX_TASK_ACCEPTANCE: u32 = 1285u32;
pub const ICON_INDEX_TASK_REJECTION: u32 = 1286u32;
pub const ICON_INDEX_TASK_REQUEST: u32 = 1284u32;
pub const ICON_INDEX_TENTATIVE: u32 = 1031u32;
pub const ICON_INDEX_TRACKED_MAIL: u32 = 304u32;
pub const ICON_INDEX_TRACKING_MAIL: u32 = 270u32;
pub const ICON_INDEX_UNASSIGNED_RECURRING_TASK: u32 = 1281u32;
pub const ICON_INDEX_UNREAD_MAIL: u32 = 257u32;
pub const ICON_INDEX_UNSENT_MAIL: u32 = 259u32;
windows_core::imp::define_interface!(
IDistList,
IDistList_Vtbl,
0x0002030e_0000_0000_c000_000000000046
);
impl core::ops::Deref for IDistList {
type Target = IMAPIContainer;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IDistList,
windows_core::IUnknown,
IMAPIProp,
IMAPIContainer
);
impl IDistList {
pub unsafe fn CreateEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: *mut Option<IMAPIProp>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
ulcreateflags,
core::mem::transmute(lppmapipropentry),
)
.ok()
}
}
pub unsafe fn CopyEntries<P2>(
&self,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyEntries)(
windows_core::Interface::as_raw(self),
lpentries as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteEntries(
&self,
lpentries: *mut SBinaryArray,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteEntries)(
windows_core::Interface::as_raw(self),
lpentries as _,
ulflags,
)
.ok()
}
}
pub unsafe fn ResolveNames(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ResolveNames)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
ulflags,
lpadrlist as _,
lpflaglist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IDistList_Vtbl {
pub base__: IMAPIContainer_Vtbl,
pub CreateEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CopyEntries: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DeleteEntries: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
u32,
) -> windows_core::HRESULT,
pub ResolveNames: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
u32,
*mut ADRLIST,
*mut FlagList,
) -> windows_core::HRESULT,
}
pub trait IDistList_Impl: IMAPIContainer_Impl {
fn CreateEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: windows_core::OutRef<'_, IMAPIProp>,
) -> windows_core::Result<()>;
fn CopyEntries(
&self,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteEntries(&self, lpentries: *mut SBinaryArray, ulflags: u32)
-> windows_core::Result<()>;
fn ResolveNames(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::Result<()>;
}
impl IDistList_Vtbl {
pub const fn new<Identity: IDistList_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateEntry<Identity: IDistList_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulcreateflags: u32,
lppmapipropentry: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IDistList_Impl::CreateEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulcreateflags),
core::mem::transmute_copy(&lppmapipropentry),
)
.into()
}
}
unsafe extern "system" fn CopyEntries<Identity: IDistList_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpentries: *mut SBinaryArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IDistList_Impl::CopyEntries(
this,
core::mem::transmute_copy(&lpentries),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteEntries<Identity: IDistList_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpentries: *mut SBinaryArray,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IDistList_Impl::DeleteEntries(
this,
core::mem::transmute_copy(&lpentries),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn ResolveNames<Identity: IDistList_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpadrlist: *mut ADRLIST,
lpflaglist: *mut FlagList,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IDistList_Impl::ResolveNames(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpadrlist),
core::mem::transmute_copy(&lpflaglist),
)
.into()
}
}
Self {
base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
CreateEntry: CreateEntry::<Identity, OFFSET>,
CopyEntries: CopyEntries::<Identity, OFFSET>,
DeleteEntries: DeleteEntries::<Identity, OFFSET>,
ResolveNames: ResolveNames::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IDistList as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
|| iid == &<IMAPIContainer as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IDistList {}
pub const IDistList_CopyEntries: METHODS = METHODS(47i32);
pub const IDistList_CreateEntry: METHODS = METHODS(46i32);
pub const IDistList_DeleteEntries: METHODS = METHODS(48i32);
pub const IDistList_ResolveNames: METHODS = METHODS(49i32);
pub const IET_7BIT: ENCODINGTYPE = ENCODINGTYPE(4i32);
pub const IET_8BIT: ENCODINGTYPE = ENCODINGTYPE(5i32);
pub const IET_BASE64: ENCODINGTYPE = ENCODINGTYPE(1i32);
pub const IET_BINARY: ENCODINGTYPE = ENCODINGTYPE(0i32);
pub const IET_BINHEX40: ENCODINGTYPE = ENCODINGTYPE(12i32);
pub const IET_CURRENT: ENCODINGTYPE = ENCODINGTYPE(10i32);
pub const IET_ENCODED: ENCODINGTYPE = ENCODINGTYPE(9i32);
pub const IET_INETCSET: ENCODINGTYPE = ENCODINGTYPE(6i32);
pub const IET_LAST: ENCODINGTYPE = ENCODINGTYPE(13i32);
pub const IET_QP: ENCODINGTYPE = ENCODINGTYPE(3i32);
pub const IET_RFC1522: ENCODINGTYPE = ENCODINGTYPE(8i32);
pub const IET_UNICODE: ENCODINGTYPE = ENCODINGTYPE(7i32);
pub const IET_UNKNOWN: ENCODINGTYPE = ENCODINGTYPE(11i32);
pub const IET_UUENCODE: ENCODINGTYPE = ENCODINGTYPE(2i32);
windows_core::imp::define_interface!(
IExchangeBadItemCallback,
IExchangeBadItemCallback_Vtbl,
0x1df85ab7_4d20_4a57_b170_2f062136c1d6
);
windows_core::imp::interface_hierarchy!(IExchangeBadItemCallback, windows_core::IUnknown);
impl IExchangeBadItemCallback {
pub unsafe fn BadItem<P2>(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lpwszfoldername: P2,
lpsbfoldereid: *mut SBinary,
cvalues: u32,
lpproparray: *mut SPropValue,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCWSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).BadItem)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lpwszfoldername.param().abi(),
lpsbfoldereid as _,
cvalues,
lpproparray as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeBadItemCallback_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub BadItem: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
windows_core::PCWSTR,
*mut SBinary,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
}
pub trait IExchangeBadItemCallback_Impl: windows_core::IUnknownImpl {
fn BadItem(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lpwszfoldername: &windows_core::PCWSTR,
lpsbfoldereid: *mut SBinary,
cvalues: u32,
lpproparray: *mut SPropValue,
) -> windows_core::Result<()>;
}
impl IExchangeBadItemCallback_Vtbl {
pub const fn new<Identity: IExchangeBadItemCallback_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn BadItem<
Identity: IExchangeBadItemCallback_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lpwszfoldername: windows_core::PCWSTR,
lpsbfoldereid: *mut SBinary,
cvalues: u32,
lpproparray: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeBadItemCallback_Impl::BadItem(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute(&lpwszfoldername),
core::mem::transmute_copy(&lpsbfoldereid),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpproparray),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
BadItem: BadItem::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeBadItemCallback as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeBadItemCallback {}
windows_core::imp::define_interface!(IExchangeChangeAdviseSink, IExchangeChangeAdviseSink_Vtbl, 0);
windows_core::imp::interface_hierarchy!(IExchangeChangeAdviseSink, windows_core::IUnknown);
impl IExchangeChangeAdviseSink {
pub unsafe fn OnNotify(&self, ulflags: u32, lpentrylist: *mut SBinaryArray) -> u32 {
unsafe {
(windows_core::Interface::vtable(self).OnNotify)(
windows_core::Interface::as_raw(self),
ulflags,
lpentrylist as _,
)
}
}
}
#[repr(C)]
pub struct IExchangeChangeAdviseSink_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnNotify: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut SBinaryArray) -> u32,
}
pub trait IExchangeChangeAdviseSink_Impl: windows_core::IUnknownImpl {
fn OnNotify(&self, ulflags: u32, lpentrylist: *mut SBinaryArray) -> u32;
}
impl IExchangeChangeAdviseSink_Vtbl {
pub const fn new<Identity: IExchangeChangeAdviseSink_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnNotify<
Identity: IExchangeChangeAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpentrylist: *mut SBinaryArray,
) -> u32 {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdviseSink_Impl::OnNotify(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpentrylist),
)
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnNotify: OnNotify::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeChangeAdviseSink as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeChangeAdviseSink {}
windows_core::imp::define_interface!(
IExchangeChangeAdvisor,
IExchangeChangeAdvisor_Vtbl,
0x1e300720_a839_11cf_bde0_00004c7531e3
);
windows_core::imp::interface_hierarchy!(IExchangeChangeAdvisor, windows_core::IUnknown);
impl IExchangeChangeAdvisor {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Config<P0, P2>(
&self,
lpstream: P0,
lpguid: *mut windows_core::GUID,
lpadvisesink: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
P2: windows_core::Param<IExchangeChangeAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Config)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
lpguid as _,
lpadvisesink.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).UpdateState)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
)
.ok()
}
}
pub unsafe fn AddKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AddKeys)(
windows_core::Interface::as_raw(self),
lpentrylist as _,
)
.ok()
}
}
pub unsafe fn RemoveKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RemoveKeys)(
windows_core::Interface::as_raw(self),
lpentrylist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeChangeAdvisor_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Config: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub UpdateState: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub AddKeys: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
) -> windows_core::HRESULT,
pub RemoveKeys: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
) -> windows_core::HRESULT,
}
pub trait IExchangeChangeAdvisor_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Config(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
lpguid: *mut windows_core::GUID,
lpadvisesink: windows_core::Ref<'_, IExchangeChangeAdviseSink>,
ulflags: u32,
) -> windows_core::Result<()>;
fn UpdateState(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn AddKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
fn RemoveKeys(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
}
impl IExchangeChangeAdvisor_Vtbl {
pub const fn new<Identity: IExchangeChangeAdvisor_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IExchangeChangeAdvisor_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdvisor_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Config<
Identity: IExchangeChangeAdvisor_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
lpguid: *mut windows_core::GUID,
lpadvisesink: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdvisor_Impl::Config(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&lpguid),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn UpdateState<
Identity: IExchangeChangeAdvisor_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdvisor_Impl::UpdateState(this, core::mem::transmute_copy(&lpstream))
.into()
}
}
unsafe extern "system" fn AddKeys<
Identity: IExchangeChangeAdvisor_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdvisor_Impl::AddKeys(this, core::mem::transmute_copy(&lpentrylist))
.into()
}
}
unsafe extern "system" fn RemoveKeys<
Identity: IExchangeChangeAdvisor_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeChangeAdvisor_Impl::RemoveKeys(
this,
core::mem::transmute_copy(&lpentrylist),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Config: Config::<Identity, OFFSET>,
UpdateState: UpdateState::<Identity, OFFSET>,
AddKeys: AddKeys::<Identity, OFFSET>,
RemoveKeys: RemoveKeys::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeChangeAdvisor as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeChangeAdvisor {}
windows_core::imp::define_interface!(
IExchangeExportChanges,
IExchangeExportChanges_Vtbl,
0xa3ea9cc0_d1b2_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeExportChanges, windows_core::IUnknown);
impl IExchangeExportChanges {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Config<P0, P2>(
&self,
lpstream: P0,
ulflags: u32,
lpunk: P2,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
P2: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
(windows_core::Interface::vtable(self).Config)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
lpunk.param().abi(),
lprestriction as _,
lpincludeprops as _,
lpexcludeprops as _,
ulbuffersize,
)
.ok()
}
}
pub unsafe fn Synchronize(
&self,
lpulsteps: *mut u32,
lpulprogress: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Synchronize)(
windows_core::Interface::as_raw(self),
lpulsteps as _,
lpulprogress as _,
)
.ok()
}
}
pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).UpdateState)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeExportChanges_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Config: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut SRestriction,
*mut SPropTagArray,
*mut SPropTagArray,
u32,
) -> windows_core::HRESULT,
pub Synchronize: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
) -> windows_core::HRESULT,
pub UpdateState: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Config(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::Result<()>;
fn Synchronize(&self, lpulsteps: *mut u32, lpulprogress: *mut u32) -> windows_core::Result<()>;
fn UpdateState(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
}
impl IExchangeExportChanges_Vtbl {
pub const fn new<Identity: IExchangeExportChanges_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IExchangeExportChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Config<
Identity: IExchangeExportChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
lpunk: *mut core::ffi::c_void,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges_Impl::Config(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpunk),
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&lpincludeprops),
core::mem::transmute_copy(&lpexcludeprops),
core::mem::transmute_copy(&ulbuffersize),
)
.into()
}
}
unsafe extern "system" fn Synchronize<
Identity: IExchangeExportChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpulsteps: *mut u32,
lpulprogress: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges_Impl::Synchronize(
this,
core::mem::transmute_copy(&lpulsteps),
core::mem::transmute_copy(&lpulprogress),
)
.into()
}
}
unsafe extern "system" fn UpdateState<
Identity: IExchangeExportChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges_Impl::UpdateState(this, core::mem::transmute_copy(&lpstream))
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Config: Config::<Identity, OFFSET>,
Synchronize: Synchronize::<Identity, OFFSET>,
UpdateState: UpdateState::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeExportChanges as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeExportChanges {}
windows_core::imp::define_interface!(
IExchangeExportChanges2,
IExchangeExportChanges2_Vtbl,
0x387cebe0_f53f_11cf_a48f_00c04fd65595
);
impl core::ops::Deref for IExchangeExportChanges2 {
type Target = IExchangeExportChanges;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IExchangeExportChanges2,
windows_core::IUnknown,
IExchangeExportChanges
);
impl IExchangeExportChanges2 {
pub unsafe fn ConfigForConversionStream<P0, P2>(
&self,
lpstream: P0,
ulflags: u32,
lpunk: P2,
lprestriction: *mut SRestriction,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
ulbuffersize: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
P2: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
(windows_core::Interface::vtable(self).ConfigForConversionStream)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
lpunk.param().abi(),
lprestriction as _,
cvaluesconversion,
lpproparrayconversion as _,
ulbuffersize,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeExportChanges2_Vtbl {
pub base__: IExchangeExportChanges_Vtbl,
pub ConfigForConversionStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut SRestriction,
u32,
*mut SPropValue,
u32,
) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges2_Impl: IExchangeExportChanges_Impl {
fn ConfigForConversionStream(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
lprestriction: *mut SRestriction,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
ulbuffersize: u32,
) -> windows_core::Result<()>;
}
impl IExchangeExportChanges2_Vtbl {
pub const fn new<Identity: IExchangeExportChanges2_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn ConfigForConversionStream<
Identity: IExchangeExportChanges2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
lpunk: *mut core::ffi::c_void,
lprestriction: *mut SRestriction,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
ulbuffersize: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges2_Impl::ConfigForConversionStream(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpunk),
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&cvaluesconversion),
core::mem::transmute_copy(&lpproparrayconversion),
core::mem::transmute_copy(&ulbuffersize),
)
.into()
}
}
Self {
base__: IExchangeExportChanges_Vtbl::new::<Identity, OFFSET>(),
ConfigForConversionStream: ConfigForConversionStream::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeExportChanges2 as windows_core::Interface>::IID
|| iid == &<IExchangeExportChanges as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeExportChanges2 {}
windows_core::imp::define_interface!(
IExchangeExportChanges3,
IExchangeExportChanges3_Vtbl,
0x702e7f86_50a6_11d1_abd6_00a0c905660a
);
impl core::ops::Deref for IExchangeExportChanges3 {
type Target = IExchangeExportChanges2;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IExchangeExportChanges3,
windows_core::IUnknown,
IExchangeExportChanges,
IExchangeExportChanges2
);
impl IExchangeExportChanges3 {
pub unsafe fn ConfigForSelectiveSync<P0, P2>(
&self,
lpstream: P0,
ulflags: u32,
lpunk: P2,
lpmsglist: *mut SBinaryArray,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
P2: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
(windows_core::Interface::vtable(self).ConfigForSelectiveSync)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
lpunk.param().abi(),
lpmsglist as _,
lprestriction as _,
lpincludeprops as _,
lpexcludeprops as _,
ulbuffersize,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeExportChanges3_Vtbl {
pub base__: IExchangeExportChanges2_Vtbl,
pub ConfigForSelectiveSync: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut SBinaryArray,
*mut SRestriction,
*mut SPropTagArray,
*mut SPropTagArray,
u32,
) -> windows_core::HRESULT,
}
pub trait IExchangeExportChanges3_Impl: IExchangeExportChanges2_Impl {
fn ConfigForSelectiveSync(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
lpmsglist: *mut SBinaryArray,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::Result<()>;
}
impl IExchangeExportChanges3_Vtbl {
pub const fn new<Identity: IExchangeExportChanges3_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn ConfigForSelectiveSync<
Identity: IExchangeExportChanges3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
lpunk: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
lprestriction: *mut SRestriction,
lpincludeprops: *mut SPropTagArray,
lpexcludeprops: *mut SPropTagArray,
ulbuffersize: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeExportChanges3_Impl::ConfigForSelectiveSync(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpunk),
core::mem::transmute_copy(&lpmsglist),
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&lpincludeprops),
core::mem::transmute_copy(&lpexcludeprops),
core::mem::transmute_copy(&ulbuffersize),
)
.into()
}
}
Self {
base__: IExchangeExportChanges2_Vtbl::new::<Identity, OFFSET>(),
ConfigForSelectiveSync: ConfigForSelectiveSync::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeExportChanges3 as windows_core::Interface>::IID
|| iid == &<IExchangeExportChanges as windows_core::Interface>::IID
|| iid == &<IExchangeExportChanges2 as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeExportChanges3 {}
windows_core::imp::define_interface!(
IExchangeFastTransfer,
IExchangeFastTransfer_Vtbl,
0xff7db070_a88a_11cd_9bc8_00aa002fc45a
);
windows_core::imp::interface_hierarchy!(IExchangeFastTransfer, windows_core::IUnknown);
impl IExchangeFastTransfer {
pub unsafe fn Config(&self, ulflags: u32, ultransfermethod: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Config)(
windows_core::Interface::as_raw(self),
ulflags,
ultransfermethod,
)
.ok()
}
}
pub unsafe fn TransferBuffer(
&self,
cb: u32,
lpb: *mut u8,
lpcbprocessed: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).TransferBuffer)(
windows_core::Interface::as_raw(self),
cb,
lpb as _,
lpcbprocessed as _,
)
.ok()
}
}
pub unsafe fn IsInterfaceOk(
&self,
ultransfermethod: u32,
refiid: *const windows_core::GUID,
lpptaglist: *mut SPropTagArray,
ulflags: u32,
) -> windows::Win32::Foundation::BOOL {
unsafe {
(windows_core::Interface::vtable(self).IsInterfaceOk)(
windows_core::Interface::as_raw(self),
ultransfermethod,
refiid,
lpptaglist as _,
ulflags,
)
}
}
}
#[repr(C)]
pub struct IExchangeFastTransfer_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Config:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
pub TransferBuffer: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
*mut u32,
) -> windows_core::HRESULT,
pub IsInterfaceOk: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*const windows_core::GUID,
*mut SPropTagArray,
u32,
) -> windows::Win32::Foundation::BOOL,
}
pub trait IExchangeFastTransfer_Impl: windows_core::IUnknownImpl {
fn Config(&self, ulflags: u32, ultransfermethod: u32) -> windows_core::Result<()>;
fn TransferBuffer(
&self,
cb: u32,
lpb: *mut u8,
lpcbprocessed: *mut u32,
) -> windows_core::Result<()>;
fn IsInterfaceOk(
&self,
ultransfermethod: u32,
refiid: *const windows_core::GUID,
lpptaglist: *mut SPropTagArray,
ulflags: u32,
) -> windows::Win32::Foundation::BOOL;
}
impl IExchangeFastTransfer_Vtbl {
pub const fn new<Identity: IExchangeFastTransfer_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Config<
Identity: IExchangeFastTransfer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
ultransfermethod: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFastTransfer_Impl::Config(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ultransfermethod),
)
.into()
}
}
unsafe extern "system" fn TransferBuffer<
Identity: IExchangeFastTransfer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cb: u32,
lpb: *mut u8,
lpcbprocessed: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFastTransfer_Impl::TransferBuffer(
this,
core::mem::transmute_copy(&cb),
core::mem::transmute_copy(&lpb),
core::mem::transmute_copy(&lpcbprocessed),
)
.into()
}
}
unsafe extern "system" fn IsInterfaceOk<
Identity: IExchangeFastTransfer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ultransfermethod: u32,
refiid: *const windows_core::GUID,
lpptaglist: *mut SPropTagArray,
ulflags: u32,
) -> windows::Win32::Foundation::BOOL {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFastTransfer_Impl::IsInterfaceOk(
this,
core::mem::transmute_copy(&ultransfermethod),
core::mem::transmute_copy(&refiid),
core::mem::transmute_copy(&lpptaglist),
core::mem::transmute_copy(&ulflags),
)
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Config: Config::<Identity, OFFSET>,
TransferBuffer: TransferBuffer::<Identity, OFFSET>,
IsInterfaceOk: IsInterfaceOk::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeFastTransfer as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeFastTransfer {}
windows_core::imp::define_interface!(
IExchangeFavorites,
IExchangeFavorites_Vtbl,
0xcf4f3bc0_ec66_11ce_b31c_00aa00574cc6
);
windows_core::imp::interface_hierarchy!(IExchangeFavorites, windows_core::IUnknown);
impl IExchangeFavorites {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn AddFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AddFavorites)(
windows_core::Interface::as_raw(self),
lpentrylist as _,
)
.ok()
}
}
pub unsafe fn DelFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DelFavorites)(
windows_core::Interface::as_raw(self),
lpentrylist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeFavorites_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub AddFavorites: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
) -> windows_core::HRESULT,
pub DelFavorites: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
) -> windows_core::HRESULT,
}
pub trait IExchangeFavorites_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn AddFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
fn DelFavorites(&self, lpentrylist: *mut SBinaryArray) -> windows_core::Result<()>;
}
impl IExchangeFavorites_Vtbl {
pub const fn new<Identity: IExchangeFavorites_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IExchangeFavorites_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFavorites_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn AddFavorites<
Identity: IExchangeFavorites_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFavorites_Impl::AddFavorites(this, core::mem::transmute_copy(&lpentrylist))
.into()
}
}
unsafe extern "system" fn DelFavorites<
Identity: IExchangeFavorites_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeFavorites_Impl::DelFavorites(this, core::mem::transmute_copy(&lpentrylist))
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
AddFavorites: AddFavorites::<Identity, OFFSET>,
DelFavorites: DelFavorites::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeFavorites as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeFavorites {}
windows_core::imp::define_interface!(
IExchangeImportContentsChanges,
IExchangeImportContentsChanges_Vtbl,
0xf75abfa0_d0e0_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeImportContentsChanges, windows_core::IUnknown);
impl IExchangeImportContentsChanges {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Config<P0>(&self, lpstream: P0, ulflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Config)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).UpdateState)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
)
.ok()
}
}
pub unsafe fn ImportMessageChange(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppmessage: *mut Option<IMessage>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportMessageChange)(
windows_core::Interface::as_raw(self),
cpvalchanges,
ppvalchanges as _,
ulflags,
core::mem::transmute(lppmessage),
)
.ok()
}
}
pub unsafe fn ImportMessageDeletion(
&self,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportMessageDeletion)(
windows_core::Interface::as_raw(self),
ulflags,
lpsrcentrylist as _,
)
.ok()
}
}
pub unsafe fn ImportPerUserReadStateChange(
&self,
celements: u32,
lpreadstate: *mut READSTATE,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportPerUserReadStateChange)(
windows_core::Interface::as_raw(self),
celements,
lpreadstate as _,
)
.ok()
}
}
pub unsafe fn ImportMessageMove(
&self,
cbsourcekeysrcfolder: u32,
pbsourcekeysrcfolder: *mut u8,
cbsourcekeysrcmessage: u32,
pbsourcekeysrcmessage: *mut u8,
cbpclmessage: u32,
pbpclmessage: *mut u8,
cbsourcekeydestmessage: u32,
pbsourcekeydestmessage: *mut u8,
cbchangenumdestmessage: u32,
pbchangenumdestmessage: *mut u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportMessageMove)(
windows_core::Interface::as_raw(self),
cbsourcekeysrcfolder,
pbsourcekeysrcfolder as _,
cbsourcekeysrcmessage,
pbsourcekeysrcmessage as _,
cbpclmessage,
pbpclmessage as _,
cbsourcekeydestmessage,
pbsourcekeydestmessage as _,
cbchangenumdestmessage,
pbchangenumdestmessage as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeImportContentsChanges_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Config: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub UpdateState: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ImportMessageChange: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ImportMessageDeletion: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SBinaryArray,
) -> windows_core::HRESULT,
pub ImportPerUserReadStateChange: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut READSTATE,
) -> windows_core::HRESULT,
pub ImportMessageMove: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u8,
u32,
*mut u8,
u32,
*mut u8,
u32,
*mut u8,
) -> windows_core::HRESULT,
}
pub trait IExchangeImportContentsChanges_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Config(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
) -> windows_core::Result<()>;
fn UpdateState(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn ImportMessageChange(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppmessage: windows_core::OutRef<'_, IMessage>,
) -> windows_core::Result<()>;
fn ImportMessageDeletion(
&self,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::Result<()>;
fn ImportPerUserReadStateChange(
&self,
celements: u32,
lpreadstate: *mut READSTATE,
) -> windows_core::Result<()>;
fn ImportMessageMove(
&self,
cbsourcekeysrcfolder: u32,
pbsourcekeysrcfolder: *mut u8,
cbsourcekeysrcmessage: u32,
pbsourcekeysrcmessage: *mut u8,
cbpclmessage: u32,
pbpclmessage: *mut u8,
cbsourcekeydestmessage: u32,
pbsourcekeydestmessage: *mut u8,
cbchangenumdestmessage: u32,
pbchangenumdestmessage: *mut u8,
) -> windows_core::Result<()>;
}
impl IExchangeImportContentsChanges_Vtbl {
pub const fn new<Identity: IExchangeImportContentsChanges_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Config<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::Config(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn UpdateState<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::UpdateState(
this,
core::mem::transmute_copy(&lpstream),
)
.into()
}
}
unsafe extern "system" fn ImportMessageChange<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppmessage: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::ImportMessageChange(
this,
core::mem::transmute_copy(&cpvalchanges),
core::mem::transmute_copy(&ppvalchanges),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmessage),
)
.into()
}
}
unsafe extern "system" fn ImportMessageDeletion<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::ImportMessageDeletion(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsrcentrylist),
)
.into()
}
}
unsafe extern "system" fn ImportPerUserReadStateChange<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
celements: u32,
lpreadstate: *mut READSTATE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::ImportPerUserReadStateChange(
this,
core::mem::transmute_copy(&celements),
core::mem::transmute_copy(&lpreadstate),
)
.into()
}
}
unsafe extern "system" fn ImportMessageMove<
Identity: IExchangeImportContentsChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbsourcekeysrcfolder: u32,
pbsourcekeysrcfolder: *mut u8,
cbsourcekeysrcmessage: u32,
pbsourcekeysrcmessage: *mut u8,
cbpclmessage: u32,
pbpclmessage: *mut u8,
cbsourcekeydestmessage: u32,
pbsourcekeydestmessage: *mut u8,
cbchangenumdestmessage: u32,
pbchangenumdestmessage: *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges_Impl::ImportMessageMove(
this,
core::mem::transmute_copy(&cbsourcekeysrcfolder),
core::mem::transmute_copy(&pbsourcekeysrcfolder),
core::mem::transmute_copy(&cbsourcekeysrcmessage),
core::mem::transmute_copy(&pbsourcekeysrcmessage),
core::mem::transmute_copy(&cbpclmessage),
core::mem::transmute_copy(&pbpclmessage),
core::mem::transmute_copy(&cbsourcekeydestmessage),
core::mem::transmute_copy(&pbsourcekeydestmessage),
core::mem::transmute_copy(&cbchangenumdestmessage),
core::mem::transmute_copy(&pbchangenumdestmessage),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Config: Config::<Identity, OFFSET>,
UpdateState: UpdateState::<Identity, OFFSET>,
ImportMessageChange: ImportMessageChange::<Identity, OFFSET>,
ImportMessageDeletion: ImportMessageDeletion::<Identity, OFFSET>,
ImportPerUserReadStateChange: ImportPerUserReadStateChange::<Identity, OFFSET>,
ImportMessageMove: ImportMessageMove::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeImportContentsChanges as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeImportContentsChanges {}
windows_core::imp::define_interface!(
IExchangeImportContentsChanges2,
IExchangeImportContentsChanges2_Vtbl,
0x7dfdd720_f53f_11cf_a48f_00c04fd65595
);
impl core::ops::Deref for IExchangeImportContentsChanges2 {
type Target = IExchangeImportContentsChanges;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IExchangeImportContentsChanges2,
windows_core::IUnknown,
IExchangeImportContentsChanges
);
impl IExchangeImportContentsChanges2 {
pub unsafe fn ConfigForConversionStream<P0>(
&self,
lpstream: P0,
ulflags: u32,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).ConfigForConversionStream)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
cvaluesconversion,
lpproparrayconversion as _,
)
.ok()
}
}
pub unsafe fn ImportMessageChangeAsAStream(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppstream: *mut Option<windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportMessageChangeAsAStream)(
windows_core::Interface::as_raw(self),
cpvalchanges,
ppvalchanges as _,
ulflags,
core::mem::transmute(lppstream),
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeImportContentsChanges2_Vtbl {
pub base__: IExchangeImportContentsChanges_Vtbl,
pub ConfigForConversionStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub ImportMessageChangeAsAStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IExchangeImportContentsChanges2_Impl: IExchangeImportContentsChanges_Impl {
fn ConfigForConversionStream(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
) -> windows_core::Result<()>;
fn ImportMessageChangeAsAStream(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
}
impl IExchangeImportContentsChanges2_Vtbl {
pub const fn new<Identity: IExchangeImportContentsChanges2_Impl, const OFFSET: isize>() -> Self
{
unsafe extern "system" fn ConfigForConversionStream<
Identity: IExchangeImportContentsChanges2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
cvaluesconversion: u32,
lpproparrayconversion: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges2_Impl::ConfigForConversionStream(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cvaluesconversion),
core::mem::transmute_copy(&lpproparrayconversion),
)
.into()
}
}
unsafe extern "system" fn ImportMessageChangeAsAStream<
Identity: IExchangeImportContentsChanges2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
ulflags: u32,
lppstream: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportContentsChanges2_Impl::ImportMessageChangeAsAStream(
this,
core::mem::transmute_copy(&cpvalchanges),
core::mem::transmute_copy(&ppvalchanges),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppstream),
)
.into()
}
}
Self {
base__: IExchangeImportContentsChanges_Vtbl::new::<Identity, OFFSET>(),
ConfigForConversionStream: ConfigForConversionStream::<Identity, OFFSET>,
ImportMessageChangeAsAStream: ImportMessageChangeAsAStream::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeImportContentsChanges2 as windows_core::Interface>::IID
|| iid == &<IExchangeImportContentsChanges as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeImportContentsChanges2 {}
windows_core::imp::define_interface!(
IExchangeImportHierarchyChanges,
IExchangeImportHierarchyChanges_Vtbl,
0x85a66cf0_d0e0_11cd_80fc_00aa004bba0b
);
windows_core::imp::interface_hierarchy!(IExchangeImportHierarchyChanges, windows_core::IUnknown);
impl IExchangeImportHierarchyChanges {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Config<P0>(&self, lpstream: P0, ulflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Config)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn UpdateState<P0>(&self, lpstream: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).UpdateState)(
windows_core::Interface::as_raw(self),
lpstream.param().abi(),
)
.ok()
}
}
pub unsafe fn ImportFolderChange(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportFolderChange)(
windows_core::Interface::as_raw(self),
cpvalchanges,
ppvalchanges as _,
)
.ok()
}
}
pub unsafe fn ImportFolderDeletion(
&self,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ImportFolderDeletion)(
windows_core::Interface::as_raw(self),
ulflags,
lpsrcentrylist as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeImportHierarchyChanges_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Config: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub UpdateState: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ImportFolderChange: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub ImportFolderDeletion: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SBinaryArray,
) -> windows_core::HRESULT,
}
pub trait IExchangeImportHierarchyChanges_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Config(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ulflags: u32,
) -> windows_core::Result<()>;
fn UpdateState(
&self,
lpstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn ImportFolderChange(
&self,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
) -> windows_core::Result<()>;
fn ImportFolderDeletion(
&self,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::Result<()>;
}
impl IExchangeImportHierarchyChanges_Vtbl {
pub const fn new<Identity: IExchangeImportHierarchyChanges_Impl, const OFFSET: isize>() -> Self
{
unsafe extern "system" fn GetLastError<
Identity: IExchangeImportHierarchyChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportHierarchyChanges_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Config<
Identity: IExchangeImportHierarchyChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportHierarchyChanges_Impl::Config(
this,
core::mem::transmute_copy(&lpstream),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn UpdateState<
Identity: IExchangeImportHierarchyChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportHierarchyChanges_Impl::UpdateState(
this,
core::mem::transmute_copy(&lpstream),
)
.into()
}
}
unsafe extern "system" fn ImportFolderChange<
Identity: IExchangeImportHierarchyChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpvalchanges: u32,
ppvalchanges: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportHierarchyChanges_Impl::ImportFolderChange(
this,
core::mem::transmute_copy(&cpvalchanges),
core::mem::transmute_copy(&ppvalchanges),
)
.into()
}
}
unsafe extern "system" fn ImportFolderDeletion<
Identity: IExchangeImportHierarchyChanges_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpsrcentrylist: *mut SBinaryArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeImportHierarchyChanges_Impl::ImportFolderDeletion(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsrcentrylist),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Config: Config::<Identity, OFFSET>,
UpdateState: UpdateState::<Identity, OFFSET>,
ImportFolderChange: ImportFolderChange::<Identity, OFFSET>,
ImportFolderDeletion: ImportFolderDeletion::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeImportHierarchyChanges as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeImportHierarchyChanges {}
windows_core::imp::define_interface!(
IExchangeManageStore,
IExchangeManageStore_Vtbl,
0x559d10b0_a772_11cd_9bc8_00aa002fc45a
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore, windows_core::IUnknown);
impl IExchangeManageStore {
pub unsafe fn CreateStoreEntryID<P0, P1>(
&self,
lpszmsgstoredn: P0,
lpszmailboxdn: P1,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateStoreEntryID)(
windows_core::Interface::as_raw(self),
lpszmsgstoredn.param().abi(),
lpszmailboxdn.param().abi(),
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
windows_core::Interface::as_raw(self),
cfolderkeysize,
lpfoldersourcekey as _,
cmessagekeysize,
lpmessagesourcekey as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRights)(
windows_core::Interface::as_raw(self),
cbuserentryid,
lpuserentryid as _,
cbentryid,
lpentryid as _,
lpulrights as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn GetPublicFolderTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPublicFolderTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeManageStore_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CreateStoreEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub EntryIDFromSourceKey: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u8,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetRights: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
) -> windows_core::HRESULT,
pub GetMailboxTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetPublicFolderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore_Impl: windows_core::IUnknownImpl {
fn CreateStoreEntryID(
&self,
lpszmsgstoredn: &windows_core::PCSTR,
lpszmailboxdn: &windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()>;
fn GetMailboxTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetPublicFolderTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
}
impl IExchangeManageStore_Vtbl {
pub const fn new<Identity: IExchangeManageStore_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateStoreEntryID<
Identity: IExchangeManageStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmsgstoredn: windows_core::PCSTR,
lpszmailboxdn: windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore_Impl::CreateStoreEntryID(
this,
core::mem::transmute(&lpszmsgstoredn),
core::mem::transmute(&lpszmailboxdn),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn EntryIDFromSourceKey<
Identity: IExchangeManageStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore_Impl::EntryIDFromSourceKey(
this,
core::mem::transmute_copy(&cfolderkeysize),
core::mem::transmute_copy(&lpfoldersourcekey),
core::mem::transmute_copy(&cmessagekeysize),
core::mem::transmute_copy(&lpmessagesourcekey),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetRights<
Identity: IExchangeManageStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore_Impl::GetRights(
this,
core::mem::transmute_copy(&cbuserentryid),
core::mem::transmute_copy(&lpuserentryid),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpulrights),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTable<
Identity: IExchangeManageStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore_Impl::GetMailboxTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetPublicFolderTable<
Identity: IExchangeManageStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore_Impl::GetPublicFolderTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
GetRights: GetRights::<Identity, OFFSET>,
GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeManageStore as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeManageStore {}
windows_core::imp::define_interface!(
IExchangeManageStore2,
IExchangeManageStore2_Vtbl,
0xb6dca470_0ff3_11d0_a409_00c04fd7bd87
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore2, windows_core::IUnknown);
impl IExchangeManageStore2 {
pub unsafe fn CreateStoreEntryID<P0, P1>(
&self,
lpszmsgstoredn: P0,
lpszmailboxdn: P1,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateStoreEntryID)(
windows_core::Interface::as_raw(self),
lpszmsgstoredn.param().abi(),
lpszmailboxdn.param().abi(),
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
windows_core::Interface::as_raw(self),
cfolderkeysize,
lpfoldersourcekey as _,
cmessagekeysize,
lpmessagesourcekey as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRights)(
windows_core::Interface::as_raw(self),
cbuserentryid,
lpuserentryid as _,
cbentryid,
lpentryid as _,
lpulrights as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn GetPublicFolderTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPublicFolderTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn CreateNewsgroupNameEntryID<P0>(
&self,
lpsznewsgroupname: P0,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
windows_core::Interface::as_raw(self),
lpsznewsgroupname.param().abi(),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeManageStore2_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CreateStoreEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub EntryIDFromSourceKey: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u8,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetRights: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
) -> windows_core::HRESULT,
pub GetMailboxTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetPublicFolderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore2_Impl: windows_core::IUnknownImpl {
fn CreateStoreEntryID(
&self,
lpszmsgstoredn: &windows_core::PCSTR,
lpszmailboxdn: &windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()>;
fn GetMailboxTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetPublicFolderTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn CreateNewsgroupNameEntryID(
&self,
lpsznewsgroupname: &windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
}
impl IExchangeManageStore2_Vtbl {
pub const fn new<Identity: IExchangeManageStore2_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateStoreEntryID<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmsgstoredn: windows_core::PCSTR,
lpszmailboxdn: windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::CreateStoreEntryID(
this,
core::mem::transmute(&lpszmsgstoredn),
core::mem::transmute(&lpszmailboxdn),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn EntryIDFromSourceKey<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::EntryIDFromSourceKey(
this,
core::mem::transmute_copy(&cfolderkeysize),
core::mem::transmute_copy(&lpfoldersourcekey),
core::mem::transmute_copy(&cmessagekeysize),
core::mem::transmute_copy(&lpmessagesourcekey),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetRights<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::GetRights(
this,
core::mem::transmute_copy(&cbuserentryid),
core::mem::transmute_copy(&lpuserentryid),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpulrights),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTable<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::GetMailboxTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetPublicFolderTable<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::GetPublicFolderTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CreateNewsgroupNameEntryID<
Identity: IExchangeManageStore2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpsznewsgroupname: windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore2_Impl::CreateNewsgroupNameEntryID(
this,
core::mem::transmute(&lpsznewsgroupname),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
GetRights: GetRights::<Identity, OFFSET>,
GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeManageStore2 as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeManageStore2 {}
windows_core::imp::define_interface!(
IExchangeManageStore3,
IExchangeManageStore3_Vtbl,
0x166d9bc2_db75_44a9_8a93_9f3ffc994d76
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore3, windows_core::IUnknown);
impl IExchangeManageStore3 {
pub unsafe fn CreateStoreEntryID<P0, P1>(
&self,
lpszmsgstoredn: P0,
lpszmailboxdn: P1,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateStoreEntryID)(
windows_core::Interface::as_raw(self),
lpszmsgstoredn.param().abi(),
lpszmailboxdn.param().abi(),
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
windows_core::Interface::as_raw(self),
cfolderkeysize,
lpfoldersourcekey as _,
cmessagekeysize,
lpmessagesourcekey as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRights)(
windows_core::Interface::as_raw(self),
cbuserentryid,
lpuserentryid as _,
cbentryid,
lpentryid as _,
lpulrights as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn GetPublicFolderTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPublicFolderTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn CreateNewsgroupNameEntryID<P0>(
&self,
lpsznewsgroupname: P0,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
windows_core::Interface::as_raw(self),
lpsznewsgroupname.param().abi(),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTableOffset<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTableOffset)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
uoffset,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeManageStore3_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CreateStoreEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub EntryIDFromSourceKey: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u8,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetRights: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
) -> windows_core::HRESULT,
pub GetMailboxTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetPublicFolderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetMailboxTableOffset: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
u32,
) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore3_Impl: windows_core::IUnknownImpl {
fn CreateStoreEntryID(
&self,
lpszmsgstoredn: &windows_core::PCSTR,
lpszmailboxdn: &windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()>;
fn GetMailboxTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetPublicFolderTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn CreateNewsgroupNameEntryID(
&self,
lpsznewsgroupname: &windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetMailboxTableOffset(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>;
}
impl IExchangeManageStore3_Vtbl {
pub const fn new<Identity: IExchangeManageStore3_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateStoreEntryID<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmsgstoredn: windows_core::PCSTR,
lpszmailboxdn: windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::CreateStoreEntryID(
this,
core::mem::transmute(&lpszmsgstoredn),
core::mem::transmute(&lpszmailboxdn),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn EntryIDFromSourceKey<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::EntryIDFromSourceKey(
this,
core::mem::transmute_copy(&cfolderkeysize),
core::mem::transmute_copy(&lpfoldersourcekey),
core::mem::transmute_copy(&cmessagekeysize),
core::mem::transmute_copy(&lpmessagesourcekey),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetRights<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::GetRights(
this,
core::mem::transmute_copy(&cbuserentryid),
core::mem::transmute_copy(&lpuserentryid),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpulrights),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTable<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::GetMailboxTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetPublicFolderTable<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::GetPublicFolderTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CreateNewsgroupNameEntryID<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpsznewsgroupname: windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::CreateNewsgroupNameEntryID(
this,
core::mem::transmute(&lpsznewsgroupname),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTableOffset<
Identity: IExchangeManageStore3_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
uoffset: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore3_Impl::GetMailboxTableOffset(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&uoffset),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
GetRights: GetRights::<Identity, OFFSET>,
GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
GetMailboxTableOffset: GetMailboxTableOffset::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeManageStore3 as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeManageStore3 {}
windows_core::imp::define_interface!(
IExchangeManageStore4,
IExchangeManageStore4_Vtbl,
0x2590ff87_c431_4f9c_b1a8_cd69d760cd10
);
windows_core::imp::interface_hierarchy!(IExchangeManageStore4, windows_core::IUnknown);
impl IExchangeManageStore4 {
pub unsafe fn CreateStoreEntryID<P0, P1>(
&self,
lpszmsgstoredn: P0,
lpszmailboxdn: P1,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateStoreEntryID)(
windows_core::Interface::as_raw(self),
lpszmsgstoredn.param().abi(),
lpszmailboxdn.param().abi(),
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EntryIDFromSourceKey)(
windows_core::Interface::as_raw(self),
cfolderkeysize,
lpfoldersourcekey as _,
cmessagekeysize,
lpmessagesourcekey as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRights)(
windows_core::Interface::as_raw(self),
cbuserentryid,
lpuserentryid as _,
cbentryid,
lpentryid as _,
lpulrights as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn GetPublicFolderTable<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPublicFolderTable)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
)
.ok()
}
}
pub unsafe fn CreateNewsgroupNameEntryID<P0>(
&self,
lpsznewsgroupname: P0,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateNewsgroupNameEntryID)(
windows_core::Interface::as_raw(self),
lpsznewsgroupname.param().abi(),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn GetMailboxTableOffset<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMailboxTableOffset)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
uoffset,
)
.ok()
}
}
pub unsafe fn GetPublicFolderTableOffset<P0>(
&self,
lpszservername: P0,
lpptable: *mut Option<IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPublicFolderTableOffset)(
windows_core::Interface::as_raw(self),
lpszservername.param().abi(),
core::mem::transmute(lpptable),
ulflags,
uoffset,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeManageStore4_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CreateStoreEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub EntryIDFromSourceKey: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u8,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetRights: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
) -> windows_core::HRESULT,
pub GetMailboxTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetPublicFolderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CreateNewsgroupNameEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub GetMailboxTableOffset: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
u32,
) -> windows_core::HRESULT,
pub GetPublicFolderTableOffset: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut core::ffi::c_void,
u32,
u32,
) -> windows_core::HRESULT,
}
pub trait IExchangeManageStore4_Impl: windows_core::IUnknownImpl {
fn CreateStoreEntryID(
&self,
lpszmsgstoredn: &windows_core::PCSTR,
lpszmailboxdn: &windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn EntryIDFromSourceKey(
&self,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetRights(
&self,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::Result<()>;
fn GetMailboxTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetPublicFolderTable(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
) -> windows_core::Result<()>;
fn CreateNewsgroupNameEntryID(
&self,
lpsznewsgroupname: &windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetMailboxTableOffset(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>;
fn GetPublicFolderTableOffset(
&self,
lpszservername: &windows_core::PCSTR,
lpptable: windows_core::OutRef<'_, IMAPITable>,
ulflags: u32,
uoffset: u32,
) -> windows_core::Result<()>;
}
impl IExchangeManageStore4_Vtbl {
pub const fn new<Identity: IExchangeManageStore4_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateStoreEntryID<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmsgstoredn: windows_core::PCSTR,
lpszmailboxdn: windows_core::PCSTR,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::CreateStoreEntryID(
this,
core::mem::transmute(&lpszmsgstoredn),
core::mem::transmute(&lpszmailboxdn),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn EntryIDFromSourceKey<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfolderkeysize: u32,
lpfoldersourcekey: *mut u8,
cmessagekeysize: u32,
lpmessagesourcekey: *mut u8,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::EntryIDFromSourceKey(
this,
core::mem::transmute_copy(&cfolderkeysize),
core::mem::transmute_copy(&lpfoldersourcekey),
core::mem::transmute_copy(&cmessagekeysize),
core::mem::transmute_copy(&lpmessagesourcekey),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetRights<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbuserentryid: u32,
lpuserentryid: *mut ENTRYID,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpulrights: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::GetRights(
this,
core::mem::transmute_copy(&cbuserentryid),
core::mem::transmute_copy(&lpuserentryid),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpulrights),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTable<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::GetMailboxTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetPublicFolderTable<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::GetPublicFolderTable(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CreateNewsgroupNameEntryID<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpsznewsgroupname: windows_core::PCSTR,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::CreateNewsgroupNameEntryID(
this,
core::mem::transmute(&lpsznewsgroupname),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn GetMailboxTableOffset<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
uoffset: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::GetMailboxTableOffset(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&uoffset),
)
.into()
}
}
unsafe extern "system" fn GetPublicFolderTableOffset<
Identity: IExchangeManageStore4_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservername: windows_core::PCSTR,
lpptable: *mut *mut core::ffi::c_void,
ulflags: u32,
uoffset: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeManageStore4_Impl::GetPublicFolderTableOffset(
this,
core::mem::transmute(&lpszservername),
core::mem::transmute_copy(&lpptable),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&uoffset),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CreateStoreEntryID: CreateStoreEntryID::<Identity, OFFSET>,
EntryIDFromSourceKey: EntryIDFromSourceKey::<Identity, OFFSET>,
GetRights: GetRights::<Identity, OFFSET>,
GetMailboxTable: GetMailboxTable::<Identity, OFFSET>,
GetPublicFolderTable: GetPublicFolderTable::<Identity, OFFSET>,
CreateNewsgroupNameEntryID: CreateNewsgroupNameEntryID::<Identity, OFFSET>,
GetMailboxTableOffset: GetMailboxTableOffset::<Identity, OFFSET>,
GetPublicFolderTableOffset: GetPublicFolderTableOffset::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeManageStore4 as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeManageStore4 {}
windows_core::imp::define_interface!(
IExchangeMessageConversion,
IExchangeMessageConversion_Vtbl,
0x3532b360_d114_11cf_a83b_00c04fd65597
);
windows_core::imp::interface_hierarchy!(IExchangeMessageConversion, windows_core::IUnknown);
impl IExchangeMessageConversion {
pub unsafe fn OpenStream(
&self,
cvalues: u32,
lpproparray: *mut SPropValue,
lppstream: *mut Option<windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenStream)(
windows_core::Interface::as_raw(self),
cvalues,
lpproparray as _,
core::mem::transmute(lppstream),
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeMessageConversion_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OpenStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IExchangeMessageConversion_Impl: windows_core::IUnknownImpl {
fn OpenStream(
&self,
cvalues: u32,
lpproparray: *mut SPropValue,
lppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
}
impl IExchangeMessageConversion_Vtbl {
pub const fn new<Identity: IExchangeMessageConversion_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OpenStream<
Identity: IExchangeMessageConversion_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cvalues: u32,
lpproparray: *mut SPropValue,
lppstream: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeMessageConversion_Impl::OpenStream(
this,
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpproparray),
core::mem::transmute_copy(&lppstream),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OpenStream: OpenStream::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeMessageConversion as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeMessageConversion {}
windows_core::imp::define_interface!(
IExchangeModifyTable,
IExchangeModifyTable_Vtbl,
0x2d734cb0_53fd_101b_b19d_08002b3056e3
);
windows_core::imp::interface_hierarchy!(IExchangeModifyTable, windows_core::IUnknown);
impl IExchangeModifyTable {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ModifyTable(
&self,
ulflags: u32,
lpmods: *mut ROWLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ModifyTable)(
windows_core::Interface::as_raw(self),
ulflags,
lpmods as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeModifyTable_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ModifyTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ROWLIST,
) -> windows_core::HRESULT,
}
pub trait IExchangeModifyTable_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn ModifyTable(&self, ulflags: u32, lpmods: *mut ROWLIST) -> windows_core::Result<()>;
}
impl IExchangeModifyTable_Vtbl {
pub const fn new<Identity: IExchangeModifyTable_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IExchangeModifyTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeModifyTable_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetTable<
Identity: IExchangeModifyTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IExchangeModifyTable_Impl::GetTable(this, core::mem::transmute_copy(&ulflags))
{
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ModifyTable<
Identity: IExchangeModifyTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmods: *mut ROWLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeModifyTable_Impl::ModifyTable(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmods),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetTable: GetTable::<Identity, OFFSET>,
ModifyTable: ModifyTable::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeModifyTable as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeModifyTable {}
windows_core::imp::define_interface!(
IExchangeMoveUserProgress,
IExchangeMoveUserProgress_Vtbl,
0xef2fb44a_8dac_4e4e_b1e3_a3b926355617
);
windows_core::imp::interface_hierarchy!(IExchangeMoveUserProgress, windows_core::IUnknown);
impl IExchangeMoveUserProgress {
pub unsafe fn NextFolder<P1>(
&self,
ulflags: u32,
lpwszfoldername: P1,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCWSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).NextFolder)(
windows_core::Interface::as_raw(self),
ulflags,
lpwszfoldername.param().abi(),
)
.ok()
}
}
pub unsafe fn Progress(
&self,
ulflags: u32,
ulcount: u32,
ultotal: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Progress)(
windows_core::Interface::as_raw(self),
ulflags,
ulcount,
ultotal,
)
.ok()
}
}
pub unsafe fn Restart(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Restart)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeMoveUserProgress_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub NextFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
windows_core::PCWSTR,
) -> windows_core::HRESULT,
pub Progress:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32, u32) -> windows_core::HRESULT,
pub Restart: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IExchangeMoveUserProgress_Impl: windows_core::IUnknownImpl {
fn NextFolder(
&self,
ulflags: u32,
lpwszfoldername: &windows_core::PCWSTR,
) -> windows_core::Result<()>;
fn Progress(&self, ulflags: u32, ulcount: u32, ultotal: u32) -> windows_core::Result<()>;
fn Restart(&self, ulflags: u32) -> windows_core::Result<()>;
}
impl IExchangeMoveUserProgress_Vtbl {
pub const fn new<Identity: IExchangeMoveUserProgress_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn NextFolder<
Identity: IExchangeMoveUserProgress_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpwszfoldername: windows_core::PCWSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeMoveUserProgress_Impl::NextFolder(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute(&lpwszfoldername),
)
.into()
}
}
unsafe extern "system" fn Progress<
Identity: IExchangeMoveUserProgress_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
ulcount: u32,
ultotal: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeMoveUserProgress_Impl::Progress(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ulcount),
core::mem::transmute_copy(&ultotal),
)
.into()
}
}
unsafe extern "system" fn Restart<
Identity: IExchangeMoveUserProgress_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeMoveUserProgress_Impl::Restart(this, core::mem::transmute_copy(&ulflags))
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
NextFolder: NextFolder::<Identity, OFFSET>,
Progress: Progress::<Identity, OFFSET>,
Restart: Restart::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeMoveUserProgress as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeMoveUserProgress {}
windows_core::imp::define_interface!(
IExchangeNntpNewsfeed,
IExchangeNntpNewsfeed_Vtbl,
0x380f41c0_3cdc_11d0_9792_00c04fd6551d
);
windows_core::imp::interface_hierarchy!(IExchangeNntpNewsfeed, windows_core::IUnknown);
impl IExchangeNntpNewsfeed {
pub unsafe fn Configure<P0>(
&self,
lpsznewsfeeddn: P0,
cvalues: u32,
lpimailproparray: *mut SPropValue,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Configure)(
windows_core::Interface::as_raw(self),
lpsznewsfeeddn.param().abi(),
cvalues,
lpimailproparray as _,
)
.ok()
}
}
pub unsafe fn CheckMsgIds<P0>(
&self,
lpszmsgids: P0,
lpcfwanted: *mut u32,
lppfwanted: *mut *mut u8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CheckMsgIds)(
windows_core::Interface::as_raw(self),
lpszmsgids.param().abi(),
lpcfwanted as _,
lppfwanted as _,
)
.ok()
}
}
pub unsafe fn OpenArticleStream(
&self,
) -> windows_core::Result<windows::Win32::System::Com::IStream> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).OpenArticleStream)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IExchangeNntpNewsfeed_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Configure: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub CheckMsgIds: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
*mut *mut u8,
) -> windows_core::HRESULT,
pub OpenArticleStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IExchangeNntpNewsfeed_Impl: windows_core::IUnknownImpl {
fn Configure(
&self,
lpsznewsfeeddn: &windows_core::PCSTR,
cvalues: u32,
lpimailproparray: *mut SPropValue,
) -> windows_core::Result<()>;
fn CheckMsgIds(
&self,
lpszmsgids: &windows_core::PCSTR,
lpcfwanted: *mut u32,
lppfwanted: *mut *mut u8,
) -> windows_core::Result<()>;
fn OpenArticleStream(&self) -> windows_core::Result<windows::Win32::System::Com::IStream>;
}
impl IExchangeNntpNewsfeed_Vtbl {
pub const fn new<Identity: IExchangeNntpNewsfeed_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Configure<
Identity: IExchangeNntpNewsfeed_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpsznewsfeeddn: windows_core::PCSTR,
cvalues: u32,
lpimailproparray: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeNntpNewsfeed_Impl::Configure(
this,
core::mem::transmute(&lpsznewsfeeddn),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpimailproparray),
)
.into()
}
}
unsafe extern "system" fn CheckMsgIds<
Identity: IExchangeNntpNewsfeed_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmsgids: windows_core::PCSTR,
lpcfwanted: *mut u32,
lppfwanted: *mut *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeNntpNewsfeed_Impl::CheckMsgIds(
this,
core::mem::transmute(&lpszmsgids),
core::mem::transmute_copy(&lpcfwanted),
core::mem::transmute_copy(&lppfwanted),
)
.into()
}
}
unsafe extern "system" fn OpenArticleStream<
Identity: IExchangeNntpNewsfeed_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lppstream: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IExchangeNntpNewsfeed_Impl::OpenArticleStream(this) {
Ok(ok__) => {
lppstream.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Configure: Configure::<Identity, OFFSET>,
CheckMsgIds: CheckMsgIds::<Identity, OFFSET>,
OpenArticleStream: OpenArticleStream::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeNntpNewsfeed as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeNntpNewsfeed {}
windows_core::imp::define_interface!(
IExchangeRuleAction,
IExchangeRuleAction_Vtbl,
0x74bba840_c93a_11ce_9581_00aa005742f7
);
windows_core::imp::interface_hierarchy!(IExchangeRuleAction, windows_core::IUnknown);
impl IExchangeRuleAction {
pub unsafe fn ActionCount(&self, lpcactions: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ActionCount)(
windows_core::Interface::as_raw(self),
lpcactions as _,
)
.ok()
}
}
pub unsafe fn GetAction(
&self,
ulactionnumber: u32,
lpruleid: *mut i64,
lppaction: *mut *mut ACTION,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetAction)(
windows_core::Interface::as_raw(self),
ulactionnumber,
lpruleid as _,
lppaction as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IExchangeRuleAction_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub ActionCount:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub GetAction: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut i64,
*mut *mut ACTION,
) -> windows_core::HRESULT,
}
pub trait IExchangeRuleAction_Impl: windows_core::IUnknownImpl {
fn ActionCount(&self, lpcactions: *mut u32) -> windows_core::Result<()>;
fn GetAction(
&self,
ulactionnumber: u32,
lpruleid: *mut i64,
lppaction: *mut *mut ACTION,
) -> windows_core::Result<()>;
}
impl IExchangeRuleAction_Vtbl {
pub const fn new<Identity: IExchangeRuleAction_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn ActionCount<
Identity: IExchangeRuleAction_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpcactions: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeRuleAction_Impl::ActionCount(this, core::mem::transmute_copy(&lpcactions))
.into()
}
}
unsafe extern "system" fn GetAction<
Identity: IExchangeRuleAction_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulactionnumber: u32,
lpruleid: *mut i64,
lppaction: *mut *mut ACTION,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IExchangeRuleAction_Impl::GetAction(
this,
core::mem::transmute_copy(&ulactionnumber),
core::mem::transmute_copy(&lpruleid),
core::mem::transmute_copy(&lppaction),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
ActionCount: ActionCount::<Identity, OFFSET>,
GetAction: GetAction::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IExchangeRuleAction as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IExchangeRuleAction {}
windows_core::imp::define_interface!(
IFontCache,
IFontCache_Vtbl,
0xb0d17fc2_7bc4_11d1_bdfa_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IFontCache, windows_core::IUnknown);
impl IFontCache {
pub unsafe fn Init<P1>(
&self,
hkey: windows::Win32::System::Registry::HKEY,
pszintlkey: P1,
dwflags: u32,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Init)(
windows_core::Interface::as_raw(self),
hkey,
pszintlkey.param().abi(),
dwflags,
)
.ok()
}
}
pub unsafe fn GetFont(
&self,
fnttype: FNTSYSTYPE,
hcharset: *mut HCHARSET__,
phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetFont)(
windows_core::Interface::as_raw(self),
fnttype,
hcharset as _,
phfont as _,
)
.ok()
}
}
pub unsafe fn OnOptionChange(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnOptionChange)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn GetJP_ISOControl(
&self,
pfusesio: *mut windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetJP_ISOControl)(
windows_core::Interface::as_raw(self),
pfusesio as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IFontCache_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Init: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows::Win32::System::Registry::HKEY,
windows_core::PCSTR,
u32,
) -> windows_core::HRESULT,
pub GetFont: unsafe extern "system" fn(
*mut core::ffi::c_void,
FNTSYSTYPE,
*mut HCHARSET__,
*mut windows::Win32::Graphics::Gdi::HFONT,
) -> windows_core::HRESULT,
pub OnOptionChange: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub GetJP_ISOControl: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT,
}
pub trait IFontCache_Impl: windows_core::IUnknownImpl {
fn Init(
&self,
hkey: windows::Win32::System::Registry::HKEY,
pszintlkey: &windows_core::PCSTR,
dwflags: u32,
) -> windows_core::Result<()>;
fn GetFont(
&self,
fnttype: FNTSYSTYPE,
hcharset: *mut HCHARSET__,
phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
) -> windows_core::Result<()>;
fn OnOptionChange(&self) -> windows_core::Result<()>;
fn GetJP_ISOControl(
&self,
pfusesio: *mut windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()>;
}
impl IFontCache_Vtbl {
pub const fn new<Identity: IFontCache_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Init<Identity: IFontCache_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hkey: windows::Win32::System::Registry::HKEY,
pszintlkey: windows_core::PCSTR,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCache_Impl::Init(
this,
core::mem::transmute_copy(&hkey),
core::mem::transmute(&pszintlkey),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn GetFont<Identity: IFontCache_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
fnttype: FNTSYSTYPE,
hcharset: *mut HCHARSET__,
phfont: *mut windows::Win32::Graphics::Gdi::HFONT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCache_Impl::GetFont(
this,
core::mem::transmute_copy(&fnttype),
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&phfont),
)
.into()
}
}
unsafe extern "system" fn OnOptionChange<Identity: IFontCache_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCache_Impl::OnOptionChange(this).into()
}
}
unsafe extern "system" fn GetJP_ISOControl<
Identity: IFontCache_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfusesio: *mut windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCache_Impl::GetJP_ISOControl(this, core::mem::transmute_copy(&pfusesio)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Init: Init::<Identity, OFFSET>,
GetFont: GetFont::<Identity, OFFSET>,
OnOptionChange: OnOptionChange::<Identity, OFFSET>,
GetJP_ISOControl: GetJP_ISOControl::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IFontCache as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IFontCache {}
windows_core::imp::define_interface!(
IFontCacheNotify,
IFontCacheNotify_Vtbl,
0xb0d17fc5_7bc4_11d1_bdfa_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IFontCacheNotify, windows_core::IUnknown);
impl IFontCacheNotify {
pub unsafe fn OnPreFontChange(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnPreFontChange)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn OnPostFontChange(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnPostFontChange)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
}
#[repr(C)]
pub struct IFontCacheNotify_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnPreFontChange: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub OnPostFontChange:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IFontCacheNotify_Impl: windows_core::IUnknownImpl {
fn OnPreFontChange(&self) -> windows_core::Result<()>;
fn OnPostFontChange(&self) -> windows_core::Result<()>;
}
impl IFontCacheNotify_Vtbl {
pub const fn new<Identity: IFontCacheNotify_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnPreFontChange<
Identity: IFontCacheNotify_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCacheNotify_Impl::OnPreFontChange(this).into()
}
}
unsafe extern "system" fn OnPostFontChange<
Identity: IFontCacheNotify_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IFontCacheNotify_Impl::OnPostFontChange(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnPreFontChange: OnPreFontChange::<Identity, OFFSET>,
OnPostFontChange: OnPostFontChange::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IFontCacheNotify as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IFontCacheNotify {}
windows_core::imp::define_interface!(
IHashTable,
IHashTable_Vtbl,
0x64577981_86d7_11d1_bdfc_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IHashTable, windows_core::IUnknown);
impl IHashTable {
pub unsafe fn Init(&self, dwsize: u32, fdupekeys: bool) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Init)(
windows_core::Interface::as_raw(self),
dwsize,
fdupekeys.into(),
)
.ok()
}
}
pub unsafe fn Insert<P0>(
&self,
psz: P0,
pv: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Insert)(
windows_core::Interface::as_raw(self),
psz.param().abi(),
pv as _,
dwflags,
)
.ok()
}
}
pub unsafe fn Replace<P0>(
&self,
psz: P0,
pv: *mut core::ffi::c_void,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Replace)(
windows_core::Interface::as_raw(self),
psz.param().abi(),
pv as _,
)
.ok()
}
}
pub unsafe fn Find<P0>(
&self,
psz: P0,
fremove: bool,
ppv: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Find)(
windows_core::Interface::as_raw(self),
psz.param().abi(),
fremove.into(),
ppv as _,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Next(
&self,
cfetch: u32,
prgpv: *mut *mut *mut core::ffi::c_void,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
prgpv as _,
pcfetched as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IHashTable_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Init: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT,
pub Insert: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub Replace: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Find: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows::Win32::Foundation::BOOL,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut *mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait IHashTable_Impl: windows_core::IUnknownImpl {
fn Init(
&self,
dwsize: u32,
fdupekeys: windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()>;
fn Insert(
&self,
psz: &windows_core::PCSTR,
pv: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::Result<()>;
fn Replace(
&self,
psz: &windows_core::PCSTR,
pv: *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn Find(
&self,
psz: &windows_core::PCSTR,
fremove: windows::Win32::Foundation::BOOL,
ppv: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Next(
&self,
cfetch: u32,
prgpv: *mut *mut *mut core::ffi::c_void,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
}
impl IHashTable_Vtbl {
pub const fn new<Identity: IHashTable_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Init<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwsize: u32,
fdupekeys: windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Init(
this,
core::mem::transmute_copy(&dwsize),
core::mem::transmute_copy(&fdupekeys),
)
.into()
}
}
unsafe extern "system" fn Insert<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
psz: windows_core::PCSTR,
pv: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Insert(
this,
core::mem::transmute(&psz),
core::mem::transmute_copy(&pv),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn Replace<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
psz: windows_core::PCSTR,
pv: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Replace(
this,
core::mem::transmute(&psz),
core::mem::transmute_copy(&pv),
)
.into()
}
}
unsafe extern "system" fn Find<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
psz: windows_core::PCSTR,
fremove: windows::Win32::Foundation::BOOL,
ppv: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Find(
this,
core::mem::transmute(&psz),
core::mem::transmute_copy(&fremove),
core::mem::transmute_copy(&ppv),
)
.into()
}
}
unsafe extern "system" fn Reset<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Next<Identity: IHashTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cfetch: u32,
prgpv: *mut *mut *mut core::ffi::c_void,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IHashTable_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&prgpv),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Init: Init::<Identity, OFFSET>,
Insert: Insert::<Identity, OFFSET>,
Replace: Replace::<Identity, OFFSET>,
Find: Find::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Next: Next::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IHashTable as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IHashTable {}
pub const ILM_BODYCSET: INETLANGMASK = INETLANGMASK(4i32);
pub const ILM_FAMILY: INETLANGMASK = INETLANGMASK(1i32);
pub const ILM_FIXEDFONT: INETLANGMASK = INETLANGMASK(32i32);
pub const ILM_HEADERCSET: INETLANGMASK = INETLANGMASK(8i32);
pub const ILM_NAME: INETLANGMASK = INETLANGMASK(2i32);
pub const ILM_VARIABLEFONT: INETLANGMASK = INETLANGMASK(64i32);
pub const ILM_WEBCSET: INETLANGMASK = INETLANGMASK(16i32);
windows_core::imp::define_interface!(
IMAPIAdviseSink,
IMAPIAdviseSink_Vtbl,
0x00020302_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIAdviseSink, windows_core::IUnknown);
impl IMAPIAdviseSink {
pub unsafe fn OnNotify(&self, cnotif: u32, lpnotifications: *mut NOTIFICATION) -> u32 {
unsafe {
(windows_core::Interface::vtable(self).OnNotify)(
windows_core::Interface::as_raw(self),
cnotif,
lpnotifications as _,
)
}
}
}
#[repr(C)]
pub struct IMAPIAdviseSink_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnNotify: unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut NOTIFICATION) -> u32,
}
pub trait IMAPIAdviseSink_Impl: windows_core::IUnknownImpl {
fn OnNotify(&self, cnotif: u32, lpnotifications: *mut NOTIFICATION) -> u32;
}
impl IMAPIAdviseSink_Vtbl {
pub const fn new<Identity: IMAPIAdviseSink_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnNotify<Identity: IMAPIAdviseSink_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cnotif: u32,
lpnotifications: *mut NOTIFICATION,
) -> u32 {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIAdviseSink_Impl::OnNotify(
this,
core::mem::transmute_copy(&cnotif),
core::mem::transmute_copy(&lpnotifications),
)
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnNotify: OnNotify::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIAdviseSink as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIAdviseSink {}
pub const IMAPIAdviseSink_OnNotify: METHODS = METHODS(137i32);
windows_core::imp::define_interface!(
IMAPIClientShutdown,
IMAPIClientShutdown_Vtbl,
0x00020397_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIClientShutdown, windows_core::IUnknown);
impl IMAPIClientShutdown {
pub unsafe fn QueryFastShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryFastShutdown)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn NotifyProcessShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NotifyProcessShutdown)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn DoFastShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DoFastShutdown)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIClientShutdown_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub QueryFastShutdown:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub NotifyProcessShutdown:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub DoFastShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIClientShutdown_Impl: windows_core::IUnknownImpl {
fn QueryFastShutdown(&self) -> windows_core::Result<()>;
fn NotifyProcessShutdown(&self) -> windows_core::Result<()>;
fn DoFastShutdown(&self) -> windows_core::Result<()>;
}
impl IMAPIClientShutdown_Vtbl {
pub const fn new<Identity: IMAPIClientShutdown_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn QueryFastShutdown<
Identity: IMAPIClientShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIClientShutdown_Impl::QueryFastShutdown(this).into()
}
}
unsafe extern "system" fn NotifyProcessShutdown<
Identity: IMAPIClientShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIClientShutdown_Impl::NotifyProcessShutdown(this).into()
}
}
unsafe extern "system" fn DoFastShutdown<
Identity: IMAPIClientShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIClientShutdown_Impl::DoFastShutdown(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
QueryFastShutdown: QueryFastShutdown::<Identity, OFFSET>,
NotifyProcessShutdown: NotifyProcessShutdown::<Identity, OFFSET>,
DoFastShutdown: DoFastShutdown::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIClientShutdown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIClientShutdown {}
windows_core::imp::define_interface!(
IMAPIContainer,
IMAPIContainer_Vtbl,
0x0002030b_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIContainer {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMAPIContainer, windows_core::IUnknown, IMAPIProp);
impl IMAPIContainer {
pub unsafe fn GetContentsTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetContentsTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetHierarchyTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetHierarchyTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn SetSearchCriteria(
&self,
lprestriction: *mut SRestriction,
lpcontainerlist: *mut SBinaryArray,
ulsearchflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetSearchCriteria)(
windows_core::Interface::as_raw(self),
lprestriction as _,
lpcontainerlist as _,
ulsearchflags,
)
.ok()
}
}
pub unsafe fn GetSearchCriteria(
&self,
ulflags: u32,
lpprestriction: *mut *mut SRestriction,
lppcontainerlist: *mut *mut SBinaryArray,
lpulsearchstate: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSearchCriteria)(
windows_core::Interface::as_raw(self),
ulflags,
lpprestriction as _,
lppcontainerlist as _,
lpulsearchstate as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIContainer_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub GetContentsTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetHierarchyTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetSearchCriteria: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SRestriction,
*mut SBinaryArray,
u32,
) -> windows_core::HRESULT,
pub GetSearchCriteria: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SRestriction,
*mut *mut SBinaryArray,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait IMAPIContainer_Impl: IMAPIProp_Impl {
fn GetContentsTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn GetHierarchyTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn SetSearchCriteria(
&self,
lprestriction: *mut SRestriction,
lpcontainerlist: *mut SBinaryArray,
ulsearchflags: u32,
) -> windows_core::Result<()>;
fn GetSearchCriteria(
&self,
ulflags: u32,
lpprestriction: *mut *mut SRestriction,
lppcontainerlist: *mut *mut SBinaryArray,
lpulsearchstate: *mut u32,
) -> windows_core::Result<()>;
}
impl IMAPIContainer_Vtbl {
pub const fn new<Identity: IMAPIContainer_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetContentsTable<
Identity: IMAPIContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIContainer_Impl::GetContentsTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetHierarchyTable<
Identity: IMAPIContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIContainer_Impl::GetHierarchyTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn OpenEntry<Identity: IMAPIContainer_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIContainer_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn SetSearchCriteria<
Identity: IMAPIContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lprestriction: *mut SRestriction,
lpcontainerlist: *mut SBinaryArray,
ulsearchflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIContainer_Impl::SetSearchCriteria(
this,
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&lpcontainerlist),
core::mem::transmute_copy(&ulsearchflags),
)
.into()
}
}
unsafe extern "system" fn GetSearchCriteria<
Identity: IMAPIContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpprestriction: *mut *mut SRestriction,
lppcontainerlist: *mut *mut SBinaryArray,
lpulsearchstate: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIContainer_Impl::GetSearchCriteria(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpprestriction),
core::mem::transmute_copy(&lppcontainerlist),
core::mem::transmute_copy(&lpulsearchstate),
)
.into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
GetContentsTable: GetContentsTable::<Identity, OFFSET>,
GetHierarchyTable: GetHierarchyTable::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
SetSearchCriteria: SetSearchCriteria::<Identity, OFFSET>,
GetSearchCriteria: GetSearchCriteria::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIContainer as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIContainer {}
pub const IMAPIContainer_GetContentsTable: METHODS = METHODS(37i32);
pub const IMAPIContainer_GetHierarchyTable: METHODS = METHODS(38i32);
pub const IMAPIContainer_GetSearchCriteria: METHODS = METHODS(41i32);
pub const IMAPIContainer_OpenEntry: METHODS = METHODS(39i32);
pub const IMAPIContainer_SetSearchCriteria: METHODS = METHODS(40i32);
windows_core::imp::define_interface!(
IMAPIControl,
IMAPIControl_Vtbl,
0x0002031b_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIControl, windows_core::IUnknown);
impl IMAPIControl {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Activate(&self, ulflags: u32, uluiparam: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Activate)(
windows_core::Interface::as_raw(self),
ulflags,
uluiparam,
)
.ok()
}
}
pub unsafe fn GetState(&self, ulflags: u32, lpulstate: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetState)(
windows_core::Interface::as_raw(self),
ulflags,
lpulstate as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIControl_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Activate:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, usize) -> windows_core::HRESULT,
pub GetState:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIControl_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Activate(&self, ulflags: u32, uluiparam: usize) -> windows_core::Result<()>;
fn GetState(&self, ulflags: u32, lpulstate: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIControl_Vtbl {
pub const fn new<Identity: IMAPIControl_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPIControl_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIControl_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Activate<Identity: IMAPIControl_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
uluiparam: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIControl_Impl::Activate(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&uluiparam),
)
.into()
}
}
unsafe extern "system" fn GetState<Identity: IMAPIControl_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpulstate: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIControl_Impl::GetState(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulstate),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Activate: Activate::<Identity, OFFSET>,
GetState: GetState::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIControl as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIControl {}
pub const IMAPIControl_Activate: METHODS = METHODS(120i32);
pub const IMAPIControl_GetLastError: METHODS = METHODS(119i32);
pub const IMAPIControl_GetState: METHODS = METHODS(121i32);
windows_core::imp::define_interface!(
IMAPIFolder,
IMAPIFolder_Vtbl,
0x0002030c_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIFolder {
type Target = IMAPIContainer;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMAPIFolder,
windows_core::IUnknown,
IMAPIProp,
IMAPIContainer
);
impl IMAPIFolder {
pub unsafe fn CreateMessage(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmessage: *mut Option<IMessage>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateMessage)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
core::mem::transmute(lppmessage),
)
.ok()
}
}
pub unsafe fn CopyMessages<P4>(
&self,
lpmsglist: *mut SBinaryArray,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: P4,
ulflags: u32,
) -> windows_core::Result<()>
where
P4: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyMessages)(
windows_core::Interface::as_raw(self),
lpmsglist as _,
lpinterface as _,
lpdestfolder as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteMessages<P2>(
&self,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteMessages)(
windows_core::Interface::as_raw(self),
lpmsglist as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn CreateFolder(
&self,
ulfoldertype: u32,
lpszfoldername: *mut i8,
lpszfoldercomment: *mut i8,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppfolder: *mut Option<IMAPIFolder>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateFolder)(
windows_core::Interface::as_raw(self),
ulfoldertype,
lpszfoldername as _,
lpszfoldercomment as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppfolder),
)
.ok()
}
}
pub unsafe fn CopyFolder<P6>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lpsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: P6,
ulflags: u32,
) -> windows_core::Result<()>
where
P6: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyFolder)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
lpdestfolder as _,
lpsznewfoldername as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteFolder<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uluiparam: usize,
lpprogress: P3,
ulflags: u32,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteFolder)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn SetReadFlags<P2>(
&self,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).SetReadFlags)(
windows_core::Interface::as_raw(self),
lpmsglist as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn GetMessageStatus(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpulmessagestatus: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMessageStatus)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
ulflags,
lpulmessagestatus as _,
)
.ok()
}
}
pub unsafe fn SetMessageStatus(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulnewstatus: u32,
ulnewstatusmask: u32,
lpuloldstatus: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetMessageStatus)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
ulnewstatus,
ulnewstatusmask,
lpuloldstatus as _,
)
.ok()
}
}
pub unsafe fn SaveContentsSort(
&self,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveContentsSort)(
windows_core::Interface::as_raw(self),
lpsortcriteria as _,
ulflags,
)
.ok()
}
}
pub unsafe fn EmptyFolder<P1>(
&self,
uluiparam: usize,
lpprogress: P1,
ulflags: u32,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).EmptyFolder)(
windows_core::Interface::as_raw(self),
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIFolder_Vtbl {
pub base__: IMAPIContainer_Vtbl,
pub CreateMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CopyMessages: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
*mut windows_core::GUID,
*mut core::ffi::c_void,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DeleteMessages: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CreateFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut i8,
*mut i8,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CopyFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
*mut core::ffi::c_void,
*mut i8,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DeleteFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub SetReadFlags: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SBinaryArray,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetMessageStatus: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub SetMessageStatus: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub SaveContentsSort: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SSortOrderSet,
u32,
) -> windows_core::HRESULT,
pub EmptyFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
}
pub trait IMAPIFolder_Impl: IMAPIContainer_Impl {
fn CreateMessage(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmessage: windows_core::OutRef<'_, IMessage>,
) -> windows_core::Result<()>;
fn CopyMessages(
&self,
lpmsglist: *mut SBinaryArray,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteMessages(
&self,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn CreateFolder(
&self,
ulfoldertype: u32,
lpszfoldername: *mut i8,
lpszfoldercomment: *mut i8,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppfolder: windows_core::OutRef<'_, IMAPIFolder>,
) -> windows_core::Result<()>;
fn CopyFolder(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lpsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteFolder(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn SetReadFlags(
&self,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetMessageStatus(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpulmessagestatus: *mut u32,
) -> windows_core::Result<()>;
fn SetMessageStatus(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulnewstatus: u32,
ulnewstatusmask: u32,
lpuloldstatus: *mut u32,
) -> windows_core::Result<()>;
fn SaveContentsSort(
&self,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::Result<()>;
fn EmptyFolder(
&self,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
}
impl IMAPIFolder_Vtbl {
pub const fn new<Identity: IMAPIFolder_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateMessage<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmessage: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::CreateMessage(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmessage),
)
.into()
}
}
unsafe extern "system" fn CopyMessages<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::CopyMessages(
this,
core::mem::transmute_copy(&lpmsglist),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpdestfolder),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteMessages<
Identity: IMAPIFolder_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::DeleteMessages(
this,
core::mem::transmute_copy(&lpmsglist),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CreateFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulfoldertype: u32,
lpszfoldername: *mut i8,
lpszfoldercomment: *mut i8,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppfolder: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::CreateFolder(
this,
core::mem::transmute_copy(&ulfoldertype),
core::mem::transmute_copy(&lpszfoldername),
core::mem::transmute_copy(&lpszfoldercomment),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppfolder),
)
.into()
}
}
unsafe extern "system" fn CopyFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lpsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::CopyFolder(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpdestfolder),
core::mem::transmute_copy(&lpsznewfoldername),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::DeleteFolder(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn SetReadFlags<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::SetReadFlags(
this,
core::mem::transmute_copy(&lpmsglist),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetMessageStatus<
Identity: IMAPIFolder_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpulmessagestatus: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::GetMessageStatus(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulmessagestatus),
)
.into()
}
}
unsafe extern "system" fn SetMessageStatus<
Identity: IMAPIFolder_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulnewstatus: u32,
ulnewstatusmask: u32,
lpuloldstatus: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::SetMessageStatus(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulnewstatus),
core::mem::transmute_copy(&ulnewstatusmask),
core::mem::transmute_copy(&lpuloldstatus),
)
.into()
}
}
unsafe extern "system" fn SaveContentsSort<
Identity: IMAPIFolder_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::SaveContentsSort(
this,
core::mem::transmute_copy(&lpsortcriteria),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn EmptyFolder<Identity: IMAPIFolder_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFolder_Impl::EmptyFolder(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
Self {
base__: IMAPIContainer_Vtbl::new::<Identity, OFFSET>(),
CreateMessage: CreateMessage::<Identity, OFFSET>,
CopyMessages: CopyMessages::<Identity, OFFSET>,
DeleteMessages: DeleteMessages::<Identity, OFFSET>,
CreateFolder: CreateFolder::<Identity, OFFSET>,
CopyFolder: CopyFolder::<Identity, OFFSET>,
DeleteFolder: DeleteFolder::<Identity, OFFSET>,
SetReadFlags: SetReadFlags::<Identity, OFFSET>,
GetMessageStatus: GetMessageStatus::<Identity, OFFSET>,
SetMessageStatus: SetMessageStatus::<Identity, OFFSET>,
SaveContentsSort: SaveContentsSort::<Identity, OFFSET>,
EmptyFolder: EmptyFolder::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFolder as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
|| iid == &<IMAPIContainer as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFolder {}
pub const IMAPIFolder_CopyFolder: METHODS = METHODS(54i32);
pub const IMAPIFolder_CopyMessages: METHODS = METHODS(51i32);
pub const IMAPIFolder_CreateFolder: METHODS = METHODS(53i32);
pub const IMAPIFolder_CreateMessage: METHODS = METHODS(50i32);
pub const IMAPIFolder_DeleteFolder: METHODS = METHODS(55i32);
pub const IMAPIFolder_DeleteMessages: METHODS = METHODS(52i32);
pub const IMAPIFolder_EmptyFolder: METHODS = METHODS(60i32);
pub const IMAPIFolder_GetMessageStatus: METHODS = METHODS(57i32);
pub const IMAPIFolder_SaveContentsSort: METHODS = METHODS(59i32);
pub const IMAPIFolder_SetMessageStatus: METHODS = METHODS(58i32);
pub const IMAPIFolder_SetReadFlags: METHODS = METHODS(56i32);
windows_core::imp::define_interface!(
IMAPIForm,
IMAPIForm_Vtbl,
0x00020327_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIForm, windows_core::IUnknown);
impl IMAPIForm {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn SetViewContext<P0>(&self, pviewcontext: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIViewContext>,
{
unsafe {
(windows_core::Interface::vtable(self).SetViewContext)(
windows_core::Interface::as_raw(self),
pviewcontext.param().abi(),
)
.ok()
}
}
pub unsafe fn GetViewContext(&self) -> windows_core::Result<IMAPIViewContext> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetViewContext)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ShutdownForm(&self, ulsaveoptions: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ShutdownForm)(
windows_core::Interface::as_raw(self),
ulsaveoptions,
)
.ok()
}
}
pub unsafe fn DoVerb<P1>(
&self,
iverb: i32,
lpviewcontext: P1,
hwndparent: usize,
lprcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMAPIViewContext>,
{
unsafe {
(windows_core::Interface::vtable(self).DoVerb)(
windows_core::Interface::as_raw(self),
iverb,
lpviewcontext.param().abi(),
hwndparent,
lprcposrect as _,
)
.ok()
}
}
pub unsafe fn Advise<P0>(&self, padvise: P0, pdwstatus: *mut usize) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIViewAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
padvise.param().abi(),
pdwstatus as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIForm_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub SetViewContext: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetViewContext: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ShutdownForm:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub DoVerb: unsafe extern "system" fn(
*mut core::ffi::c_void,
i32,
*mut core::ffi::c_void,
usize,
*mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
}
pub trait IMAPIForm_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn SetViewContext(
&self,
pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
) -> windows_core::Result<()>;
fn GetViewContext(&self) -> windows_core::Result<IMAPIViewContext>;
fn ShutdownForm(&self, ulsaveoptions: u32) -> windows_core::Result<()>;
fn DoVerb(
&self,
iverb: i32,
lpviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
hwndparent: usize,
lprcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>;
fn Advise(
&self,
padvise: windows_core::Ref<'_, IMAPIViewAdviseSink>,
pdwstatus: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
}
impl IMAPIForm_Vtbl {
pub const fn new<Identity: IMAPIForm_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn SetViewContext<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pviewcontext: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::SetViewContext(this, core::mem::transmute_copy(&pviewcontext))
.into()
}
}
unsafe extern "system" fn GetViewContext<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppviewcontext: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIForm_Impl::GetViewContext(this) {
Ok(ok__) => {
ppviewcontext.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ShutdownForm<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulsaveoptions: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::ShutdownForm(this, core::mem::transmute_copy(&ulsaveoptions)).into()
}
}
unsafe extern "system" fn DoVerb<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
iverb: i32,
lpviewcontext: *mut core::ffi::c_void,
hwndparent: usize,
lprcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::DoVerb(
this,
core::mem::transmute_copy(&iverb),
core::mem::transmute_copy(&lpviewcontext),
core::mem::transmute_copy(&hwndparent),
core::mem::transmute_copy(&lprcposrect),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
padvise: *mut core::ffi::c_void,
pdwstatus: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::Advise(
this,
core::mem::transmute_copy(&padvise),
core::mem::transmute_copy(&pdwstatus),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IMAPIForm_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIForm_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
SetViewContext: SetViewContext::<Identity, OFFSET>,
GetViewContext: GetViewContext::<Identity, OFFSET>,
ShutdownForm: ShutdownForm::<Identity, OFFSET>,
DoVerb: DoVerb::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIForm as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIForm {}
windows_core::imp::define_interface!(
IMAPIFormAdviseSink,
IMAPIFormAdviseSink_Vtbl,
0x0002032f_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormAdviseSink, windows_core::IUnknown);
impl IMAPIFormAdviseSink {
pub unsafe fn OnChange(&self, uldir: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnChange)(
windows_core::Interface::as_raw(self),
uldir,
)
.ok()
}
}
pub unsafe fn OnActivateNext<P0>(
&self,
lpszmessageclass: P0,
ulmessagestatus: u32,
ulmessageflags: u32,
) -> windows_core::Result<IPersistMessage>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).OnActivateNext)(
windows_core::Interface::as_raw(self),
lpszmessageclass.param().abi(),
ulmessagestatus,
ulmessageflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMAPIFormAdviseSink_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnChange: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub OnActivateNext: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMAPIFormAdviseSink_Impl: windows_core::IUnknownImpl {
fn OnChange(&self, uldir: u32) -> windows_core::Result<()>;
fn OnActivateNext(
&self,
lpszmessageclass: &windows_core::PCSTR,
ulmessagestatus: u32,
ulmessageflags: u32,
) -> windows_core::Result<IPersistMessage>;
}
impl IMAPIFormAdviseSink_Vtbl {
pub const fn new<Identity: IMAPIFormAdviseSink_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnChange<
Identity: IMAPIFormAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uldir: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormAdviseSink_Impl::OnChange(this, core::mem::transmute_copy(&uldir)).into()
}
}
unsafe extern "system" fn OnActivateNext<
Identity: IMAPIFormAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmessageclass: windows_core::PCSTR,
ulmessagestatus: u32,
ulmessageflags: u32,
pppersistmessage: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormAdviseSink_Impl::OnActivateNext(
this,
core::mem::transmute(&lpszmessageclass),
core::mem::transmute_copy(&ulmessagestatus),
core::mem::transmute_copy(&ulmessageflags),
) {
Ok(ok__) => {
pppersistmessage.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnChange: OnChange::<Identity, OFFSET>,
OnActivateNext: OnActivateNext::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFormAdviseSink as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFormAdviseSink {}
windows_core::imp::define_interface!(
IMAPIFormContainer,
IMAPIFormContainer_Vtbl,
0x0002032e_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormContainer, windows_core::IUnknown);
impl IMAPIFormContainer {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn InstallForm(
&self,
uluiparam: usize,
ulflags: u32,
szcfgpathname: *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).InstallForm)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
szcfgpathname as _,
)
.ok()
}
}
pub unsafe fn RemoveForm<P0>(&self, szmessageclass: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).RemoveForm)(
windows_core::Interface::as_raw(self),
szmessageclass.param().abi(),
)
.ok()
}
}
pub unsafe fn ResolveMessageClass<P0>(
&self,
szmessageclass: P0,
ulflags: u32,
) -> windows_core::Result<IMAPIFormInfo>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).ResolveMessageClass)(
windows_core::Interface::as_raw(self),
szmessageclass.param().abi(),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ResolveMultipleMessageClasses(
&self,
pmsgclassarray: *mut SMessageClassArray,
ulflags: u32,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ResolveMultipleMessageClasses)(
windows_core::Interface::as_raw(self),
pmsgclassarray as _,
ulflags,
ppfrminfoarray as _,
)
.ok()
}
}
pub unsafe fn CalcFormPropSet(
&self,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CalcFormPropSet)(
windows_core::Interface::as_raw(self),
ulflags,
ppresults as _,
)
.ok()
}
}
pub unsafe fn GetDisplay(
&self,
ulflags: u32,
pszdisplayname: *mut *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetDisplay)(
windows_core::Interface::as_raw(self),
ulflags,
pszdisplayname as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIFormContainer_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub InstallForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
) -> windows_core::HRESULT,
pub RemoveForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub ResolveMessageClass: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ResolveMultipleMessageClasses: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SMessageClassArray,
u32,
*mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT,
pub CalcFormPropSet: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT,
pub GetDisplay: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut i8,
) -> windows_core::HRESULT,
}
pub trait IMAPIFormContainer_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn InstallForm(
&self,
uluiparam: usize,
ulflags: u32,
szcfgpathname: *mut i8,
) -> windows_core::Result<()>;
fn RemoveForm(&self, szmessageclass: &windows_core::PCSTR) -> windows_core::Result<()>;
fn ResolveMessageClass(
&self,
szmessageclass: &windows_core::PCSTR,
ulflags: u32,
) -> windows_core::Result<IMAPIFormInfo>;
fn ResolveMultipleMessageClasses(
&self,
pmsgclassarray: *mut SMessageClassArray,
ulflags: u32,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()>;
fn CalcFormPropSet(
&self,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()>;
fn GetDisplay(&self, ulflags: u32, pszdisplayname: *mut *mut i8) -> windows_core::Result<()>;
}
impl IMAPIFormContainer_Vtbl {
pub const fn new<Identity: IMAPIFormContainer_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn InstallForm<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
szcfgpathname: *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::InstallForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&szcfgpathname),
)
.into()
}
}
unsafe extern "system" fn RemoveForm<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
szmessageclass: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::RemoveForm(this, core::mem::transmute(&szmessageclass))
.into()
}
}
unsafe extern "system" fn ResolveMessageClass<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
szmessageclass: windows_core::PCSTR,
ulflags: u32,
pforminfo: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormContainer_Impl::ResolveMessageClass(
this,
core::mem::transmute(&szmessageclass),
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
pforminfo.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ResolveMultipleMessageClasses<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pmsgclassarray: *mut SMessageClassArray,
ulflags: u32,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::ResolveMultipleMessageClasses(
this,
core::mem::transmute_copy(&pmsgclassarray),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ppfrminfoarray),
)
.into()
}
}
unsafe extern "system" fn CalcFormPropSet<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::CalcFormPropSet(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ppresults),
)
.into()
}
}
unsafe extern "system" fn GetDisplay<
Identity: IMAPIFormContainer_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
pszdisplayname: *mut *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormContainer_Impl::GetDisplay(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&pszdisplayname),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
InstallForm: InstallForm::<Identity, OFFSET>,
RemoveForm: RemoveForm::<Identity, OFFSET>,
ResolveMessageClass: ResolveMessageClass::<Identity, OFFSET>,
ResolveMultipleMessageClasses: ResolveMultipleMessageClasses::<Identity, OFFSET>,
CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
GetDisplay: GetDisplay::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFormContainer as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFormContainer {}
windows_core::imp::define_interface!(
IMAPIFormFactory,
IMAPIFormFactory_Vtbl,
0x00020350_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormFactory, windows_core::IUnknown);
impl IMAPIFormFactory {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn CreateClassFactory(
&self,
clsidform: *const windows_core::GUID,
ulflags: u32,
) -> windows_core::Result<windows::Win32::System::Com::IClassFactory> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).CreateClassFactory)(
windows_core::Interface::as_raw(self),
clsidform,
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn LockServer(&self, ulflags: u32, flockserver: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).LockServer)(
windows_core::Interface::as_raw(self),
ulflags,
flockserver,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIFormFactory_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub CreateClassFactory: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub LockServer:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
}
pub trait IMAPIFormFactory_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn CreateClassFactory(
&self,
clsidform: *const windows_core::GUID,
ulflags: u32,
) -> windows_core::Result<windows::Win32::System::Com::IClassFactory>;
fn LockServer(&self, ulflags: u32, flockserver: u32) -> windows_core::Result<()>;
}
impl IMAPIFormFactory_Vtbl {
pub const fn new<Identity: IMAPIFormFactory_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMAPIFormFactory_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormFactory_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn CreateClassFactory<
Identity: IMAPIFormFactory_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
clsidform: *const windows_core::GUID,
ulflags: u32,
lppclassfactory: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormFactory_Impl::CreateClassFactory(
this,
core::mem::transmute_copy(&clsidform),
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lppclassfactory.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn LockServer<
Identity: IMAPIFormFactory_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
flockserver: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormFactory_Impl::LockServer(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&flockserver),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
CreateClassFactory: CreateClassFactory::<Identity, OFFSET>,
LockServer: LockServer::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFormFactory as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFormFactory {}
windows_core::imp::define_interface!(
IMAPIFormInfo,
IMAPIFormInfo_Vtbl,
0x00020324_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIFormInfo {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMAPIFormInfo, windows_core::IUnknown, IMAPIProp);
impl IMAPIFormInfo {
pub unsafe fn CalcFormPropSet(
&self,
ulflags: u32,
ppformproparray: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CalcFormPropSet)(
windows_core::Interface::as_raw(self),
ulflags,
ppformproparray as _,
)
.ok()
}
}
pub unsafe fn CalcVerbSet(
&self,
ulflags: u32,
ppmapiverbarray: *mut *mut SMAPIVerbArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CalcVerbSet)(
windows_core::Interface::as_raw(self),
ulflags,
ppmapiverbarray as _,
)
.ok()
}
}
pub unsafe fn MakeIconFromBinary(
&self,
npropid: u32,
phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MakeIconFromBinary)(
windows_core::Interface::as_raw(self),
npropid,
phicon as _,
)
.ok()
}
}
pub unsafe fn SaveForm(&self, szfilename: *mut i8) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveForm)(
windows_core::Interface::as_raw(self),
szfilename as _,
)
.ok()
}
}
pub unsafe fn OpenFormContainer(&self) -> windows_core::Result<IMAPIFormContainer> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).OpenFormContainer)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMAPIFormInfo_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub CalcFormPropSet: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT,
pub CalcVerbSet: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SMAPIVerbArray,
) -> windows_core::HRESULT,
pub MakeIconFromBinary: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::UI::WindowsAndMessaging::HICON,
) -> windows_core::HRESULT,
pub SaveForm:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8) -> windows_core::HRESULT,
pub OpenFormContainer: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMAPIFormInfo_Impl: IMAPIProp_Impl {
fn CalcFormPropSet(
&self,
ulflags: u32,
ppformproparray: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()>;
fn CalcVerbSet(
&self,
ulflags: u32,
ppmapiverbarray: *mut *mut SMAPIVerbArray,
) -> windows_core::Result<()>;
fn MakeIconFromBinary(
&self,
npropid: u32,
phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
) -> windows_core::Result<()>;
fn SaveForm(&self, szfilename: *mut i8) -> windows_core::Result<()>;
fn OpenFormContainer(&self) -> windows_core::Result<IMAPIFormContainer>;
}
impl IMAPIFormInfo_Vtbl {
pub const fn new<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CalcFormPropSet<
Identity: IMAPIFormInfo_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
ppformproparray: *mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormInfo_Impl::CalcFormPropSet(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ppformproparray),
)
.into()
}
}
unsafe extern "system" fn CalcVerbSet<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
ppmapiverbarray: *mut *mut SMAPIVerbArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormInfo_Impl::CalcVerbSet(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ppmapiverbarray),
)
.into()
}
}
unsafe extern "system" fn MakeIconFromBinary<
Identity: IMAPIFormInfo_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
npropid: u32,
phicon: *mut windows::Win32::UI::WindowsAndMessaging::HICON,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormInfo_Impl::MakeIconFromBinary(
this,
core::mem::transmute_copy(&npropid),
core::mem::transmute_copy(&phicon),
)
.into()
}
}
unsafe extern "system" fn SaveForm<Identity: IMAPIFormInfo_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
szfilename: *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormInfo_Impl::SaveForm(this, core::mem::transmute_copy(&szfilename)).into()
}
}
unsafe extern "system" fn OpenFormContainer<
Identity: IMAPIFormInfo_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppformcontainer: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormInfo_Impl::OpenFormContainer(this) {
Ok(ok__) => {
ppformcontainer.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
CalcVerbSet: CalcVerbSet::<Identity, OFFSET>,
MakeIconFromBinary: MakeIconFromBinary::<Identity, OFFSET>,
SaveForm: SaveForm::<Identity, OFFSET>,
OpenFormContainer: OpenFormContainer::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFormInfo as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFormInfo {}
windows_core::imp::define_interface!(
IMAPIFormMgr,
IMAPIFormMgr_Vtbl,
0x00020322_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIFormMgr, windows_core::IUnknown);
impl IMAPIFormMgr {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn LoadForm<P2, P5, P6, P7, P8>(
&self,
uluiparam: usize,
ulflags: u32,
lpszmessageclass: P2,
ulmessagestatus: u32,
ulmessageflags: u32,
pfolderfocus: P5,
pmessagesite: P6,
pmsg: P7,
pviewcontext: P8,
riid: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
P5: windows_core::Param<IMAPIFolder>,
P6: windows_core::Param<IMAPIMessageSite>,
P7: windows_core::Param<IMessage>,
P8: windows_core::Param<IMAPIViewContext>,
{
unsafe {
(windows_core::Interface::vtable(self).LoadForm)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
lpszmessageclass.param().abi(),
ulmessagestatus,
ulmessageflags,
pfolderfocus.param().abi(),
pmessagesite.param().abi(),
pmsg.param().abi(),
pviewcontext.param().abi(),
riid,
ppvobj as _,
)
.ok()
}
}
pub unsafe fn ResolveMessageClass<P0, P2>(
&self,
szmsgclass: P0,
ulflags: u32,
pfolderfocus: P2,
) -> windows_core::Result<IMAPIFormInfo>
where
P0: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<IMAPIFolder>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).ResolveMessageClass)(
windows_core::Interface::as_raw(self),
szmsgclass.param().abi(),
ulflags,
pfolderfocus.param().abi(),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ResolveMultipleMessageClasses<P2>(
&self,
pmsgclasses: *mut SMessageClassArray,
ulflags: u32,
pfolderfocus: P2,
pfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIFolder>,
{
unsafe {
(windows_core::Interface::vtable(self).ResolveMultipleMessageClasses)(
windows_core::Interface::as_raw(self),
pmsgclasses as _,
ulflags,
pfolderfocus.param().abi(),
pfrminfoarray as _,
)
.ok()
}
}
pub unsafe fn CalcFormPropSet(
&self,
pfrminfoarray: *mut SMAPIFormInfoArray,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CalcFormPropSet)(
windows_core::Interface::as_raw(self),
core::mem::transmute(pfrminfoarray),
ulflags,
ppresults as _,
)
.ok()
}
}
pub unsafe fn CreateForm<P2>(
&self,
uluiparam: usize,
ulflags: u32,
pfrminfotoactivate: P2,
refiidtoask: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIFormInfo>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateForm)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
pfrminfotoactivate.param().abi(),
refiidtoask,
ppvobj as _,
)
.ok()
}
}
pub unsafe fn SelectForm<P3>(
&self,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: P3,
ppfrminforeturned: *mut Option<IMAPIFormInfo>,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIFolder>,
{
unsafe {
(windows_core::Interface::vtable(self).SelectForm)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
psztitle as _,
pfld.param().abi(),
core::mem::transmute(ppfrminforeturned),
)
.ok()
}
}
pub unsafe fn SelectMultipleForms<P3>(
&self,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: P3,
pfrminfoarray: *mut SMAPIFormInfoArray,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIFolder>,
{
unsafe {
(windows_core::Interface::vtable(self).SelectMultipleForms)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
psztitle as _,
pfld.param().abi(),
core::mem::transmute(pfrminfoarray),
ppfrminfoarray as _,
)
.ok()
}
}
pub unsafe fn SelectFormContainer(
&self,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<IMAPIFormContainer> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).SelectFormContainer)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn OpenFormContainer<P1>(
&self,
hfrmreg: u32,
lpunk: P1,
) -> windows_core::Result<IMAPIFormContainer>
where
P1: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).OpenFormContainer)(
windows_core::Interface::as_raw(self),
hfrmreg,
lpunk.param().abi(),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn PrepareForm<P2>(
&self,
uluiparam: usize,
ulflags: u32,
pfrminfo: P2,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIFormInfo>,
{
unsafe {
(windows_core::Interface::vtable(self).PrepareForm)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
pfrminfo.param().abi(),
)
.ok()
}
}
pub unsafe fn IsInConflict<P2, P3>(
&self,
ulmessageflags: u32,
ulmessagestatus: u32,
szmessageclass: P2,
pfolderfocus: P3,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
P3: windows_core::Param<IMAPIFolder>,
{
unsafe {
(windows_core::Interface::vtable(self).IsInConflict)(
windows_core::Interface::as_raw(self),
ulmessageflags,
ulmessagestatus,
szmessageclass.param().abi(),
pfolderfocus.param().abi(),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIFormMgr_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub LoadForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
windows_core::PCSTR,
u32,
u32,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ResolveMessageClass: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ResolveMultipleMessageClasses: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SMessageClassArray,
u32,
*mut core::ffi::c_void,
*mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT,
pub CalcFormPropSet: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SMAPIFormInfoArray,
u32,
*mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT,
pub CreateForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SelectForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SelectMultipleForms: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
*mut core::ffi::c_void,
*mut SMAPIFormInfoArray,
*mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT,
pub SelectFormContainer: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenFormContainer: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub PrepareForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub IsInConflict: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
windows_core::PCSTR,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMAPIFormMgr_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn LoadForm(
&self,
uluiparam: usize,
ulflags: u32,
lpszmessageclass: &windows_core::PCSTR,
ulmessagestatus: u32,
ulmessageflags: u32,
pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
pmsg: windows_core::Ref<'_, IMessage>,
pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
riid: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn ResolveMessageClass(
&self,
szmsgclass: &windows_core::PCSTR,
ulflags: u32,
pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
) -> windows_core::Result<IMAPIFormInfo>;
fn ResolveMultipleMessageClasses(
&self,
pmsgclasses: *mut SMessageClassArray,
ulflags: u32,
pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
pfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()>;
fn CalcFormPropSet(
&self,
pfrminfoarray: *mut SMAPIFormInfoArray,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::Result<()>;
fn CreateForm(
&self,
uluiparam: usize,
ulflags: u32,
pfrminfotoactivate: windows_core::Ref<'_, IMAPIFormInfo>,
refiidtoask: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn SelectForm(
&self,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: windows_core::Ref<'_, IMAPIFolder>,
ppfrminforeturned: windows_core::OutRef<'_, IMAPIFormInfo>,
) -> windows_core::Result<()>;
fn SelectMultipleForms(
&self,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: windows_core::Ref<'_, IMAPIFolder>,
pfrminfoarray: *mut SMAPIFormInfoArray,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::Result<()>;
fn SelectFormContainer(
&self,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<IMAPIFormContainer>;
fn OpenFormContainer(
&self,
hfrmreg: u32,
lpunk: windows_core::Ref<'_, windows_core::IUnknown>,
) -> windows_core::Result<IMAPIFormContainer>;
fn PrepareForm(
&self,
uluiparam: usize,
ulflags: u32,
pfrminfo: windows_core::Ref<'_, IMAPIFormInfo>,
) -> windows_core::Result<()>;
fn IsInConflict(
&self,
ulmessageflags: u32,
ulmessagestatus: u32,
szmessageclass: &windows_core::PCSTR,
pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
) -> windows_core::Result<()>;
}
impl IMAPIFormMgr_Vtbl {
pub const fn new<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn LoadForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lpszmessageclass: windows_core::PCSTR,
ulmessagestatus: u32,
ulmessageflags: u32,
pfolderfocus: *mut core::ffi::c_void,
pmessagesite: *mut core::ffi::c_void,
pmsg: *mut core::ffi::c_void,
pviewcontext: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::LoadForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute(&lpszmessageclass),
core::mem::transmute_copy(&ulmessagestatus),
core::mem::transmute_copy(&ulmessageflags),
core::mem::transmute_copy(&pfolderfocus),
core::mem::transmute_copy(&pmessagesite),
core::mem::transmute_copy(&pmsg),
core::mem::transmute_copy(&pviewcontext),
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobj),
)
.into()
}
}
unsafe extern "system" fn ResolveMessageClass<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
szmsgclass: windows_core::PCSTR,
ulflags: u32,
pfolderfocus: *mut core::ffi::c_void,
ppresult: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormMgr_Impl::ResolveMessageClass(
this,
core::mem::transmute(&szmsgclass),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&pfolderfocus),
) {
Ok(ok__) => {
ppresult.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ResolveMultipleMessageClasses<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pmsgclasses: *mut SMessageClassArray,
ulflags: u32,
pfolderfocus: *mut core::ffi::c_void,
pfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::ResolveMultipleMessageClasses(
this,
core::mem::transmute_copy(&pmsgclasses),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&pfolderfocus),
core::mem::transmute_copy(&pfrminfoarray),
)
.into()
}
}
unsafe extern "system" fn CalcFormPropSet<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfrminfoarray: *mut SMAPIFormInfoArray,
ulflags: u32,
ppresults: *mut *mut SMAPIFormPropArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::CalcFormPropSet(
this,
core::mem::transmute_copy(&pfrminfoarray),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ppresults),
)
.into()
}
}
unsafe extern "system" fn CreateForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
pfrminfotoactivate: *mut core::ffi::c_void,
refiidtoask: *const windows_core::GUID,
ppvobj: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::CreateForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&pfrminfotoactivate),
core::mem::transmute_copy(&refiidtoask),
core::mem::transmute_copy(&ppvobj),
)
.into()
}
}
unsafe extern "system" fn SelectForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: *mut core::ffi::c_void,
ppfrminforeturned: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::SelectForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&psztitle),
core::mem::transmute_copy(&pfld),
core::mem::transmute_copy(&ppfrminforeturned),
)
.into()
}
}
unsafe extern "system" fn SelectMultipleForms<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
psztitle: *mut i8,
pfld: *mut core::ffi::c_void,
pfrminfoarray: *mut SMAPIFormInfoArray,
ppfrminfoarray: *mut *mut SMAPIFormInfoArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::SelectMultipleForms(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&psztitle),
core::mem::transmute_copy(&pfld),
core::mem::transmute_copy(&pfrminfoarray),
core::mem::transmute_copy(&ppfrminfoarray),
)
.into()
}
}
unsafe extern "system" fn SelectFormContainer<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lppfcnt: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormMgr_Impl::SelectFormContainer(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lppfcnt.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn OpenFormContainer<
Identity: IMAPIFormMgr_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hfrmreg: u32,
lpunk: *mut core::ffi::c_void,
lppfcnt: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIFormMgr_Impl::OpenFormContainer(
this,
core::mem::transmute_copy(&hfrmreg),
core::mem::transmute_copy(&lpunk),
) {
Ok(ok__) => {
lppfcnt.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn PrepareForm<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
pfrminfo: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::PrepareForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&pfrminfo),
)
.into()
}
}
unsafe extern "system" fn IsInConflict<Identity: IMAPIFormMgr_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulmessageflags: u32,
ulmessagestatus: u32,
szmessageclass: windows_core::PCSTR,
pfolderfocus: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIFormMgr_Impl::IsInConflict(
this,
core::mem::transmute_copy(&ulmessageflags),
core::mem::transmute_copy(&ulmessagestatus),
core::mem::transmute(&szmessageclass),
core::mem::transmute_copy(&pfolderfocus),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
LoadForm: LoadForm::<Identity, OFFSET>,
ResolveMessageClass: ResolveMessageClass::<Identity, OFFSET>,
ResolveMultipleMessageClasses: ResolveMultipleMessageClasses::<Identity, OFFSET>,
CalcFormPropSet: CalcFormPropSet::<Identity, OFFSET>,
CreateForm: CreateForm::<Identity, OFFSET>,
SelectForm: SelectForm::<Identity, OFFSET>,
SelectMultipleForms: SelectMultipleForms::<Identity, OFFSET>,
SelectFormContainer: SelectFormContainer::<Identity, OFFSET>,
OpenFormContainer: OpenFormContainer::<Identity, OFFSET>,
PrepareForm: PrepareForm::<Identity, OFFSET>,
IsInConflict: IsInConflict::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIFormMgr as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIFormMgr {}
windows_core::imp::define_interface!(
IMAPIMessageSite,
IMAPIMessageSite_Vtbl,
0x00020370_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIMessageSite, windows_core::IUnknown);
impl IMAPIMessageSite {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetSession(&self) -> windows_core::Result<IMAPISession> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetSession)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetStore(&self) -> windows_core::Result<IMsgStore> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetStore)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetFolder(&self) -> windows_core::Result<IMAPIFolder> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetFolder)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetMessageA(&self) -> windows_core::Result<IMessage> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetMessageA)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetFormManager(&self) -> windows_core::Result<IMAPIFormMgr> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetFormManager)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn NewMessage<P1, P2>(
&self,
fcomposeinfolder: u32,
pfolderfocus: P1,
ppersistmessage: P2,
ppmessage: *mut Option<IMessage>,
ppmessagesite: *mut Option<IMAPIMessageSite>,
ppviewcontext: *mut Option<IMAPIViewContext>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMAPIFolder>,
P2: windows_core::Param<IPersistMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).NewMessage)(
windows_core::Interface::as_raw(self),
fcomposeinfolder,
pfolderfocus.param().abi(),
ppersistmessage.param().abi(),
core::mem::transmute(ppmessage),
core::mem::transmute(ppmessagesite),
core::mem::transmute(ppviewcontext),
)
.ok()
}
}
pub unsafe fn CopyMessage<P0>(&self, pfolderdestination: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIFolder>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyMessage)(
windows_core::Interface::as_raw(self),
pfolderdestination.param().abi(),
)
.ok()
}
}
pub unsafe fn MoveMessage<P0, P1>(
&self,
pfolderdestination: P0,
pviewcontext: P1,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIFolder>,
P1: windows_core::Param<IMAPIViewContext>,
{
unsafe {
(windows_core::Interface::vtable(self).MoveMessage)(
windows_core::Interface::as_raw(self),
pfolderdestination.param().abi(),
pviewcontext.param().abi(),
prcposrect as _,
)
.ok()
}
}
pub unsafe fn DeleteMessage<P0>(
&self,
pviewcontext: P0,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIViewContext>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteMessage)(
windows_core::Interface::as_raw(self),
pviewcontext.param().abi(),
prcposrect as _,
)
.ok()
}
}
pub unsafe fn SaveMessage(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveMessage)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SubmitMessage)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn GetSiteStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSiteStatus)(
windows_core::Interface::as_raw(self),
lpulstatus as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIMessageSite_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetSession: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetStore: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetMessageA: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetFormManager: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub NewMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CopyMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub MoveMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT,
pub DeleteMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT,
pub SaveMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub SubmitMessage:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub GetSiteStatus:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIMessageSite_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetSession(&self) -> windows_core::Result<IMAPISession>;
fn GetStore(&self) -> windows_core::Result<IMsgStore>;
fn GetFolder(&self) -> windows_core::Result<IMAPIFolder>;
fn GetMessageA(&self) -> windows_core::Result<IMessage>;
fn GetFormManager(&self) -> windows_core::Result<IMAPIFormMgr>;
fn NewMessage(
&self,
fcomposeinfolder: u32,
pfolderfocus: windows_core::Ref<'_, IMAPIFolder>,
ppersistmessage: windows_core::Ref<'_, IPersistMessage>,
ppmessage: windows_core::OutRef<'_, IMessage>,
ppmessagesite: windows_core::OutRef<'_, IMAPIMessageSite>,
ppviewcontext: windows_core::OutRef<'_, IMAPIViewContext>,
) -> windows_core::Result<()>;
fn CopyMessage(
&self,
pfolderdestination: windows_core::Ref<'_, IMAPIFolder>,
) -> windows_core::Result<()>;
fn MoveMessage(
&self,
pfolderdestination: windows_core::Ref<'_, IMAPIFolder>,
pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>;
fn DeleteMessage(
&self,
pviewcontext: windows_core::Ref<'_, IMAPIViewContext>,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>;
fn SaveMessage(&self) -> windows_core::Result<()>;
fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()>;
fn GetSiteStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIMessageSite_Vtbl {
pub const fn new<Identity: IMAPIMessageSite_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetSession<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppsession: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIMessageSite_Impl::GetSession(this) {
Ok(ok__) => {
ppsession.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetStore<Identity: IMAPIMessageSite_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppstore: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIMessageSite_Impl::GetStore(this) {
Ok(ok__) => {
ppstore.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetFolder<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppfolder: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIMessageSite_Impl::GetFolder(this) {
Ok(ok__) => {
ppfolder.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetMessageA<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppmsg: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIMessageSite_Impl::GetMessageA(this) {
Ok(ok__) => {
ppmsg.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetFormManager<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppformmgr: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPIMessageSite_Impl::GetFormManager(this) {
Ok(ok__) => {
ppformmgr.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn NewMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
fcomposeinfolder: u32,
pfolderfocus: *mut core::ffi::c_void,
ppersistmessage: *mut core::ffi::c_void,
ppmessage: *mut *mut core::ffi::c_void,
ppmessagesite: *mut *mut core::ffi::c_void,
ppviewcontext: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::NewMessage(
this,
core::mem::transmute_copy(&fcomposeinfolder),
core::mem::transmute_copy(&pfolderfocus),
core::mem::transmute_copy(&ppersistmessage),
core::mem::transmute_copy(&ppmessage),
core::mem::transmute_copy(&ppmessagesite),
core::mem::transmute_copy(&ppviewcontext),
)
.into()
}
}
unsafe extern "system" fn CopyMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfolderdestination: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::CopyMessage(
this,
core::mem::transmute_copy(&pfolderdestination),
)
.into()
}
}
unsafe extern "system" fn MoveMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfolderdestination: *mut core::ffi::c_void,
pviewcontext: *mut core::ffi::c_void,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::MoveMessage(
this,
core::mem::transmute_copy(&pfolderdestination),
core::mem::transmute_copy(&pviewcontext),
core::mem::transmute_copy(&prcposrect),
)
.into()
}
}
unsafe extern "system" fn DeleteMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pviewcontext: *mut core::ffi::c_void,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::DeleteMessage(
this,
core::mem::transmute_copy(&pviewcontext),
core::mem::transmute_copy(&prcposrect),
)
.into()
}
}
unsafe extern "system" fn SaveMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::SaveMessage(this).into()
}
}
unsafe extern "system" fn SubmitMessage<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::SubmitMessage(this, core::mem::transmute_copy(&ulflags))
.into()
}
}
unsafe extern "system" fn GetSiteStatus<
Identity: IMAPIMessageSite_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpulstatus: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIMessageSite_Impl::GetSiteStatus(this, core::mem::transmute_copy(&lpulstatus))
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetSession: GetSession::<Identity, OFFSET>,
GetStore: GetStore::<Identity, OFFSET>,
GetFolder: GetFolder::<Identity, OFFSET>,
GetMessageA: GetMessageA::<Identity, OFFSET>,
GetFormManager: GetFormManager::<Identity, OFFSET>,
NewMessage: NewMessage::<Identity, OFFSET>,
CopyMessage: CopyMessage::<Identity, OFFSET>,
MoveMessage: MoveMessage::<Identity, OFFSET>,
DeleteMessage: DeleteMessage::<Identity, OFFSET>,
SaveMessage: SaveMessage::<Identity, OFFSET>,
SubmitMessage: SubmitMessage::<Identity, OFFSET>,
GetSiteStatus: GetSiteStatus::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIMessageSite as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIMessageSite {}
windows_core::imp::define_interface!(
IMAPIProgress,
IMAPIProgress_Vtbl,
0x0002031f_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProgress, windows_core::IUnknown);
impl IMAPIProgress {
pub unsafe fn Progress(
&self,
ulvalue: u32,
ulcount: u32,
ultotal: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Progress)(
windows_core::Interface::as_raw(self),
ulvalue,
ulcount,
ultotal,
)
.ok()
}
}
pub unsafe fn GetFlags(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetFlags)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn GetMax(&self, lpulmax: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMax)(
windows_core::Interface::as_raw(self),
lpulmax as _,
)
.ok()
}
}
pub unsafe fn GetMin(&self, lpulmin: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMin)(
windows_core::Interface::as_raw(self),
lpulmin as _,
)
.ok()
}
}
pub unsafe fn SetLimits(
&self,
lpulmin: *mut u32,
lpulmax: *mut u32,
lpulflags: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetLimits)(
windows_core::Interface::as_raw(self),
lpulmin as _,
lpulmax as _,
lpulflags as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIProgress_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Progress:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32, u32) -> windows_core::HRESULT,
pub GetFlags:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub GetMax:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub GetMin:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub SetLimits: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait IMAPIProgress_Impl: windows_core::IUnknownImpl {
fn Progress(&self, ulvalue: u32, ulcount: u32, ultotal: u32) -> windows_core::Result<()>;
fn GetFlags(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn GetMax(&self, lpulmax: *mut u32) -> windows_core::Result<()>;
fn GetMin(&self, lpulmin: *mut u32) -> windows_core::Result<()>;
fn SetLimits(
&self,
lpulmin: *mut u32,
lpulmax: *mut u32,
lpulflags: *mut u32,
) -> windows_core::Result<()>;
}
impl IMAPIProgress_Vtbl {
pub const fn new<Identity: IMAPIProgress_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Progress<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulvalue: u32,
ulcount: u32,
ultotal: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProgress_Impl::Progress(
this,
core::mem::transmute_copy(&ulvalue),
core::mem::transmute_copy(&ulcount),
core::mem::transmute_copy(&ultotal),
)
.into()
}
}
unsafe extern "system" fn GetFlags<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProgress_Impl::GetFlags(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn GetMax<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulmax: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProgress_Impl::GetMax(this, core::mem::transmute_copy(&lpulmax)).into()
}
}
unsafe extern "system" fn GetMin<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulmin: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProgress_Impl::GetMin(this, core::mem::transmute_copy(&lpulmin)).into()
}
}
unsafe extern "system" fn SetLimits<Identity: IMAPIProgress_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulmin: *mut u32,
lpulmax: *mut u32,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProgress_Impl::SetLimits(
this,
core::mem::transmute_copy(&lpulmin),
core::mem::transmute_copy(&lpulmax),
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Progress: Progress::<Identity, OFFSET>,
GetFlags: GetFlags::<Identity, OFFSET>,
GetMax: GetMax::<Identity, OFFSET>,
GetMin: GetMin::<Identity, OFFSET>,
SetLimits: SetLimits::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIProgress as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIProgress {}
windows_core::imp::define_interface!(
IMAPIProp,
IMAPIProp_Vtbl,
0x00020303_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProp, windows_core::IUnknown);
impl IMAPIProp {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn SaveChanges(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveChanges)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn GetProps(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpcvalues: *mut u32,
lppproparray: *mut *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetProps)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
ulflags,
lpcvalues as _,
lppproparray as _,
)
.ok()
}
}
pub unsafe fn GetPropList(
&self,
ulflags: u32,
lppproptagarray: *mut *mut SPropTagArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetPropList)(
windows_core::Interface::as_raw(self),
ulflags,
lppproptagarray as _,
)
.ok()
}
}
pub unsafe fn OpenProperty(
&self,
ulproptag: u32,
lpiid: *mut windows_core::GUID,
ulinterfaceoptions: u32,
ulflags: u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProperty)(
windows_core::Interface::as_raw(self),
ulproptag,
lpiid as _,
ulinterfaceoptions,
ulflags,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn SetProps(
&self,
cvalues: u32,
lpproparray: *mut SPropValue,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetProps)(
windows_core::Interface::as_raw(self),
cvalues,
lpproparray as _,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn DeleteProps(
&self,
lpproptagarray: *mut SPropTagArray,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteProps)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn CopyTo<P4>(
&self,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: P4,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>
where
P4: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyTo)(
windows_core::Interface::as_raw(self),
ciidexclude,
rgiidexclude as _,
lpexcludeprops as _,
uluiparam,
lpprogress.param().abi(),
lpinterface as _,
lpdestobj as _,
ulflags,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn CopyProps<P2>(
&self,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: P2,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyProps)(
windows_core::Interface::as_raw(self),
lpincludeprops as _,
uluiparam,
lpprogress.param().abi(),
lpinterface as _,
lpdestobj as _,
ulflags,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn GetNamesFromIDs(
&self,
lppproptags: *mut *mut SPropTagArray,
lppropsetguid: *mut windows_core::GUID,
ulflags: u32,
lpcpropnames: *mut u32,
lppppropnames: *mut *mut *mut MAPINAMEID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetNamesFromIDs)(
windows_core::Interface::as_raw(self),
lppproptags as _,
lppropsetguid as _,
ulflags,
lpcpropnames as _,
lppppropnames as _,
)
.ok()
}
}
pub unsafe fn GetIDsFromNames(
&self,
cpropnames: u32,
lpppropnames: *mut *mut MAPINAMEID,
ulflags: u32,
lppproptags: *mut *mut SPropTagArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetIDsFromNames)(
windows_core::Interface::as_raw(self),
cpropnames,
lpppropnames as _,
ulflags,
lppproptags as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIProp_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub SaveChanges:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub GetProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
u32,
*mut u32,
*mut *mut SPropValue,
) -> windows_core::HRESULT,
pub GetPropList: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SPropTagArray,
) -> windows_core::HRESULT,
pub OpenProperty: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows_core::GUID,
u32,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub DeleteProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub CopyTo: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows_core::GUID,
*mut SPropTagArray,
usize,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub CopyProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
usize,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub GetNamesFromIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut SPropTagArray,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut *mut MAPINAMEID,
) -> windows_core::HRESULT,
pub GetIDsFromNames: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut MAPINAMEID,
u32,
*mut *mut SPropTagArray,
) -> windows_core::HRESULT,
}
pub trait IMAPIProp_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn SaveChanges(&self, ulflags: u32) -> windows_core::Result<()>;
fn GetProps(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpcvalues: *mut u32,
lppproparray: *mut *mut SPropValue,
) -> windows_core::Result<()>;
fn GetPropList(
&self,
ulflags: u32,
lppproptagarray: *mut *mut SPropTagArray,
) -> windows_core::Result<()>;
fn OpenProperty(
&self,
ulproptag: u32,
lpiid: *mut windows_core::GUID,
ulinterfaceoptions: u32,
ulflags: u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn SetProps(
&self,
cvalues: u32,
lpproparray: *mut SPropValue,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn DeleteProps(
&self,
lpproptagarray: *mut SPropTagArray,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn CopyTo(
&self,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn CopyProps(
&self,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn GetNamesFromIDs(
&self,
lppproptags: *mut *mut SPropTagArray,
lppropsetguid: *mut windows_core::GUID,
ulflags: u32,
lpcpropnames: *mut u32,
lppppropnames: *mut *mut *mut MAPINAMEID,
) -> windows_core::Result<()>;
fn GetIDsFromNames(
&self,
cpropnames: u32,
lpppropnames: *mut *mut MAPINAMEID,
ulflags: u32,
lppproptags: *mut *mut SPropTagArray,
) -> windows_core::Result<()>;
}
impl IMAPIProp_Vtbl {
pub const fn new<Identity: IMAPIProp_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn SaveChanges<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::SaveChanges(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn GetProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
lpcvalues: *mut u32,
lppproparray: *mut *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::GetProps(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcvalues),
core::mem::transmute_copy(&lppproparray),
)
.into()
}
}
unsafe extern "system" fn GetPropList<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lppproptagarray: *mut *mut SPropTagArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::GetPropList(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproptagarray),
)
.into()
}
}
unsafe extern "system" fn OpenProperty<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulproptag: u32,
lpiid: *mut windows_core::GUID,
ulinterfaceoptions: u32,
ulflags: u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::OpenProperty(
this,
core::mem::transmute_copy(&ulproptag),
core::mem::transmute_copy(&lpiid),
core::mem::transmute_copy(&ulinterfaceoptions),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn SetProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cvalues: u32,
lpproparray: *mut SPropValue,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::SetProps(
this,
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpproparray),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn DeleteProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::DeleteProps(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn CopyTo<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::CopyTo(
this,
core::mem::transmute_copy(&ciidexclude),
core::mem::transmute_copy(&rgiidexclude),
core::mem::transmute_copy(&lpexcludeprops),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpdestobj),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn CopyProps<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::CopyProps(
this,
core::mem::transmute_copy(&lpincludeprops),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpdestobj),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn GetNamesFromIDs<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lppproptags: *mut *mut SPropTagArray,
lppropsetguid: *mut windows_core::GUID,
ulflags: u32,
lpcpropnames: *mut u32,
lppppropnames: *mut *mut *mut MAPINAMEID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::GetNamesFromIDs(
this,
core::mem::transmute_copy(&lppproptags),
core::mem::transmute_copy(&lppropsetguid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcpropnames),
core::mem::transmute_copy(&lppppropnames),
)
.into()
}
}
unsafe extern "system" fn GetIDsFromNames<Identity: IMAPIProp_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cpropnames: u32,
lpppropnames: *mut *mut MAPINAMEID,
ulflags: u32,
lppproptags: *mut *mut SPropTagArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProp_Impl::GetIDsFromNames(
this,
core::mem::transmute_copy(&cpropnames),
core::mem::transmute_copy(&lpppropnames),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproptags),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
SaveChanges: SaveChanges::<Identity, OFFSET>,
GetProps: GetProps::<Identity, OFFSET>,
GetPropList: GetPropList::<Identity, OFFSET>,
OpenProperty: OpenProperty::<Identity, OFFSET>,
SetProps: SetProps::<Identity, OFFSET>,
DeleteProps: DeleteProps::<Identity, OFFSET>,
CopyTo: CopyTo::<Identity, OFFSET>,
CopyProps: CopyProps::<Identity, OFFSET>,
GetNamesFromIDs: GetNamesFromIDs::<Identity, OFFSET>,
GetIDsFromNames: GetIDsFromNames::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIProp {}
pub const IMAPIProp_CopyProps: METHODS = METHODS(11i32);
pub const IMAPIProp_CopyTo: METHODS = METHODS(10i32);
pub const IMAPIProp_DeleteProps: METHODS = METHODS(9i32);
pub const IMAPIProp_GetIDsFromNames: METHODS = METHODS(13i32);
pub const IMAPIProp_GetLastError: METHODS = METHODS(3i32);
pub const IMAPIProp_GetNamesFromIDs: METHODS = METHODS(12i32);
pub const IMAPIProp_GetPropList: METHODS = METHODS(6i32);
pub const IMAPIProp_GetProps: METHODS = METHODS(5i32);
pub const IMAPIProp_OpenProperty: METHODS = METHODS(7i32);
pub const IMAPIProp_SaveChanges: METHODS = METHODS(4i32);
pub const IMAPIProp_SetProps: METHODS = METHODS(8i32);
windows_core::imp::define_interface!(
IMAPIProviderShutdown,
IMAPIProviderShutdown_Vtbl,
0x00020398_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIProviderShutdown, windows_core::IUnknown);
impl IMAPIProviderShutdown {
pub unsafe fn QueryFastShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryFastShutdown)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn NotifyProcessShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NotifyProcessShutdown)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn DoFastShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DoFastShutdown)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIProviderShutdown_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub QueryFastShutdown:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub NotifyProcessShutdown:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub DoFastShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIProviderShutdown_Impl: windows_core::IUnknownImpl {
fn QueryFastShutdown(&self) -> windows_core::Result<()>;
fn NotifyProcessShutdown(&self) -> windows_core::Result<()>;
fn DoFastShutdown(&self) -> windows_core::Result<()>;
}
impl IMAPIProviderShutdown_Vtbl {
pub const fn new<Identity: IMAPIProviderShutdown_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn QueryFastShutdown<
Identity: IMAPIProviderShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProviderShutdown_Impl::QueryFastShutdown(this).into()
}
}
unsafe extern "system" fn NotifyProcessShutdown<
Identity: IMAPIProviderShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProviderShutdown_Impl::NotifyProcessShutdown(this).into()
}
}
unsafe extern "system" fn DoFastShutdown<
Identity: IMAPIProviderShutdown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIProviderShutdown_Impl::DoFastShutdown(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
QueryFastShutdown: QueryFastShutdown::<Identity, OFFSET>,
NotifyProcessShutdown: NotifyProcessShutdown::<Identity, OFFSET>,
DoFastShutdown: DoFastShutdown::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIProviderShutdown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIProviderShutdown {}
windows_core::imp::define_interface!(
IMAPISession,
IMAPISession_Vtbl,
0x00020300_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPISession, windows_core::IUnknown);
impl IMAPISession {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetMsgStoresTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetMsgStoresTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn OpenMsgStore(
&self,
uluiparam: usize,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmdb: *mut Option<IMsgStore>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenMsgStore)(
windows_core::Interface::as_raw(self),
uluiparam,
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppmdb),
)
.ok()
}
}
pub unsafe fn OpenAddressBook(
&self,
uluiparam: usize,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: *mut Option<IAddrBook>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenAddressBook)(
windows_core::Interface::as_raw(self),
uluiparam,
lpinterface as _,
ulflags,
core::mem::transmute(lppadrbook),
)
.ok()
}
}
pub unsafe fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut Option<IProfSect>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProfileSection)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppprofsect),
)
.ok()
}
}
pub unsafe fn GetStatusTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetStatusTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn Advise<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn MessageOptions<P3>(
&self,
uluiparam: usize,
ulflags: u32,
lpszadrtype: *mut i8,
lpmessage: P3,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).MessageOptions)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
lpszadrtype as _,
lpmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn QueryDefaultMessageOpt(
&self,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryDefaultMessageOpt)(
windows_core::Interface::as_raw(self),
lpszadrtype as _,
ulflags,
lpcvalues as _,
lppoptions as _,
)
.ok()
}
}
pub unsafe fn EnumAdrTypes(
&self,
ulflags: u32,
lpcadrtypes: *mut u32,
lpppszadrtypes: *mut *mut *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EnumAdrTypes)(
windows_core::Interface::as_raw(self),
ulflags,
lpcadrtypes as _,
lpppszadrtypes as _,
)
.ok()
}
}
pub unsafe fn QueryIdentity(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryIdentity)(
windows_core::Interface::as_raw(self),
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn Logoff(
&self,
uluiparam: usize,
ulflags: u32,
ulreserved: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Logoff)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
ulreserved,
)
.ok()
}
}
pub unsafe fn SetDefaultStore(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetDefaultStore)(
windows_core::Interface::as_raw(self),
ulflags,
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn AdminServices(&self, ulflags: u32) -> windows_core::Result<IMsgServiceAdmin> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).AdminServices)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ShowForm<P1, P2, P5, P10>(
&self,
uluiparam: usize,
lpmsgstore: P1,
lpparentfolder: P2,
lpinterface: *mut windows_core::GUID,
ulmessagetoken: usize,
lpmessagesent: P5,
ulflags: u32,
ulmessagestatus: u32,
ulmessageflags: u32,
ulaccess: u32,
lpszmessageclass: P10,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMsgStore>,
P2: windows_core::Param<IMAPIFolder>,
P5: windows_core::Param<IMessage>,
P10: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).ShowForm)(
windows_core::Interface::as_raw(self),
uluiparam,
lpmsgstore.param().abi(),
lpparentfolder.param().abi(),
lpinterface as _,
ulmessagetoken,
lpmessagesent.param().abi(),
ulflags,
ulmessagestatus,
ulmessageflags,
ulaccess,
lpszmessageclass.param().abi(),
)
.ok()
}
}
pub unsafe fn PrepareForm<P1>(
&self,
lpinterface: *mut windows_core::GUID,
lpmessage: P1,
lpulmessagetoken: *mut usize,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).PrepareForm)(
windows_core::Interface::as_raw(self),
lpinterface as _,
lpmessage.param().abi(),
lpulmessagetoken as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPISession_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetMsgStoresTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenMsgStore: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenAddressBook: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenProfileSection: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetStatusTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub MessageOptions: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub QueryDefaultMessageOpt: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
u32,
*mut u32,
*mut *mut SPropValue,
) -> windows_core::HRESULT,
pub EnumAdrTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u32,
*mut *mut *mut i8,
) -> windows_core::HRESULT,
pub QueryIdentity: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub Logoff:
unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32, u32) -> windows_core::HRESULT,
pub SetDefaultStore: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub AdminServices: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ShowForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut windows_core::GUID,
usize,
*mut core::ffi::c_void,
u32,
u32,
u32,
u32,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub PrepareForm: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
}
pub trait IMAPISession_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetMsgStoresTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn OpenMsgStore(
&self,
uluiparam: usize,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmdb: windows_core::OutRef<'_, IMsgStore>,
) -> windows_core::Result<()>;
fn OpenAddressBook(
&self,
uluiparam: usize,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: windows_core::OutRef<'_, IAddrBook>,
) -> windows_core::Result<()>;
fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: windows_core::OutRef<'_, IProfSect>,
) -> windows_core::Result<()>;
fn GetStatusTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn Advise(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn MessageOptions(
&self,
uluiparam: usize,
ulflags: u32,
lpszadrtype: *mut i8,
lpmessage: windows_core::Ref<'_, IMessage>,
) -> windows_core::Result<()>;
fn QueryDefaultMessageOpt(
&self,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::Result<()>;
fn EnumAdrTypes(
&self,
ulflags: u32,
lpcadrtypes: *mut u32,
lpppszadrtypes: *mut *mut *mut i8,
) -> windows_core::Result<()>;
fn QueryIdentity(
&self,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn Logoff(&self, uluiparam: usize, ulflags: u32, ulreserved: u32) -> windows_core::Result<()>;
fn SetDefaultStore(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()>;
fn AdminServices(&self, ulflags: u32) -> windows_core::Result<IMsgServiceAdmin>;
fn ShowForm(
&self,
uluiparam: usize,
lpmsgstore: windows_core::Ref<'_, IMsgStore>,
lpparentfolder: windows_core::Ref<'_, IMAPIFolder>,
lpinterface: *mut windows_core::GUID,
ulmessagetoken: usize,
lpmessagesent: windows_core::Ref<'_, IMessage>,
ulflags: u32,
ulmessagestatus: u32,
ulmessageflags: u32,
ulaccess: u32,
lpszmessageclass: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn PrepareForm(
&self,
lpinterface: *mut windows_core::GUID,
lpmessage: windows_core::Ref<'_, IMessage>,
lpulmessagetoken: *mut usize,
) -> windows_core::Result<()>;
}
impl IMAPISession_Vtbl {
pub const fn new<Identity: IMAPISession_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetMsgStoresTable<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISession_Impl::GetMsgStoresTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn OpenMsgStore<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppmdb: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::OpenMsgStore(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmdb),
)
.into()
}
}
unsafe extern "system" fn OpenAddressBook<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::OpenAddressBook(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppadrbook),
)
.into()
}
}
unsafe extern "system" fn OpenProfileSection<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::OpenProfileSection(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprofsect),
)
.into()
}
}
unsafe extern "system" fn GetStatusTable<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISession_Impl::GetStatusTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn OpenEntry<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn CompareEntryIDs<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::Advise(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn MessageOptions<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lpszadrtype: *mut i8,
lpmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::MessageOptions(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&lpmessage),
)
.into()
}
}
unsafe extern "system" fn QueryDefaultMessageOpt<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszadrtype: *mut i8,
ulflags: u32,
lpcvalues: *mut u32,
lppoptions: *mut *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::QueryDefaultMessageOpt(
this,
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcvalues),
core::mem::transmute_copy(&lppoptions),
)
.into()
}
}
unsafe extern "system" fn EnumAdrTypes<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpcadrtypes: *mut u32,
lpppszadrtypes: *mut *mut *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::EnumAdrTypes(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcadrtypes),
core::mem::transmute_copy(&lpppszadrtypes),
)
.into()
}
}
unsafe extern "system" fn QueryIdentity<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::QueryIdentity(
this,
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn Logoff<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
ulreserved: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::Logoff(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ulreserved),
)
.into()
}
}
unsafe extern "system" fn SetDefaultStore<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::SetDefaultStore(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn AdminServices<
Identity: IMAPISession_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lppserviceadmin: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISession_Impl::AdminServices(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lppserviceadmin.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ShowForm<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
lpmsgstore: *mut core::ffi::c_void,
lpparentfolder: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulmessagetoken: usize,
lpmessagesent: *mut core::ffi::c_void,
ulflags: u32,
ulmessagestatus: u32,
ulmessageflags: u32,
ulaccess: u32,
lpszmessageclass: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::ShowForm(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpmsgstore),
core::mem::transmute_copy(&lpparentfolder),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulmessagetoken),
core::mem::transmute_copy(&lpmessagesent),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ulmessagestatus),
core::mem::transmute_copy(&ulmessageflags),
core::mem::transmute_copy(&ulaccess),
core::mem::transmute(&lpszmessageclass),
)
.into()
}
}
unsafe extern "system" fn PrepareForm<Identity: IMAPISession_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
lpmessage: *mut core::ffi::c_void,
lpulmessagetoken: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISession_Impl::PrepareForm(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpulmessagetoken),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetMsgStoresTable: GetMsgStoresTable::<Identity, OFFSET>,
OpenMsgStore: OpenMsgStore::<Identity, OFFSET>,
OpenAddressBook: OpenAddressBook::<Identity, OFFSET>,
OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
GetStatusTable: GetStatusTable::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
MessageOptions: MessageOptions::<Identity, OFFSET>,
QueryDefaultMessageOpt: QueryDefaultMessageOpt::<Identity, OFFSET>,
EnumAdrTypes: EnumAdrTypes::<Identity, OFFSET>,
QueryIdentity: QueryIdentity::<Identity, OFFSET>,
Logoff: Logoff::<Identity, OFFSET>,
SetDefaultStore: SetDefaultStore::<Identity, OFFSET>,
AdminServices: AdminServices::<Identity, OFFSET>,
ShowForm: ShowForm::<Identity, OFFSET>,
PrepareForm: PrepareForm::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPISession as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPISession {}
windows_core::imp::define_interface!(
IMAPIStatus,
IMAPIStatus_Vtbl,
0x00020305_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMAPIStatus {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMAPIStatus, windows_core::IUnknown, IMAPIProp);
impl IMAPIStatus {
pub unsafe fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ValidateState)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn SettingsDialog(
&self,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SettingsDialog)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn ChangePassword(
&self,
lpoldpass: *mut i8,
lpnewpass: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ChangePassword)(
windows_core::Interface::as_raw(self),
lpoldpass as _,
lpnewpass as _,
ulflags,
)
.ok()
}
}
pub unsafe fn FlushQueues(
&self,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FlushQueues)(
windows_core::Interface::as_raw(self),
uluiparam,
cbtargettransport,
lptargettransport as _,
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIStatus_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub ValidateState:
unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
pub SettingsDialog:
unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
pub ChangePassword: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
u32,
) -> windows_core::HRESULT,
pub FlushQueues: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut ENTRYID,
u32,
) -> windows_core::HRESULT,
}
pub trait IMAPIStatus_Impl: IMAPIProp_Impl {
fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
fn SettingsDialog(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
fn ChangePassword(
&self,
lpoldpass: *mut i8,
lpnewpass: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>;
fn FlushQueues(
&self,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()>;
}
impl IMAPIStatus_Vtbl {
pub const fn new<Identity: IMAPIStatus_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn ValidateState<Identity: IMAPIStatus_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIStatus_Impl::ValidateState(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn SettingsDialog<
Identity: IMAPIStatus_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIStatus_Impl::SettingsDialog(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn ChangePassword<
Identity: IMAPIStatus_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpoldpass: *mut i8,
lpnewpass: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIStatus_Impl::ChangePassword(
this,
core::mem::transmute_copy(&lpoldpass),
core::mem::transmute_copy(&lpnewpass),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn FlushQueues<Identity: IMAPIStatus_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIStatus_Impl::FlushQueues(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&cbtargettransport),
core::mem::transmute_copy(&lptargettransport),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
ValidateState: ValidateState::<Identity, OFFSET>,
SettingsDialog: SettingsDialog::<Identity, OFFSET>,
ChangePassword: ChangePassword::<Identity, OFFSET>,
FlushQueues: FlushQueues::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIStatus as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIStatus {}
pub const IMAPIStatus_ChangePassword: METHODS = METHODS(124i32);
pub const IMAPIStatus_FlushQueues: METHODS = METHODS(125i32);
pub const IMAPIStatus_SettingsDialog: METHODS = METHODS(123i32);
pub const IMAPIStatus_ValidateState: METHODS = METHODS(122i32);
windows_core::imp::define_interface!(IMAPISupport, IMAPISupport_Vtbl, 0);
windows_core::imp::interface_hierarchy!(IMAPISupport, windows_core::IUnknown);
impl IMAPISupport {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetMemAllocRoutines(
&self,
lpallocatebuffer: *mut LPALLOCATEBUFFER,
lpallocatemore: *mut LPALLOCATEMORE,
lpfreebuffer: *mut LPFREEBUFFER,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMemAllocRoutines)(
windows_core::Interface::as_raw(self),
lpallocatebuffer as _,
lpallocatemore as _,
lpfreebuffer as _,
)
.ok()
}
}
pub unsafe fn Subscribe<P3>(
&self,
lpkey: *mut NOTIFKEY,
uleventmask: u32,
ulflags: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Subscribe)(
windows_core::Interface::as_raw(self),
lpkey as _,
uleventmask,
ulflags,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unsubscribe(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unsubscribe)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn Notify(
&self,
lpkey: *mut NOTIFKEY,
cnotification: u32,
lpnotifications: *mut NOTIFICATION,
lpulflags: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Notify)(
windows_core::Interface::as_raw(self),
lpkey as _,
cnotification,
lpnotifications as _,
lpulflags as _,
)
.ok()
}
}
pub unsafe fn ModifyStatusRow(
&self,
cvalues: u32,
lpcolumnvals: *mut SPropValue,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ModifyStatusRow)(
windows_core::Interface::as_raw(self),
cvalues,
lpcolumnvals as _,
ulflags,
)
.ok()
}
}
pub unsafe fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprofileobj: *mut Option<IProfSect>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProfileSection)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
core::mem::transmute(lppprofileobj),
)
.ok()
}
}
pub unsafe fn RegisterPreprocessor<P3, P4>(
&self,
lpmuid: *mut MAPIUID,
lpszadrtype: *mut i8,
lpszdllname: *mut i8,
lpszpreprocess: P3,
lpszremovepreprocessinfo: P4,
ulflags: u32,
) -> windows_core::Result<()>
where
P3: windows_core::Param<windows_core::PCSTR>,
P4: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).RegisterPreprocessor)(
windows_core::Interface::as_raw(self),
lpmuid as _,
lpszadrtype as _,
lpszdllname as _,
lpszpreprocess.param().abi(),
lpszremovepreprocessinfo.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn NewUID(&self, lpmuid: *mut MAPIUID) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NewUID)(
windows_core::Interface::as_raw(self),
lpmuid as _,
)
.ok()
}
}
pub unsafe fn MakeInvalid(
&self,
ulflags: u32,
lpobject: *mut core::ffi::c_void,
ulrefcount: u32,
cmethods: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MakeInvalid)(
windows_core::Interface::as_raw(self),
ulflags,
lpobject as _,
ulrefcount,
cmethods,
)
.ok()
}
}
pub unsafe fn SpoolerYield(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SpoolerYield)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn SpoolerNotify(
&self,
ulflags: u32,
lpvdata: *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SpoolerNotify)(
windows_core::Interface::as_raw(self),
ulflags,
lpvdata as _,
)
.ok()
}
}
pub unsafe fn CreateOneOff(
&self,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateOneOff)(
windows_core::Interface::as_raw(self),
lpszname as _,
lpszadrtype as _,
lpszaddress as _,
ulflags,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn SetProviderUID(
&self,
lpproviderid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetProviderUID)(
windows_core::Interface::as_raw(self),
lpproviderid as _,
ulflags,
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentry1: u32,
lpentry1: *mut ENTRYID,
cbentry2: u32,
lpentry2: *mut ENTRYID,
ulcompareflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentry1,
lpentry1 as _,
cbentry2,
lpentry2 as _,
ulcompareflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn OpenTemplateID<P3, P6>(
&self,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: P3,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: *mut Option<IMAPIProp>,
lpmapipropsibling: P6,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIProp>,
P6: windows_core::Param<IMAPIProp>,
{
unsafe {
(windows_core::Interface::vtable(self).OpenTemplateID)(
windows_core::Interface::as_raw(self),
cbtemplateid,
lptemplateid as _,
ultemplateflags,
lpmapipropdata.param().abi(),
lpinterface as _,
core::mem::transmute(lppmapipropnew),
lpmapipropsibling.param().abi(),
)
.ok()
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulopenflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulopenflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetOneOffTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Address(
&self,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Address)(
windows_core::Interface::as_raw(self),
lpuluiparam as _,
lpadrparms as _,
lppadrlist as _,
)
.ok()
}
}
pub unsafe fn Details(
&self,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Details)(
windows_core::Interface::as_raw(self),
lpuluiparam as _,
lpfndismiss,
lpvdismisscontext as _,
cbentryid,
lpentryid as _,
lpfbuttoncallback,
lpvbuttoncontext as _,
lpszbuttontext as _,
ulflags,
)
.ok()
}
}
pub unsafe fn NewEntry(
&self,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NewEntry)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
cbeidcontainer,
lpeidcontainer as _,
cbeidnewentrytpl,
lpeidnewentrytpl as _,
lpcbeidnewentry as _,
lppeidnewentry as _,
)
.ok()
}
}
pub unsafe fn DoConfigPropsheet<P3, P4>(
&self,
uluiparam: usize,
ulflags: u32,
lpsztitle: *mut i8,
lpdisplaytable: P3,
lpconfigdata: P4,
ultoppage: u32,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPITable>,
P4: windows_core::Param<IMAPIProp>,
{
unsafe {
(windows_core::Interface::vtable(self).DoConfigPropsheet)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
lpsztitle as _,
lpdisplaytable.param().abi(),
lpconfigdata.param().abi(),
ultoppage,
)
.ok()
}
}
pub unsafe fn CopyMessages<P6>(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: P6,
ulflags: u32,
) -> windows_core::Result<()>
where
P6: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyMessages)(
windows_core::Interface::as_raw(self),
lpsrcinterface as _,
lpsrcfolder as _,
lpmsglist as _,
lpdestinterface as _,
lpdestfolder as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn CopyFolder<P8>(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: P8,
ulflags: u32,
) -> windows_core::Result<()>
where
P8: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyFolder)(
windows_core::Interface::as_raw(self),
lpsrcinterface as _,
lpsrcfolder as _,
cbentryid,
lpentryid as _,
lpdestinterface as _,
lpdestfolder as _,
lsznewfoldername as _,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn DoCopyTo<P6>(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: P6,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>
where
P6: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).DoCopyTo)(
windows_core::Interface::as_raw(self),
lpsrcinterface as _,
lpsrcobj as _,
ciidexclude,
rgiidexclude as _,
lpexcludeprops as _,
uluiparam,
lpprogress.param().abi(),
lpdestinterface as _,
lpdestobj as _,
ulflags,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn DoCopyProps<P4>(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: P4,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>
where
P4: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).DoCopyProps)(
windows_core::Interface::as_raw(self),
lpsrcinterface as _,
lpsrcobj as _,
lpincludeprops as _,
uluiparam,
lpprogress.param().abi(),
lpdestinterface as _,
lpdestobj as _,
ulflags,
lppproblems as _,
)
.ok()
}
}
pub unsafe fn DoProgressDialog(
&self,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<IMAPIProgress> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).DoProgressDialog)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ReadReceipt<P1>(
&self,
ulflags: u32,
lpreadmessage: P1,
) -> windows_core::Result<IMessage>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).ReadReceipt)(
windows_core::Interface::as_raw(self),
ulflags,
lpreadmessage.param().abi(),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn PrepareSubmit<P0>(
&self,
lpmessage: P0,
lpulflags: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).PrepareSubmit)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn ExpandRecips<P0>(
&self,
lpmessage: P0,
lpulflags: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).ExpandRecips)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn UpdatePAB<P1>(&self, ulflags: u32, lpmessage: P1) -> windows_core::Result<()>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).UpdatePAB)(
windows_core::Interface::as_raw(self),
ulflags,
lpmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn DoSentMail<P1>(&self, ulflags: u32, lpmessage: P1) -> windows_core::Result<()>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).DoSentMail)(
windows_core::Interface::as_raw(self),
ulflags,
lpmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn OpenAddressBook(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: *mut Option<IAddrBook>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenAddressBook)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
core::mem::transmute(lppadrbook),
)
.ok()
}
}
pub unsafe fn Preprocess(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Preprocess)(
windows_core::Interface::as_raw(self),
ulflags,
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn CompleteMsg(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompleteMsg)(
windows_core::Interface::as_raw(self),
ulflags,
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn StoreLogoffTransports(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).StoreLogoffTransports)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn StatusRecips<P0>(
&self,
lpmessage: P0,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).StatusRecips)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
lpreciplist as _,
)
.ok()
}
}
pub unsafe fn WrapStoreEntryID(
&self,
cborigentry: u32,
lporigentry: *mut ENTRYID,
lpcbwrappedentry: *mut u32,
lppwrappedentry: *mut *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).WrapStoreEntryID)(
windows_core::Interface::as_raw(self),
cborigentry,
lporigentry as _,
lpcbwrappedentry as _,
lppwrappedentry as _,
)
.ok()
}
}
pub unsafe fn ModifyProfile(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ModifyProfile)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn IStorageFromStream<P0>(
&self,
lpunkin: P0,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppstorageout: *mut Option<windows::Win32::System::Com::StructuredStorage::IStorage>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
(windows_core::Interface::vtable(self).IStorageFromStream)(
windows_core::Interface::as_raw(self),
lpunkin.param().abi(),
lpinterface as _,
ulflags,
core::mem::transmute(lppstorageout),
)
.ok()
}
}
pub unsafe fn GetSvcConfigSupportObj(
&self,
ulflags: u32,
) -> windows_core::Result<IMAPISupport> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetSvcConfigSupportObj)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMAPISupport_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetMemAllocRoutines: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut LPALLOCATEBUFFER,
*mut LPALLOCATEMORE,
*mut LPFREEBUFFER,
) -> windows_core::HRESULT,
pub Subscribe: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut NOTIFKEY,
u32,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unsubscribe:
unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub Notify: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut NOTIFKEY,
u32,
*mut NOTIFICATION,
*mut u32,
) -> windows_core::HRESULT,
pub ModifyStatusRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SPropValue,
u32,
) -> windows_core::HRESULT,
pub OpenProfileSection: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub RegisterPreprocessor: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut i8,
*mut i8,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
) -> windows_core::HRESULT,
pub NewUID:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
pub MakeInvalid: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
u32,
u32,
) -> windows_core::HRESULT,
pub SpoolerYield:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub SpoolerNotify: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateOneOff: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
*mut i8,
u32,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub SetProviderUID: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub OpenTemplateID: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut *mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetOneOffTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Address: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut usize,
*mut ADRPARM,
*mut *mut ADRLIST,
) -> windows_core::HRESULT,
pub Details: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut usize,
LPFNDISMISS,
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
windows::Win32::System::AddressBook::LPFNBUTTON,
*mut core::ffi::c_void,
*mut i8,
u32,
) -> windows_core::HRESULT,
pub NewEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub DoConfigPropsheet: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut i8,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CopyMessages: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
*mut SBinaryArray,
*mut windows_core::GUID,
*mut core::ffi::c_void,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub CopyFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
*mut core::ffi::c_void,
*mut i8,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DoCopyTo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut windows_core::GUID,
*mut SPropTagArray,
usize,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub DoCopyProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
*mut SPropTagArray,
usize,
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut core::ffi::c_void,
u32,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
pub DoProgressDialog: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ReadReceipt: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub PrepareSubmit: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub ExpandRecips: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub UpdatePAB: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub DoSentMail: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenAddressBook: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Preprocess: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub CompleteMsg: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub StoreLogoffTransports:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub StatusRecips: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut ADRLIST,
) -> windows_core::HRESULT,
pub WrapStoreEntryID: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut u32,
*mut *mut ENTRYID,
) -> windows_core::HRESULT,
pub ModifyProfile:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub IStorageFromStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetSvcConfigSupportObj: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMAPISupport_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetMemAllocRoutines(
&self,
lpallocatebuffer: *mut LPALLOCATEBUFFER,
lpallocatemore: *mut LPALLOCATEMORE,
lpfreebuffer: *mut LPFREEBUFFER,
) -> windows_core::Result<()>;
fn Subscribe(
&self,
lpkey: *mut NOTIFKEY,
uleventmask: u32,
ulflags: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unsubscribe(&self, ulconnection: usize) -> windows_core::Result<()>;
fn Notify(
&self,
lpkey: *mut NOTIFKEY,
cnotification: u32,
lpnotifications: *mut NOTIFICATION,
lpulflags: *mut u32,
) -> windows_core::Result<()>;
fn ModifyStatusRow(
&self,
cvalues: u32,
lpcolumnvals: *mut SPropValue,
ulflags: u32,
) -> windows_core::Result<()>;
fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprofileobj: windows_core::OutRef<'_, IProfSect>,
) -> windows_core::Result<()>;
fn RegisterPreprocessor(
&self,
lpmuid: *mut MAPIUID,
lpszadrtype: *mut i8,
lpszdllname: *mut i8,
lpszpreprocess: &windows_core::PCSTR,
lpszremovepreprocessinfo: &windows_core::PCSTR,
ulflags: u32,
) -> windows_core::Result<()>;
fn NewUID(&self, lpmuid: *mut MAPIUID) -> windows_core::Result<()>;
fn MakeInvalid(
&self,
ulflags: u32,
lpobject: *mut core::ffi::c_void,
ulrefcount: u32,
cmethods: u32,
) -> windows_core::Result<()>;
fn SpoolerYield(&self, ulflags: u32) -> windows_core::Result<()>;
fn SpoolerNotify(
&self,
ulflags: u32,
lpvdata: *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn CreateOneOff(
&self,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn SetProviderUID(&self, lpproviderid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentry1: u32,
lpentry1: *mut ENTRYID,
cbentry2: u32,
lpentry2: *mut ENTRYID,
ulcompareflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn OpenTemplateID(
&self,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: windows_core::Ref<'_, IMAPIProp>,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: windows_core::OutRef<'_, IMAPIProp>,
lpmapipropsibling: windows_core::Ref<'_, IMAPIProp>,
) -> windows_core::Result<()>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulopenflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn GetOneOffTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn Address(
&self,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::Result<()>;
fn Details(
&self,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>;
fn NewEntry(
&self,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn DoConfigPropsheet(
&self,
uluiparam: usize,
ulflags: u32,
lpsztitle: *mut i8,
lpdisplaytable: windows_core::Ref<'_, IMAPITable>,
lpconfigdata: windows_core::Ref<'_, IMAPIProp>,
ultoppage: u32,
) -> windows_core::Result<()>;
fn CopyMessages(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn CopyFolder(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn DoCopyTo(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn DoCopyProps(
&self,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
fn DoProgressDialog(
&self,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<IMAPIProgress>;
fn ReadReceipt(
&self,
ulflags: u32,
lpreadmessage: windows_core::Ref<'_, IMessage>,
) -> windows_core::Result<IMessage>;
fn PrepareSubmit(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
lpulflags: *mut u32,
) -> windows_core::Result<()>;
fn ExpandRecips(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
lpulflags: *mut u32,
) -> windows_core::Result<()>;
fn UpdatePAB(
&self,
ulflags: u32,
lpmessage: windows_core::Ref<'_, IMessage>,
) -> windows_core::Result<()>;
fn DoSentMail(
&self,
ulflags: u32,
lpmessage: windows_core::Ref<'_, IMessage>,
) -> windows_core::Result<()>;
fn OpenAddressBook(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: windows_core::OutRef<'_, IAddrBook>,
) -> windows_core::Result<()>;
fn Preprocess(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()>;
fn CompleteMsg(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()>;
fn StoreLogoffTransports(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn StatusRecips(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
lpreciplist: *mut ADRLIST,
) -> windows_core::Result<()>;
fn WrapStoreEntryID(
&self,
cborigentry: u32,
lporigentry: *mut ENTRYID,
lpcbwrappedentry: *mut u32,
lppwrappedentry: *mut *mut ENTRYID,
) -> windows_core::Result<()>;
fn ModifyProfile(&self, ulflags: u32) -> windows_core::Result<()>;
fn IStorageFromStream(
&self,
lpunkin: windows_core::Ref<'_, windows_core::IUnknown>,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppstorageout: windows_core::OutRef<
'_,
windows::Win32::System::Com::StructuredStorage::IStorage,
>,
) -> windows_core::Result<()>;
fn GetSvcConfigSupportObj(&self, ulflags: u32) -> windows_core::Result<IMAPISupport>;
}
impl IMAPISupport_Vtbl {
pub const fn new<Identity: IMAPISupport_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetMemAllocRoutines<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpallocatebuffer: *mut LPALLOCATEBUFFER,
lpallocatemore: *mut LPALLOCATEMORE,
lpfreebuffer: *mut LPFREEBUFFER,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::GetMemAllocRoutines(
this,
core::mem::transmute_copy(&lpallocatebuffer),
core::mem::transmute_copy(&lpallocatemore),
core::mem::transmute_copy(&lpfreebuffer),
)
.into()
}
}
unsafe extern "system" fn Subscribe<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpkey: *mut NOTIFKEY,
uleventmask: u32,
ulflags: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Subscribe(
this,
core::mem::transmute_copy(&lpkey),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unsubscribe<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Unsubscribe(this, core::mem::transmute_copy(&ulconnection))
.into()
}
}
unsafe extern "system" fn Notify<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpkey: *mut NOTIFKEY,
cnotification: u32,
lpnotifications: *mut NOTIFICATION,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Notify(
this,
core::mem::transmute_copy(&lpkey),
core::mem::transmute_copy(&cnotification),
core::mem::transmute_copy(&lpnotifications),
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
unsafe extern "system" fn ModifyStatusRow<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cvalues: u32,
lpcolumnvals: *mut SPropValue,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::ModifyStatusRow(
this,
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpcolumnvals),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn OpenProfileSection<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprofileobj: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::OpenProfileSection(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprofileobj),
)
.into()
}
}
unsafe extern "system" fn RegisterPreprocessor<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmuid: *mut MAPIUID,
lpszadrtype: *mut i8,
lpszdllname: *mut i8,
lpszpreprocess: windows_core::PCSTR,
lpszremovepreprocessinfo: windows_core::PCSTR,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::RegisterPreprocessor(
this,
core::mem::transmute_copy(&lpmuid),
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&lpszdllname),
core::mem::transmute(&lpszpreprocess),
core::mem::transmute(&lpszremovepreprocessinfo),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn NewUID<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmuid: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::NewUID(this, core::mem::transmute_copy(&lpmuid)).into()
}
}
unsafe extern "system" fn MakeInvalid<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpobject: *mut core::ffi::c_void,
ulrefcount: u32,
cmethods: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::MakeInvalid(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpobject),
core::mem::transmute_copy(&ulrefcount),
core::mem::transmute_copy(&cmethods),
)
.into()
}
}
unsafe extern "system" fn SpoolerYield<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::SpoolerYield(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn SpoolerNotify<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpvdata: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::SpoolerNotify(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpvdata),
)
.into()
}
}
unsafe extern "system" fn CreateOneOff<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszname: *mut i8,
lpszadrtype: *mut i8,
lpszaddress: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::CreateOneOff(
this,
core::mem::transmute_copy(&lpszname),
core::mem::transmute_copy(&lpszadrtype),
core::mem::transmute_copy(&lpszaddress),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn SetProviderUID<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpproviderid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::SetProviderUID(
this,
core::mem::transmute_copy(&lpproviderid),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CompareEntryIDs<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbentry1: u32,
lpentry1: *mut ENTRYID,
cbentry2: u32,
lpentry2: *mut ENTRYID,
ulcompareflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentry1),
core::mem::transmute_copy(&lpentry1),
core::mem::transmute_copy(&cbentry2),
core::mem::transmute_copy(&lpentry2),
core::mem::transmute_copy(&ulcompareflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn OpenTemplateID<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbtemplateid: u32,
lptemplateid: *mut ENTRYID,
ultemplateflags: u32,
lpmapipropdata: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
lppmapipropnew: *mut *mut core::ffi::c_void,
lpmapipropsibling: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::OpenTemplateID(
this,
core::mem::transmute_copy(&cbtemplateid),
core::mem::transmute_copy(&lptemplateid),
core::mem::transmute_copy(&ultemplateflags),
core::mem::transmute_copy(&lpmapipropdata),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lppmapipropnew),
core::mem::transmute_copy(&lpmapipropsibling),
)
.into()
}
}
unsafe extern "system" fn OpenEntry<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulopenflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulopenflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn GetOneOffTable<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISupport_Impl::GetOneOffTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Address<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpuluiparam: *mut usize,
lpadrparms: *mut ADRPARM,
lppadrlist: *mut *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Address(
this,
core::mem::transmute_copy(&lpuluiparam),
core::mem::transmute_copy(&lpadrparms),
core::mem::transmute_copy(&lppadrlist),
)
.into()
}
}
unsafe extern "system" fn Details<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpuluiparam: *mut usize,
lpfndismiss: LPFNDISMISS,
lpvdismisscontext: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpfbuttoncallback: windows::Win32::System::AddressBook::LPFNBUTTON,
lpvbuttoncontext: *mut core::ffi::c_void,
lpszbuttontext: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Details(
this,
core::mem::transmute_copy(&lpuluiparam),
core::mem::transmute_copy(&lpfndismiss),
core::mem::transmute_copy(&lpvdismisscontext),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpfbuttoncallback),
core::mem::transmute_copy(&lpvbuttoncontext),
core::mem::transmute_copy(&lpszbuttontext),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn NewEntry<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
cbeidcontainer: u32,
lpeidcontainer: *mut ENTRYID,
cbeidnewentrytpl: u32,
lpeidnewentrytpl: *mut ENTRYID,
lpcbeidnewentry: *mut u32,
lppeidnewentry: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::NewEntry(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbeidcontainer),
core::mem::transmute_copy(&lpeidcontainer),
core::mem::transmute_copy(&cbeidnewentrytpl),
core::mem::transmute_copy(&lpeidnewentrytpl),
core::mem::transmute_copy(&lpcbeidnewentry),
core::mem::transmute_copy(&lppeidnewentry),
)
.into()
}
}
unsafe extern "system" fn DoConfigPropsheet<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lpsztitle: *mut i8,
lpdisplaytable: *mut core::ffi::c_void,
lpconfigdata: *mut core::ffi::c_void,
ultoppage: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::DoConfigPropsheet(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsztitle),
core::mem::transmute_copy(&lpdisplaytable),
core::mem::transmute_copy(&lpconfigdata),
core::mem::transmute_copy(&ultoppage),
)
.into()
}
}
unsafe extern "system" fn CopyMessages<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
lpmsglist: *mut SBinaryArray,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::CopyMessages(
this,
core::mem::transmute_copy(&lpsrcinterface),
core::mem::transmute_copy(&lpsrcfolder),
core::mem::transmute_copy(&lpmsglist),
core::mem::transmute_copy(&lpdestinterface),
core::mem::transmute_copy(&lpdestfolder),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CopyFolder<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpsrcinterface: *mut windows_core::GUID,
lpsrcfolder: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpdestinterface: *mut windows_core::GUID,
lpdestfolder: *mut core::ffi::c_void,
lsznewfoldername: *mut i8,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::CopyFolder(
this,
core::mem::transmute_copy(&lpsrcinterface),
core::mem::transmute_copy(&lpsrcfolder),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpdestinterface),
core::mem::transmute_copy(&lpdestfolder),
core::mem::transmute_copy(&lsznewfoldername),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DoCopyTo<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
ciidexclude: u32,
rgiidexclude: *mut windows_core::GUID,
lpexcludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::DoCopyTo(
this,
core::mem::transmute_copy(&lpsrcinterface),
core::mem::transmute_copy(&lpsrcobj),
core::mem::transmute_copy(&ciidexclude),
core::mem::transmute_copy(&rgiidexclude),
core::mem::transmute_copy(&lpexcludeprops),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&lpdestinterface),
core::mem::transmute_copy(&lpdestobj),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn DoCopyProps<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpsrcinterface: *mut windows_core::GUID,
lpsrcobj: *mut core::ffi::c_void,
lpincludeprops: *mut SPropTagArray,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
lpdestinterface: *mut windows_core::GUID,
lpdestobj: *mut core::ffi::c_void,
ulflags: u32,
lppproblems: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::DoCopyProps(
this,
core::mem::transmute_copy(&lpsrcinterface),
core::mem::transmute_copy(&lpsrcobj),
core::mem::transmute_copy(&lpincludeprops),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&lpdestinterface),
core::mem::transmute_copy(&lpdestobj),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppproblems),
)
.into()
}
}
unsafe extern "system" fn DoProgressDialog<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
lppprogress: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISupport_Impl::DoProgressDialog(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lppprogress.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ReadReceipt<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpreadmessage: *mut core::ffi::c_void,
lppemptymessage: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISupport_Impl::ReadReceipt(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpreadmessage),
) {
Ok(ok__) => {
lppemptymessage.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn PrepareSubmit<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::PrepareSubmit(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
unsafe extern "system" fn ExpandRecips<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::ExpandRecips(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
unsafe extern "system" fn UpdatePAB<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::UpdatePAB(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmessage),
)
.into()
}
}
unsafe extern "system" fn DoSentMail<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::DoSentMail(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmessage),
)
.into()
}
}
unsafe extern "system" fn OpenAddressBook<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppadrbook: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::OpenAddressBook(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppadrbook),
)
.into()
}
}
unsafe extern "system" fn Preprocess<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::Preprocess(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn CompleteMsg<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::CompleteMsg(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn StoreLogoffTransports<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::StoreLogoffTransports(
this,
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
unsafe extern "system" fn StatusRecips<Identity: IMAPISupport_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
lpreciplist: *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::StatusRecips(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpreciplist),
)
.into()
}
}
unsafe extern "system" fn WrapStoreEntryID<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cborigentry: u32,
lporigentry: *mut ENTRYID,
lpcbwrappedentry: *mut u32,
lppwrappedentry: *mut *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::WrapStoreEntryID(
this,
core::mem::transmute_copy(&cborigentry),
core::mem::transmute_copy(&lporigentry),
core::mem::transmute_copy(&lpcbwrappedentry),
core::mem::transmute_copy(&lppwrappedentry),
)
.into()
}
}
unsafe extern "system" fn ModifyProfile<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::ModifyProfile(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn IStorageFromStream<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpunkin: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppstorageout: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPISupport_Impl::IStorageFromStream(
this,
core::mem::transmute_copy(&lpunkin),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppstorageout),
)
.into()
}
}
unsafe extern "system" fn GetSvcConfigSupportObj<
Identity: IMAPISupport_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lppsvcsupport: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMAPISupport_Impl::GetSvcConfigSupportObj(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lppsvcsupport.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetMemAllocRoutines: GetMemAllocRoutines::<Identity, OFFSET>,
Subscribe: Subscribe::<Identity, OFFSET>,
Unsubscribe: Unsubscribe::<Identity, OFFSET>,
Notify: Notify::<Identity, OFFSET>,
ModifyStatusRow: ModifyStatusRow::<Identity, OFFSET>,
OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
RegisterPreprocessor: RegisterPreprocessor::<Identity, OFFSET>,
NewUID: NewUID::<Identity, OFFSET>,
MakeInvalid: MakeInvalid::<Identity, OFFSET>,
SpoolerYield: SpoolerYield::<Identity, OFFSET>,
SpoolerNotify: SpoolerNotify::<Identity, OFFSET>,
CreateOneOff: CreateOneOff::<Identity, OFFSET>,
SetProviderUID: SetProviderUID::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
OpenTemplateID: OpenTemplateID::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
GetOneOffTable: GetOneOffTable::<Identity, OFFSET>,
Address: Address::<Identity, OFFSET>,
Details: Details::<Identity, OFFSET>,
NewEntry: NewEntry::<Identity, OFFSET>,
DoConfigPropsheet: DoConfigPropsheet::<Identity, OFFSET>,
CopyMessages: CopyMessages::<Identity, OFFSET>,
CopyFolder: CopyFolder::<Identity, OFFSET>,
DoCopyTo: DoCopyTo::<Identity, OFFSET>,
DoCopyProps: DoCopyProps::<Identity, OFFSET>,
DoProgressDialog: DoProgressDialog::<Identity, OFFSET>,
ReadReceipt: ReadReceipt::<Identity, OFFSET>,
PrepareSubmit: PrepareSubmit::<Identity, OFFSET>,
ExpandRecips: ExpandRecips::<Identity, OFFSET>,
UpdatePAB: UpdatePAB::<Identity, OFFSET>,
DoSentMail: DoSentMail::<Identity, OFFSET>,
OpenAddressBook: OpenAddressBook::<Identity, OFFSET>,
Preprocess: Preprocess::<Identity, OFFSET>,
CompleteMsg: CompleteMsg::<Identity, OFFSET>,
StoreLogoffTransports: StoreLogoffTransports::<Identity, OFFSET>,
StatusRecips: StatusRecips::<Identity, OFFSET>,
WrapStoreEntryID: WrapStoreEntryID::<Identity, OFFSET>,
ModifyProfile: ModifyProfile::<Identity, OFFSET>,
IStorageFromStream: IStorageFromStream::<Identity, OFFSET>,
GetSvcConfigSupportObj: GetSvcConfigSupportObj::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPISupport as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPISupport {}
windows_core::imp::define_interface!(
IMAPITable,
IMAPITable_Vtbl,
0x00020301_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPITable, windows_core::IUnknown);
impl IMAPITable {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Advise<P1>(
&self,
uleventmask: u32,
lpadvisesink: P1,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn GetStatus(
&self,
lpultablestatus: *mut u32,
lpultabletype: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetStatus)(
windows_core::Interface::as_raw(self),
lpultablestatus as _,
lpultabletype as _,
)
.ok()
}
}
pub unsafe fn SetColumns(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetColumns)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
ulflags,
)
.ok()
}
}
pub unsafe fn QueryColumns(
&self,
ulflags: u32,
lpproptagarray: *mut *mut SPropTagArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryColumns)(
windows_core::Interface::as_raw(self),
ulflags,
lpproptagarray as _,
)
.ok()
}
}
pub unsafe fn GetRowCount(
&self,
ulflags: u32,
lpulcount: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRowCount)(
windows_core::Interface::as_raw(self),
ulflags,
lpulcount as _,
)
.ok()
}
}
pub unsafe fn SeekRow(
&self,
bkorigin: usize,
lrowcount: i32,
lplrowssought: *mut i32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SeekRow)(
windows_core::Interface::as_raw(self),
bkorigin,
lrowcount,
lplrowssought as _,
)
.ok()
}
}
pub unsafe fn SeekRowApprox(
&self,
ulnumerator: u32,
uldenominator: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SeekRowApprox)(
windows_core::Interface::as_raw(self),
ulnumerator,
uldenominator,
)
.ok()
}
}
pub unsafe fn QueryPosition(
&self,
lpulrow: *mut u32,
lpulnumerator: *mut u32,
lpuldenominator: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryPosition)(
windows_core::Interface::as_raw(self),
lpulrow as _,
lpulnumerator as _,
lpuldenominator as _,
)
.ok()
}
}
pub unsafe fn FindRow(
&self,
lprestriction: *mut SRestriction,
bkorigin: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindRow)(
windows_core::Interface::as_raw(self),
lprestriction as _,
bkorigin,
ulflags,
)
.ok()
}
}
pub unsafe fn Restrict(
&self,
lprestriction: *mut SRestriction,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Restrict)(
windows_core::Interface::as_raw(self),
lprestriction as _,
ulflags,
)
.ok()
}
}
pub unsafe fn CreateBookmark(&self, lpbkposition: *mut usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateBookmark)(
windows_core::Interface::as_raw(self),
lpbkposition as _,
)
.ok()
}
}
pub unsafe fn FreeBookmark(&self, bkposition: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeBookmark)(
windows_core::Interface::as_raw(self),
bkposition,
)
.ok()
}
}
pub unsafe fn SortTable(
&self,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SortTable)(
windows_core::Interface::as_raw(self),
lpsortcriteria as _,
ulflags,
)
.ok()
}
}
pub unsafe fn QuerySortOrder(
&self,
lppsortcriteria: *mut *mut SSortOrderSet,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QuerySortOrder)(
windows_core::Interface::as_raw(self),
lppsortcriteria as _,
)
.ok()
}
}
pub unsafe fn QueryRows(
&self,
lrowcount: i32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).QueryRows)(
windows_core::Interface::as_raw(self),
lrowcount,
ulflags,
lpprows as _,
)
.ok()
}
}
pub unsafe fn Abort(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Abort)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn ExpandRow(
&self,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulrowcount: u32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
lpulmorerows: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ExpandRow)(
windows_core::Interface::as_raw(self),
cbinstancekey,
pbinstancekey as _,
ulrowcount,
ulflags,
lpprows as _,
lpulmorerows as _,
)
.ok()
}
}
pub unsafe fn CollapseRow(
&self,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulflags: u32,
lpulrowcount: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CollapseRow)(
windows_core::Interface::as_raw(self),
cbinstancekey,
pbinstancekey as _,
ulflags,
lpulrowcount as _,
)
.ok()
}
}
pub unsafe fn WaitForCompletion(
&self,
ulflags: u32,
ultimeout: u32,
lpultablestatus: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).WaitForCompletion)(
windows_core::Interface::as_raw(self),
ulflags,
ultimeout,
lpultablestatus as _,
)
.ok()
}
}
pub unsafe fn GetCollapseState(
&self,
ulflags: u32,
cbinstancekey: u32,
lpbinstancekey: *mut u8,
lpcbcollapsestate: *mut u32,
lppbcollapsestate: *mut *mut u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCollapseState)(
windows_core::Interface::as_raw(self),
ulflags,
cbinstancekey,
lpbinstancekey as _,
lpcbcollapsestate as _,
lppbcollapsestate as _,
)
.ok()
}
}
pub unsafe fn SetCollapseState(
&self,
ulflags: u32,
pbcollapsestate: &mut [u8],
lpbklocation: *mut usize,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetCollapseState)(
windows_core::Interface::as_raw(self),
ulflags,
pbcollapsestate.len().try_into().unwrap(),
core::mem::transmute(pbcollapsestate.as_ptr()),
lpbklocation as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPITable_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub GetStatus: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
) -> windows_core::HRESULT,
pub SetColumns: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
u32,
) -> windows_core::HRESULT,
pub QueryColumns: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SPropTagArray,
) -> windows_core::HRESULT,
pub GetRowCount:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
pub SeekRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
i32,
*mut i32,
) -> windows_core::HRESULT,
pub SeekRowApprox:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
pub QueryPosition: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut u32,
) -> windows_core::HRESULT,
pub FindRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SRestriction,
usize,
u32,
) -> windows_core::HRESULT,
pub Restrict: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SRestriction,
u32,
) -> windows_core::HRESULT,
pub CreateBookmark:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut usize) -> windows_core::HRESULT,
pub FreeBookmark:
unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub SortTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SSortOrderSet,
u32,
) -> windows_core::HRESULT,
pub QuerySortOrder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut SSortOrderSet,
) -> windows_core::HRESULT,
pub QueryRows: unsafe extern "system" fn(
*mut core::ffi::c_void,
i32,
u32,
*mut *mut SRowSet,
) -> windows_core::HRESULT,
pub Abort: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub ExpandRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
u32,
*mut *mut SRowSet,
*mut u32,
) -> windows_core::HRESULT,
pub CollapseRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut u8,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub WaitForCompletion: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub GetCollapseState: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut u8,
*mut u32,
*mut *mut u8,
) -> windows_core::HRESULT,
pub SetCollapseState: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut u8,
*mut usize,
) -> windows_core::HRESULT,
}
pub trait IMAPITable_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Advise(
&self,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn GetStatus(
&self,
lpultablestatus: *mut u32,
lpultabletype: *mut u32,
) -> windows_core::Result<()>;
fn SetColumns(
&self,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
) -> windows_core::Result<()>;
fn QueryColumns(
&self,
ulflags: u32,
lpproptagarray: *mut *mut SPropTagArray,
) -> windows_core::Result<()>;
fn GetRowCount(&self, ulflags: u32, lpulcount: *mut u32) -> windows_core::Result<()>;
fn SeekRow(
&self,
bkorigin: usize,
lrowcount: i32,
lplrowssought: *mut i32,
) -> windows_core::Result<()>;
fn SeekRowApprox(&self, ulnumerator: u32, uldenominator: u32) -> windows_core::Result<()>;
fn QueryPosition(
&self,
lpulrow: *mut u32,
lpulnumerator: *mut u32,
lpuldenominator: *mut u32,
) -> windows_core::Result<()>;
fn FindRow(
&self,
lprestriction: *mut SRestriction,
bkorigin: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn Restrict(&self, lprestriction: *mut SRestriction, ulflags: u32) -> windows_core::Result<()>;
fn CreateBookmark(&self, lpbkposition: *mut usize) -> windows_core::Result<()>;
fn FreeBookmark(&self, bkposition: usize) -> windows_core::Result<()>;
fn SortTable(
&self,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::Result<()>;
fn QuerySortOrder(&self, lppsortcriteria: *mut *mut SSortOrderSet) -> windows_core::Result<()>;
fn QueryRows(
&self,
lrowcount: i32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
) -> windows_core::Result<()>;
fn Abort(&self) -> windows_core::Result<()>;
fn ExpandRow(
&self,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulrowcount: u32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
lpulmorerows: *mut u32,
) -> windows_core::Result<()>;
fn CollapseRow(
&self,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulflags: u32,
lpulrowcount: *mut u32,
) -> windows_core::Result<()>;
fn WaitForCompletion(
&self,
ulflags: u32,
ultimeout: u32,
lpultablestatus: *mut u32,
) -> windows_core::Result<()>;
fn GetCollapseState(
&self,
ulflags: u32,
cbinstancekey: u32,
lpbinstancekey: *mut u8,
lpcbcollapsestate: *mut u32,
lppbcollapsestate: *mut *mut u8,
) -> windows_core::Result<()>;
fn SetCollapseState(
&self,
ulflags: u32,
cbcollapsestate: u32,
pbcollapsestate: *mut u8,
lpbklocation: *mut usize,
) -> windows_core::Result<()>;
}
impl IMAPITable_Vtbl {
pub const fn new<Identity: IMAPITable_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::Advise(
this,
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn GetStatus<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpultablestatus: *mut u32,
lpultabletype: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::GetStatus(
this,
core::mem::transmute_copy(&lpultablestatus),
core::mem::transmute_copy(&lpultabletype),
)
.into()
}
}
unsafe extern "system" fn SetColumns<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::SetColumns(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn QueryColumns<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpproptagarray: *mut *mut SPropTagArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::QueryColumns(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpproptagarray),
)
.into()
}
}
unsafe extern "system" fn GetRowCount<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpulcount: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::GetRowCount(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulcount),
)
.into()
}
}
unsafe extern "system" fn SeekRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
bkorigin: usize,
lrowcount: i32,
lplrowssought: *mut i32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::SeekRow(
this,
core::mem::transmute_copy(&bkorigin),
core::mem::transmute_copy(&lrowcount),
core::mem::transmute_copy(&lplrowssought),
)
.into()
}
}
unsafe extern "system" fn SeekRowApprox<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulnumerator: u32,
uldenominator: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::SeekRowApprox(
this,
core::mem::transmute_copy(&ulnumerator),
core::mem::transmute_copy(&uldenominator),
)
.into()
}
}
unsafe extern "system" fn QueryPosition<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulrow: *mut u32,
lpulnumerator: *mut u32,
lpuldenominator: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::QueryPosition(
this,
core::mem::transmute_copy(&lpulrow),
core::mem::transmute_copy(&lpulnumerator),
core::mem::transmute_copy(&lpuldenominator),
)
.into()
}
}
unsafe extern "system" fn FindRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lprestriction: *mut SRestriction,
bkorigin: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::FindRow(
this,
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&bkorigin),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn Restrict<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lprestriction: *mut SRestriction,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::Restrict(
this,
core::mem::transmute_copy(&lprestriction),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CreateBookmark<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpbkposition: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::CreateBookmark(this, core::mem::transmute_copy(&lpbkposition))
.into()
}
}
unsafe extern "system" fn FreeBookmark<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
bkposition: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::FreeBookmark(this, core::mem::transmute_copy(&bkposition)).into()
}
}
unsafe extern "system" fn SortTable<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpsortcriteria: *mut SSortOrderSet,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::SortTable(
this,
core::mem::transmute_copy(&lpsortcriteria),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn QuerySortOrder<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lppsortcriteria: *mut *mut SSortOrderSet,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::QuerySortOrder(this, core::mem::transmute_copy(&lppsortcriteria))
.into()
}
}
unsafe extern "system" fn QueryRows<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lrowcount: i32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::QueryRows(
this,
core::mem::transmute_copy(&lrowcount),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpprows),
)
.into()
}
}
unsafe extern "system" fn Abort<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::Abort(this).into()
}
}
unsafe extern "system" fn ExpandRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulrowcount: u32,
ulflags: u32,
lpprows: *mut *mut SRowSet,
lpulmorerows: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::ExpandRow(
this,
core::mem::transmute_copy(&cbinstancekey),
core::mem::transmute_copy(&pbinstancekey),
core::mem::transmute_copy(&ulrowcount),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpprows),
core::mem::transmute_copy(&lpulmorerows),
)
.into()
}
}
unsafe extern "system" fn CollapseRow<Identity: IMAPITable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbinstancekey: u32,
pbinstancekey: *mut u8,
ulflags: u32,
lpulrowcount: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::CollapseRow(
this,
core::mem::transmute_copy(&cbinstancekey),
core::mem::transmute_copy(&pbinstancekey),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulrowcount),
)
.into()
}
}
unsafe extern "system" fn WaitForCompletion<
Identity: IMAPITable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
ultimeout: u32,
lpultablestatus: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::WaitForCompletion(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&ultimeout),
core::mem::transmute_copy(&lpultablestatus),
)
.into()
}
}
unsafe extern "system" fn GetCollapseState<
Identity: IMAPITable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbinstancekey: u32,
lpbinstancekey: *mut u8,
lpcbcollapsestate: *mut u32,
lppbcollapsestate: *mut *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::GetCollapseState(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbinstancekey),
core::mem::transmute_copy(&lpbinstancekey),
core::mem::transmute_copy(&lpcbcollapsestate),
core::mem::transmute_copy(&lppbcollapsestate),
)
.into()
}
}
unsafe extern "system" fn SetCollapseState<
Identity: IMAPITable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbcollapsestate: u32,
pbcollapsestate: *mut u8,
lpbklocation: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPITable_Impl::SetCollapseState(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbcollapsestate),
core::mem::transmute_copy(&pbcollapsestate),
core::mem::transmute_copy(&lpbklocation),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
GetStatus: GetStatus::<Identity, OFFSET>,
SetColumns: SetColumns::<Identity, OFFSET>,
QueryColumns: QueryColumns::<Identity, OFFSET>,
GetRowCount: GetRowCount::<Identity, OFFSET>,
SeekRow: SeekRow::<Identity, OFFSET>,
SeekRowApprox: SeekRowApprox::<Identity, OFFSET>,
QueryPosition: QueryPosition::<Identity, OFFSET>,
FindRow: FindRow::<Identity, OFFSET>,
Restrict: Restrict::<Identity, OFFSET>,
CreateBookmark: CreateBookmark::<Identity, OFFSET>,
FreeBookmark: FreeBookmark::<Identity, OFFSET>,
SortTable: SortTable::<Identity, OFFSET>,
QuerySortOrder: QuerySortOrder::<Identity, OFFSET>,
QueryRows: QueryRows::<Identity, OFFSET>,
Abort: Abort::<Identity, OFFSET>,
ExpandRow: ExpandRow::<Identity, OFFSET>,
CollapseRow: CollapseRow::<Identity, OFFSET>,
WaitForCompletion: WaitForCompletion::<Identity, OFFSET>,
GetCollapseState: GetCollapseState::<Identity, OFFSET>,
SetCollapseState: SetCollapseState::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPITable as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPITable {}
pub const IMAPITable_Abort: METHODS = METHODS(31i32);
pub const IMAPITable_Advise: METHODS = METHODS(15i32);
pub const IMAPITable_CollapseRow: METHODS = METHODS(33i32);
pub const IMAPITable_CreateBookmark: METHODS = METHODS(26i32);
pub const IMAPITable_ExpandRow: METHODS = METHODS(32i32);
pub const IMAPITable_FindRow: METHODS = METHODS(24i32);
pub const IMAPITable_FreeBookmark: METHODS = METHODS(27i32);
pub const IMAPITable_GetCollapseState: METHODS = METHODS(35i32);
pub const IMAPITable_GetLastError: METHODS = METHODS(14i32);
pub const IMAPITable_GetRowCount: METHODS = METHODS(20i32);
pub const IMAPITable_GetStatus: METHODS = METHODS(17i32);
pub const IMAPITable_QueryColumns: METHODS = METHODS(19i32);
pub const IMAPITable_QueryPosition: METHODS = METHODS(23i32);
pub const IMAPITable_QueryRows: METHODS = METHODS(30i32);
pub const IMAPITable_QuerySortOrder: METHODS = METHODS(29i32);
pub const IMAPITable_Restrict: METHODS = METHODS(25i32);
pub const IMAPITable_SeekRow: METHODS = METHODS(21i32);
pub const IMAPITable_SeekRowApprox: METHODS = METHODS(22i32);
pub const IMAPITable_SetCollapseState: METHODS = METHODS(36i32);
pub const IMAPITable_SetColumns: METHODS = METHODS(18i32);
pub const IMAPITable_SortTable: METHODS = METHODS(28i32);
pub const IMAPITable_Unadvise: METHODS = METHODS(16i32);
pub const IMAPITable_WaitForCompletion: METHODS = METHODS(34i32);
windows_core::imp::define_interface!(
IMAPIViewAdviseSink,
IMAPIViewAdviseSink_Vtbl,
0x0002032b_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIViewAdviseSink, windows_core::IUnknown);
impl IMAPIViewAdviseSink {
pub unsafe fn OnShutdown(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnShutdown)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn OnNewMessage(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnNewMessage)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn OnPrint(
&self,
dwpagenumber: u32,
hrstatus: windows_core::HRESULT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnPrint)(
windows_core::Interface::as_raw(self),
dwpagenumber,
hrstatus,
)
.ok()
}
}
pub unsafe fn OnSubmitted(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnSubmitted)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn OnSaved(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnSaved)(windows_core::Interface::as_raw(self))
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIViewAdviseSink_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnShutdown: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub OnNewMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub OnPrint: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
windows_core::HRESULT,
) -> windows_core::HRESULT,
pub OnSubmitted: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub OnSaved: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IMAPIViewAdviseSink_Impl: windows_core::IUnknownImpl {
fn OnShutdown(&self) -> windows_core::Result<()>;
fn OnNewMessage(&self) -> windows_core::Result<()>;
fn OnPrint(
&self,
dwpagenumber: u32,
hrstatus: windows_core::HRESULT,
) -> windows_core::Result<()>;
fn OnSubmitted(&self) -> windows_core::Result<()>;
fn OnSaved(&self) -> windows_core::Result<()>;
}
impl IMAPIViewAdviseSink_Vtbl {
pub const fn new<Identity: IMAPIViewAdviseSink_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnShutdown<
Identity: IMAPIViewAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewAdviseSink_Impl::OnShutdown(this).into()
}
}
unsafe extern "system" fn OnNewMessage<
Identity: IMAPIViewAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewAdviseSink_Impl::OnNewMessage(this).into()
}
}
unsafe extern "system" fn OnPrint<
Identity: IMAPIViewAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwpagenumber: u32,
hrstatus: windows_core::HRESULT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewAdviseSink_Impl::OnPrint(
this,
core::mem::transmute_copy(&dwpagenumber),
core::mem::transmute_copy(&hrstatus),
)
.into()
}
}
unsafe extern "system" fn OnSubmitted<
Identity: IMAPIViewAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewAdviseSink_Impl::OnSubmitted(this).into()
}
}
unsafe extern "system" fn OnSaved<
Identity: IMAPIViewAdviseSink_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewAdviseSink_Impl::OnSaved(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnShutdown: OnShutdown::<Identity, OFFSET>,
OnNewMessage: OnNewMessage::<Identity, OFFSET>,
OnPrint: OnPrint::<Identity, OFFSET>,
OnSubmitted: OnSubmitted::<Identity, OFFSET>,
OnSaved: OnSaved::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIViewAdviseSink as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIViewAdviseSink {}
windows_core::imp::define_interface!(
IMAPIViewContext,
IMAPIViewContext_Vtbl,
0x00020321_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMAPIViewContext, windows_core::IUnknown);
impl IMAPIViewContext {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn SetAdviseSink<P0>(&self, pmvns: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIFormAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).SetAdviseSink)(
windows_core::Interface::as_raw(self),
pmvns.param().abi(),
)
.ok()
}
}
pub unsafe fn ActivateNext(
&self,
uldir: u32,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ActivateNext)(
windows_core::Interface::as_raw(self),
uldir,
prcposrect as _,
)
.ok()
}
}
pub unsafe fn GetPrintSetup(
&self,
ulflags: u32,
lppformprintsetup: *mut *mut FORMPRINTSETUP,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetPrintSetup)(
windows_core::Interface::as_raw(self),
ulflags,
lppformprintsetup as _,
)
.ok()
}
}
pub unsafe fn GetSaveStream(
&self,
pulflags: *mut u32,
pulformat: *mut u32,
ppstm: *mut Option<windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSaveStream)(
windows_core::Interface::as_raw(self),
pulflags as _,
pulformat as _,
core::mem::transmute(ppstm),
)
.ok()
}
}
pub unsafe fn GetViewStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetViewStatus)(
windows_core::Interface::as_raw(self),
lpulstatus as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMAPIViewContext_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub SetAdviseSink: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ActivateNext: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT,
pub GetPrintSetup: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut FORMPRINTSETUP,
) -> windows_core::HRESULT,
pub GetSaveStream: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetViewStatus:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMAPIViewContext_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn SetAdviseSink(
&self,
pmvns: windows_core::Ref<'_, IMAPIFormAdviseSink>,
) -> windows_core::Result<()>;
fn ActivateNext(
&self,
uldir: u32,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::Result<()>;
fn GetPrintSetup(
&self,
ulflags: u32,
lppformprintsetup: *mut *mut FORMPRINTSETUP,
) -> windows_core::Result<()>;
fn GetSaveStream(
&self,
pulflags: *mut u32,
pulformat: *mut u32,
ppstm: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn GetViewStatus(&self, lpulstatus: *mut u32) -> windows_core::Result<()>;
}
impl IMAPIViewContext_Vtbl {
pub const fn new<Identity: IMAPIViewContext_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn SetAdviseSink<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pmvns: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::SetAdviseSink(this, core::mem::transmute_copy(&pmvns)).into()
}
}
unsafe extern "system" fn ActivateNext<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
uldir: u32,
prcposrect: *mut windows::Win32::Foundation::RECT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::ActivateNext(
this,
core::mem::transmute_copy(&uldir),
core::mem::transmute_copy(&prcposrect),
)
.into()
}
}
unsafe extern "system" fn GetPrintSetup<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lppformprintsetup: *mut *mut FORMPRINTSETUP,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::GetPrintSetup(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppformprintsetup),
)
.into()
}
}
unsafe extern "system" fn GetSaveStream<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pulflags: *mut u32,
pulformat: *mut u32,
ppstm: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::GetSaveStream(
this,
core::mem::transmute_copy(&pulflags),
core::mem::transmute_copy(&pulformat),
core::mem::transmute_copy(&ppstm),
)
.into()
}
}
unsafe extern "system" fn GetViewStatus<
Identity: IMAPIViewContext_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpulstatus: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMAPIViewContext_Impl::GetViewStatus(this, core::mem::transmute_copy(&lpulstatus))
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
SetAdviseSink: SetAdviseSink::<Identity, OFFSET>,
ActivateNext: ActivateNext::<Identity, OFFSET>,
GetPrintSetup: GetPrintSetup::<Identity, OFFSET>,
GetSaveStream: GetSaveStream::<Identity, OFFSET>,
GetViewStatus: GetViewStatus::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMAPIViewContext as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMAPIViewContext {}
pub const IMF_ATTACHMENTS: IMSGFLAGS = IMSGFLAGS(1i32);
pub const IMF_CSETTAGGED: IMSGFLAGS = IMSGFLAGS(8192i32);
pub const IMF_ENCRYPTED: IMSGFLAGS = IMSGFLAGS(256i32);
pub const IMF_HASVCARD: IMSGFLAGS = IMSGFLAGS(65536i32);
pub const IMF_HTML: IMSGFLAGS = IMSGFLAGS(16i32);
pub const IMF_MHTML: IMSGFLAGS = IMSGFLAGS(1024i32);
pub const IMF_MIME: IMSGFLAGS = IMSGFLAGS(8i32);
pub const IMF_MULTIPART: IMSGFLAGS = IMSGFLAGS(2i32);
pub const IMF_NEWS: IMSGFLAGS = IMSGFLAGS(16384i32);
pub const IMF_PARTIAL: IMSGFLAGS = IMSGFLAGS(64i32);
pub const IMF_PLAIN: IMSGFLAGS = IMSGFLAGS(32i32);
pub const IMF_RFC1154: IMSGFLAGS = IMSGFLAGS(131072i32);
pub const IMF_SECURE: IMSGFLAGS = IMSGFLAGS(2048i32);
pub const IMF_SIGNED: IMSGFLAGS = IMSGFLAGS(128i32);
pub const IMF_SUBMULTIPART: IMSGFLAGS = IMSGFLAGS(4i32);
pub const IMF_TEXT: IMSGFLAGS = IMSGFLAGS(4096i32);
pub const IMF_TNEF: IMSGFLAGS = IMSGFLAGS(512i32);
pub const IMF_VOICEMAIL: IMSGFLAGS = IMSGFLAGS(32768i32);
pub const IMPORTANCE_HIGH: u32 = 2u32;
pub const IMPORTANCE_LOW: u32 = 0u32;
pub const IMPORTANCE_NORMAL: u32 = 1u32;
windows_core::imp::define_interface!(
IMSCapabilities,
IMSCapabilities_Vtbl,
0x00020393_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSCapabilities, windows_core::IUnknown);
impl IMSCapabilities {
pub unsafe fn GetCapabilities(&self, mscapselector: MSCAP_SELECTOR) -> u32 {
unsafe {
(windows_core::Interface::vtable(self).GetCapabilities)(
windows_core::Interface::as_raw(self),
mscapselector,
)
}
}
}
#[repr(C)]
pub struct IMSCapabilities_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetCapabilities: unsafe extern "system" fn(*mut core::ffi::c_void, MSCAP_SELECTOR) -> u32,
}
pub trait IMSCapabilities_Impl: windows_core::IUnknownImpl {
fn GetCapabilities(&self, mscapselector: MSCAP_SELECTOR) -> u32;
}
impl IMSCapabilities_Vtbl {
pub const fn new<Identity: IMSCapabilities_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetCapabilities<
Identity: IMSCapabilities_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
mscapselector: MSCAP_SELECTOR,
) -> u32 {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSCapabilities_Impl::GetCapabilities(
this,
core::mem::transmute_copy(&mscapselector),
)
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetCapabilities: GetCapabilities::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMSCapabilities as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMSCapabilities {}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGBODYTYPE(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGFLAGS(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct IMSGPRIORITY(pub i32);
pub const IMSG_NO_ISTG_COMMIT: u32 = 1u32;
pub const IMSG_PRI_HIGH: IMSGPRIORITY = IMSGPRIORITY(1i32);
pub const IMSG_PRI_LOW: IMSGPRIORITY = IMSGPRIORITY(5i32);
pub const IMSG_PRI_NORMAL: IMSGPRIORITY = IMSGPRIORITY(3i32);
windows_core::imp::define_interface!(
IMSLogon,
IMSLogon_Vtbl,
0x00020313_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSLogon, windows_core::IUnknown);
impl IMSLogon {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn Logoff(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Logoff)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn Advise<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenStatusEntry)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
lpulobjtype as _,
lppentry as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMSLogon_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub Logoff:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub OpenStatusEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMSLogon_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn Logoff(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn Advise(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
}
impl IMSLogon_Vtbl {
pub const fn new<Identity: IMSLogon_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn Logoff<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::Logoff(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn OpenEntry<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn CompareEntryIDs<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn Advise<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::Advise(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn OpenStatusEntry<Identity: IMSLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSLogon_Impl::OpenStatusEntry(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppentry),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
Logoff: Logoff::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMSLogon as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMSLogon {}
pub const IMSLogon_Advise: METHODS = METHODS(116i32);
pub const IMSLogon_CompareEntryIDs: METHODS = METHODS(115i32);
pub const IMSLogon_GetLastError: METHODS = METHODS(112i32);
pub const IMSLogon_Logoff: METHODS = METHODS(113i32);
pub const IMSLogon_OpenEntry: METHODS = METHODS(114i32);
pub const IMSLogon_OpenStatusEntry: METHODS = METHODS(118i32);
pub const IMSLogon_Unadvise: METHODS = METHODS(117i32);
windows_core::imp::define_interface!(
IMSProvider,
IMSProvider_Vtbl,
0x00020310_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMSProvider, windows_core::IUnknown);
impl IMSProvider {
pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Shutdown)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn Logon<P0>(
&self,
lpmapisup: P0,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
lpcbspoolsecurity: *mut u32,
lppbspoolsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: *mut Option<IMSLogon>,
lppmdb: *mut Option<IMsgStore>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISupport>,
{
unsafe {
(windows_core::Interface::vtable(self).Logon)(
windows_core::Interface::as_raw(self),
lpmapisup.param().abi(),
uluiparam,
lpszprofilename as _,
cbentryid,
lpentryid as _,
ulflags,
lpinterface as _,
lpcbspoolsecurity as _,
lppbspoolsecurity as _,
lppmapierror as _,
core::mem::transmute(lppmslogon),
core::mem::transmute(lppmdb),
)
.ok()
}
}
pub unsafe fn SpoolerLogon<P0>(
&self,
lpmapisup: P0,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
cbspoolsecurity: u32,
lpbspoolsecurity: *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: *mut Option<IMSLogon>,
lppmdb: *mut Option<IMsgStore>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISupport>,
{
unsafe {
(windows_core::Interface::vtable(self).SpoolerLogon)(
windows_core::Interface::as_raw(self),
lpmapisup.param().abi(),
uluiparam,
lpszprofilename as _,
cbentryid,
lpentryid as _,
ulflags,
lpinterface as _,
cbspoolsecurity,
lpbspoolsecurity as _,
lppmapierror as _,
core::mem::transmute(lppmslogon),
core::mem::transmute(lppmdb),
)
.ok()
}
}
pub unsafe fn CompareStoreIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareStoreIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMSProvider_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Shutdown:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub Logon: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
usize,
*mut i8,
u32,
*mut ENTRYID,
u32,
*mut windows_core::GUID,
*mut u32,
*mut *mut u8,
*mut *mut MAPIERROR,
*mut *mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SpoolerLogon: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
usize,
*mut i8,
u32,
*mut ENTRYID,
u32,
*mut windows_core::GUID,
u32,
*mut u8,
*mut *mut MAPIERROR,
*mut *mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CompareStoreIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait IMSProvider_Impl: windows_core::IUnknownImpl {
fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn Logon(
&self,
lpmapisup: windows_core::Ref<'_, IMAPISupport>,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
lpcbspoolsecurity: *mut u32,
lppbspoolsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: windows_core::OutRef<'_, IMSLogon>,
lppmdb: windows_core::OutRef<'_, IMsgStore>,
) -> windows_core::Result<()>;
fn SpoolerLogon(
&self,
lpmapisup: windows_core::Ref<'_, IMAPISupport>,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
cbspoolsecurity: u32,
lpbspoolsecurity: *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: windows_core::OutRef<'_, IMSLogon>,
lppmdb: windows_core::OutRef<'_, IMsgStore>,
) -> windows_core::Result<()>;
fn CompareStoreIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
}
impl IMSProvider_Vtbl {
pub const fn new<Identity: IMSProvider_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Shutdown<Identity: IMSProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn Logon<Identity: IMSProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmapisup: *mut core::ffi::c_void,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
lpcbspoolsecurity: *mut u32,
lppbspoolsecurity: *mut *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: *mut *mut core::ffi::c_void,
lppmdb: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSProvider_Impl::Logon(
this,
core::mem::transmute_copy(&lpmapisup),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&lpcbspoolsecurity),
core::mem::transmute_copy(&lppbspoolsecurity),
core::mem::transmute_copy(&lppmapierror),
core::mem::transmute_copy(&lppmslogon),
core::mem::transmute_copy(&lppmdb),
)
.into()
}
}
unsafe extern "system" fn SpoolerLogon<Identity: IMSProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmapisup: *mut core::ffi::c_void,
uluiparam: usize,
lpszprofilename: *mut i8,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
lpinterface: *mut windows_core::GUID,
cbspoolsecurity: u32,
lpbspoolsecurity: *mut u8,
lppmapierror: *mut *mut MAPIERROR,
lppmslogon: *mut *mut core::ffi::c_void,
lppmdb: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSProvider_Impl::SpoolerLogon(
this,
core::mem::transmute_copy(&lpmapisup),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&cbspoolsecurity),
core::mem::transmute_copy(&lpbspoolsecurity),
core::mem::transmute_copy(&lppmapierror),
core::mem::transmute_copy(&lppmslogon),
core::mem::transmute_copy(&lppmdb),
)
.into()
}
}
unsafe extern "system" fn CompareStoreIDs<
Identity: IMSProvider_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMSProvider_Impl::CompareStoreIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Shutdown: Shutdown::<Identity, OFFSET>,
Logon: Logon::<Identity, OFFSET>,
SpoolerLogon: SpoolerLogon::<Identity, OFFSET>,
CompareStoreIDs: CompareStoreIDs::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMSProvider as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMSProvider {}
pub const IMSProvider_CompareStoreIDs: METHODS = METHODS(111i32);
pub const IMSProvider_Logon: METHODS = METHODS(109i32);
pub const IMSProvider_Shutdown: METHODS = METHODS(108i32);
pub const IMSProvider_SpoolerLogon: METHODS = METHODS(110i32);
windows_core::imp::define_interface!(
IMailUser,
IMailUser_Vtbl,
0x0002030a_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMailUser {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMailUser, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IMailUser_Vtbl {
pub base__: IMAPIProp_Vtbl,
}
pub trait IMailUser_Impl: IMAPIProp_Impl {}
impl IMailUser_Vtbl {
pub const fn new<Identity: IMailUser_Impl, const OFFSET: isize>() -> Self {
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMailUser as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMailUser {}
windows_core::imp::define_interface!(
IMessage,
IMessage_Vtbl,
0x00020307_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMessage {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMessage, windows_core::IUnknown, IMAPIProp);
impl IMessage {
pub unsafe fn GetAttachmentTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetAttachmentTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn OpenAttach(
&self,
ulattachmentnum: u32,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppattach: *mut Option<IAttach>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenAttach)(
windows_core::Interface::as_raw(self),
ulattachmentnum,
lpinterface as _,
ulflags,
core::mem::transmute(lppattach),
)
.ok()
}
}
pub unsafe fn CreateAttach(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulattachmentnum: *mut u32,
lppattach: *mut Option<IAttach>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateAttach)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
lpulattachmentnum as _,
core::mem::transmute(lppattach),
)
.ok()
}
}
pub unsafe fn DeleteAttach<P2>(
&self,
ulattachmentnum: u32,
uluiparam: usize,
lpprogress: P2,
ulflags: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMAPIProgress>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteAttach)(
windows_core::Interface::as_raw(self),
ulattachmentnum,
uluiparam,
lpprogress.param().abi(),
ulflags,
)
.ok()
}
}
pub unsafe fn GetRecipientTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetRecipientTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn ModifyRecipients(
&self,
ulflags: u32,
lpmods: *mut ADRLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ModifyRecipients)(
windows_core::Interface::as_raw(self),
ulflags,
lpmods as _,
)
.ok()
}
}
pub unsafe fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SubmitMessage)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn SetReadFlag(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetReadFlag)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMessage_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub GetAttachmentTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OpenAttach: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateAttach: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub DeleteAttach: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
usize,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetRecipientTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ModifyRecipients: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ADRLIST,
) -> windows_core::HRESULT,
pub SubmitMessage:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub SetReadFlag:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IMessage_Impl: IMAPIProp_Impl {
fn GetAttachmentTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn OpenAttach(
&self,
ulattachmentnum: u32,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppattach: windows_core::OutRef<'_, IAttach>,
) -> windows_core::Result<()>;
fn CreateAttach(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulattachmentnum: *mut u32,
lppattach: windows_core::OutRef<'_, IAttach>,
) -> windows_core::Result<()>;
fn DeleteAttach(
&self,
ulattachmentnum: u32,
uluiparam: usize,
lpprogress: windows_core::Ref<'_, IMAPIProgress>,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetRecipientTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn ModifyRecipients(&self, ulflags: u32, lpmods: *mut ADRLIST) -> windows_core::Result<()>;
fn SubmitMessage(&self, ulflags: u32) -> windows_core::Result<()>;
fn SetReadFlag(&self, ulflags: u32) -> windows_core::Result<()>;
}
impl IMessage_Vtbl {
pub const fn new<Identity: IMessage_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetAttachmentTable<
Identity: IMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMessage_Impl::GetAttachmentTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn OpenAttach<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulattachmentnum: u32,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppattach: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::OpenAttach(
this,
core::mem::transmute_copy(&ulattachmentnum),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppattach),
)
.into()
}
}
unsafe extern "system" fn CreateAttach<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulattachmentnum: *mut u32,
lppattach: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::CreateAttach(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulattachmentnum),
core::mem::transmute_copy(&lppattach),
)
.into()
}
}
unsafe extern "system" fn DeleteAttach<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulattachmentnum: u32,
uluiparam: usize,
lpprogress: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::DeleteAttach(
this,
core::mem::transmute_copy(&ulattachmentnum),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpprogress),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetRecipientTable<
Identity: IMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMessage_Impl::GetRecipientTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn ModifyRecipients<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmods: *mut ADRLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::ModifyRecipients(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmods),
)
.into()
}
}
unsafe extern "system" fn SubmitMessage<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::SubmitMessage(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn SetReadFlag<Identity: IMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMessage_Impl::SetReadFlag(this, core::mem::transmute_copy(&ulflags)).into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
GetAttachmentTable: GetAttachmentTable::<Identity, OFFSET>,
OpenAttach: OpenAttach::<Identity, OFFSET>,
CreateAttach: CreateAttach::<Identity, OFFSET>,
DeleteAttach: DeleteAttach::<Identity, OFFSET>,
GetRecipientTable: GetRecipientTable::<Identity, OFFSET>,
ModifyRecipients: ModifyRecipients::<Identity, OFFSET>,
SubmitMessage: SubmitMessage::<Identity, OFFSET>,
SetReadFlag: SetReadFlag::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMessage as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMessage {}
pub const IMessage_CreateAttach: METHODS = METHODS(76i32);
pub const IMessage_DeleteAttach: METHODS = METHODS(77i32);
pub const IMessage_GetAttachmentTable: METHODS = METHODS(74i32);
pub const IMessage_GetRecipientTable: METHODS = METHODS(78i32);
pub const IMessage_ModifyRecipients: METHODS = METHODS(79i32);
pub const IMessage_OpenAttach: METHODS = METHODS(75i32);
pub const IMessage_SetReadFlag: METHODS = METHODS(81i32);
pub const IMessage_SubmitMessage: METHODS = METHODS(80i32);
windows_core::imp::define_interface!(
IMimeAddressTable,
IMimeAddressTable_Vtbl,
0xc558834a_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeAddressTable, windows_core::IUnknown);
impl IMimeAddressTable {
pub unsafe fn Append<P2, P3>(
&self,
dwadrtype: u32,
ietfriendly: ENCODINGTYPE,
pszfriendly: P2,
pszemail: P3,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
P3: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Append)(
windows_core::Interface::as_raw(self),
dwadrtype,
ietfriendly,
pszfriendly.param().abi(),
pszemail.param().abi(),
phaddress as _,
)
.ok()
}
}
pub unsafe fn Insert(
&self,
paddress: *mut ADDRESSPROPS,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Insert)(
windows_core::Interface::as_raw(self),
paddress as _,
phaddress as _,
)
.ok()
}
}
pub unsafe fn SetProps(
&self,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetProps)(
windows_core::Interface::as_raw(self),
haddress as _,
paddress as _,
)
.ok()
}
}
pub unsafe fn GetProps(
&self,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetProps)(
windows_core::Interface::as_raw(self),
haddress as _,
paddress as _,
)
.ok()
}
}
pub unsafe fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSender)(
windows_core::Interface::as_raw(self),
paddress as _,
)
.ok()
}
}
pub unsafe fn CountTypes(&self, dwadrtypes: u32, pcadrs: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CountTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
pcadrs as _,
)
.ok()
}
}
pub unsafe fn GetTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
dwprops,
plist as _,
)
.ok()
}
}
pub unsafe fn EnumTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
) -> windows_core::Result<IMimeEnumAddressTypes> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
dwprops,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Delete(&self, haddress: *mut HADDRESS__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Delete)(
windows_core::Interface::as_raw(self),
haddress as _,
)
.ok()
}
}
pub unsafe fn DeleteTypes(&self, dwadrtypes: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
)
.ok()
}
}
pub unsafe fn GetFormat(
&self,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetFormat)(
windows_core::Interface::as_raw(self),
dwadrtype,
format,
ppszformat as _,
)
.ok()
}
}
pub unsafe fn AppendRfc822<P2>(
&self,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: P2,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).AppendRfc822)(
windows_core::Interface::as_raw(self),
dwadrtype,
ietencoding,
pszrfc822adr.param().abi(),
)
.ok()
}
}
pub unsafe fn ParseRfc822<P2>(
&self,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: P2,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).ParseRfc822)(
windows_core::Interface::as_raw(self),
dwadrtype,
ietencoding,
pszrfc822adr.param().abi(),
plist as _,
)
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeAddressTable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).BindToObject)(
windows_core::Interface::as_raw(self),
riid,
ppvobject as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeAddressTable_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Append: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ENCODINGTYPE,
windows_core::PCSTR,
windows_core::PCSTR,
*mut *mut HADDRESS__,
) -> windows_core::HRESULT,
pub Insert: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ADDRESSPROPS,
*mut *mut HADDRESS__,
) -> windows_core::HRESULT,
pub SetProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HADDRESS__,
*mut ADDRESSPROPS,
) -> windows_core::HRESULT,
pub GetProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HADDRESS__,
*mut ADDRESSPROPS,
) -> windows_core::HRESULT,
pub GetSender: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ADDRESSPROPS,
) -> windows_core::HRESULT,
pub CountTypes:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut u32) -> windows_core::HRESULT,
pub GetTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ADDRESSLIST,
) -> windows_core::HRESULT,
pub EnumTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Delete:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut HADDRESS__) -> windows_core::HRESULT,
pub DeleteTypes:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub GetFormat: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ADDRESSFORMAT,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub AppendRfc822: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ENCODINGTYPE,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub ParseRfc822: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ENCODINGTYPE,
windows_core::PCSTR,
*mut ADDRESSLIST,
) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub BindToObject: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeAddressTable_Impl: windows_core::IUnknownImpl {
fn Append(
&self,
dwadrtype: u32,
ietfriendly: ENCODINGTYPE,
pszfriendly: &windows_core::PCSTR,
pszemail: &windows_core::PCSTR,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::Result<()>;
fn Insert(
&self,
paddress: *mut ADDRESSPROPS,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::Result<()>;
fn SetProps(
&self,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::Result<()>;
fn GetProps(
&self,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::Result<()>;
fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
fn CountTypes(&self, dwadrtypes: u32, pcadrs: *mut u32) -> windows_core::Result<()>;
fn GetTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()>;
fn EnumTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
) -> windows_core::Result<IMimeEnumAddressTypes>;
fn Delete(&self, haddress: *mut HADDRESS__) -> windows_core::Result<()>;
fn DeleteTypes(&self, dwadrtypes: u32) -> windows_core::Result<()>;
fn GetFormat(
&self,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
fn AppendRfc822(
&self,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn ParseRfc822(
&self,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: &windows_core::PCSTR,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimeAddressTable>;
fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
}
impl IMimeAddressTable_Vtbl {
pub const fn new<Identity: IMimeAddressTable_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Append<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwadrtype: u32,
ietfriendly: ENCODINGTYPE,
pszfriendly: windows_core::PCSTR,
pszemail: windows_core::PCSTR,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::Append(
this,
core::mem::transmute_copy(&dwadrtype),
core::mem::transmute_copy(&ietfriendly),
core::mem::transmute(&pszfriendly),
core::mem::transmute(&pszemail),
core::mem::transmute_copy(&phaddress),
)
.into()
}
}
unsafe extern "system" fn Insert<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
paddress: *mut ADDRESSPROPS,
phaddress: *mut *mut HADDRESS__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::Insert(
this,
core::mem::transmute_copy(&paddress),
core::mem::transmute_copy(&phaddress),
)
.into()
}
}
unsafe extern "system" fn SetProps<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::SetProps(
this,
core::mem::transmute_copy(&haddress),
core::mem::transmute_copy(&paddress),
)
.into()
}
}
unsafe extern "system" fn GetProps<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
haddress: *mut HADDRESS__,
paddress: *mut ADDRESSPROPS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::GetProps(
this,
core::mem::transmute_copy(&haddress),
core::mem::transmute_copy(&paddress),
)
.into()
}
}
unsafe extern "system" fn GetSender<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
paddress: *mut ADDRESSPROPS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::GetSender(this, core::mem::transmute_copy(&paddress)).into()
}
}
unsafe extern "system" fn CountTypes<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
pcadrs: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::CountTypes(
this,
core::mem::transmute_copy(&dwadrtypes),
core::mem::transmute_copy(&pcadrs),
)
.into()
}
}
unsafe extern "system" fn GetTypes<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::GetTypes(
this,
core::mem::transmute_copy(&dwadrtypes),
core::mem::transmute_copy(&dwprops),
core::mem::transmute_copy(&plist),
)
.into()
}
}
unsafe extern "system" fn EnumTypes<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
dwprops: u32,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeAddressTable_Impl::EnumTypes(
this,
core::mem::transmute_copy(&dwadrtypes),
core::mem::transmute_copy(&dwprops),
) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Delete<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
haddress: *mut HADDRESS__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::Delete(this, core::mem::transmute_copy(&haddress)).into()
}
}
unsafe extern "system" fn DeleteTypes<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::DeleteTypes(this, core::mem::transmute_copy(&dwadrtypes))
.into()
}
}
unsafe extern "system" fn GetFormat<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::GetFormat(
this,
core::mem::transmute_copy(&dwadrtype),
core::mem::transmute_copy(&format),
core::mem::transmute_copy(&ppszformat),
)
.into()
}
}
unsafe extern "system" fn AppendRfc822<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::AppendRfc822(
this,
core::mem::transmute_copy(&dwadrtype),
core::mem::transmute_copy(&ietencoding),
core::mem::transmute(&pszrfc822adr),
)
.into()
}
}
unsafe extern "system" fn ParseRfc822<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtype: u32,
ietencoding: ENCODINGTYPE,
pszrfc822adr: windows_core::PCSTR,
plist: *mut ADDRESSLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::ParseRfc822(
this,
core::mem::transmute_copy(&dwadrtype),
core::mem::transmute_copy(&ietencoding),
core::mem::transmute(&pszrfc822adr),
core::mem::transmute_copy(&plist),
)
.into()
}
}
unsafe extern "system" fn Clone<Identity: IMimeAddressTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeAddressTable_Impl::Clone(this) {
Ok(ok__) => {
pptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn BindToObject<
Identity: IMimeAddressTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAddressTable_Impl::BindToObject(
this,
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Append: Append::<Identity, OFFSET>,
Insert: Insert::<Identity, OFFSET>,
SetProps: SetProps::<Identity, OFFSET>,
GetProps: GetProps::<Identity, OFFSET>,
GetSender: GetSender::<Identity, OFFSET>,
CountTypes: CountTypes::<Identity, OFFSET>,
GetTypes: GetTypes::<Identity, OFFSET>,
EnumTypes: EnumTypes::<Identity, OFFSET>,
Delete: Delete::<Identity, OFFSET>,
DeleteTypes: DeleteTypes::<Identity, OFFSET>,
GetFormat: GetFormat::<Identity, OFFSET>,
AppendRfc822: AppendRfc822::<Identity, OFFSET>,
ParseRfc822: ParseRfc822::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
BindToObject: BindToObject::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeAddressTable as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeAddressTable {}
windows_core::imp::define_interface!(
IMimeAllocator,
IMimeAllocator_Vtbl,
0xc5588351_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeAllocator {
type Target = windows::Win32::System::Com::IMalloc;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimeAllocator,
windows_core::IUnknown,
windows::Win32::System::Com::IMalloc
);
impl IMimeAllocator {
pub unsafe fn FreeParamInfoArray(
&self,
cparams: u32,
prgparam: *mut MIMEPARAMINFO,
ffreearray: u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeParamInfoArray)(
windows_core::Interface::as_raw(self),
cparams,
prgparam as _,
ffreearray,
)
.ok()
}
}
pub unsafe fn FreeAddressList(&self, plist: *mut ADDRESSLIST) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeAddressList)(
windows_core::Interface::as_raw(self),
plist as _,
)
.ok()
}
}
pub unsafe fn FreeAddressProps(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeAddressProps)(
windows_core::Interface::as_raw(self),
paddress as _,
)
.ok()
}
}
pub unsafe fn ReleaseObjects(
&self,
cobjects: u32,
prgpunknown: *mut Option<windows_core::IUnknown>,
ffreearray: u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ReleaseObjects)(
windows_core::Interface::as_raw(self),
cobjects,
core::mem::transmute(prgpunknown),
ffreearray,
)
.ok()
}
}
pub unsafe fn FreeEnumHeaderRowArray(
&self,
crows: u32,
prgrow: *mut ENUMHEADERROW,
ffreearray: u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeEnumHeaderRowArray)(
windows_core::Interface::as_raw(self),
crows,
prgrow as _,
ffreearray,
)
.ok()
}
}
pub unsafe fn FreeEnumPropertyArray(
&self,
cprops: u32,
prgprop: *mut ENUMPROPERTY,
ffreearray: u8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeEnumPropertyArray)(
windows_core::Interface::as_raw(self),
cprops,
prgprop as _,
ffreearray,
)
.ok()
}
}
pub unsafe fn FreeThumbprint(
&self,
pthumbprint: *mut windows::Win32::System::Com::BLOB,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeThumbprint)(
windows_core::Interface::as_raw(self),
pthumbprint as _,
)
.ok()
}
}
pub unsafe fn PropVariantClear(
&self,
pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PropVariantClear)(
windows_core::Interface::as_raw(self),
core::mem::transmute(pprop),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeAllocator_Vtbl {
pub base__: windows::Win32::System::Com::IMalloc_Vtbl,
pub FreeParamInfoArray: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut MIMEPARAMINFO,
u8,
) -> windows_core::HRESULT,
pub FreeAddressList: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ADDRESSLIST,
) -> windows_core::HRESULT,
pub FreeAddressProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ADDRESSPROPS,
) -> windows_core::HRESULT,
pub ReleaseObjects: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
u8,
) -> windows_core::HRESULT,
pub FreeEnumHeaderRowArray: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENUMHEADERROW,
u8,
) -> windows_core::HRESULT,
pub FreeEnumPropertyArray: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENUMPROPERTY,
u8,
) -> windows_core::HRESULT,
pub FreeThumbprint: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows::Win32::System::Com::BLOB,
) -> windows_core::HRESULT,
pub PropVariantClear: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
}
pub trait IMimeAllocator_Impl: windows::Win32::System::Com::IMalloc_Impl {
fn FreeParamInfoArray(
&self,
cparams: u32,
prgparam: *mut MIMEPARAMINFO,
ffreearray: u8,
) -> windows_core::Result<()>;
fn FreeAddressList(&self, plist: *mut ADDRESSLIST) -> windows_core::Result<()>;
fn FreeAddressProps(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
fn ReleaseObjects(
&self,
cobjects: u32,
prgpunknown: windows_core::OutRef<'_, windows_core::IUnknown>,
ffreearray: u8,
) -> windows_core::Result<()>;
fn FreeEnumHeaderRowArray(
&self,
crows: u32,
prgrow: *mut ENUMHEADERROW,
ffreearray: u8,
) -> windows_core::Result<()>;
fn FreeEnumPropertyArray(
&self,
cprops: u32,
prgprop: *mut ENUMPROPERTY,
ffreearray: u8,
) -> windows_core::Result<()>;
fn FreeThumbprint(
&self,
pthumbprint: *mut windows::Win32::System::Com::BLOB,
) -> windows_core::Result<()>;
fn PropVariantClear(
&self,
pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
}
impl IMimeAllocator_Vtbl {
pub const fn new<Identity: IMimeAllocator_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn FreeParamInfoArray<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cparams: u32,
prgparam: *mut MIMEPARAMINFO,
ffreearray: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeParamInfoArray(
this,
core::mem::transmute_copy(&cparams),
core::mem::transmute_copy(&prgparam),
core::mem::transmute_copy(&ffreearray),
)
.into()
}
}
unsafe extern "system" fn FreeAddressList<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
plist: *mut ADDRESSLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeAddressList(this, core::mem::transmute_copy(&plist)).into()
}
}
unsafe extern "system" fn FreeAddressProps<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
paddress: *mut ADDRESSPROPS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeAddressProps(this, core::mem::transmute_copy(&paddress))
.into()
}
}
unsafe extern "system" fn ReleaseObjects<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cobjects: u32,
prgpunknown: *mut *mut core::ffi::c_void,
ffreearray: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::ReleaseObjects(
this,
core::mem::transmute_copy(&cobjects),
core::mem::transmute_copy(&prgpunknown),
core::mem::transmute_copy(&ffreearray),
)
.into()
}
}
unsafe extern "system" fn FreeEnumHeaderRowArray<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
crows: u32,
prgrow: *mut ENUMHEADERROW,
ffreearray: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeEnumHeaderRowArray(
this,
core::mem::transmute_copy(&crows),
core::mem::transmute_copy(&prgrow),
core::mem::transmute_copy(&ffreearray),
)
.into()
}
}
unsafe extern "system" fn FreeEnumPropertyArray<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cprops: u32,
prgprop: *mut ENUMPROPERTY,
ffreearray: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeEnumPropertyArray(
this,
core::mem::transmute_copy(&cprops),
core::mem::transmute_copy(&prgprop),
core::mem::transmute_copy(&ffreearray),
)
.into()
}
}
unsafe extern "system" fn FreeThumbprint<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pthumbprint: *mut windows::Win32::System::Com::BLOB,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::FreeThumbprint(this, core::mem::transmute_copy(&pthumbprint))
.into()
}
}
unsafe extern "system" fn PropVariantClear<
Identity: IMimeAllocator_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pprop: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeAllocator_Impl::PropVariantClear(this, core::mem::transmute_copy(&pprop))
.into()
}
}
Self {
base__: windows::Win32::System::Com::IMalloc_Vtbl::new::<Identity, OFFSET>(),
FreeParamInfoArray: FreeParamInfoArray::<Identity, OFFSET>,
FreeAddressList: FreeAddressList::<Identity, OFFSET>,
FreeAddressProps: FreeAddressProps::<Identity, OFFSET>,
ReleaseObjects: ReleaseObjects::<Identity, OFFSET>,
FreeEnumHeaderRowArray: FreeEnumHeaderRowArray::<Identity, OFFSET>,
FreeEnumPropertyArray: FreeEnumPropertyArray::<Identity, OFFSET>,
FreeThumbprint: FreeThumbprint::<Identity, OFFSET>,
PropVariantClear: PropVariantClear::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeAllocator as windows_core::Interface>::IID
|| iid == &<windows::Win32::System::Com::IMalloc as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeAllocator {}
windows_core::imp::define_interface!(
IMimeBody,
IMimeBody_Vtbl,
0xc558834c_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeBody {
type Target = IMimePropertySet;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimeBody,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist,
windows::Win32::System::Com::IPersistStreamInit,
IMimePropertySet
);
impl IMimeBody {
pub unsafe fn IsType(&self, bodytype: IMSGBODYTYPE) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).IsType)(
windows_core::Interface::as_raw(self),
bodytype,
)
.ok()
}
}
pub unsafe fn SetDisplayName<P0>(&self, pszdisplay: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetDisplayName)(
windows_core::Interface::as_raw(self),
pszdisplay.param().abi(),
)
.ok()
}
}
pub unsafe fn GetDisplayName(
&self,
ppszdisplay: *mut windows_core::PSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetDisplayName)(
windows_core::Interface::as_raw(self),
ppszdisplay as _,
)
.ok()
}
}
pub unsafe fn GetOffsets(&self, poffsets: *mut BODYOFFSETS) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetOffsets)(
windows_core::Interface::as_raw(self),
poffsets as _,
)
.ok()
}
}
pub unsafe fn GetCurrentEncoding(
&self,
pietencoding: *mut ENCODINGTYPE,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCurrentEncoding)(
windows_core::Interface::as_raw(self),
pietencoding as _,
)
.ok()
}
}
pub unsafe fn SetCurrentEncoding(&self, ietencoding: ENCODINGTYPE) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetCurrentEncoding)(
windows_core::Interface::as_raw(self),
ietencoding,
)
.ok()
}
}
pub unsafe fn GetEstimatedSize(
&self,
ietencoding: ENCODINGTYPE,
pcbsize: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetEstimatedSize)(
windows_core::Interface::as_raw(self),
ietencoding,
pcbsize as _,
)
.ok()
}
}
pub unsafe fn GetDataHere<P1>(
&self,
ietencoding: ENCODINGTYPE,
pstream: P1,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).GetDataHere)(
windows_core::Interface::as_raw(self),
ietencoding,
pstream.param().abi(),
)
.ok()
}
}
pub unsafe fn GetData(
&self,
ietencoding: ENCODINGTYPE,
) -> windows_core::Result<windows::Win32::System::Com::IStream> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetData)(
windows_core::Interface::as_raw(self),
ietencoding,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn SetData<P1, P2>(
&self,
ietencoding: ENCODINGTYPE,
pszpritype: P1,
pszsubtype: P2,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetData)(
windows_core::Interface::as_raw(self),
ietencoding,
pszpritype.param().abi(),
pszsubtype.param().abi(),
riid,
pvobject as _,
)
.ok()
}
}
pub unsafe fn EmptyData(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EmptyData)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn CopyTo<P0>(&self, pbody: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeBody>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyTo)(
windows_core::Interface::as_raw(self),
pbody.param().abi(),
)
.ok()
}
}
pub unsafe fn GetTransmitInfo(
&self,
ptransmitinfo: *mut TRANSMITINFO,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetTransmitInfo)(
windows_core::Interface::as_raw(self),
ptransmitinfo as _,
)
.ok()
}
}
pub unsafe fn SaveToFile<P1>(
&self,
ietencoding: ENCODINGTYPE,
pszfilepath: P1,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SaveToFile)(
windows_core::Interface::as_raw(self),
ietencoding,
pszfilepath.param().abi(),
)
.ok()
}
}
pub unsafe fn GetHandle(&self, phbody: *mut *mut HBODY__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetHandle)(
windows_core::Interface::as_raw(self),
phbody as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeBody_Vtbl {
pub base__: IMimePropertySet_Vtbl,
pub IsType:
unsafe extern "system" fn(*mut core::ffi::c_void, IMSGBODYTYPE) -> windows_core::HRESULT,
pub SetDisplayName: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub GetDisplayName: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub GetOffsets: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut BODYOFFSETS,
) -> windows_core::HRESULT,
pub GetCurrentEncoding: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ENCODINGTYPE,
) -> windows_core::HRESULT,
pub SetCurrentEncoding:
unsafe extern "system" fn(*mut core::ffi::c_void, ENCODINGTYPE) -> windows_core::HRESULT,
pub GetEstimatedSize: unsafe extern "system" fn(
*mut core::ffi::c_void,
ENCODINGTYPE,
*mut u32,
) -> windows_core::HRESULT,
pub GetDataHere: unsafe extern "system" fn(
*mut core::ffi::c_void,
ENCODINGTYPE,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetData: unsafe extern "system" fn(
*mut core::ffi::c_void,
ENCODINGTYPE,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetData: unsafe extern "system" fn(
*mut core::ffi::c_void,
ENCODINGTYPE,
windows_core::PCSTR,
windows_core::PCSTR,
*const windows_core::GUID,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub EmptyData: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub CopyTo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetTransmitInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut TRANSMITINFO,
) -> windows_core::HRESULT,
pub SaveToFile: unsafe extern "system" fn(
*mut core::ffi::c_void,
ENCODINGTYPE,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub GetHandle: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
}
pub trait IMimeBody_Impl: IMimePropertySet_Impl {
fn IsType(&self, bodytype: IMSGBODYTYPE) -> windows_core::Result<()>;
fn SetDisplayName(&self, pszdisplay: &windows_core::PCSTR) -> windows_core::Result<()>;
fn GetDisplayName(&self, ppszdisplay: *mut windows_core::PSTR) -> windows_core::Result<()>;
fn GetOffsets(&self, poffsets: *mut BODYOFFSETS) -> windows_core::Result<()>;
fn GetCurrentEncoding(&self, pietencoding: *mut ENCODINGTYPE) -> windows_core::Result<()>;
fn SetCurrentEncoding(&self, ietencoding: ENCODINGTYPE) -> windows_core::Result<()>;
fn GetEstimatedSize(
&self,
ietencoding: ENCODINGTYPE,
pcbsize: *mut u32,
) -> windows_core::Result<()>;
fn GetDataHere(
&self,
ietencoding: ENCODINGTYPE,
pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn GetData(
&self,
ietencoding: ENCODINGTYPE,
) -> windows_core::Result<windows::Win32::System::Com::IStream>;
fn SetData(
&self,
ietencoding: ENCODINGTYPE,
pszpritype: &windows_core::PCSTR,
pszsubtype: &windows_core::PCSTR,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn EmptyData(&self) -> windows_core::Result<()>;
fn CopyTo(&self, pbody: windows_core::Ref<'_, IMimeBody>) -> windows_core::Result<()>;
fn GetTransmitInfo(&self, ptransmitinfo: *mut TRANSMITINFO) -> windows_core::Result<()>;
fn SaveToFile(
&self,
ietencoding: ENCODINGTYPE,
pszfilepath: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn GetHandle(&self, phbody: *mut *mut HBODY__) -> windows_core::Result<()>;
}
impl IMimeBody_Vtbl {
pub const fn new<Identity: IMimeBody_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn IsType<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
bodytype: IMSGBODYTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::IsType(this, core::mem::transmute_copy(&bodytype)).into()
}
}
unsafe extern "system" fn SetDisplayName<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszdisplay: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::SetDisplayName(this, core::mem::transmute(&pszdisplay)).into()
}
}
unsafe extern "system" fn GetDisplayName<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppszdisplay: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetDisplayName(this, core::mem::transmute_copy(&ppszdisplay)).into()
}
}
unsafe extern "system" fn GetOffsets<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
poffsets: *mut BODYOFFSETS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetOffsets(this, core::mem::transmute_copy(&poffsets)).into()
}
}
unsafe extern "system" fn GetCurrentEncoding<
Identity: IMimeBody_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pietencoding: *mut ENCODINGTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetCurrentEncoding(this, core::mem::transmute_copy(&pietencoding))
.into()
}
}
unsafe extern "system" fn SetCurrentEncoding<
Identity: IMimeBody_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::SetCurrentEncoding(this, core::mem::transmute_copy(&ietencoding))
.into()
}
}
unsafe extern "system" fn GetEstimatedSize<
Identity: IMimeBody_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
pcbsize: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetEstimatedSize(
this,
core::mem::transmute_copy(&ietencoding),
core::mem::transmute_copy(&pcbsize),
)
.into()
}
}
unsafe extern "system" fn GetDataHere<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
pstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetDataHere(
this,
core::mem::transmute_copy(&ietencoding),
core::mem::transmute_copy(&pstream),
)
.into()
}
}
unsafe extern "system" fn GetData<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
ppstream: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeBody_Impl::GetData(this, core::mem::transmute_copy(&ietencoding)) {
Ok(ok__) => {
ppstream.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn SetData<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
pszpritype: windows_core::PCSTR,
pszsubtype: windows_core::PCSTR,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::SetData(
this,
core::mem::transmute_copy(&ietencoding),
core::mem::transmute(&pszpritype),
core::mem::transmute(&pszsubtype),
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&pvobject),
)
.into()
}
}
unsafe extern "system" fn EmptyData<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::EmptyData(this).into()
}
}
unsafe extern "system" fn CopyTo<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pbody: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::CopyTo(this, core::mem::transmute_copy(&pbody)).into()
}
}
unsafe extern "system" fn GetTransmitInfo<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ptransmitinfo: *mut TRANSMITINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetTransmitInfo(this, core::mem::transmute_copy(&ptransmitinfo))
.into()
}
}
unsafe extern "system" fn SaveToFile<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ietencoding: ENCODINGTYPE,
pszfilepath: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::SaveToFile(
this,
core::mem::transmute_copy(&ietencoding),
core::mem::transmute(&pszfilepath),
)
.into()
}
}
unsafe extern "system" fn GetHandle<Identity: IMimeBody_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeBody_Impl::GetHandle(this, core::mem::transmute_copy(&phbody)).into()
}
}
Self {
base__: IMimePropertySet_Vtbl::new::<Identity, OFFSET>(),
IsType: IsType::<Identity, OFFSET>,
SetDisplayName: SetDisplayName::<Identity, OFFSET>,
GetDisplayName: GetDisplayName::<Identity, OFFSET>,
GetOffsets: GetOffsets::<Identity, OFFSET>,
GetCurrentEncoding: GetCurrentEncoding::<Identity, OFFSET>,
SetCurrentEncoding: SetCurrentEncoding::<Identity, OFFSET>,
GetEstimatedSize: GetEstimatedSize::<Identity, OFFSET>,
GetDataHere: GetDataHere::<Identity, OFFSET>,
GetData: GetData::<Identity, OFFSET>,
SetData: SetData::<Identity, OFFSET>,
EmptyData: EmptyData::<Identity, OFFSET>,
CopyTo: CopyTo::<Identity, OFFSET>,
GetTransmitInfo: GetTransmitInfo::<Identity, OFFSET>,
SaveToFile: SaveToFile::<Identity, OFFSET>,
GetHandle: GetHandle::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == & < IMimeBody as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID || iid == & < IMimePropertySet as windows_core::Interface >::IID
}
}
impl windows_core::RuntimeName for IMimeBody {}
windows_core::imp::define_interface!(
IMimeEditTag,
IMimeEditTag_Vtbl,
0x70183210_7b36_11d2_8c12_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IMimeEditTag, windows_core::IUnknown);
impl IMimeEditTag {
pub unsafe fn GetSrc(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSrc)(
windows_core::Interface::as_raw(self),
core::mem::transmute(pbstr),
)
.ok()
}
}
pub unsafe fn SetSrc(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetSrc)(
windows_core::Interface::as_raw(self),
core::mem::transmute_copy(bstr),
)
.ok()
}
}
pub unsafe fn GetDest(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetDest)(
windows_core::Interface::as_raw(self),
core::mem::transmute(pbstr),
)
.ok()
}
}
pub unsafe fn SetDest(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetDest)(
windows_core::Interface::as_raw(self),
core::mem::transmute_copy(bstr),
)
.ok()
}
}
pub unsafe fn OnPreSave(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnPreSave)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn OnPostSave(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OnPostSave)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn CanPackage(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CanPackage)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn IsValidMimeType<P0>(&self, psztypew: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCWSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).IsValidMimeType)(
windows_core::Interface::as_raw(self),
psztypew.param().abi(),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEditTag_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetSrc: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetSrc: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetDest: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetDest: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub OnPreSave: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub OnPostSave: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub CanPackage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub IsValidMimeType: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCWSTR,
) -> windows_core::HRESULT,
}
pub trait IMimeEditTag_Impl: windows_core::IUnknownImpl {
fn GetSrc(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()>;
fn SetSrc(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()>;
fn GetDest(&self, pbstr: *mut windows_core::BSTR) -> windows_core::Result<()>;
fn SetDest(&self, bstr: &windows_core::BSTR) -> windows_core::Result<()>;
fn OnPreSave(&self) -> windows_core::Result<()>;
fn OnPostSave(&self) -> windows_core::Result<()>;
fn CanPackage(&self) -> windows_core::Result<()>;
fn IsValidMimeType(&self, psztypew: &windows_core::PCWSTR) -> windows_core::Result<()>;
}
impl IMimeEditTag_Vtbl {
pub const fn new<Identity: IMimeEditTag_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetSrc<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pbstr: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::GetSrc(this, core::mem::transmute_copy(&pbstr)).into()
}
}
unsafe extern "system" fn SetSrc<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
bstr: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::SetSrc(this, core::mem::transmute(&bstr)).into()
}
}
unsafe extern "system" fn GetDest<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pbstr: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::GetDest(this, core::mem::transmute_copy(&pbstr)).into()
}
}
unsafe extern "system" fn SetDest<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
bstr: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::SetDest(this, core::mem::transmute(&bstr)).into()
}
}
unsafe extern "system" fn OnPreSave<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::OnPreSave(this).into()
}
}
unsafe extern "system" fn OnPostSave<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::OnPostSave(this).into()
}
}
unsafe extern "system" fn CanPackage<Identity: IMimeEditTag_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::CanPackage(this).into()
}
}
unsafe extern "system" fn IsValidMimeType<
Identity: IMimeEditTag_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
psztypew: windows_core::PCWSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTag_Impl::IsValidMimeType(this, core::mem::transmute(&psztypew)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetSrc: GetSrc::<Identity, OFFSET>,
SetSrc: SetSrc::<Identity, OFFSET>,
GetDest: GetDest::<Identity, OFFSET>,
SetDest: SetDest::<Identity, OFFSET>,
OnPreSave: OnPreSave::<Identity, OFFSET>,
OnPostSave: OnPostSave::<Identity, OFFSET>,
CanPackage: CanPackage::<Identity, OFFSET>,
IsValidMimeType: IsValidMimeType::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEditTag as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEditTag {}
windows_core::imp::define_interface!(
IMimeEditTagCollection,
IMimeEditTagCollection_Vtbl,
0xd09ee528_7b38_11d2_8c12_00c04fa31009
);
windows_core::imp::interface_hierarchy!(IMimeEditTagCollection, windows_core::IUnknown);
impl IMimeEditTagCollection {
pub unsafe fn Init<P0>(&self, phtmldoc: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::IUnknown>,
{
unsafe {
(windows_core::Interface::vtable(self).Init)(
windows_core::Interface::as_raw(self),
phtmldoc.param().abi(),
)
.ok()
}
}
pub unsafe fn Next(
&self,
cfetch: u32,
pptag: *mut Option<IMimeEditTag>,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
core::mem::transmute(pptag),
pcfetched as _,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Count)(
windows_core::Interface::as_raw(self),
pcitems as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEditTagCollection_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Init: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEditTagCollection_Impl: windows_core::IUnknownImpl {
fn Init(
&self,
phtmldoc: windows_core::Ref<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn Next(
&self,
cfetch: u32,
pptag: windows_core::OutRef<'_, IMimeEditTag>,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEditTagCollection_Vtbl {
pub const fn new<Identity: IMimeEditTagCollection_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Init<
Identity: IMimeEditTagCollection_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
phtmldoc: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTagCollection_Impl::Init(this, core::mem::transmute_copy(&phtmldoc)).into()
}
}
unsafe extern "system" fn Next<
Identity: IMimeEditTagCollection_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfetch: u32,
pptag: *mut *mut core::ffi::c_void,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTagCollection_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&pptag),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
unsafe extern "system" fn Reset<
Identity: IMimeEditTagCollection_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTagCollection_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Count<
Identity: IMimeEditTagCollection_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcitems: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEditTagCollection_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Init: Init::<Identity, OFFSET>,
Next: Next::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Count: Count::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEditTagCollection as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEditTagCollection {}
windows_core::imp::define_interface!(
IMimeEnumAddressTypes,
IMimeEnumAddressTypes_Vtbl,
0xc5588354_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumAddressTypes, windows_core::IUnknown);
impl IMimeEnumAddressTypes {
pub unsafe fn Next(
&self,
cfetch: u32,
prgadr: *mut ADDRESSPROPS,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
prgadr as _,
pcfetched as _,
)
.ok()
}
}
pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Skip)(
windows_core::Interface::as_raw(self),
citems,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumAddressTypes> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Count)(
windows_core::Interface::as_raw(self),
pcitems as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEnumAddressTypes_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ADDRESSPROPS,
*mut u32,
) -> windows_core::HRESULT,
pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumAddressTypes_Impl: windows_core::IUnknownImpl {
fn Next(
&self,
cfetch: u32,
prgadr: *mut ADDRESSPROPS,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
fn Skip(&self, citems: u32) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimeEnumAddressTypes>;
fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumAddressTypes_Vtbl {
pub const fn new<Identity: IMimeEnumAddressTypes_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Next<
Identity: IMimeEnumAddressTypes_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfetch: u32,
prgadr: *mut ADDRESSPROPS,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumAddressTypes_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&prgadr),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
unsafe extern "system" fn Skip<
Identity: IMimeEnumAddressTypes_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
citems: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumAddressTypes_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
}
}
unsafe extern "system" fn Reset<
Identity: IMimeEnumAddressTypes_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumAddressTypes_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Clone<
Identity: IMimeEnumAddressTypes_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeEnumAddressTypes_Impl::Clone(this) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Count<
Identity: IMimeEnumAddressTypes_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcitems: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumAddressTypes_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Next: Next::<Identity, OFFSET>,
Skip: Skip::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
Count: Count::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEnumAddressTypes as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEnumAddressTypes {}
windows_core::imp::define_interface!(
IMimeEnumHeaderRows,
IMimeEnumHeaderRows_Vtbl,
0xc558834d_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumHeaderRows, windows_core::IUnknown);
impl IMimeEnumHeaderRows {
pub unsafe fn Next(
&self,
cfetch: u32,
prgrow: *mut ENUMHEADERROW,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
prgrow as _,
pcfetched as _,
)
.ok()
}
}
pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Skip)(
windows_core::Interface::as_raw(self),
citems,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumHeaderRows> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Count)(
windows_core::Interface::as_raw(self),
pcitems as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEnumHeaderRows_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENUMHEADERROW,
*mut u32,
) -> windows_core::HRESULT,
pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumHeaderRows_Impl: windows_core::IUnknownImpl {
fn Next(
&self,
cfetch: u32,
prgrow: *mut ENUMHEADERROW,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
fn Skip(&self, citems: u32) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimeEnumHeaderRows>;
fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumHeaderRows_Vtbl {
pub const fn new<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Next<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cfetch: u32,
prgrow: *mut ENUMHEADERROW,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumHeaderRows_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&prgrow),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
unsafe extern "system" fn Skip<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
citems: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumHeaderRows_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
}
}
unsafe extern "system" fn Reset<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumHeaderRows_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Clone<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeEnumHeaderRows_Impl::Clone(this) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Count<Identity: IMimeEnumHeaderRows_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pcitems: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumHeaderRows_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Next: Next::<Identity, OFFSET>,
Skip: Skip::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
Count: Count::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEnumHeaderRows as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEnumHeaderRows {}
windows_core::imp::define_interface!(
IMimeEnumMessageParts,
IMimeEnumMessageParts_Vtbl,
0xc5588350_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumMessageParts, windows_core::IUnknown);
impl IMimeEnumMessageParts {
pub unsafe fn Next(
&self,
cfetch: u32,
prgpmessage: *mut Option<IMimeMessage>,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
core::mem::transmute(prgpmessage),
pcfetched as _,
)
.ok()
}
}
pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Skip)(
windows_core::Interface::as_raw(self),
citems,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumMessageParts> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Count)(
windows_core::Interface::as_raw(self),
pcitems as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEnumMessageParts_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumMessageParts_Impl: windows_core::IUnknownImpl {
fn Next(
&self,
cfetch: u32,
prgpmessage: windows_core::OutRef<'_, IMimeMessage>,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
fn Skip(&self, citems: u32) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimeEnumMessageParts>;
fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumMessageParts_Vtbl {
pub const fn new<Identity: IMimeEnumMessageParts_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Next<
Identity: IMimeEnumMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cfetch: u32,
prgpmessage: *mut *mut core::ffi::c_void,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumMessageParts_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&prgpmessage),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
unsafe extern "system" fn Skip<
Identity: IMimeEnumMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
citems: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumMessageParts_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
}
}
unsafe extern "system" fn Reset<
Identity: IMimeEnumMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumMessageParts_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Clone<
Identity: IMimeEnumMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeEnumMessageParts_Impl::Clone(this) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Count<
Identity: IMimeEnumMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcitems: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumMessageParts_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Next: Next::<Identity, OFFSET>,
Skip: Skip::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
Count: Count::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEnumMessageParts as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEnumMessageParts {}
windows_core::imp::define_interface!(
IMimeEnumProperties,
IMimeEnumProperties_Vtbl,
0xfd853cee_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeEnumProperties, windows_core::IUnknown);
impl IMimeEnumProperties {
pub unsafe fn Next(
&self,
cfetch: u32,
prgprop: *mut ENUMPROPERTY,
pcfetched: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Next)(
windows_core::Interface::as_raw(self),
cfetch,
prgprop as _,
pcfetched as _,
)
.ok()
}
}
pub unsafe fn Skip(&self, citems: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Skip)(
windows_core::Interface::as_raw(self),
citems,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeEnumProperties> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Count)(
windows_core::Interface::as_raw(self),
pcitems as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeEnumProperties_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Next: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENUMPROPERTY,
*mut u32,
) -> windows_core::HRESULT,
pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Count: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
}
pub trait IMimeEnumProperties_Impl: windows_core::IUnknownImpl {
fn Next(
&self,
cfetch: u32,
prgprop: *mut ENUMPROPERTY,
pcfetched: *mut u32,
) -> windows_core::Result<()>;
fn Skip(&self, citems: u32) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimeEnumProperties>;
fn Count(&self, pcitems: *mut u32) -> windows_core::Result<()>;
}
impl IMimeEnumProperties_Vtbl {
pub const fn new<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Next<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cfetch: u32,
prgprop: *mut ENUMPROPERTY,
pcfetched: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumProperties_Impl::Next(
this,
core::mem::transmute_copy(&cfetch),
core::mem::transmute_copy(&prgprop),
core::mem::transmute_copy(&pcfetched),
)
.into()
}
}
unsafe extern "system" fn Skip<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
citems: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumProperties_Impl::Skip(this, core::mem::transmute_copy(&citems)).into()
}
}
unsafe extern "system" fn Reset<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumProperties_Impl::Reset(this).into()
}
}
unsafe extern "system" fn Clone<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeEnumProperties_Impl::Clone(this) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Count<Identity: IMimeEnumProperties_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pcitems: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeEnumProperties_Impl::Count(this, core::mem::transmute_copy(&pcitems)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Next: Next::<Identity, OFFSET>,
Skip: Skip::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
Count: Count::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeEnumProperties as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeEnumProperties {}
windows_core::imp::define_interface!(
IMimeHeaderTable,
IMimeHeaderTable_Vtbl,
0xfd853cd1_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeHeaderTable {
type Target = windows::Win32::System::Com::IPersistStream;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimeHeaderTable,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist,
windows::Win32::System::Com::IPersistStream
);
impl IMimeHeaderTable {
pub unsafe fn Load<P0>(&self, pstm: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Load)(
windows_core::Interface::as_raw(self),
pstm.param().abi(),
)
.ok()
}
}
pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Save)(
windows_core::Interface::as_raw(self),
pstm.param().abi(),
fcleardirty.into(),
)
.ok()
}
}
pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetSizeMax)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.map(|| result__)
}
}
pub unsafe fn FindFirstRow(
&self,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindFirstRow)(
windows_core::Interface::as_raw(self),
pfindheader as _,
phrow as _,
)
.ok()
}
}
pub unsafe fn FindNextRow(
&self,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindNextRow)(
windows_core::Interface::as_raw(self),
pfindheader as _,
phrow as _,
)
.ok()
}
}
pub unsafe fn CountRows<P0>(&self, pszheader: P0, pcrows: *mut u32) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).CountRows)(
windows_core::Interface::as_raw(self),
pszheader.param().abi(),
pcrows as _,
)
.ok()
}
}
pub unsafe fn AppendRow<P0, P2>(
&self,
pszheader: P0,
dwflags: u32,
pszdata: P2,
cchdata: u32,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).AppendRow)(
windows_core::Interface::as_raw(self),
pszheader.param().abi(),
dwflags,
pszdata.param().abi(),
cchdata,
phrow as _,
)
.ok()
}
}
pub unsafe fn DeleteRow(&self, hrow: *mut HHEADERROW__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteRow)(
windows_core::Interface::as_raw(self),
hrow as _,
)
.ok()
}
}
pub unsafe fn GetRowData(
&self,
hrow: *mut HHEADERROW__,
dwflags: u32,
ppszdata: *mut windows_core::PSTR,
pcchdata: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRowData)(
windows_core::Interface::as_raw(self),
hrow as _,
dwflags,
ppszdata as _,
pcchdata as _,
)
.ok()
}
}
pub unsafe fn SetRowData<P2>(
&self,
hrow: *mut HHEADERROW__,
dwflags: u32,
pszdata: P2,
cchdata: u32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetRowData)(
windows_core::Interface::as_raw(self),
hrow as _,
dwflags,
pszdata.param().abi(),
cchdata,
)
.ok()
}
}
pub unsafe fn GetRowInfo(
&self,
hrow: *mut HHEADERROW__,
pinfo: *mut HEADERROWINFO,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetRowInfo)(
windows_core::Interface::as_raw(self),
hrow as _,
pinfo as _,
)
.ok()
}
}
pub unsafe fn SetRowNumber(
&self,
hrow: *mut HHEADERROW__,
dwrownumber: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetRowNumber)(
windows_core::Interface::as_raw(self),
hrow as _,
dwrownumber,
)
.ok()
}
}
pub unsafe fn EnumRows<P0>(
&self,
pszheader: P0,
dwflags: u32,
) -> windows_core::Result<IMimeEnumHeaderRows>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumRows)(
windows_core::Interface::as_raw(self),
pszheader.param().abi(),
dwflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimeHeaderTable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).BindToObject)(
windows_core::Interface::as_raw(self),
riid,
ppvobject as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeHeaderTable_Vtbl {
pub base__: windows::Win32::System::Com::IPersistStream_Vtbl,
pub Load: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Save: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT,
pub GetSizeMax:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
pub FindFirstRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut FINDHEADER,
*mut *mut HHEADERROW__,
) -> windows_core::HRESULT,
pub FindNextRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut FINDHEADER,
*mut *mut HHEADERROW__,
) -> windows_core::HRESULT,
pub CountRows: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
) -> windows_core::HRESULT,
pub AppendRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
windows_core::PCSTR,
u32,
*mut *mut HHEADERROW__,
) -> windows_core::HRESULT,
pub DeleteRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HHEADERROW__,
) -> windows_core::HRESULT,
pub GetRowData: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HHEADERROW__,
u32,
*mut windows_core::PSTR,
*mut u32,
) -> windows_core::HRESULT,
pub SetRowData: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HHEADERROW__,
u32,
windows_core::PCSTR,
u32,
) -> windows_core::HRESULT,
pub GetRowInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HHEADERROW__,
*mut HEADERROWINFO,
) -> windows_core::HRESULT,
pub SetRowNumber: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HHEADERROW__,
u32,
) -> windows_core::HRESULT,
pub EnumRows: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub BindToObject: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeHeaderTable_Impl: windows::Win32::System::Com::IPersistStream_Impl {
fn Load(
&self,
pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn Save(
&self,
pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()>;
fn GetSizeMax(&self) -> windows_core::Result<u64>;
fn FindFirstRow(
&self,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()>;
fn FindNextRow(
&self,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()>;
fn CountRows(
&self,
pszheader: &windows_core::PCSTR,
pcrows: *mut u32,
) -> windows_core::Result<()>;
fn AppendRow(
&self,
pszheader: &windows_core::PCSTR,
dwflags: u32,
pszdata: &windows_core::PCSTR,
cchdata: u32,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::Result<()>;
fn DeleteRow(&self, hrow: *mut HHEADERROW__) -> windows_core::Result<()>;
fn GetRowData(
&self,
hrow: *mut HHEADERROW__,
dwflags: u32,
ppszdata: *mut windows_core::PSTR,
pcchdata: *mut u32,
) -> windows_core::Result<()>;
fn SetRowData(
&self,
hrow: *mut HHEADERROW__,
dwflags: u32,
pszdata: &windows_core::PCSTR,
cchdata: u32,
) -> windows_core::Result<()>;
fn GetRowInfo(
&self,
hrow: *mut HHEADERROW__,
pinfo: *mut HEADERROWINFO,
) -> windows_core::Result<()>;
fn SetRowNumber(&self, hrow: *mut HHEADERROW__, dwrownumber: u32) -> windows_core::Result<()>;
fn EnumRows(
&self,
pszheader: &windows_core::PCSTR,
dwflags: u32,
) -> windows_core::Result<IMimeEnumHeaderRows>;
fn Clone(&self) -> windows_core::Result<IMimeHeaderTable>;
fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
}
impl IMimeHeaderTable_Vtbl {
pub const fn new<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Load<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pstm: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::Load(this, core::mem::transmute_copy(&pstm)).into()
}
}
unsafe extern "system" fn Save<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pstm: *mut core::ffi::c_void,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::Save(
this,
core::mem::transmute_copy(&pstm),
core::mem::transmute_copy(&fcleardirty),
)
.into()
}
}
unsafe extern "system" fn GetSizeMax<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcbsize: *mut u64,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeHeaderTable_Impl::GetSizeMax(this) {
Ok(ok__) => {
pcbsize.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn FindFirstRow<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::FindFirstRow(
this,
core::mem::transmute_copy(&pfindheader),
core::mem::transmute_copy(&phrow),
)
.into()
}
}
unsafe extern "system" fn FindNextRow<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfindheader: *mut FINDHEADER,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::FindNextRow(
this,
core::mem::transmute_copy(&pfindheader),
core::mem::transmute_copy(&phrow),
)
.into()
}
}
unsafe extern "system" fn CountRows<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszheader: windows_core::PCSTR,
pcrows: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::CountRows(
this,
core::mem::transmute(&pszheader),
core::mem::transmute_copy(&pcrows),
)
.into()
}
}
unsafe extern "system" fn AppendRow<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszheader: windows_core::PCSTR,
dwflags: u32,
pszdata: windows_core::PCSTR,
cchdata: u32,
phrow: *mut *mut HHEADERROW__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::AppendRow(
this,
core::mem::transmute(&pszheader),
core::mem::transmute_copy(&dwflags),
core::mem::transmute(&pszdata),
core::mem::transmute_copy(&cchdata),
core::mem::transmute_copy(&phrow),
)
.into()
}
}
unsafe extern "system" fn DeleteRow<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrow: *mut HHEADERROW__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::DeleteRow(this, core::mem::transmute_copy(&hrow)).into()
}
}
unsafe extern "system" fn GetRowData<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrow: *mut HHEADERROW__,
dwflags: u32,
ppszdata: *mut windows_core::PSTR,
pcchdata: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::GetRowData(
this,
core::mem::transmute_copy(&hrow),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&ppszdata),
core::mem::transmute_copy(&pcchdata),
)
.into()
}
}
unsafe extern "system" fn SetRowData<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrow: *mut HHEADERROW__,
dwflags: u32,
pszdata: windows_core::PCSTR,
cchdata: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::SetRowData(
this,
core::mem::transmute_copy(&hrow),
core::mem::transmute_copy(&dwflags),
core::mem::transmute(&pszdata),
core::mem::transmute_copy(&cchdata),
)
.into()
}
}
unsafe extern "system" fn GetRowInfo<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrow: *mut HHEADERROW__,
pinfo: *mut HEADERROWINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::GetRowInfo(
this,
core::mem::transmute_copy(&hrow),
core::mem::transmute_copy(&pinfo),
)
.into()
}
}
unsafe extern "system" fn SetRowNumber<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrow: *mut HHEADERROW__,
dwrownumber: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::SetRowNumber(
this,
core::mem::transmute_copy(&hrow),
core::mem::transmute_copy(&dwrownumber),
)
.into()
}
}
unsafe extern "system" fn EnumRows<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszheader: windows_core::PCSTR,
dwflags: u32,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeHeaderTable_Impl::EnumRows(
this,
core::mem::transmute(&pszheader),
core::mem::transmute_copy(&dwflags),
) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Clone<Identity: IMimeHeaderTable_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeHeaderTable_Impl::Clone(this) {
Ok(ok__) => {
pptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn BindToObject<
Identity: IMimeHeaderTable_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeHeaderTable_Impl::BindToObject(
this,
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
Self {
base__: windows::Win32::System::Com::IPersistStream_Vtbl::new::<Identity, OFFSET>(),
Load: Load::<Identity, OFFSET>,
Save: Save::<Identity, OFFSET>,
GetSizeMax: GetSizeMax::<Identity, OFFSET>,
FindFirstRow: FindFirstRow::<Identity, OFFSET>,
FindNextRow: FindNextRow::<Identity, OFFSET>,
CountRows: CountRows::<Identity, OFFSET>,
AppendRow: AppendRow::<Identity, OFFSET>,
DeleteRow: DeleteRow::<Identity, OFFSET>,
GetRowData: GetRowData::<Identity, OFFSET>,
SetRowData: SetRowData::<Identity, OFFSET>,
GetRowInfo: GetRowInfo::<Identity, OFFSET>,
SetRowNumber: SetRowNumber::<Identity, OFFSET>,
EnumRows: EnumRows::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
BindToObject: BindToObject::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeHeaderTable as windows_core::Interface>::IID
|| iid == &<windows::Win32::System::Com::IPersist as windows_core::Interface>::IID
|| iid == &<windows::Win32::System::Com::IPersistStream as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeHeaderTable {}
windows_core::imp::define_interface!(
IMimeInternational,
IMimeInternational_Vtbl,
0xc5588349_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeInternational, windows_core::IUnknown);
impl IMimeInternational {
pub unsafe fn SetDefaultCharset(&self, hcharset: *mut HCHARSET__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetDefaultCharset)(
windows_core::Interface::as_raw(self),
hcharset as _,
)
.ok()
}
}
pub unsafe fn GetDefaultCharset(
&self,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetDefaultCharset)(
windows_core::Interface::as_raw(self),
phcharset as _,
)
.ok()
}
}
pub unsafe fn GetCodePageCharset(
&self,
cpicodepage: u32,
ctcsettype: CHARSETTYPE,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCodePageCharset)(
windows_core::Interface::as_raw(self),
cpicodepage,
ctcsettype,
phcharset as _,
)
.ok()
}
}
pub unsafe fn FindCharset<P0>(
&self,
pszcharset: P0,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).FindCharset)(
windows_core::Interface::as_raw(self),
pszcharset.param().abi(),
phcharset as _,
)
.ok()
}
}
pub unsafe fn GetCharsetInfo(
&self,
hcharset: *mut HCHARSET__,
pcsetinfo: *mut INETCSETINFO,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCharsetInfo)(
windows_core::Interface::as_raw(self),
hcharset as _,
pcsetinfo as _,
)
.ok()
}
}
pub unsafe fn GetCodePageInfo(
&self,
cpicodepage: u32,
pcodepageinfo: *mut CODEPAGEINFO,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCodePageInfo)(
windows_core::Interface::as_raw(self),
cpicodepage,
pcodepageinfo as _,
)
.ok()
}
}
pub unsafe fn CanConvertCodePages(
&self,
cpisource: u32,
cpidest: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CanConvertCodePages)(
windows_core::Interface::as_raw(self),
cpisource,
cpidest,
)
.ok()
}
}
pub unsafe fn DecodeHeader<P1>(
&self,
hcharset: *mut HCHARSET__,
pszdata: P1,
pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).DecodeHeader)(
windows_core::Interface::as_raw(self),
hcharset as _,
pszdata.param().abi(),
core::mem::transmute(pdecoded),
prfc1522info as _,
)
.ok()
}
}
pub unsafe fn EncodeHeader(
&self,
hcharset: *mut HCHARSET__,
pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
ppszencoded: *mut windows_core::PSTR,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EncodeHeader)(
windows_core::Interface::as_raw(self),
hcharset as _,
core::mem::transmute(pdata),
ppszencoded as _,
prfc1522info as _,
)
.ok()
}
}
pub unsafe fn ConvertBuffer(
&self,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::BLOB,
pout: *mut windows::Win32::System::Com::BLOB,
pcbread: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ConvertBuffer)(
windows_core::Interface::as_raw(self),
cpisource,
cpidest,
pin as _,
pout as _,
pcbread as _,
)
.ok()
}
}
pub unsafe fn ConvertString(
&self,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ConvertString)(
windows_core::Interface::as_raw(self),
cpisource,
cpidest,
core::mem::transmute(pin),
core::mem::transmute(pout),
)
.ok()
}
}
pub unsafe fn MLANG_ConvertInetReset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MLANG_ConvertInetReset)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn MLANG_ConvertInetString<P2, P4>(
&self,
cpisource: u32,
cpidest: u32,
psource: P2,
pnsizeofsource: *mut i32,
pdestination: P4,
pndstsize: *mut i32,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCSTR>,
P4: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).MLANG_ConvertInetString)(
windows_core::Interface::as_raw(self),
cpisource,
cpidest,
psource.param().abi(),
pnsizeofsource as _,
pdestination.param().abi(),
pndstsize as _,
)
.ok()
}
}
pub unsafe fn Rfc1522Decode<P0, P1>(
&self,
pszvalue: P0,
pszcharset: P1,
cchmax: u32,
ppszdecoded: *mut windows_core::PSTR,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Rfc1522Decode)(
windows_core::Interface::as_raw(self),
pszvalue.param().abi(),
pszcharset.param().abi(),
cchmax,
ppszdecoded as _,
)
.ok()
}
}
pub unsafe fn Rfc1522Encode<P0>(
&self,
pszvalue: P0,
hcharset: *mut HCHARSET__,
ppszencoded: *mut windows_core::PSTR,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).Rfc1522Encode)(
windows_core::Interface::as_raw(self),
pszvalue.param().abi(),
hcharset as _,
ppszencoded as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeInternational_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub SetDefaultCharset:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut HCHARSET__) -> windows_core::HRESULT,
pub GetDefaultCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut HCHARSET__,
) -> windows_core::HRESULT,
pub GetCodePageCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
CHARSETTYPE,
*mut *mut HCHARSET__,
) -> windows_core::HRESULT,
pub FindCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut *mut HCHARSET__,
) -> windows_core::HRESULT,
pub GetCharsetInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HCHARSET__,
*mut INETCSETINFO,
) -> windows_core::HRESULT,
pub GetCodePageInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut CODEPAGEINFO,
) -> windows_core::HRESULT,
pub CanConvertCodePages:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
pub DecodeHeader: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HCHARSET__,
windows_core::PCSTR,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
*mut RFC1522INFO,
) -> windows_core::HRESULT,
pub EncodeHeader: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HCHARSET__,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
*mut windows_core::PSTR,
*mut RFC1522INFO,
) -> windows_core::HRESULT,
pub ConvertBuffer: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut windows::Win32::System::Com::BLOB,
*mut windows::Win32::System::Com::BLOB,
*mut u32,
) -> windows_core::HRESULT,
pub ConvertString: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub MLANG_ConvertInetReset:
unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub MLANG_ConvertInetString: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
windows_core::PCSTR,
*mut i32,
windows_core::PCSTR,
*mut i32,
) -> windows_core::HRESULT,
pub Rfc1522Decode: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub Rfc1522Encode: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut HCHARSET__,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
}
pub trait IMimeInternational_Impl: windows_core::IUnknownImpl {
fn SetDefaultCharset(&self, hcharset: *mut HCHARSET__) -> windows_core::Result<()>;
fn GetDefaultCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
fn GetCodePageCharset(
&self,
cpicodepage: u32,
ctcsettype: CHARSETTYPE,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::Result<()>;
fn FindCharset(
&self,
pszcharset: &windows_core::PCSTR,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::Result<()>;
fn GetCharsetInfo(
&self,
hcharset: *mut HCHARSET__,
pcsetinfo: *mut INETCSETINFO,
) -> windows_core::Result<()>;
fn GetCodePageInfo(
&self,
cpicodepage: u32,
pcodepageinfo: *mut CODEPAGEINFO,
) -> windows_core::Result<()>;
fn CanConvertCodePages(&self, cpisource: u32, cpidest: u32) -> windows_core::Result<()>;
fn DecodeHeader(
&self,
hcharset: *mut HCHARSET__,
pszdata: &windows_core::PCSTR,
pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::Result<()>;
fn EncodeHeader(
&self,
hcharset: *mut HCHARSET__,
pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
ppszencoded: *mut windows_core::PSTR,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::Result<()>;
fn ConvertBuffer(
&self,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::BLOB,
pout: *mut windows::Win32::System::Com::BLOB,
pcbread: *mut u32,
) -> windows_core::Result<()>;
fn ConvertString(
&self,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn MLANG_ConvertInetReset(&self) -> windows_core::Result<()>;
fn MLANG_ConvertInetString(
&self,
cpisource: u32,
cpidest: u32,
psource: &windows_core::PCSTR,
pnsizeofsource: *mut i32,
pdestination: &windows_core::PCSTR,
pndstsize: *mut i32,
) -> windows_core::Result<()>;
fn Rfc1522Decode(
&self,
pszvalue: &windows_core::PCSTR,
pszcharset: &windows_core::PCSTR,
cchmax: u32,
ppszdecoded: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
fn Rfc1522Encode(
&self,
pszvalue: &windows_core::PCSTR,
hcharset: *mut HCHARSET__,
ppszencoded: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
}
impl IMimeInternational_Vtbl {
pub const fn new<Identity: IMimeInternational_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn SetDefaultCharset<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::SetDefaultCharset(
this,
core::mem::transmute_copy(&hcharset),
)
.into()
}
}
unsafe extern "system" fn GetDefaultCharset<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::GetDefaultCharset(
this,
core::mem::transmute_copy(&phcharset),
)
.into()
}
}
unsafe extern "system" fn GetCodePageCharset<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpicodepage: u32,
ctcsettype: CHARSETTYPE,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::GetCodePageCharset(
this,
core::mem::transmute_copy(&cpicodepage),
core::mem::transmute_copy(&ctcsettype),
core::mem::transmute_copy(&phcharset),
)
.into()
}
}
unsafe extern "system" fn FindCharset<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszcharset: windows_core::PCSTR,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::FindCharset(
this,
core::mem::transmute(&pszcharset),
core::mem::transmute_copy(&phcharset),
)
.into()
}
}
unsafe extern "system" fn GetCharsetInfo<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
pcsetinfo: *mut INETCSETINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::GetCharsetInfo(
this,
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&pcsetinfo),
)
.into()
}
}
unsafe extern "system" fn GetCodePageInfo<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpicodepage: u32,
pcodepageinfo: *mut CODEPAGEINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::GetCodePageInfo(
this,
core::mem::transmute_copy(&cpicodepage),
core::mem::transmute_copy(&pcodepageinfo),
)
.into()
}
}
unsafe extern "system" fn CanConvertCodePages<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpisource: u32,
cpidest: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::CanConvertCodePages(
this,
core::mem::transmute_copy(&cpisource),
core::mem::transmute_copy(&cpidest),
)
.into()
}
}
unsafe extern "system" fn DecodeHeader<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
pszdata: windows_core::PCSTR,
pdecoded: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::DecodeHeader(
this,
core::mem::transmute_copy(&hcharset),
core::mem::transmute(&pszdata),
core::mem::transmute_copy(&pdecoded),
core::mem::transmute_copy(&prfc1522info),
)
.into()
}
}
unsafe extern "system" fn EncodeHeader<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
pdata: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
ppszencoded: *mut windows_core::PSTR,
prfc1522info: *mut RFC1522INFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::EncodeHeader(
this,
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&pdata),
core::mem::transmute_copy(&ppszencoded),
core::mem::transmute_copy(&prfc1522info),
)
.into()
}
}
unsafe extern "system" fn ConvertBuffer<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::BLOB,
pout: *mut windows::Win32::System::Com::BLOB,
pcbread: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::ConvertBuffer(
this,
core::mem::transmute_copy(&cpisource),
core::mem::transmute_copy(&cpidest),
core::mem::transmute_copy(&pin),
core::mem::transmute_copy(&pout),
core::mem::transmute_copy(&pcbread),
)
.into()
}
}
unsafe extern "system" fn ConvertString<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpisource: u32,
cpidest: u32,
pin: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
pout: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::ConvertString(
this,
core::mem::transmute_copy(&cpisource),
core::mem::transmute_copy(&cpidest),
core::mem::transmute_copy(&pin),
core::mem::transmute_copy(&pout),
)
.into()
}
}
unsafe extern "system" fn MLANG_ConvertInetReset<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::MLANG_ConvertInetReset(this).into()
}
}
unsafe extern "system" fn MLANG_ConvertInetString<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cpisource: u32,
cpidest: u32,
psource: windows_core::PCSTR,
pnsizeofsource: *mut i32,
pdestination: windows_core::PCSTR,
pndstsize: *mut i32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::MLANG_ConvertInetString(
this,
core::mem::transmute_copy(&cpisource),
core::mem::transmute_copy(&cpidest),
core::mem::transmute(&psource),
core::mem::transmute_copy(&pnsizeofsource),
core::mem::transmute(&pdestination),
core::mem::transmute_copy(&pndstsize),
)
.into()
}
}
unsafe extern "system" fn Rfc1522Decode<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszvalue: windows_core::PCSTR,
pszcharset: windows_core::PCSTR,
cchmax: u32,
ppszdecoded: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::Rfc1522Decode(
this,
core::mem::transmute(&pszvalue),
core::mem::transmute(&pszcharset),
core::mem::transmute_copy(&cchmax),
core::mem::transmute_copy(&ppszdecoded),
)
.into()
}
}
unsafe extern "system" fn Rfc1522Encode<
Identity: IMimeInternational_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszvalue: windows_core::PCSTR,
hcharset: *mut HCHARSET__,
ppszencoded: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeInternational_Impl::Rfc1522Encode(
this,
core::mem::transmute(&pszvalue),
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&ppszencoded),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
SetDefaultCharset: SetDefaultCharset::<Identity, OFFSET>,
GetDefaultCharset: GetDefaultCharset::<Identity, OFFSET>,
GetCodePageCharset: GetCodePageCharset::<Identity, OFFSET>,
FindCharset: FindCharset::<Identity, OFFSET>,
GetCharsetInfo: GetCharsetInfo::<Identity, OFFSET>,
GetCodePageInfo: GetCodePageInfo::<Identity, OFFSET>,
CanConvertCodePages: CanConvertCodePages::<Identity, OFFSET>,
DecodeHeader: DecodeHeader::<Identity, OFFSET>,
EncodeHeader: EncodeHeader::<Identity, OFFSET>,
ConvertBuffer: ConvertBuffer::<Identity, OFFSET>,
ConvertString: ConvertString::<Identity, OFFSET>,
MLANG_ConvertInetReset: MLANG_ConvertInetReset::<Identity, OFFSET>,
MLANG_ConvertInetString: MLANG_ConvertInetString::<Identity, OFFSET>,
Rfc1522Decode: Rfc1522Decode::<Identity, OFFSET>,
Rfc1522Encode: Rfc1522Encode::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeInternational as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeInternational {}
windows_core::imp::define_interface!(
IMimeMessage,
IMimeMessage_Vtbl,
0xfd853cd5_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeMessage {
type Target = IMimeMessageTree;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimeMessage,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist,
windows::Win32::System::Com::IPersistStreamInit,
IMimeMessageTree
);
impl IMimeMessage {
pub unsafe fn CreateWebPage<P0, P2>(
&self,
prootstm: P0,
poptions: *mut WEBPAGEOPTIONS,
pcallback: P2,
ppmoniker: *mut Option<windows::Win32::System::Com::IMoniker>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
P2: windows_core::Param<IMimeMessageCallback>,
{
unsafe {
(windows_core::Interface::vtable(self).CreateWebPage)(
windows_core::Interface::as_raw(self),
prootstm.param().abi(),
poptions as _,
pcallback.param().abi(),
core::mem::transmute(ppmoniker),
)
.ok()
}
}
pub unsafe fn GetPropA<P0>(
&self,
pszname: P0,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPropA)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn SetPropA<P0>(
&self,
pszname: P0,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetPropA)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn DeleteProp<P0>(&self, pszname: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteProp)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
)
.ok()
}
}
pub unsafe fn QueryProp<P0, P1>(
&self,
pszname: P0,
pszcriteria: P1,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).QueryProp)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pszcriteria.param().abi(),
fsubstring,
fcasesensitive,
)
.ok()
}
}
pub unsafe fn GetTextBody(
&self,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
ppstream: *mut Option<windows::Win32::System::Com::IStream>,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetTextBody)(
windows_core::Interface::as_raw(self),
dwtxttype,
ietencoding,
core::mem::transmute(ppstream),
phbody as _,
)
.ok()
}
}
pub unsafe fn SetTextBody<P3>(
&self,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
halternative: *mut HBODY__,
pstream: P3,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>
where
P3: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).SetTextBody)(
windows_core::Interface::as_raw(self),
dwtxttype,
ietencoding,
halternative as _,
pstream.param().abi(),
phbody as _,
)
.ok()
}
}
pub unsafe fn AttachObject(
&self,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AttachObject)(
windows_core::Interface::as_raw(self),
riid,
pvobject as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn AttachFile<P0, P1>(
&self,
pszfilepath: P0,
pstmfile: P1,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).AttachFile)(
windows_core::Interface::as_raw(self),
pszfilepath.param().abi(),
pstmfile.param().abi(),
phbody as _,
)
.ok()
}
}
pub unsafe fn AttachURL<P0, P1, P3>(
&self,
pszbase: P0,
pszurl: P1,
dwflags: u32,
pstmurl: P3,
ppszcidurl: *mut windows_core::PSTR,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
P3: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).AttachURL)(
windows_core::Interface::as_raw(self),
pszbase.param().abi(),
pszurl.param().abi(),
dwflags,
pstmurl.param().abi(),
ppszcidurl as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn GetAttachments(
&self,
pcattach: *mut u32,
pprghattach: *mut *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetAttachments)(
windows_core::Interface::as_raw(self),
pcattach as _,
pprghattach as _,
)
.ok()
}
}
pub unsafe fn GetAddressTable(&self) -> windows_core::Result<IMimeAddressTable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetAddressTable)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetSender)(
windows_core::Interface::as_raw(self),
paddress as _,
)
.ok()
}
}
pub unsafe fn GetAddressTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetAddressTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
dwprops,
plist as _,
)
.ok()
}
}
pub unsafe fn GetAddressFormat(
&self,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetAddressFormat)(
windows_core::Interface::as_raw(self),
dwadrtype,
format,
ppszformat as _,
)
.ok()
}
}
pub unsafe fn EnumAddressTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
) -> windows_core::Result<IMimeEnumAddressTypes> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumAddressTypes)(
windows_core::Interface::as_raw(self),
dwadrtypes,
dwprops,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn SplitMessage(&self, cbmaxpart: u32) -> windows_core::Result<IMimeMessageParts> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).SplitMessage)(
windows_core::Interface::as_raw(self),
cbmaxpart,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn GetRootMoniker(
&self,
) -> windows_core::Result<windows::Win32::System::Com::IMoniker> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetRootMoniker)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMimeMessage_Vtbl {
pub base__: IMimeMessageTree_Vtbl,
pub CreateWebPage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut WEBPAGEOPTIONS,
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub SetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub DeleteProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub QueryProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u8,
u8,
) -> windows_core::HRESULT,
pub GetTextBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ENCODINGTYPE,
*mut *mut core::ffi::c_void,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub SetTextBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ENCODINGTYPE,
*mut HBODY__,
*mut core::ffi::c_void,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub AttachObject: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut core::ffi::c_void,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub AttachFile: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut core::ffi::c_void,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub AttachURL: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut core::ffi::c_void,
*mut windows_core::PSTR,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub GetAttachments: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut *mut *mut HBODY__,
) -> windows_core::HRESULT,
pub GetAddressTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetSender: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut ADDRESSPROPS,
) -> windows_core::HRESULT,
pub GetAddressTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ADDRESSLIST,
) -> windows_core::HRESULT,
pub GetAddressFormat: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
ADDRESSFORMAT,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub EnumAddressTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SplitMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetRootMoniker: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeMessage_Impl: IMimeMessageTree_Impl {
fn CreateWebPage(
&self,
prootstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
poptions: *mut WEBPAGEOPTIONS,
pcallback: windows_core::Ref<'_, IMimeMessageCallback>,
ppmoniker: windows_core::OutRef<'_, windows::Win32::System::Com::IMoniker>,
) -> windows_core::Result<()>;
fn GetPropA(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn SetPropA(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn DeleteProp(&self, pszname: &windows_core::PCSTR) -> windows_core::Result<()>;
fn QueryProp(
&self,
pszname: &windows_core::PCSTR,
pszcriteria: &windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>;
fn GetTextBody(
&self,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
ppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn SetTextBody(
&self,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
halternative: *mut HBODY__,
pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn AttachObject(
&self,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn AttachFile(
&self,
pszfilepath: &windows_core::PCSTR,
pstmfile: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn AttachURL(
&self,
pszbase: &windows_core::PCSTR,
pszurl: &windows_core::PCSTR,
dwflags: u32,
pstmurl: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
ppszcidurl: *mut windows_core::PSTR,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn GetAttachments(
&self,
pcattach: *mut u32,
pprghattach: *mut *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn GetAddressTable(&self) -> windows_core::Result<IMimeAddressTable>;
fn GetSender(&self, paddress: *mut ADDRESSPROPS) -> windows_core::Result<()>;
fn GetAddressTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::Result<()>;
fn GetAddressFormat(
&self,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
fn EnumAddressTypes(
&self,
dwadrtypes: u32,
dwprops: u32,
) -> windows_core::Result<IMimeEnumAddressTypes>;
fn SplitMessage(&self, cbmaxpart: u32) -> windows_core::Result<IMimeMessageParts>;
fn GetRootMoniker(&self) -> windows_core::Result<windows::Win32::System::Com::IMoniker>;
}
impl IMimeMessage_Vtbl {
pub const fn new<Identity: IMimeMessage_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateWebPage<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
prootstm: *mut core::ffi::c_void,
poptions: *mut WEBPAGEOPTIONS,
pcallback: *mut core::ffi::c_void,
ppmoniker: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::CreateWebPage(
this,
core::mem::transmute_copy(&prootstm),
core::mem::transmute_copy(&poptions),
core::mem::transmute_copy(&pcallback),
core::mem::transmute_copy(&ppmoniker),
)
.into()
}
}
unsafe extern "system" fn GetPropA<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetPropA(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn SetPropA<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::SetPropA(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn DeleteProp<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::DeleteProp(this, core::mem::transmute(&pszname)).into()
}
}
unsafe extern "system" fn QueryProp<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pszcriteria: windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::QueryProp(
this,
core::mem::transmute(&pszname),
core::mem::transmute(&pszcriteria),
core::mem::transmute_copy(&fsubstring),
core::mem::transmute_copy(&fcasesensitive),
)
.into()
}
}
unsafe extern "system" fn GetTextBody<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
ppstream: *mut *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetTextBody(
this,
core::mem::transmute_copy(&dwtxttype),
core::mem::transmute_copy(&ietencoding),
core::mem::transmute_copy(&ppstream),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn SetTextBody<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwtxttype: u32,
ietencoding: ENCODINGTYPE,
halternative: *mut HBODY__,
pstream: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::SetTextBody(
this,
core::mem::transmute_copy(&dwtxttype),
core::mem::transmute_copy(&ietencoding),
core::mem::transmute_copy(&halternative),
core::mem::transmute_copy(&pstream),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn AttachObject<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
pvobject: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::AttachObject(
this,
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&pvobject),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn AttachFile<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszfilepath: windows_core::PCSTR,
pstmfile: *mut core::ffi::c_void,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::AttachFile(
this,
core::mem::transmute(&pszfilepath),
core::mem::transmute_copy(&pstmfile),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn AttachURL<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszbase: windows_core::PCSTR,
pszurl: windows_core::PCSTR,
dwflags: u32,
pstmurl: *mut core::ffi::c_void,
ppszcidurl: *mut windows_core::PSTR,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::AttachURL(
this,
core::mem::transmute(&pszbase),
core::mem::transmute(&pszurl),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pstmurl),
core::mem::transmute_copy(&ppszcidurl),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn GetAttachments<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcattach: *mut u32,
pprghattach: *mut *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetAttachments(
this,
core::mem::transmute_copy(&pcattach),
core::mem::transmute_copy(&pprghattach),
)
.into()
}
}
unsafe extern "system" fn GetAddressTable<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessage_Impl::GetAddressTable(this) {
Ok(ok__) => {
pptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetSender<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
paddress: *mut ADDRESSPROPS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetSender(this, core::mem::transmute_copy(&paddress)).into()
}
}
unsafe extern "system" fn GetAddressTypes<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
dwprops: u32,
plist: *mut ADDRESSLIST,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetAddressTypes(
this,
core::mem::transmute_copy(&dwadrtypes),
core::mem::transmute_copy(&dwprops),
core::mem::transmute_copy(&plist),
)
.into()
}
}
unsafe extern "system" fn GetAddressFormat<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtype: u32,
format: ADDRESSFORMAT,
ppszformat: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessage_Impl::GetAddressFormat(
this,
core::mem::transmute_copy(&dwadrtype),
core::mem::transmute_copy(&format),
core::mem::transmute_copy(&ppszformat),
)
.into()
}
}
unsafe extern "system" fn EnumAddressTypes<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwadrtypes: u32,
dwprops: u32,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessage_Impl::EnumAddressTypes(
this,
core::mem::transmute_copy(&dwadrtypes),
core::mem::transmute_copy(&dwprops),
) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn SplitMessage<Identity: IMimeMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbmaxpart: u32,
ppparts: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessage_Impl::SplitMessage(this, core::mem::transmute_copy(&cbmaxpart)) {
Ok(ok__) => {
ppparts.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn GetRootMoniker<
Identity: IMimeMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppmoniker: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessage_Impl::GetRootMoniker(this) {
Ok(ok__) => {
ppmoniker.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: IMimeMessageTree_Vtbl::new::<Identity, OFFSET>(),
CreateWebPage: CreateWebPage::<Identity, OFFSET>,
GetPropA: GetPropA::<Identity, OFFSET>,
SetPropA: SetPropA::<Identity, OFFSET>,
DeleteProp: DeleteProp::<Identity, OFFSET>,
QueryProp: QueryProp::<Identity, OFFSET>,
GetTextBody: GetTextBody::<Identity, OFFSET>,
SetTextBody: SetTextBody::<Identity, OFFSET>,
AttachObject: AttachObject::<Identity, OFFSET>,
AttachFile: AttachFile::<Identity, OFFSET>,
AttachURL: AttachURL::<Identity, OFFSET>,
GetAttachments: GetAttachments::<Identity, OFFSET>,
GetAddressTable: GetAddressTable::<Identity, OFFSET>,
GetSender: GetSender::<Identity, OFFSET>,
GetAddressTypes: GetAddressTypes::<Identity, OFFSET>,
GetAddressFormat: GetAddressFormat::<Identity, OFFSET>,
EnumAddressTypes: EnumAddressTypes::<Identity, OFFSET>,
SplitMessage: SplitMessage::<Identity, OFFSET>,
GetRootMoniker: GetRootMoniker::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == & < IMimeMessage as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID || iid == & < IMimeMessageTree as windows_core::Interface >::IID
}
}
impl windows_core::RuntimeName for IMimeMessage {}
windows_core::imp::define_interface!(
IMimeMessageCallback,
IMimeMessageCallback_Vtbl,
0x761aa641_7bda_11d1_8aa9_00c04fb951f3
);
windows_core::imp::interface_hierarchy!(IMimeMessageCallback, windows_core::IUnknown);
impl IMimeMessageCallback {
pub unsafe fn OnWebPageSplitter<P1>(
&self,
cinlined: u32,
ppstream: P1,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).OnWebPageSplitter)(
windows_core::Interface::as_raw(self),
cinlined,
ppstream.param().abi(),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeMessageCallback_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub OnWebPageSplitter: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeMessageCallback_Impl: windows_core::IUnknownImpl {
fn OnWebPageSplitter(
&self,
cinlined: u32,
ppstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
}
impl IMimeMessageCallback_Vtbl {
pub const fn new<Identity: IMimeMessageCallback_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn OnWebPageSplitter<
Identity: IMimeMessageCallback_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cinlined: u32,
ppstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageCallback_Impl::OnWebPageSplitter(
this,
core::mem::transmute_copy(&cinlined),
core::mem::transmute_copy(&ppstream),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
OnWebPageSplitter: OnWebPageSplitter::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeMessageCallback as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeMessageCallback {}
windows_core::imp::define_interface!(
IMimeMessageParts,
IMimeMessageParts_Vtbl,
0xc558834f_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeMessageParts, windows_core::IUnknown);
impl IMimeMessageParts {
pub unsafe fn CombineParts(&self) -> windows_core::Result<IMimeMessage> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).CombineParts)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn AddPart<P0>(&self, pmessage: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).AddPart)(
windows_core::Interface::as_raw(self),
pmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn SetMaxParts(&self, cparts: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetMaxParts)(
windows_core::Interface::as_raw(self),
cparts,
)
.ok()
}
}
pub unsafe fn CountParts(&self, pcparts: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CountParts)(
windows_core::Interface::as_raw(self),
pcparts as _,
)
.ok()
}
}
pub unsafe fn EnumParts(&self) -> windows_core::Result<IMimeEnumMessageParts> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumParts)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMimeMessageParts_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CombineParts: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub AddPart: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetMaxParts:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub CountParts:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub EnumParts: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeMessageParts_Impl: windows_core::IUnknownImpl {
fn CombineParts(&self) -> windows_core::Result<IMimeMessage>;
fn AddPart(&self, pmessage: windows_core::Ref<'_, IMimeMessage>) -> windows_core::Result<()>;
fn SetMaxParts(&self, cparts: u32) -> windows_core::Result<()>;
fn CountParts(&self, pcparts: *mut u32) -> windows_core::Result<()>;
fn EnumParts(&self) -> windows_core::Result<IMimeEnumMessageParts>;
}
impl IMimeMessageParts_Vtbl {
pub const fn new<Identity: IMimeMessageParts_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CombineParts<
Identity: IMimeMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppmessage: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessageParts_Impl::CombineParts(this) {
Ok(ok__) => {
ppmessage.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn AddPart<Identity: IMimeMessageParts_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageParts_Impl::AddPart(this, core::mem::transmute_copy(&pmessage)).into()
}
}
unsafe extern "system" fn SetMaxParts<
Identity: IMimeMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cparts: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageParts_Impl::SetMaxParts(this, core::mem::transmute_copy(&cparts)).into()
}
}
unsafe extern "system" fn CountParts<
Identity: IMimeMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcparts: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageParts_Impl::CountParts(this, core::mem::transmute_copy(&pcparts)).into()
}
}
unsafe extern "system" fn EnumParts<
Identity: IMimeMessageParts_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessageParts_Impl::EnumParts(this) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CombineParts: CombineParts::<Identity, OFFSET>,
AddPart: AddPart::<Identity, OFFSET>,
SetMaxParts: SetMaxParts::<Identity, OFFSET>,
CountParts: CountParts::<Identity, OFFSET>,
EnumParts: EnumParts::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeMessageParts as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeMessageParts {}
windows_core::imp::define_interface!(
IMimeMessageTree,
IMimeMessageTree_Vtbl,
0xfd853cd4_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimeMessageTree {
type Target = windows::Win32::System::Com::IPersistStreamInit;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimeMessageTree,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist,
windows::Win32::System::Com::IPersistStreamInit
);
impl IMimeMessageTree {
pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Save)(
windows_core::Interface::as_raw(self),
pstm.param().abi(),
fcleardirty.into(),
)
.ok()
}
}
pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetSizeMax)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.map(|| result__)
}
}
pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn GetMessageSource(
&self,
ppstream: *mut Option<windows::Win32::System::Com::IStream>,
dwflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMessageSource)(
windows_core::Interface::as_raw(self),
core::mem::transmute(ppstream),
dwflags,
)
.ok()
}
}
pub unsafe fn GetMessageSize(
&self,
pcbsize: *mut u32,
dwflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetMessageSize)(
windows_core::Interface::as_raw(self),
pcbsize as _,
dwflags,
)
.ok()
}
}
pub unsafe fn LoadOffsetTable<P0>(&self, pstream: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).LoadOffsetTable)(
windows_core::Interface::as_raw(self),
pstream.param().abi(),
)
.ok()
}
}
pub unsafe fn SaveOffsetTable<P0>(&self, pstream: P0, dwflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).SaveOffsetTable)(
windows_core::Interface::as_raw(self),
pstream.param().abi(),
dwflags,
)
.ok()
}
}
pub unsafe fn GetFlags(&self, pdwflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetFlags)(
windows_core::Interface::as_raw(self),
pdwflags as _,
)
.ok()
}
}
pub unsafe fn Commit(&self, dwflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Commit)(
windows_core::Interface::as_raw(self),
dwflags,
)
.ok()
}
}
pub unsafe fn HandsOffStorage(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HandsOffStorage)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
pub unsafe fn BindToObject(
&self,
hbody: *const HBODY__,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).BindToObject)(
windows_core::Interface::as_raw(self),
hbody,
riid,
ppvobject as _,
)
.ok()
}
}
pub unsafe fn SaveBody<P2>(
&self,
hbody: *mut HBODY__,
dwflags: u32,
pstream: P2,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).SaveBody)(
windows_core::Interface::as_raw(self),
hbody as _,
dwflags,
pstream.param().abi(),
)
.ok()
}
}
pub unsafe fn InsertBody(
&self,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).InsertBody)(
windows_core::Interface::as_raw(self),
location,
hpivot as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn GetBody(
&self,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetBody)(
windows_core::Interface::as_raw(self),
location,
hpivot as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn DeleteBody(&self, hbody: *mut HBODY__, dwflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteBody)(
windows_core::Interface::as_raw(self),
hbody as _,
dwflags,
)
.ok()
}
}
pub unsafe fn MoveBody(
&self,
hbody: *mut HBODY__,
location: BODYLOCATION,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MoveBody)(
windows_core::Interface::as_raw(self),
hbody as _,
location,
)
.ok()
}
}
pub unsafe fn CountBodies(
&self,
hparent: *mut HBODY__,
frecurse: u8,
pcbodies: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CountBodies)(
windows_core::Interface::as_raw(self),
hparent as _,
frecurse,
pcbodies as _,
)
.ok()
}
}
pub unsafe fn FindFirst(
&self,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindFirst)(
windows_core::Interface::as_raw(self),
pfindbody as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn FindNext(
&self,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindNext)(
windows_core::Interface::as_raw(self),
pfindbody as _,
phbody as _,
)
.ok()
}
}
pub unsafe fn ResolveURL<P1, P2>(
&self,
hrelated: *mut HBODY__,
pszbase: P1,
pszurl: P2,
dwflags: u32,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).ResolveURL)(
windows_core::Interface::as_raw(self),
hrelated as _,
pszbase.param().abi(),
pszurl.param().abi(),
dwflags,
phbody as _,
)
.ok()
}
}
pub unsafe fn ToMultipart<P1>(
&self,
hbody: *mut HBODY__,
pszsubtype: P1,
phmultipart: *mut *mut HBODY__,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).ToMultipart)(
windows_core::Interface::as_raw(self),
hbody as _,
pszsubtype.param().abi(),
phmultipart as _,
)
.ok()
}
}
pub unsafe fn GetBodyOffsets(
&self,
hbody: *mut HBODY__,
poffsets: *mut BODYOFFSETS,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetBodyOffsets)(
windows_core::Interface::as_raw(self),
hbody as _,
poffsets as _,
)
.ok()
}
}
pub unsafe fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCharset)(
windows_core::Interface::as_raw(self),
phcharset as _,
)
.ok()
}
}
pub unsafe fn SetCharset(
&self,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetCharset)(
windows_core::Interface::as_raw(self),
hcharset as _,
applytype,
)
.ok()
}
}
pub unsafe fn IsBodyType(
&self,
hbody: *mut HBODY__,
bodytype: IMSGBODYTYPE,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).IsBodyType)(
windows_core::Interface::as_raw(self),
hbody as _,
bodytype,
)
.ok()
}
}
pub unsafe fn IsContentType<P1, P2>(
&self,
hbody: *mut HBODY__,
pszpritype: P1,
pszsubtype: P2,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).IsContentType)(
windows_core::Interface::as_raw(self),
hbody as _,
pszpritype.param().abi(),
pszsubtype.param().abi(),
)
.ok()
}
}
pub unsafe fn QueryBodyProp<P1, P2>(
&self,
hbody: *mut HBODY__,
pszname: P1,
pszcriteria: P2,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
P2: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).QueryBodyProp)(
windows_core::Interface::as_raw(self),
hbody as _,
pszname.param().abi(),
pszcriteria.param().abi(),
fsubstring,
fcasesensitive,
)
.ok()
}
}
pub unsafe fn GetBodyProp<P1>(
&self,
hbody: *mut HBODY__,
pszname: P1,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetBodyProp)(
windows_core::Interface::as_raw(self),
hbody as _,
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn SetBodyProp<P1>(
&self,
hbody: *mut HBODY__,
pszname: P1,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetBodyProp)(
windows_core::Interface::as_raw(self),
hbody as _,
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn DeleteBodyProp<P1>(
&self,
hbody: *mut HBODY__,
pszname: P1,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteBodyProp)(
windows_core::Interface::as_raw(self),
hbody as _,
pszname.param().abi(),
)
.ok()
}
}
pub unsafe fn SetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetOption)(
windows_core::Interface::as_raw(self),
oid,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn GetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetOption)(
windows_core::Interface::as_raw(self),
oid,
core::mem::transmute(pvalue),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeMessageTree_Vtbl {
pub base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl,
pub Save: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT,
pub GetSizeMax:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub GetMessageSource: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetMessageSize:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32, u32) -> windows_core::HRESULT,
pub LoadOffsetTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SaveOffsetTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub GetFlags:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub Commit: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub HandsOffStorage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub BindToObject: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const HBODY__,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SaveBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
u32,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub InsertBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
BODYLOCATION,
*mut HBODY__,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub GetBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
BODYLOCATION,
*mut HBODY__,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub DeleteBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
u32,
) -> windows_core::HRESULT,
pub MoveBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
BODYLOCATION,
) -> windows_core::HRESULT,
pub CountBodies: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
u8,
*mut u32,
) -> windows_core::HRESULT,
pub FindFirst: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut FINDBODY,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub FindNext: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut FINDBODY,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub ResolveURL: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
windows_core::PCSTR,
u32,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub ToMultipart: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
*mut *mut HBODY__,
) -> windows_core::HRESULT,
pub GetBodyOffsets: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
*mut BODYOFFSETS,
) -> windows_core::HRESULT,
pub GetCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut HCHARSET__,
) -> windows_core::HRESULT,
pub SetCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HCHARSET__,
CSETAPPLYTYPE,
) -> windows_core::HRESULT,
pub IsBodyType: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
IMSGBODYTYPE,
) -> windows_core::HRESULT,
pub IsContentType: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub QueryBodyProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
windows_core::PCSTR,
u8,
u8,
) -> windows_core::HRESULT,
pub GetBodyProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub SetBodyProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub DeleteBodyProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HBODY__,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub SetOption: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub GetOption: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
}
pub trait IMimeMessageTree_Impl: windows::Win32::System::Com::IPersistStreamInit_Impl {
fn Save(
&self,
pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()>;
fn GetSizeMax(&self) -> windows_core::Result<u64>;
fn InitNew(&self) -> windows_core::Result<()>;
fn GetMessageSource(
&self,
ppstream: windows_core::OutRef<'_, windows::Win32::System::Com::IStream>,
dwflags: u32,
) -> windows_core::Result<()>;
fn GetMessageSize(&self, pcbsize: *mut u32, dwflags: u32) -> windows_core::Result<()>;
fn LoadOffsetTable(
&self,
pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn SaveOffsetTable(
&self,
pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
dwflags: u32,
) -> windows_core::Result<()>;
fn GetFlags(&self, pdwflags: *mut u32) -> windows_core::Result<()>;
fn Commit(&self, dwflags: u32) -> windows_core::Result<()>;
fn HandsOffStorage(&self) -> windows_core::Result<()>;
fn BindToObject(
&self,
hbody: *const HBODY__,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn SaveBody(
&self,
hbody: *mut HBODY__,
dwflags: u32,
pstream: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
) -> windows_core::Result<()>;
fn InsertBody(
&self,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn GetBody(
&self,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn DeleteBody(&self, hbody: *mut HBODY__, dwflags: u32) -> windows_core::Result<()>;
fn MoveBody(&self, hbody: *mut HBODY__, location: BODYLOCATION) -> windows_core::Result<()>;
fn CountBodies(
&self,
hparent: *mut HBODY__,
frecurse: u8,
pcbodies: *mut u32,
) -> windows_core::Result<()>;
fn FindFirst(
&self,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn FindNext(
&self,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn ResolveURL(
&self,
hrelated: *mut HBODY__,
pszbase: &windows_core::PCSTR,
pszurl: &windows_core::PCSTR,
dwflags: u32,
phbody: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn ToMultipart(
&self,
hbody: *mut HBODY__,
pszsubtype: &windows_core::PCSTR,
phmultipart: *mut *mut HBODY__,
) -> windows_core::Result<()>;
fn GetBodyOffsets(
&self,
hbody: *mut HBODY__,
poffsets: *mut BODYOFFSETS,
) -> windows_core::Result<()>;
fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
fn SetCharset(
&self,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::Result<()>;
fn IsBodyType(&self, hbody: *mut HBODY__, bodytype: IMSGBODYTYPE) -> windows_core::Result<()>;
fn IsContentType(
&self,
hbody: *mut HBODY__,
pszpritype: &windows_core::PCSTR,
pszsubtype: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn QueryBodyProp(
&self,
hbody: *mut HBODY__,
pszname: &windows_core::PCSTR,
pszcriteria: &windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>;
fn GetBodyProp(
&self,
hbody: *mut HBODY__,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn SetBodyProp(
&self,
hbody: *mut HBODY__,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn DeleteBodyProp(
&self,
hbody: *mut HBODY__,
pszname: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn SetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn GetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
}
impl IMimeMessageTree_Vtbl {
pub const fn new<Identity: IMimeMessageTree_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Save<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pstm: *mut core::ffi::c_void,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::Save(
this,
core::mem::transmute_copy(&pstm),
core::mem::transmute_copy(&fcleardirty),
)
.into()
}
}
unsafe extern "system" fn GetSizeMax<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcbsize: *mut u64,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimeMessageTree_Impl::GetSizeMax(this) {
Ok(ok__) => {
pcbsize.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn InitNew<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::InitNew(this).into()
}
}
unsafe extern "system" fn GetMessageSource<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppstream: *mut *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetMessageSource(
this,
core::mem::transmute_copy(&ppstream),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn GetMessageSize<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcbsize: *mut u32,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetMessageSize(
this,
core::mem::transmute_copy(&pcbsize),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn LoadOffsetTable<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::LoadOffsetTable(this, core::mem::transmute_copy(&pstream))
.into()
}
}
unsafe extern "system" fn SaveOffsetTable<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pstream: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::SaveOffsetTable(
this,
core::mem::transmute_copy(&pstream),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn GetFlags<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pdwflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetFlags(this, core::mem::transmute_copy(&pdwflags)).into()
}
}
unsafe extern "system" fn Commit<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::Commit(this, core::mem::transmute_copy(&dwflags)).into()
}
}
unsafe extern "system" fn HandsOffStorage<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::HandsOffStorage(this).into()
}
}
unsafe extern "system" fn BindToObject<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *const HBODY__,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::BindToObject(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
unsafe extern "system" fn SaveBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
dwflags: u32,
pstream: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::SaveBody(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pstream),
)
.into()
}
}
unsafe extern "system" fn InsertBody<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::InsertBody(
this,
core::mem::transmute_copy(&location),
core::mem::transmute_copy(&hpivot),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn GetBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
location: BODYLOCATION,
hpivot: *mut HBODY__,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetBody(
this,
core::mem::transmute_copy(&location),
core::mem::transmute_copy(&hpivot),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn DeleteBody<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::DeleteBody(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn MoveBody<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
location: BODYLOCATION,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::MoveBody(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&location),
)
.into()
}
}
unsafe extern "system" fn CountBodies<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hparent: *mut HBODY__,
frecurse: u8,
pcbodies: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::CountBodies(
this,
core::mem::transmute_copy(&hparent),
core::mem::transmute_copy(&frecurse),
core::mem::transmute_copy(&pcbodies),
)
.into()
}
}
unsafe extern "system" fn FindFirst<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::FindFirst(
this,
core::mem::transmute_copy(&pfindbody),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn FindNext<Identity: IMimeMessageTree_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pfindbody: *mut FINDBODY,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::FindNext(
this,
core::mem::transmute_copy(&pfindbody),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn ResolveURL<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hrelated: *mut HBODY__,
pszbase: windows_core::PCSTR,
pszurl: windows_core::PCSTR,
dwflags: u32,
phbody: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::ResolveURL(
this,
core::mem::transmute_copy(&hrelated),
core::mem::transmute(&pszbase),
core::mem::transmute(&pszurl),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&phbody),
)
.into()
}
}
unsafe extern "system" fn ToMultipart<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszsubtype: windows_core::PCSTR,
phmultipart: *mut *mut HBODY__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::ToMultipart(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszsubtype),
core::mem::transmute_copy(&phmultipart),
)
.into()
}
}
unsafe extern "system" fn GetBodyOffsets<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
poffsets: *mut BODYOFFSETS,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetBodyOffsets(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&poffsets),
)
.into()
}
}
unsafe extern "system" fn GetCharset<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetCharset(this, core::mem::transmute_copy(&phcharset))
.into()
}
}
unsafe extern "system" fn SetCharset<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::SetCharset(
this,
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&applytype),
)
.into()
}
}
unsafe extern "system" fn IsBodyType<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
bodytype: IMSGBODYTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::IsBodyType(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute_copy(&bodytype),
)
.into()
}
}
unsafe extern "system" fn IsContentType<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszpritype: windows_core::PCSTR,
pszsubtype: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::IsContentType(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszpritype),
core::mem::transmute(&pszsubtype),
)
.into()
}
}
unsafe extern "system" fn QueryBodyProp<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszname: windows_core::PCSTR,
pszcriteria: windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::QueryBodyProp(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszname),
core::mem::transmute(&pszcriteria),
core::mem::transmute_copy(&fsubstring),
core::mem::transmute_copy(&fcasesensitive),
)
.into()
}
}
unsafe extern "system" fn GetBodyProp<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetBodyProp(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn SetBodyProp<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::SetBodyProp(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn DeleteBodyProp<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hbody: *mut HBODY__,
pszname: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::DeleteBodyProp(
this,
core::mem::transmute_copy(&hbody),
core::mem::transmute(&pszname),
)
.into()
}
}
unsafe extern "system" fn SetOption<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::SetOption(
this,
core::mem::transmute_copy(&oid),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn GetOption<
Identity: IMimeMessageTree_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeMessageTree_Impl::GetOption(
this,
core::mem::transmute_copy(&oid),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
Self {
base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl::new::<Identity, OFFSET>(),
Save: Save::<Identity, OFFSET>,
GetSizeMax: GetSizeMax::<Identity, OFFSET>,
InitNew: InitNew::<Identity, OFFSET>,
GetMessageSource: GetMessageSource::<Identity, OFFSET>,
GetMessageSize: GetMessageSize::<Identity, OFFSET>,
LoadOffsetTable: LoadOffsetTable::<Identity, OFFSET>,
SaveOffsetTable: SaveOffsetTable::<Identity, OFFSET>,
GetFlags: GetFlags::<Identity, OFFSET>,
Commit: Commit::<Identity, OFFSET>,
HandsOffStorage: HandsOffStorage::<Identity, OFFSET>,
BindToObject: BindToObject::<Identity, OFFSET>,
SaveBody: SaveBody::<Identity, OFFSET>,
InsertBody: InsertBody::<Identity, OFFSET>,
GetBody: GetBody::<Identity, OFFSET>,
DeleteBody: DeleteBody::<Identity, OFFSET>,
MoveBody: MoveBody::<Identity, OFFSET>,
CountBodies: CountBodies::<Identity, OFFSET>,
FindFirst: FindFirst::<Identity, OFFSET>,
FindNext: FindNext::<Identity, OFFSET>,
ResolveURL: ResolveURL::<Identity, OFFSET>,
ToMultipart: ToMultipart::<Identity, OFFSET>,
GetBodyOffsets: GetBodyOffsets::<Identity, OFFSET>,
GetCharset: GetCharset::<Identity, OFFSET>,
SetCharset: SetCharset::<Identity, OFFSET>,
IsBodyType: IsBodyType::<Identity, OFFSET>,
IsContentType: IsContentType::<Identity, OFFSET>,
QueryBodyProp: QueryBodyProp::<Identity, OFFSET>,
GetBodyProp: GetBodyProp::<Identity, OFFSET>,
SetBodyProp: SetBodyProp::<Identity, OFFSET>,
DeleteBodyProp: DeleteBodyProp::<Identity, OFFSET>,
SetOption: SetOption::<Identity, OFFSET>,
GetOption: GetOption::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == & < IMimeMessageTree as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID
}
}
impl windows_core::RuntimeName for IMimeMessageTree {}
windows_core::imp::define_interface!(
IMimeObjResolver,
IMimeObjResolver_Vtbl,
0xfeceaffd_c441_11d1_960e_00c04fbd7c09
);
windows_core::imp::interface_hierarchy!(IMimeObjResolver, windows_core::IUnknown);
impl IMimeObjResolver {
pub unsafe fn MimeOleObjectFromMoniker<P1, P2>(
&self,
bindf: windows::Win32::System::Com::Urlmon::BINDF,
pmkoriginal: P1,
pbindctx: P2,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
ppmknew: *mut Option<windows::Win32::System::Com::IMoniker>,
) -> windows_core::Result<()>
where
P1: windows_core::Param<windows::Win32::System::Com::IMoniker>,
P2: windows_core::Param<windows::Win32::System::Com::IBindCtx>,
{
unsafe {
(windows_core::Interface::vtable(self).MimeOleObjectFromMoniker)(
windows_core::Interface::as_raw(self),
bindf,
pmkoriginal.param().abi(),
pbindctx.param().abi(),
riid,
ppvobject as _,
core::mem::transmute(ppmknew),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeObjResolver_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub MimeOleObjectFromMoniker: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows::Win32::System::Com::Urlmon::BINDF,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeObjResolver_Impl: windows_core::IUnknownImpl {
fn MimeOleObjectFromMoniker(
&self,
bindf: windows::Win32::System::Com::Urlmon::BINDF,
pmkoriginal: windows_core::Ref<'_, windows::Win32::System::Com::IMoniker>,
pbindctx: windows_core::Ref<'_, windows::Win32::System::Com::IBindCtx>,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
ppmknew: windows_core::OutRef<'_, windows::Win32::System::Com::IMoniker>,
) -> windows_core::Result<()>;
}
impl IMimeObjResolver_Vtbl {
pub const fn new<Identity: IMimeObjResolver_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn MimeOleObjectFromMoniker<
Identity: IMimeObjResolver_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
bindf: windows::Win32::System::Com::Urlmon::BINDF,
pmkoriginal: *mut core::ffi::c_void,
pbindctx: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
ppmknew: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeObjResolver_Impl::MimeOleObjectFromMoniker(
this,
core::mem::transmute_copy(&bindf),
core::mem::transmute_copy(&pmkoriginal),
core::mem::transmute_copy(&pbindctx),
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
core::mem::transmute_copy(&ppmknew),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
MimeOleObjectFromMoniker: MimeOleObjectFromMoniker::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeObjResolver as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeObjResolver {}
windows_core::imp::define_interface!(
IMimePropertySchema,
IMimePropertySchema_Vtbl,
0xfd853cec_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimePropertySchema, windows_core::IUnknown);
impl IMimePropertySchema {
pub unsafe fn RegisterProperty<P0>(
&self,
pszname: P0,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
pdwpropid: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).RegisterProperty)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
dwrownumber,
vtdefault,
pdwpropid as _,
)
.ok()
}
}
pub unsafe fn ModifyProperty<P0>(
&self,
pszname: P0,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).ModifyProperty)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
dwrownumber,
vtdefault,
)
.ok()
}
}
pub unsafe fn GetPropertyId<P0>(
&self,
pszname: P0,
pdwpropid: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPropertyId)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pdwpropid as _,
)
.ok()
}
}
pub unsafe fn GetPropertyName(
&self,
dwpropid: u32,
ppszname: *mut windows_core::PSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetPropertyName)(
windows_core::Interface::as_raw(self),
dwpropid,
ppszname as _,
)
.ok()
}
}
pub unsafe fn RegisterAddressType<P0>(
&self,
pszname: P0,
pdwadrtype: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).RegisterAddressType)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pdwadrtype as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimePropertySchema_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub RegisterProperty: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
u32,
u16,
*mut u32,
) -> windows_core::HRESULT,
pub ModifyProperty: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
u32,
u16,
) -> windows_core::HRESULT,
pub GetPropertyId: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
) -> windows_core::HRESULT,
pub GetPropertyName: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub RegisterAddressType: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait IMimePropertySchema_Impl: windows_core::IUnknownImpl {
fn RegisterProperty(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
pdwpropid: *mut u32,
) -> windows_core::Result<()>;
fn ModifyProperty(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
) -> windows_core::Result<()>;
fn GetPropertyId(
&self,
pszname: &windows_core::PCSTR,
pdwpropid: *mut u32,
) -> windows_core::Result<()>;
fn GetPropertyName(
&self,
dwpropid: u32,
ppszname: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
fn RegisterAddressType(
&self,
pszname: &windows_core::PCSTR,
pdwadrtype: *mut u32,
) -> windows_core::Result<()>;
}
impl IMimePropertySchema_Vtbl {
pub const fn new<Identity: IMimePropertySchema_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn RegisterProperty<
Identity: IMimePropertySchema_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
pdwpropid: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySchema_Impl::RegisterProperty(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&dwrownumber),
core::mem::transmute_copy(&vtdefault),
core::mem::transmute_copy(&pdwpropid),
)
.into()
}
}
unsafe extern "system" fn ModifyProperty<
Identity: IMimePropertySchema_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
dwrownumber: u32,
vtdefault: u16,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySchema_Impl::ModifyProperty(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&dwrownumber),
core::mem::transmute_copy(&vtdefault),
)
.into()
}
}
unsafe extern "system" fn GetPropertyId<
Identity: IMimePropertySchema_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pdwpropid: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySchema_Impl::GetPropertyId(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&pdwpropid),
)
.into()
}
}
unsafe extern "system" fn GetPropertyName<
Identity: IMimePropertySchema_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwpropid: u32,
ppszname: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySchema_Impl::GetPropertyName(
this,
core::mem::transmute_copy(&dwpropid),
core::mem::transmute_copy(&ppszname),
)
.into()
}
}
unsafe extern "system" fn RegisterAddressType<
Identity: IMimePropertySchema_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pdwadrtype: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySchema_Impl::RegisterAddressType(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&pdwadrtype),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
RegisterProperty: RegisterProperty::<Identity, OFFSET>,
ModifyProperty: ModifyProperty::<Identity, OFFSET>,
GetPropertyId: GetPropertyId::<Identity, OFFSET>,
GetPropertyName: GetPropertyName::<Identity, OFFSET>,
RegisterAddressType: RegisterAddressType::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimePropertySchema as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimePropertySchema {}
windows_core::imp::define_interface!(
IMimePropertySet,
IMimePropertySet_Vtbl,
0xfd853cd3_7f86_11d0_8252_00c04fd85ab4
);
impl core::ops::Deref for IMimePropertySet {
type Target = windows::Win32::System::Com::IPersistStreamInit;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IMimePropertySet,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist,
windows::Win32::System::Com::IPersistStreamInit
);
impl IMimePropertySet {
pub unsafe fn Save<P0>(&self, pstm: P0, fcleardirty: bool) -> windows_core::Result<()>
where
P0: windows_core::Param<windows::Win32::System::Com::IStream>,
{
unsafe {
(windows_core::Interface::vtable(self).Save)(
windows_core::Interface::as_raw(self),
pstm.param().abi(),
fcleardirty.into(),
)
.ok()
}
}
pub unsafe fn GetSizeMax(&self) -> windows_core::Result<u64> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetSizeMax)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.map(|| result__)
}
}
pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn GetPropInfo<P0>(
&self,
pszname: P0,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPropInfo)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pinfo as _,
)
.ok()
}
}
pub unsafe fn SetPropInfo<P0>(
&self,
pszname: P0,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetPropInfo)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pinfo as _,
)
.ok()
}
}
pub unsafe fn GetPropA<P0>(
&self,
pszname: P0,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetPropA)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn SetPropA<P0>(
&self,
pszname: P0,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).SetPropA)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn AppendProp<P0>(
&self,
pszname: P0,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).AppendProp)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
dwflags,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn DeleteProp<P0>(&self, pszname: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).DeleteProp)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
)
.ok()
}
}
pub unsafe fn CopyProps<P2>(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: P2,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMimePropertySet>,
{
unsafe {
(windows_core::Interface::vtable(self).CopyProps)(
windows_core::Interface::as_raw(self),
cnames,
prgszname,
ppropertyset.param().abi(),
)
.ok()
}
}
pub unsafe fn MoveProps<P2>(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: P2,
) -> windows_core::Result<()>
where
P2: windows_core::Param<IMimePropertySet>,
{
unsafe {
(windows_core::Interface::vtable(self).MoveProps)(
windows_core::Interface::as_raw(self),
cnames,
prgszname,
ppropertyset.param().abi(),
)
.ok()
}
}
pub unsafe fn DeleteExcept(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteExcept)(
windows_core::Interface::as_raw(self),
cnames,
prgszname,
)
.ok()
}
}
pub unsafe fn QueryProp<P0, P1>(
&self,
pszname: P0,
pszcriteria: P1,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).QueryProp)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pszcriteria.param().abi(),
fsubstring,
fcasesensitive,
)
.ok()
}
}
pub unsafe fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCharset)(
windows_core::Interface::as_raw(self),
phcharset as _,
)
.ok()
}
}
pub unsafe fn SetCharset(
&self,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetCharset)(
windows_core::Interface::as_raw(self),
hcharset as _,
applytype,
)
.ok()
}
}
pub unsafe fn GetParameters<P0>(
&self,
pszname: P0,
pcparams: *mut u32,
pprgparam: *mut *mut MIMEPARAMINFO,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetParameters)(
windows_core::Interface::as_raw(self),
pszname.param().abi(),
pcparams as _,
pprgparam as _,
)
.ok()
}
}
pub unsafe fn IsContentType<P0, P1>(
&self,
pszpritype: P0,
pszsubtype: P1,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCSTR>,
P1: windows_core::Param<windows_core::PCSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).IsContentType)(
windows_core::Interface::as_raw(self),
pszpritype.param().abi(),
pszsubtype.param().abi(),
)
.ok()
}
}
pub unsafe fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).BindToObject)(
windows_core::Interface::as_raw(self),
riid,
ppvobject as _,
)
.ok()
}
}
pub unsafe fn Clone(&self) -> windows_core::Result<IMimePropertySet> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).Clone)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn SetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetOption)(
windows_core::Interface::as_raw(self),
oid,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn GetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetOption)(
windows_core::Interface::as_raw(self),
oid,
core::mem::transmute(pvalue),
)
.ok()
}
}
pub unsafe fn EnumPropsA(&self, dwflags: u32) -> windows_core::Result<IMimeEnumProperties> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumPropsA)(
windows_core::Interface::as_raw(self),
dwflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMimePropertySet_Vtbl {
pub base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl,
pub Save: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT,
pub GetSizeMax:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub GetPropInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut MIMEPROPINFO,
) -> windows_core::HRESULT,
pub SetPropInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut MIMEPROPINFO,
) -> windows_core::HRESULT,
pub GetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub SetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub AppendProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub DeleteProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub CopyProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*const windows_core::PCSTR,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub MoveProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*const windows_core::PCSTR,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub DeleteExcept: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*const windows_core::PCSTR,
) -> windows_core::HRESULT,
pub QueryProp: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
u8,
u8,
) -> windows_core::HRESULT,
pub GetCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut HCHARSET__,
) -> windows_core::HRESULT,
pub SetCharset: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut HCHARSET__,
CSETAPPLYTYPE,
) -> windows_core::HRESULT,
pub GetParameters: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
*mut u32,
*mut *mut MIMEPARAMINFO,
) -> windows_core::HRESULT,
pub IsContentType: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCSTR,
windows_core::PCSTR,
) -> windows_core::HRESULT,
pub BindToObject: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Clone: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetOption: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub GetOption: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
pub EnumPropsA: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimePropertySet_Impl: windows::Win32::System::Com::IPersistStreamInit_Impl {
fn Save(
&self,
pstm: windows_core::Ref<'_, windows::Win32::System::Com::IStream>,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::Result<()>;
fn GetSizeMax(&self) -> windows_core::Result<u64>;
fn InitNew(&self) -> windows_core::Result<()>;
fn GetPropInfo(
&self,
pszname: &windows_core::PCSTR,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::Result<()>;
fn SetPropInfo(
&self,
pszname: &windows_core::PCSTR,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::Result<()>;
fn GetPropA(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn SetPropA(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn AppendProp(
&self,
pszname: &windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn DeleteProp(&self, pszname: &windows_core::PCSTR) -> windows_core::Result<()>;
fn CopyProps(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: windows_core::Ref<'_, IMimePropertySet>,
) -> windows_core::Result<()>;
fn MoveProps(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: windows_core::Ref<'_, IMimePropertySet>,
) -> windows_core::Result<()>;
fn DeleteExcept(
&self,
cnames: u32,
prgszname: *const windows_core::PCSTR,
) -> windows_core::Result<()>;
fn QueryProp(
&self,
pszname: &windows_core::PCSTR,
pszcriteria: &windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::Result<()>;
fn GetCharset(&self, phcharset: *mut *mut HCHARSET__) -> windows_core::Result<()>;
fn SetCharset(
&self,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::Result<()>;
fn GetParameters(
&self,
pszname: &windows_core::PCSTR,
pcparams: *mut u32,
pprgparam: *mut *mut MIMEPARAMINFO,
) -> windows_core::Result<()>;
fn IsContentType(
&self,
pszpritype: &windows_core::PCSTR,
pszsubtype: &windows_core::PCSTR,
) -> windows_core::Result<()>;
fn BindToObject(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn Clone(&self) -> windows_core::Result<IMimePropertySet>;
fn SetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn GetOption(
&self,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
fn EnumPropsA(&self, dwflags: u32) -> windows_core::Result<IMimeEnumProperties>;
}
impl IMimePropertySet_Vtbl {
pub const fn new<Identity: IMimePropertySet_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Save<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pstm: *mut core::ffi::c_void,
fcleardirty: windows::Win32::Foundation::BOOL,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::Save(
this,
core::mem::transmute_copy(&pstm),
core::mem::transmute_copy(&fcleardirty),
)
.into()
}
}
unsafe extern "system" fn GetSizeMax<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pcbsize: *mut u64,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimePropertySet_Impl::GetSizeMax(this) {
Ok(ok__) => {
pcbsize.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn InitNew<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::InitNew(this).into()
}
}
unsafe extern "system" fn GetPropInfo<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::GetPropInfo(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&pinfo),
)
.into()
}
}
unsafe extern "system" fn SetPropInfo<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pinfo: *mut MIMEPROPINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::SetPropInfo(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&pinfo),
)
.into()
}
}
unsafe extern "system" fn GetPropA<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::GetPropA(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn SetPropA<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::SetPropA(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn AppendProp<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
dwflags: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::AppendProp(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&dwflags),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn DeleteProp<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::DeleteProp(this, core::mem::transmute(&pszname)).into()
}
}
unsafe extern "system" fn CopyProps<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::CopyProps(
this,
core::mem::transmute_copy(&cnames),
core::mem::transmute_copy(&prgszname),
core::mem::transmute_copy(&ppropertyset),
)
.into()
}
}
unsafe extern "system" fn MoveProps<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cnames: u32,
prgszname: *const windows_core::PCSTR,
ppropertyset: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::MoveProps(
this,
core::mem::transmute_copy(&cnames),
core::mem::transmute_copy(&prgszname),
core::mem::transmute_copy(&ppropertyset),
)
.into()
}
}
unsafe extern "system" fn DeleteExcept<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cnames: u32,
prgszname: *const windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::DeleteExcept(
this,
core::mem::transmute_copy(&cnames),
core::mem::transmute_copy(&prgszname),
)
.into()
}
}
unsafe extern "system" fn QueryProp<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pszcriteria: windows_core::PCSTR,
fsubstring: u8,
fcasesensitive: u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::QueryProp(
this,
core::mem::transmute(&pszname),
core::mem::transmute(&pszcriteria),
core::mem::transmute_copy(&fsubstring),
core::mem::transmute_copy(&fcasesensitive),
)
.into()
}
}
unsafe extern "system" fn GetCharset<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
phcharset: *mut *mut HCHARSET__,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::GetCharset(this, core::mem::transmute_copy(&phcharset))
.into()
}
}
unsafe extern "system" fn SetCharset<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hcharset: *mut HCHARSET__,
applytype: CSETAPPLYTYPE,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::SetCharset(
this,
core::mem::transmute_copy(&hcharset),
core::mem::transmute_copy(&applytype),
)
.into()
}
}
unsafe extern "system" fn GetParameters<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszname: windows_core::PCSTR,
pcparams: *mut u32,
pprgparam: *mut *mut MIMEPARAMINFO,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::GetParameters(
this,
core::mem::transmute(&pszname),
core::mem::transmute_copy(&pcparams),
core::mem::transmute_copy(&pprgparam),
)
.into()
}
}
unsafe extern "system" fn IsContentType<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pszpritype: windows_core::PCSTR,
pszsubtype: windows_core::PCSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::IsContentType(
this,
core::mem::transmute(&pszpritype),
core::mem::transmute(&pszsubtype),
)
.into()
}
}
unsafe extern "system" fn BindToObject<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::BindToObject(
this,
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
unsafe extern "system" fn Clone<Identity: IMimePropertySet_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pppropertyset: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimePropertySet_Impl::Clone(this) {
Ok(ok__) => {
pppropertyset.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn SetOption<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::SetOption(
this,
core::mem::transmute_copy(&oid),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn GetOption<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
oid: u32,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimePropertySet_Impl::GetOption(
this,
core::mem::transmute_copy(&oid),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
unsafe extern "system" fn EnumPropsA<
Identity: IMimePropertySet_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwflags: u32,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMimePropertySet_Impl::EnumPropsA(this, core::mem::transmute_copy(&dwflags)) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows::Win32::System::Com::IPersistStreamInit_Vtbl::new::<Identity, OFFSET>(),
Save: Save::<Identity, OFFSET>,
GetSizeMax: GetSizeMax::<Identity, OFFSET>,
InitNew: InitNew::<Identity, OFFSET>,
GetPropInfo: GetPropInfo::<Identity, OFFSET>,
SetPropInfo: SetPropInfo::<Identity, OFFSET>,
GetPropA: GetPropA::<Identity, OFFSET>,
SetPropA: SetPropA::<Identity, OFFSET>,
AppendProp: AppendProp::<Identity, OFFSET>,
DeleteProp: DeleteProp::<Identity, OFFSET>,
CopyProps: CopyProps::<Identity, OFFSET>,
MoveProps: MoveProps::<Identity, OFFSET>,
DeleteExcept: DeleteExcept::<Identity, OFFSET>,
QueryProp: QueryProp::<Identity, OFFSET>,
GetCharset: GetCharset::<Identity, OFFSET>,
SetCharset: SetCharset::<Identity, OFFSET>,
GetParameters: GetParameters::<Identity, OFFSET>,
IsContentType: IsContentType::<Identity, OFFSET>,
BindToObject: BindToObject::<Identity, OFFSET>,
Clone: Clone::<Identity, OFFSET>,
SetOption: SetOption::<Identity, OFFSET>,
GetOption: GetOption::<Identity, OFFSET>,
EnumPropsA: EnumPropsA::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == & < IMimePropertySet as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersist as windows_core::Interface >::IID || iid == & < windows::Win32::System::Com:: IPersistStreamInit as windows_core::Interface >::IID
}
}
impl windows_core::RuntimeName for IMimePropertySet {}
windows_core::imp::define_interface!(
IMimeSecurity,
IMimeSecurity_Vtbl,
0xc5588353_7f86_11d0_8252_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeSecurity, windows_core::IUnknown);
impl IMimeSecurity {
pub unsafe fn InitNew(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).InitNew)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn CheckInit(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CheckInit)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn EncodeMessage<P0>(&self, ptree: P0, dwflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessageTree>,
{
unsafe {
(windows_core::Interface::vtable(self).EncodeMessage)(
windows_core::Interface::as_raw(self),
ptree.param().abi(),
dwflags,
)
.ok()
}
}
pub unsafe fn EncodeBody<P0>(
&self,
ptree: P0,
hencoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessageTree>,
{
unsafe {
(windows_core::Interface::vtable(self).EncodeBody)(
windows_core::Interface::as_raw(self),
ptree.param().abi(),
hencoderoot as _,
dwflags,
)
.ok()
}
}
pub unsafe fn DecodeMessage<P0>(&self, ptree: P0, dwflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessageTree>,
{
unsafe {
(windows_core::Interface::vtable(self).DecodeMessage)(
windows_core::Interface::as_raw(self),
ptree.param().abi(),
dwflags,
)
.ok()
}
}
pub unsafe fn DecodeBody<P0>(
&self,
ptree: P0,
hdecoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessageTree>,
{
unsafe {
(windows_core::Interface::vtable(self).DecodeBody)(
windows_core::Interface::as_raw(self),
ptree.param().abi(),
hdecoderoot as _,
dwflags,
)
.ok()
}
}
pub unsafe fn EnumCertificates(
&self,
hc: *mut core::ffi::c_void,
dwusage: u32,
pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EnumCertificates)(
windows_core::Interface::as_raw(self),
hc as _,
dwusage,
pprev as _,
ppcert as _,
)
.ok()
}
}
pub unsafe fn GetCertificateName(
&self,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
cn: CERTNAMETYPE,
ppszname: *mut windows_core::PSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCertificateName)(
windows_core::Interface::as_raw(self),
px509cert,
cn,
ppszname as _,
)
.ok()
}
}
pub unsafe fn GetMessageType<P1>(
&self,
hwndparent: windows::Win32::Foundation::HWND,
pbody: P1,
pdwsectype: *mut u32,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMimeBody>,
{
unsafe {
(windows_core::Interface::vtable(self).GetMessageType)(
windows_core::Interface::as_raw(self),
hwndparent,
pbody.param().abi(),
pdwsectype as _,
)
.ok()
}
}
pub unsafe fn GetCertData(
&self,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
dataid: CERTDATAID,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCertData)(
windows_core::Interface::as_raw(self),
px509cert,
dataid,
core::mem::transmute(pvalue),
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeSecurity_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub InitNew: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub CheckInit: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub EncodeMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub EncodeBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut HBODY__,
u32,
) -> windows_core::HRESULT,
pub DecodeMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DecodeBody: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut HBODY__,
u32,
) -> windows_core::HRESULT,
pub EnumCertificates: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
*mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
*mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
) -> windows_core::HRESULT,
pub GetCertificateName: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows::Win32::Security::Cryptography::CERT_CONTEXT,
CERTNAMETYPE,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub GetMessageType: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows::Win32::Foundation::HWND,
*mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub GetCertData: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows::Win32::Security::Cryptography::CERT_CONTEXT,
CERTDATAID,
*mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT,
}
pub trait IMimeSecurity_Impl: windows_core::IUnknownImpl {
fn InitNew(&self) -> windows_core::Result<()>;
fn CheckInit(&self) -> windows_core::Result<()>;
fn EncodeMessage(
&self,
ptree: windows_core::Ref<'_, IMimeMessageTree>,
dwflags: u32,
) -> windows_core::Result<()>;
fn EncodeBody(
&self,
ptree: windows_core::Ref<'_, IMimeMessageTree>,
hencoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::Result<()>;
fn DecodeMessage(
&self,
ptree: windows_core::Ref<'_, IMimeMessageTree>,
dwflags: u32,
) -> windows_core::Result<()>;
fn DecodeBody(
&self,
ptree: windows_core::Ref<'_, IMimeMessageTree>,
hdecoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::Result<()>;
fn EnumCertificates(
&self,
hc: *mut core::ffi::c_void,
dwusage: u32,
pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
) -> windows_core::Result<()>;
fn GetCertificateName(
&self,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
cn: CERTNAMETYPE,
ppszname: *mut windows_core::PSTR,
) -> windows_core::Result<()>;
fn GetMessageType(
&self,
hwndparent: windows::Win32::Foundation::HWND,
pbody: windows_core::Ref<'_, IMimeBody>,
pdwsectype: *mut u32,
) -> windows_core::Result<()>;
fn GetCertData(
&self,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
dataid: CERTDATAID,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::Result<()>;
}
impl IMimeSecurity_Vtbl {
pub const fn new<Identity: IMimeSecurity_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn InitNew<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::InitNew(this).into()
}
}
unsafe extern "system" fn CheckInit<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::CheckInit(this).into()
}
}
unsafe extern "system" fn EncodeMessage<
Identity: IMimeSecurity_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ptree: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::EncodeMessage(
this,
core::mem::transmute_copy(&ptree),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn EncodeBody<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ptree: *mut core::ffi::c_void,
hencoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::EncodeBody(
this,
core::mem::transmute_copy(&ptree),
core::mem::transmute_copy(&hencoderoot),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn DecodeMessage<
Identity: IMimeSecurity_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ptree: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::DecodeMessage(
this,
core::mem::transmute_copy(&ptree),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn DecodeBody<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ptree: *mut core::ffi::c_void,
hdecoderoot: *mut HBODY__,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::DecodeBody(
this,
core::mem::transmute_copy(&ptree),
core::mem::transmute_copy(&hdecoderoot),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn EnumCertificates<
Identity: IMimeSecurity_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hc: *mut core::ffi::c_void,
dwusage: u32,
pprev: *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
ppcert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::EnumCertificates(
this,
core::mem::transmute_copy(&hc),
core::mem::transmute_copy(&dwusage),
core::mem::transmute_copy(&pprev),
core::mem::transmute_copy(&ppcert),
)
.into()
}
}
unsafe extern "system" fn GetCertificateName<
Identity: IMimeSecurity_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
cn: CERTNAMETYPE,
ppszname: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::GetCertificateName(
this,
core::mem::transmute_copy(&px509cert),
core::mem::transmute_copy(&cn),
core::mem::transmute_copy(&ppszname),
)
.into()
}
}
unsafe extern "system" fn GetMessageType<
Identity: IMimeSecurity_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hwndparent: windows::Win32::Foundation::HWND,
pbody: *mut core::ffi::c_void,
pdwsectype: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::GetMessageType(
this,
core::mem::transmute_copy(&hwndparent),
core::mem::transmute_copy(&pbody),
core::mem::transmute_copy(&pdwsectype),
)
.into()
}
}
unsafe extern "system" fn GetCertData<Identity: IMimeSecurity_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
px509cert: *const windows::Win32::Security::Cryptography::CERT_CONTEXT,
dataid: CERTDATAID,
pvalue: *mut windows::Win32::System::Com::StructuredStorage::PROPVARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeSecurity_Impl::GetCertData(
this,
core::mem::transmute_copy(&px509cert),
core::mem::transmute_copy(&dataid),
core::mem::transmute_copy(&pvalue),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
InitNew: InitNew::<Identity, OFFSET>,
CheckInit: CheckInit::<Identity, OFFSET>,
EncodeMessage: EncodeMessage::<Identity, OFFSET>,
EncodeBody: EncodeBody::<Identity, OFFSET>,
DecodeMessage: DecodeMessage::<Identity, OFFSET>,
DecodeBody: DecodeBody::<Identity, OFFSET>,
EnumCertificates: EnumCertificates::<Identity, OFFSET>,
GetCertificateName: GetCertificateName::<Identity, OFFSET>,
GetMessageType: GetMessageType::<Identity, OFFSET>,
GetCertData: GetCertData::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeSecurity as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeSecurity {}
windows_core::imp::define_interface!(
IMimeWebDocument,
IMimeWebDocument_Vtbl,
0xee519f11_851a_11d0_825c_00c04fd85ab4
);
windows_core::imp::interface_hierarchy!(IMimeWebDocument, windows_core::IUnknown);
impl IMimeWebDocument {
pub unsafe fn GetURL(&self, ppszurl: *mut windows_core::PSTR) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetURL)(
windows_core::Interface::as_raw(self),
ppszurl as _,
)
.ok()
}
}
pub unsafe fn BindToStorage(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).BindToStorage)(
windows_core::Interface::as_raw(self),
riid,
ppvobject as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMimeWebDocument_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetURL: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::PSTR,
) -> windows_core::HRESULT,
pub BindToStorage: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMimeWebDocument_Impl: windows_core::IUnknownImpl {
fn GetURL(&self, ppszurl: *mut windows_core::PSTR) -> windows_core::Result<()>;
fn BindToStorage(
&self,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
}
impl IMimeWebDocument_Vtbl {
pub const fn new<Identity: IMimeWebDocument_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetURL<Identity: IMimeWebDocument_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppszurl: *mut windows_core::PSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeWebDocument_Impl::GetURL(this, core::mem::transmute_copy(&ppszurl)).into()
}
}
unsafe extern "system" fn BindToStorage<
Identity: IMimeWebDocument_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMimeWebDocument_Impl::BindToStorage(
this,
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetURL: GetURL::<Identity, OFFSET>,
BindToStorage: BindToStorage::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMimeWebDocument as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMimeWebDocument {}
windows_core::imp::define_interface!(
IMsgServiceAdmin,
IMsgServiceAdmin_Vtbl,
0x0002031d_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMsgServiceAdmin, windows_core::IUnknown);
impl IMsgServiceAdmin {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetMsgServiceTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn CreateMsgService(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateMsgService)(
windows_core::Interface::as_raw(self),
lpszservice as _,
lpszdisplayname as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
)
.ok()
}
}
pub unsafe fn CopyMsgService(
&self,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CopyMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpszdisplayname as _,
lpinterfacetocopy as _,
lpinterfacedst as _,
lpobjectdst as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn RenameMsgService(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RenameMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
lpszdisplayname as _,
)
.ok()
}
}
pub unsafe fn ConfigureMsgService(
&self,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ConfigureMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
uluiparam,
ulflags,
cvalues,
lpprops as _,
)
.ok()
}
}
pub unsafe fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut Option<IProfSect>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProfileSection)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppprofsect),
)
.ok()
}
}
pub unsafe fn MsgServiceTransportOrder(
&self,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MsgServiceTransportOrder)(
windows_core::Interface::as_raw(self),
cuid,
lpuidlist as _,
ulflags,
)
.ok()
}
}
pub unsafe fn AdminProviders(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: *mut Option<IProviderAdmin>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AdminProviders)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
core::mem::transmute(lppprovideradmin),
)
.ok()
}
}
pub unsafe fn SetPrimaryIdentity(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetPrimaryIdentity)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
)
.ok()
}
}
pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetProviderTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IMsgServiceAdmin_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetMsgServiceTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
usize,
u32,
) -> windows_core::HRESULT,
pub DeleteMsgService:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
pub CopyMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut i8,
*mut windows_core::GUID,
*mut windows_core::GUID,
*mut core::ffi::c_void,
usize,
u32,
) -> windows_core::HRESULT,
pub RenameMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
*mut i8,
) -> windows_core::HRESULT,
pub ConfigureMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
usize,
u32,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub OpenProfileSection: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub MsgServiceTransportOrder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut MAPIUID,
u32,
) -> windows_core::HRESULT,
pub AdminProviders: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetPrimaryIdentity: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
) -> windows_core::HRESULT,
pub GetProviderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IMsgServiceAdmin_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn CreateMsgService(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
fn CopyMsgService(
&self,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn RenameMsgService(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::Result<()>;
fn ConfigureMsgService(
&self,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::Result<()>;
fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: windows_core::OutRef<'_, IProfSect>,
) -> windows_core::Result<()>;
fn MsgServiceTransportOrder(
&self,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()>;
fn AdminProviders(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: windows_core::OutRef<'_, IProviderAdmin>,
) -> windows_core::Result<()>;
fn SetPrimaryIdentity(&self, lpuid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
}
impl IMsgServiceAdmin_Vtbl {
pub const fn new<Identity: IMsgServiceAdmin_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetMsgServiceTable<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgServiceAdmin_Impl::GetMsgServiceTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn CreateMsgService<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::CreateMsgService(
this,
core::mem::transmute_copy(&lpszservice),
core::mem::transmute_copy(&lpszdisplayname),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteMsgService<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::DeleteMsgService(this, core::mem::transmute_copy(&lpuid))
.into()
}
}
unsafe extern "system" fn CopyMsgService<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::CopyMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpszdisplayname),
core::mem::transmute_copy(&lpinterfacetocopy),
core::mem::transmute_copy(&lpinterfacedst),
core::mem::transmute_copy(&lpobjectdst),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn RenameMsgService<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::RenameMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpszdisplayname),
)
.into()
}
}
unsafe extern "system" fn ConfigureMsgService<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::ConfigureMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpprops),
)
.into()
}
}
unsafe extern "system" fn OpenProfileSection<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::OpenProfileSection(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprofsect),
)
.into()
}
}
unsafe extern "system" fn MsgServiceTransportOrder<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::MsgServiceTransportOrder(
this,
core::mem::transmute_copy(&cuid),
core::mem::transmute_copy(&lpuidlist),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn AdminProviders<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::AdminProviders(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprovideradmin),
)
.into()
}
}
unsafe extern "system" fn SetPrimaryIdentity<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin_Impl::SetPrimaryIdentity(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetProviderTable<
Identity: IMsgServiceAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgServiceAdmin_Impl::GetProviderTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetMsgServiceTable: GetMsgServiceTable::<Identity, OFFSET>,
CreateMsgService: CreateMsgService::<Identity, OFFSET>,
DeleteMsgService: DeleteMsgService::<Identity, OFFSET>,
CopyMsgService: CopyMsgService::<Identity, OFFSET>,
RenameMsgService: RenameMsgService::<Identity, OFFSET>,
ConfigureMsgService: ConfigureMsgService::<Identity, OFFSET>,
OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
MsgServiceTransportOrder: MsgServiceTransportOrder::<Identity, OFFSET>,
AdminProviders: AdminProviders::<Identity, OFFSET>,
SetPrimaryIdentity: SetPrimaryIdentity::<Identity, OFFSET>,
GetProviderTable: GetProviderTable::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMsgServiceAdmin as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMsgServiceAdmin {}
windows_core::imp::define_interface!(
IMsgServiceAdmin2,
IMsgServiceAdmin2_Vtbl,
0x00020387_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IMsgServiceAdmin2, windows_core::IUnknown);
impl IMsgServiceAdmin2 {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetMsgServiceTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn CreateMsgService(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateMsgService)(
windows_core::Interface::as_raw(self),
lpszservice as _,
lpszdisplayname as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
)
.ok()
}
}
pub unsafe fn CopyMsgService(
&self,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CopyMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpszdisplayname as _,
lpinterfacetocopy as _,
lpinterfacedst as _,
lpobjectdst as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn RenameMsgService(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RenameMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
lpszdisplayname as _,
)
.ok()
}
}
pub unsafe fn ConfigureMsgService(
&self,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ConfigureMsgService)(
windows_core::Interface::as_raw(self),
lpuid as _,
uluiparam,
ulflags,
cvalues,
lpprops as _,
)
.ok()
}
}
pub unsafe fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut Option<IProfSect>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProfileSection)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppprofsect),
)
.ok()
}
}
pub unsafe fn MsgServiceTransportOrder(
&self,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).MsgServiceTransportOrder)(
windows_core::Interface::as_raw(self),
cuid,
lpuidlist as _,
ulflags,
)
.ok()
}
}
pub unsafe fn AdminProviders(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: *mut Option<IProviderAdmin>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AdminProviders)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
core::mem::transmute(lppprovideradmin),
)
.ok()
}
}
pub unsafe fn SetPrimaryIdentity(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetPrimaryIdentity)(
windows_core::Interface::as_raw(self),
lpuid as _,
ulflags,
)
.ok()
}
}
pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetProviderTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn CreateMsgServiceEx(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
lpuidservice: *mut MAPIUID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateMsgServiceEx)(
windows_core::Interface::as_raw(self),
lpszservice as _,
lpszdisplayname as _,
uluiparam,
ulflags,
lpuidservice as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMsgServiceAdmin2_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetMsgServiceTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
usize,
u32,
) -> windows_core::HRESULT,
pub DeleteMsgService:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
pub CopyMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut i8,
*mut windows_core::GUID,
*mut windows_core::GUID,
*mut core::ffi::c_void,
usize,
u32,
) -> windows_core::HRESULT,
pub RenameMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
*mut i8,
) -> windows_core::HRESULT,
pub ConfigureMsgService: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
usize,
u32,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub OpenProfileSection: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub MsgServiceTransportOrder: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut MAPIUID,
u32,
) -> windows_core::HRESULT,
pub AdminProviders: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetPrimaryIdentity: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
u32,
) -> windows_core::HRESULT,
pub GetProviderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateMsgServiceEx: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
usize,
u32,
*mut MAPIUID,
) -> windows_core::HRESULT,
}
pub trait IMsgServiceAdmin2_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetMsgServiceTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn CreateMsgService(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteMsgService(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
fn CopyMsgService(
&self,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn RenameMsgService(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::Result<()>;
fn ConfigureMsgService(
&self,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::Result<()>;
fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: windows_core::OutRef<'_, IProfSect>,
) -> windows_core::Result<()>;
fn MsgServiceTransportOrder(
&self,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::Result<()>;
fn AdminProviders(
&self,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: windows_core::OutRef<'_, IProviderAdmin>,
) -> windows_core::Result<()>;
fn SetPrimaryIdentity(&self, lpuid: *mut MAPIUID, ulflags: u32) -> windows_core::Result<()>;
fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn CreateMsgServiceEx(
&self,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
lpuidservice: *mut MAPIUID,
) -> windows_core::Result<()>;
}
impl IMsgServiceAdmin2_Vtbl {
pub const fn new<Identity: IMsgServiceAdmin2_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetMsgServiceTable<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgServiceAdmin2_Impl::GetMsgServiceTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn CreateMsgService<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::CreateMsgService(
this,
core::mem::transmute_copy(&lpszservice),
core::mem::transmute_copy(&lpszdisplayname),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteMsgService<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::DeleteMsgService(this, core::mem::transmute_copy(&lpuid))
.into()
}
}
unsafe extern "system" fn CopyMsgService<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpszdisplayname: *mut i8,
lpinterfacetocopy: *mut windows_core::GUID,
lpinterfacedst: *mut windows_core::GUID,
lpobjectdst: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::CopyMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpszdisplayname),
core::mem::transmute_copy(&lpinterfacetocopy),
core::mem::transmute_copy(&lpinterfacedst),
core::mem::transmute_copy(&lpobjectdst),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn RenameMsgService<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
lpszdisplayname: *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::RenameMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpszdisplayname),
)
.into()
}
}
unsafe extern "system" fn ConfigureMsgService<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
uluiparam: usize,
ulflags: u32,
cvalues: u32,
lpprops: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::ConfigureMsgService(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpprops),
)
.into()
}
}
unsafe extern "system" fn OpenProfileSection<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::OpenProfileSection(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprofsect),
)
.into()
}
}
unsafe extern "system" fn MsgServiceTransportOrder<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
cuid: u32,
lpuidlist: *mut MAPIUID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::MsgServiceTransportOrder(
this,
core::mem::transmute_copy(&cuid),
core::mem::transmute_copy(&lpuidlist),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn AdminProviders<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
lppprovideradmin: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::AdminProviders(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprovideradmin),
)
.into()
}
}
unsafe extern "system" fn SetPrimaryIdentity<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::SetPrimaryIdentity(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetProviderTable<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgServiceAdmin2_Impl::GetProviderTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn CreateMsgServiceEx<
Identity: IMsgServiceAdmin2_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszservice: *mut i8,
lpszdisplayname: *mut i8,
uluiparam: usize,
ulflags: u32,
lpuidservice: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgServiceAdmin2_Impl::CreateMsgServiceEx(
this,
core::mem::transmute_copy(&lpszservice),
core::mem::transmute_copy(&lpszdisplayname),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpuidservice),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetMsgServiceTable: GetMsgServiceTable::<Identity, OFFSET>,
CreateMsgService: CreateMsgService::<Identity, OFFSET>,
DeleteMsgService: DeleteMsgService::<Identity, OFFSET>,
CopyMsgService: CopyMsgService::<Identity, OFFSET>,
RenameMsgService: RenameMsgService::<Identity, OFFSET>,
ConfigureMsgService: ConfigureMsgService::<Identity, OFFSET>,
OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
MsgServiceTransportOrder: MsgServiceTransportOrder::<Identity, OFFSET>,
AdminProviders: AdminProviders::<Identity, OFFSET>,
SetPrimaryIdentity: SetPrimaryIdentity::<Identity, OFFSET>,
GetProviderTable: GetProviderTable::<Identity, OFFSET>,
CreateMsgServiceEx: CreateMsgServiceEx::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMsgServiceAdmin2 as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMsgServiceAdmin2 {}
windows_core::imp::define_interface!(
IMsgStore,
IMsgStore_Vtbl,
0x00020306_0000_0000_c000_000000000046
);
impl core::ops::Deref for IMsgStore {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IMsgStore, windows_core::IUnknown, IMAPIProp);
impl IMsgStore {
pub unsafe fn Advise<P3>(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: P3,
lpulconnection: *mut usize,
) -> windows_core::Result<()>
where
P3: windows_core::Param<IMAPIAdviseSink>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
uleventmask,
lpadvisesink.param().abi(),
lpulconnection as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
ulconnection,
)
.ok()
}
}
pub unsafe fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CompareEntryIDs)(
windows_core::Interface::as_raw(self),
cbentryid1,
lpentryid1 as _,
cbentryid2,
lpentryid2 as _,
ulflags,
lpulresult as _,
)
.ok()
}
}
pub unsafe fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut Option<windows_core::IUnknown>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenEntry)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppunk),
)
.ok()
}
}
pub unsafe fn SetReceiveFolder(
&self,
lpszmessageclass: *mut i8,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetReceiveFolder)(
windows_core::Interface::as_raw(self),
lpszmessageclass as _,
ulflags,
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn GetReceiveFolder(
&self,
lpszmessageclass: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
lppszexplicitclass: *mut *mut i8,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetReceiveFolder)(
windows_core::Interface::as_raw(self),
lpszmessageclass as _,
ulflags,
lpcbentryid as _,
lppentryid as _,
lppszexplicitclass as _,
)
.ok()
}
}
pub unsafe fn GetReceiveFolderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetReceiveFolderTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn StoreLogoff(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).StoreLogoff)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn AbortSubmit(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AbortSubmit)(
windows_core::Interface::as_raw(self),
cbentryid,
lpentryid as _,
ulflags,
)
.ok()
}
}
pub unsafe fn GetOutgoingQueue(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetOutgoingQueue)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn SetLockState<P0>(
&self,
lpmessage: P0,
ullockstate: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).SetLockState)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
ullockstate,
)
.ok()
}
}
pub unsafe fn FinishedMsg(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FinishedMsg)(
windows_core::Interface::as_raw(self),
ulflags,
cbentryid,
lpentryid as _,
)
.ok()
}
}
pub unsafe fn NotifyNewMail(
&self,
lpnotification: *mut NOTIFICATION,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).NotifyNewMail)(
windows_core::Interface::as_raw(self),
lpnotification as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IMsgStore_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub Unadvise: unsafe extern "system" fn(*mut core::ffi::c_void, usize) -> windows_core::HRESULT,
pub CompareEntryIDs: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
*mut ENTRYID,
u32,
*mut u32,
) -> windows_core::HRESULT,
pub OpenEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetReceiveFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
u32,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub GetReceiveFolder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
u32,
*mut u32,
*mut *mut ENTRYID,
*mut *mut i8,
) -> windows_core::HRESULT,
pub GetReceiveFolderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub StoreLogoff:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub AbortSubmit: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ENTRYID,
u32,
) -> windows_core::HRESULT,
pub GetOutgoingQueue: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub SetLockState: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub FinishedMsg: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut ENTRYID,
) -> windows_core::HRESULT,
pub NotifyNewMail: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut NOTIFICATION,
) -> windows_core::HRESULT,
}
pub trait IMsgStore_Impl: IMAPIProp_Impl {
fn Advise(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: windows_core::Ref<'_, IMAPIAdviseSink>,
lpulconnection: *mut usize,
) -> windows_core::Result<()>;
fn Unadvise(&self, ulconnection: usize) -> windows_core::Result<()>;
fn CompareEntryIDs(
&self,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::Result<()>;
fn OpenEntry(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: windows_core::OutRef<'_, windows_core::IUnknown>,
) -> windows_core::Result<()>;
fn SetReceiveFolder(
&self,
lpszmessageclass: *mut i8,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()>;
fn GetReceiveFolder(
&self,
lpszmessageclass: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
lppszexplicitclass: *mut *mut i8,
) -> windows_core::Result<()>;
fn GetReceiveFolderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn StoreLogoff(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn AbortSubmit(
&self,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()>;
fn GetOutgoingQueue(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn SetLockState(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
ullockstate: u32,
) -> windows_core::Result<()>;
fn FinishedMsg(
&self,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::Result<()>;
fn NotifyNewMail(&self, lpnotification: *mut NOTIFICATION) -> windows_core::Result<()>;
}
impl IMsgStore_Vtbl {
pub const fn new<Identity: IMsgStore_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Advise<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
uleventmask: u32,
lpadvisesink: *mut core::ffi::c_void,
lpulconnection: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::Advise(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&uleventmask),
core::mem::transmute_copy(&lpadvisesink),
core::mem::transmute_copy(&lpulconnection),
)
.into()
}
}
unsafe extern "system" fn Unadvise<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulconnection: usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::Unadvise(this, core::mem::transmute_copy(&ulconnection)).into()
}
}
unsafe extern "system" fn CompareEntryIDs<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid1: u32,
lpentryid1: *mut ENTRYID,
cbentryid2: u32,
lpentryid2: *mut ENTRYID,
ulflags: u32,
lpulresult: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::CompareEntryIDs(
this,
core::mem::transmute_copy(&cbentryid1),
core::mem::transmute_copy(&lpentryid1),
core::mem::transmute_copy(&cbentryid2),
core::mem::transmute_copy(&lpentryid2),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulresult),
)
.into()
}
}
unsafe extern "system" fn OpenEntry<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::OpenEntry(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppunk),
)
.into()
}
}
unsafe extern "system" fn SetReceiveFolder<
Identity: IMsgStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmessageclass: *mut i8,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::SetReceiveFolder(
this,
core::mem::transmute_copy(&lpszmessageclass),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn GetReceiveFolder<
Identity: IMsgStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszmessageclass: *mut i8,
ulflags: u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut ENTRYID,
lppszexplicitclass: *mut *mut i8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::GetReceiveFolder(
this,
core::mem::transmute_copy(&lpszmessageclass),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
core::mem::transmute_copy(&lppszexplicitclass),
)
.into()
}
}
unsafe extern "system" fn GetReceiveFolderTable<
Identity: IMsgStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgStore_Impl::GetReceiveFolderTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn StoreLogoff<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::StoreLogoff(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn AbortSubmit<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cbentryid: u32,
lpentryid: *mut ENTRYID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::AbortSubmit(
this,
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn GetOutgoingQueue<
Identity: IMsgStore_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IMsgStore_Impl::GetOutgoingQueue(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn SetLockState<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
ullockstate: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::SetLockState(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&ullockstate),
)
.into()
}
}
unsafe extern "system" fn FinishedMsg<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
cbentryid: u32,
lpentryid: *mut ENTRYID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::FinishedMsg(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cbentryid),
core::mem::transmute_copy(&lpentryid),
)
.into()
}
}
unsafe extern "system" fn NotifyNewMail<Identity: IMsgStore_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpnotification: *mut NOTIFICATION,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IMsgStore_Impl::NotifyNewMail(this, core::mem::transmute_copy(&lpnotification))
.into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
CompareEntryIDs: CompareEntryIDs::<Identity, OFFSET>,
OpenEntry: OpenEntry::<Identity, OFFSET>,
SetReceiveFolder: SetReceiveFolder::<Identity, OFFSET>,
GetReceiveFolder: GetReceiveFolder::<Identity, OFFSET>,
GetReceiveFolderTable: GetReceiveFolderTable::<Identity, OFFSET>,
StoreLogoff: StoreLogoff::<Identity, OFFSET>,
AbortSubmit: AbortSubmit::<Identity, OFFSET>,
GetOutgoingQueue: GetOutgoingQueue::<Identity, OFFSET>,
SetLockState: SetLockState::<Identity, OFFSET>,
FinishedMsg: FinishedMsg::<Identity, OFFSET>,
NotifyNewMail: NotifyNewMail::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IMsgStore as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IMsgStore {}
pub const IMsgStore_AbortSubmit: METHODS = METHODS(69i32);
pub const IMsgStore_Advise: METHODS = METHODS(61i32);
pub const IMsgStore_CompareEntryIDs: METHODS = METHODS(63i32);
pub const IMsgStore_FinishedMsg: METHODS = METHODS(72i32);
pub const IMsgStore_GetOutgoingQueue: METHODS = METHODS(70i32);
pub const IMsgStore_GetReceiveFolder: METHODS = METHODS(66i32);
pub const IMsgStore_GetReceiveFolderTable: METHODS = METHODS(67i32);
pub const IMsgStore_NotifyNewMail: METHODS = METHODS(73i32);
pub const IMsgStore_OpenEntry: METHODS = METHODS(64i32);
pub const IMsgStore_SetLockState: METHODS = METHODS(71i32);
pub const IMsgStore_SetReceiveFolder: METHODS = METHODS(65i32);
pub const IMsgStore_StoreLogoff: METHODS = METHODS(68i32);
pub const IMsgStore_Unadvise: METHODS = METHODS(62i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INETCSETINFO {
pub szName: [i8; 128],
pub hCharset: *mut HCHARSET__,
pub cpiWindows: u32,
pub cpiInternet: u32,
pub dwReserved1: u32,
}
impl Default for INETCSETINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct INETLANGMASK(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INTTRACEENTRY {
pub lAction: i32,
pub ftArrivalTime: windows::Win32::Foundation::FILETIME,
pub ftDeferredTime: windows::Win32::Foundation::FILETIME,
pub rgchADMDName: [i8; 20],
pub rgchCountryName: [i8; 4],
pub rgchPRMDId: [i8; 20],
pub rgchAttADMDName: [i8; 20],
pub rgchAttCountryName: [i8; 4],
pub rgchAttPRMDId: [i8; 20],
pub rgchMTAName: [i8; 36],
pub rgchAttMTAName: [i8; 35],
pub bAdditionalActions: u8,
}
impl Default for INTTRACEENTRY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct INTTRACEINFO {
pub cEntries: u32,
pub rgIntTraceEntry: [INTTRACEENTRY; 1],
}
impl Default for INTTRACEINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
windows_core::imp::define_interface!(
IOlkAccount,
IOlkAccount_Vtbl,
0x9240a6d2_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccount {
type Target = IOlkErrorUnknown;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IOlkAccount, windows_core::IUnknown, IOlkErrorUnknown);
impl IOlkAccount {
pub unsafe fn PlaceHolder1(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder1)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder2(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder2)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder3(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder3)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder4(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder4)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder5(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder5)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder6(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder6)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn GetAccountInfo(
&self,
pclsidtype: *mut windows_core::GUID,
pccategories: *mut u32,
prgclsidcategory: *mut *mut windows_core::GUID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetAccountInfo)(
windows_core::Interface::as_raw(self),
pclsidtype as _,
pccategories as _,
prgclsidcategory as _,
)
.ok()
}
}
pub unsafe fn GetPropA(
&self,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetPropA)(
windows_core::Interface::as_raw(self),
dwprop,
pvar as _,
)
.ok()
}
}
pub unsafe fn SetPropA(
&self,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetPropA)(
windows_core::Interface::as_raw(self),
dwprop,
pvar as _,
)
.ok()
}
}
pub unsafe fn PlaceHolder7(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder7)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder8(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder8)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder9(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder9)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeMemory)(
windows_core::Interface::as_raw(self),
pv as _,
)
.ok()
}
}
pub unsafe fn PlaceHolder10(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder10)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn SaveChanges(&self, dwflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveChanges)(
windows_core::Interface::as_raw(self),
dwflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IOlkAccount_Vtbl {
pub base__: IOlkErrorUnknown_Vtbl,
pub PlaceHolder1: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder2: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder3: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder4: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder5: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder6: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub GetAccountInfo: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
*mut u32,
*mut *mut windows_core::GUID,
) -> windows_core::HRESULT,
pub GetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ACCT_VARIANT,
) -> windows_core::HRESULT,
pub SetPropA: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ACCT_VARIANT,
) -> windows_core::HRESULT,
pub PlaceHolder7: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder8: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder9: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub FreeMemory:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u8) -> windows_core::HRESULT,
pub PlaceHolder10: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub SaveChanges:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IOlkAccount_Impl: IOlkErrorUnknown_Impl {
fn PlaceHolder1(&self) -> windows_core::Result<()>;
fn PlaceHolder2(&self) -> windows_core::Result<()>;
fn PlaceHolder3(&self) -> windows_core::Result<()>;
fn PlaceHolder4(&self) -> windows_core::Result<()>;
fn PlaceHolder5(&self) -> windows_core::Result<()>;
fn PlaceHolder6(&self) -> windows_core::Result<()>;
fn GetAccountInfo(
&self,
pclsidtype: *mut windows_core::GUID,
pccategories: *mut u32,
prgclsidcategory: *mut *mut windows_core::GUID,
) -> windows_core::Result<()>;
fn GetPropA(&self, dwprop: u32, pvar: *mut ACCT_VARIANT) -> windows_core::Result<()>;
fn SetPropA(&self, dwprop: u32, pvar: *mut ACCT_VARIANT) -> windows_core::Result<()>;
fn PlaceHolder7(&self) -> windows_core::Result<()>;
fn PlaceHolder8(&self) -> windows_core::Result<()>;
fn PlaceHolder9(&self) -> windows_core::Result<()>;
fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()>;
fn PlaceHolder10(&self) -> windows_core::Result<()>;
fn SaveChanges(&self, dwflags: u32) -> windows_core::Result<()>;
}
impl IOlkAccount_Vtbl {
pub const fn new<Identity: IOlkAccount_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn PlaceHolder1<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder1(this).into()
}
}
unsafe extern "system" fn PlaceHolder2<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder2(this).into()
}
}
unsafe extern "system" fn PlaceHolder3<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder3(this).into()
}
}
unsafe extern "system" fn PlaceHolder4<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder4(this).into()
}
}
unsafe extern "system" fn PlaceHolder5<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder5(this).into()
}
}
unsafe extern "system" fn PlaceHolder6<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder6(this).into()
}
}
unsafe extern "system" fn GetAccountInfo<
Identity: IOlkAccount_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pclsidtype: *mut windows_core::GUID,
pccategories: *mut u32,
prgclsidcategory: *mut *mut windows_core::GUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::GetAccountInfo(
this,
core::mem::transmute_copy(&pclsidtype),
core::mem::transmute_copy(&pccategories),
core::mem::transmute_copy(&prgclsidcategory),
)
.into()
}
}
unsafe extern "system" fn GetPropA<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::GetPropA(
this,
core::mem::transmute_copy(&dwprop),
core::mem::transmute_copy(&pvar),
)
.into()
}
}
unsafe extern "system" fn SetPropA<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::SetPropA(
this,
core::mem::transmute_copy(&dwprop),
core::mem::transmute_copy(&pvar),
)
.into()
}
}
unsafe extern "system" fn PlaceHolder7<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder7(this).into()
}
}
unsafe extern "system" fn PlaceHolder8<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder8(this).into()
}
}
unsafe extern "system" fn PlaceHolder9<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder9(this).into()
}
}
unsafe extern "system" fn FreeMemory<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pv: *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::FreeMemory(this, core::mem::transmute_copy(&pv)).into()
}
}
unsafe extern "system" fn PlaceHolder10<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::PlaceHolder10(this).into()
}
}
unsafe extern "system" fn SaveChanges<Identity: IOlkAccount_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccount_Impl::SaveChanges(this, core::mem::transmute_copy(&dwflags)).into()
}
}
Self {
base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
PlaceHolder2: PlaceHolder2::<Identity, OFFSET>,
PlaceHolder3: PlaceHolder3::<Identity, OFFSET>,
PlaceHolder4: PlaceHolder4::<Identity, OFFSET>,
PlaceHolder5: PlaceHolder5::<Identity, OFFSET>,
PlaceHolder6: PlaceHolder6::<Identity, OFFSET>,
GetAccountInfo: GetAccountInfo::<Identity, OFFSET>,
GetPropA: GetPropA::<Identity, OFFSET>,
SetPropA: SetPropA::<Identity, OFFSET>,
PlaceHolder7: PlaceHolder7::<Identity, OFFSET>,
PlaceHolder8: PlaceHolder8::<Identity, OFFSET>,
PlaceHolder9: PlaceHolder9::<Identity, OFFSET>,
FreeMemory: FreeMemory::<Identity, OFFSET>,
PlaceHolder10: PlaceHolder10::<Identity, OFFSET>,
SaveChanges: SaveChanges::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkAccount as windows_core::Interface>::IID
|| iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkAccount {}
windows_core::imp::define_interface!(
IOlkAccountHelper,
IOlkAccountHelper_Vtbl,
0x9240a6cb_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkAccountHelper, windows_core::IUnknown);
impl IOlkAccountHelper {
pub unsafe fn PlaceHolder1(&self, param0: *mut core::ffi::c_void) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder1)(
windows_core::Interface::as_raw(self),
param0 as _,
)
.ok()
}
}
pub unsafe fn GetIdentity<P0>(
&self,
pwszidentity: P0,
pcch: *mut u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<windows_core::PCWSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).GetIdentity)(
windows_core::Interface::as_raw(self),
pwszidentity.param().abi(),
pcch as _,
)
.ok()
}
}
pub unsafe fn GetMapiSession(&self) -> windows_core::Result<windows_core::IUnknown> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetMapiSession)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn HandsOffSession(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HandsOffSession)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
}
#[repr(C)]
pub struct IOlkAccountHelper_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub PlaceHolder1: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub GetIdentity: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::PCWSTR,
*mut u32,
) -> windows_core::HRESULT,
pub GetMapiSession: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub HandsOffSession: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IOlkAccountHelper_Impl: windows_core::IUnknownImpl {
fn PlaceHolder1(&self, param0: *mut core::ffi::c_void) -> windows_core::Result<()>;
fn GetIdentity(
&self,
pwszidentity: &windows_core::PCWSTR,
pcch: *mut u32,
) -> windows_core::Result<()>;
fn GetMapiSession(&self) -> windows_core::Result<windows_core::IUnknown>;
fn HandsOffSession(&self) -> windows_core::Result<()>;
}
impl IOlkAccountHelper_Vtbl {
pub const fn new<Identity: IOlkAccountHelper_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn PlaceHolder1<
Identity: IOlkAccountHelper_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
param0: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountHelper_Impl::PlaceHolder1(this, core::mem::transmute_copy(¶m0))
.into()
}
}
unsafe extern "system" fn GetIdentity<
Identity: IOlkAccountHelper_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pwszidentity: windows_core::PCWSTR,
pcch: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountHelper_Impl::GetIdentity(
this,
core::mem::transmute(&pwszidentity),
core::mem::transmute_copy(&pcch),
)
.into()
}
}
unsafe extern "system" fn GetMapiSession<
Identity: IOlkAccountHelper_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ppmsess: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IOlkAccountHelper_Impl::GetMapiSession(this) {
Ok(ok__) => {
ppmsess.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn HandsOffSession<
Identity: IOlkAccountHelper_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountHelper_Impl::HandsOffSession(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
GetIdentity: GetIdentity::<Identity, OFFSET>,
GetMapiSession: GetMapiSession::<Identity, OFFSET>,
HandsOffSession: HandsOffSession::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkAccountHelper as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkAccountHelper {}
windows_core::imp::define_interface!(
IOlkAccountManager,
IOlkAccountManager_Vtbl,
0x9240a6cd_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccountManager {
type Target = IOlkErrorUnknown;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IOlkAccountManager,
windows_core::IUnknown,
IOlkErrorUnknown
);
impl IOlkAccountManager {
pub unsafe fn Init<P0>(&self, paccthelper: P0, dwflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IOlkAccountHelper>,
{
unsafe {
(windows_core::Interface::vtable(self).Init)(
windows_core::Interface::as_raw(self),
paccthelper.param().abi(),
dwflags,
)
.ok()
}
}
pub unsafe fn DisplayAccountList<P2>(
&self,
hwnd: windows::Win32::Foundation::HWND,
dwflags: u32,
wsztitle: P2,
ccategories: u32,
rgclsidcategories: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
) -> windows_core::Result<()>
where
P2: windows_core::Param<windows_core::PCWSTR>,
{
unsafe {
(windows_core::Interface::vtable(self).DisplayAccountList)(
windows_core::Interface::as_raw(self),
hwnd,
dwflags,
wsztitle.param().abi(),
ccategories,
rgclsidcategories,
pclsidtype,
)
.ok()
}
}
pub unsafe fn PlaceHolder1(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder1)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder2(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder2)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder3(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder3)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder4(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder4)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder5(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder5)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn FindAccount(
&self,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
ppaccount: *mut Option<IOlkAccount>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FindAccount)(
windows_core::Interface::as_raw(self),
dwprop,
pvar as _,
core::mem::transmute(ppaccount),
)
.ok()
}
}
pub unsafe fn PlaceHolder6(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder6)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder7(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder7)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder8(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder8)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn DeleteAccount(&self, dwacctid: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteAccount)(
windows_core::Interface::as_raw(self),
dwacctid,
)
.ok()
}
}
pub unsafe fn PlaceHolder9(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder9)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn SaveChanges(&self, dwacctid: u32, dwflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SaveChanges)(
windows_core::Interface::as_raw(self),
dwacctid,
dwflags,
)
.ok()
}
}
pub unsafe fn GetOrder(
&self,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetOrder)(
windows_core::Interface::as_raw(self),
pclsidcategory,
pcaccts as _,
prgaccts as _,
)
.ok()
}
}
pub unsafe fn SetOrder(
&self,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetOrder)(
windows_core::Interface::as_raw(self),
pclsidcategory,
pcaccts as _,
prgaccts as _,
)
.ok()
}
}
pub unsafe fn EnumerateAccounts(
&self,
pclsidcategory: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
dwflags: u32,
) -> windows_core::Result<IOlkEnum> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).EnumerateAccounts)(
windows_core::Interface::as_raw(self),
pclsidcategory,
pclsidtype,
dwflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn PlaceHolder10(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder10)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder11(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder11)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FreeMemory)(
windows_core::Interface::as_raw(self),
pv as _,
)
.ok()
}
}
pub unsafe fn Advise<P0>(&self, pnotify: P0, pdwcookie: *mut u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IOlkAccountNotify>,
{
unsafe {
(windows_core::Interface::vtable(self).Advise)(
windows_core::Interface::as_raw(self),
pnotify.param().abi(),
pdwcookie as _,
)
.ok()
}
}
pub unsafe fn Unadvise(&self, pdwcookie: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Unadvise)(
windows_core::Interface::as_raw(self),
pdwcookie as _,
)
.ok()
}
}
pub unsafe fn PlaceHolder12(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder12)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder13(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder13)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
pub unsafe fn PlaceHolder14(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).PlaceHolder14)(windows_core::Interface::as_raw(
self,
))
.ok()
}
}
}
#[repr(C)]
pub struct IOlkAccountManager_Vtbl {
pub base__: IOlkErrorUnknown_Vtbl,
pub Init: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub DisplayAccountList: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows::Win32::Foundation::HWND,
u32,
windows_core::PCWSTR,
u32,
*const windows_core::GUID,
*const windows_core::GUID,
) -> windows_core::HRESULT,
pub PlaceHolder1: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder2: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder3: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder4: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder5: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub FindAccount: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut ACCT_VARIANT,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub PlaceHolder6: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder7: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder8: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub DeleteAccount:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub PlaceHolder9: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub SaveChanges:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, u32) -> windows_core::HRESULT,
pub GetOrder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut u32,
*mut *mut u32,
) -> windows_core::HRESULT,
pub SetOrder: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut u32,
*mut *mut u32,
) -> windows_core::HRESULT,
pub EnumerateAccounts: unsafe extern "system" fn(
*mut core::ffi::c_void,
*const windows_core::GUID,
*const windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub PlaceHolder10: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder11: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub FreeMemory:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u8) -> windows_core::HRESULT,
pub Advise: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut u32,
) -> windows_core::HRESULT,
pub Unadvise:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub PlaceHolder12: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder13: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub PlaceHolder14: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IOlkAccountManager_Impl: IOlkErrorUnknown_Impl {
fn Init(
&self,
paccthelper: windows_core::Ref<'_, IOlkAccountHelper>,
dwflags: u32,
) -> windows_core::Result<()>;
fn DisplayAccountList(
&self,
hwnd: windows::Win32::Foundation::HWND,
dwflags: u32,
wsztitle: &windows_core::PCWSTR,
ccategories: u32,
rgclsidcategories: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
) -> windows_core::Result<()>;
fn PlaceHolder1(&self) -> windows_core::Result<()>;
fn PlaceHolder2(&self) -> windows_core::Result<()>;
fn PlaceHolder3(&self) -> windows_core::Result<()>;
fn PlaceHolder4(&self) -> windows_core::Result<()>;
fn PlaceHolder5(&self) -> windows_core::Result<()>;
fn FindAccount(
&self,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
ppaccount: windows_core::OutRef<'_, IOlkAccount>,
) -> windows_core::Result<()>;
fn PlaceHolder6(&self) -> windows_core::Result<()>;
fn PlaceHolder7(&self) -> windows_core::Result<()>;
fn PlaceHolder8(&self) -> windows_core::Result<()>;
fn DeleteAccount(&self, dwacctid: u32) -> windows_core::Result<()>;
fn PlaceHolder9(&self) -> windows_core::Result<()>;
fn SaveChanges(&self, dwacctid: u32, dwflags: u32) -> windows_core::Result<()>;
fn GetOrder(
&self,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::Result<()>;
fn SetOrder(
&self,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::Result<()>;
fn EnumerateAccounts(
&self,
pclsidcategory: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
dwflags: u32,
) -> windows_core::Result<IOlkEnum>;
fn PlaceHolder10(&self) -> windows_core::Result<()>;
fn PlaceHolder11(&self) -> windows_core::Result<()>;
fn FreeMemory(&self, pv: *mut u8) -> windows_core::Result<()>;
fn Advise(
&self,
pnotify: windows_core::Ref<'_, IOlkAccountNotify>,
pdwcookie: *mut u32,
) -> windows_core::Result<()>;
fn Unadvise(&self, pdwcookie: *mut u32) -> windows_core::Result<()>;
fn PlaceHolder12(&self) -> windows_core::Result<()>;
fn PlaceHolder13(&self) -> windows_core::Result<()>;
fn PlaceHolder14(&self) -> windows_core::Result<()>;
}
impl IOlkAccountManager_Vtbl {
pub const fn new<Identity: IOlkAccountManager_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Init<Identity: IOlkAccountManager_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
paccthelper: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::Init(
this,
core::mem::transmute_copy(&paccthelper),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn DisplayAccountList<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hwnd: windows::Win32::Foundation::HWND,
dwflags: u32,
wsztitle: windows_core::PCWSTR,
ccategories: u32,
rgclsidcategories: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::DisplayAccountList(
this,
core::mem::transmute_copy(&hwnd),
core::mem::transmute_copy(&dwflags),
core::mem::transmute(&wsztitle),
core::mem::transmute_copy(&ccategories),
core::mem::transmute_copy(&rgclsidcategories),
core::mem::transmute_copy(&pclsidtype),
)
.into()
}
}
unsafe extern "system" fn PlaceHolder1<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder1(this).into()
}
}
unsafe extern "system" fn PlaceHolder2<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder2(this).into()
}
}
unsafe extern "system" fn PlaceHolder3<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder3(this).into()
}
}
unsafe extern "system" fn PlaceHolder4<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder4(this).into()
}
}
unsafe extern "system" fn PlaceHolder5<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder5(this).into()
}
}
unsafe extern "system" fn FindAccount<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwprop: u32,
pvar: *mut ACCT_VARIANT,
ppaccount: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::FindAccount(
this,
core::mem::transmute_copy(&dwprop),
core::mem::transmute_copy(&pvar),
core::mem::transmute_copy(&ppaccount),
)
.into()
}
}
unsafe extern "system" fn PlaceHolder6<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder6(this).into()
}
}
unsafe extern "system" fn PlaceHolder7<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder7(this).into()
}
}
unsafe extern "system" fn PlaceHolder8<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder8(this).into()
}
}
unsafe extern "system" fn DeleteAccount<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwacctid: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::DeleteAccount(this, core::mem::transmute_copy(&dwacctid))
.into()
}
}
unsafe extern "system" fn PlaceHolder9<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder9(this).into()
}
}
unsafe extern "system" fn SaveChanges<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
dwacctid: u32,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::SaveChanges(
this,
core::mem::transmute_copy(&dwacctid),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
unsafe extern "system" fn GetOrder<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::GetOrder(
this,
core::mem::transmute_copy(&pclsidcategory),
core::mem::transmute_copy(&pcaccts),
core::mem::transmute_copy(&prgaccts),
)
.into()
}
}
unsafe extern "system" fn SetOrder<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pclsidcategory: *const windows_core::GUID,
pcaccts: *mut u32,
prgaccts: *mut *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::SetOrder(
this,
core::mem::transmute_copy(&pclsidcategory),
core::mem::transmute_copy(&pcaccts),
core::mem::transmute_copy(&prgaccts),
)
.into()
}
}
unsafe extern "system" fn EnumerateAccounts<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pclsidcategory: *const windows_core::GUID,
pclsidtype: *const windows_core::GUID,
dwflags: u32,
ppenum: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IOlkAccountManager_Impl::EnumerateAccounts(
this,
core::mem::transmute_copy(&pclsidcategory),
core::mem::transmute_copy(&pclsidtype),
core::mem::transmute_copy(&dwflags),
) {
Ok(ok__) => {
ppenum.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn PlaceHolder10<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder10(this).into()
}
}
unsafe extern "system" fn PlaceHolder11<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder11(this).into()
}
}
unsafe extern "system" fn FreeMemory<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pv: *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::FreeMemory(this, core::mem::transmute_copy(&pv)).into()
}
}
unsafe extern "system" fn Advise<Identity: IOlkAccountManager_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pnotify: *mut core::ffi::c_void,
pdwcookie: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::Advise(
this,
core::mem::transmute_copy(&pnotify),
core::mem::transmute_copy(&pdwcookie),
)
.into()
}
}
unsafe extern "system" fn Unadvise<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pdwcookie: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::Unadvise(this, core::mem::transmute_copy(&pdwcookie))
.into()
}
}
unsafe extern "system" fn PlaceHolder12<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder12(this).into()
}
}
unsafe extern "system" fn PlaceHolder13<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder13(this).into()
}
}
unsafe extern "system" fn PlaceHolder14<
Identity: IOlkAccountManager_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkAccountManager_Impl::PlaceHolder14(this).into()
}
}
Self {
base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
Init: Init::<Identity, OFFSET>,
DisplayAccountList: DisplayAccountList::<Identity, OFFSET>,
PlaceHolder1: PlaceHolder1::<Identity, OFFSET>,
PlaceHolder2: PlaceHolder2::<Identity, OFFSET>,
PlaceHolder3: PlaceHolder3::<Identity, OFFSET>,
PlaceHolder4: PlaceHolder4::<Identity, OFFSET>,
PlaceHolder5: PlaceHolder5::<Identity, OFFSET>,
FindAccount: FindAccount::<Identity, OFFSET>,
PlaceHolder6: PlaceHolder6::<Identity, OFFSET>,
PlaceHolder7: PlaceHolder7::<Identity, OFFSET>,
PlaceHolder8: PlaceHolder8::<Identity, OFFSET>,
DeleteAccount: DeleteAccount::<Identity, OFFSET>,
PlaceHolder9: PlaceHolder9::<Identity, OFFSET>,
SaveChanges: SaveChanges::<Identity, OFFSET>,
GetOrder: GetOrder::<Identity, OFFSET>,
SetOrder: SetOrder::<Identity, OFFSET>,
EnumerateAccounts: EnumerateAccounts::<Identity, OFFSET>,
PlaceHolder10: PlaceHolder10::<Identity, OFFSET>,
PlaceHolder11: PlaceHolder11::<Identity, OFFSET>,
FreeMemory: FreeMemory::<Identity, OFFSET>,
Advise: Advise::<Identity, OFFSET>,
Unadvise: Unadvise::<Identity, OFFSET>,
PlaceHolder12: PlaceHolder12::<Identity, OFFSET>,
PlaceHolder13: PlaceHolder13::<Identity, OFFSET>,
PlaceHolder14: PlaceHolder14::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkAccountManager as windows_core::Interface>::IID
|| iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkAccountManager {}
windows_core::imp::define_interface!(
IOlkAccountNotify,
IOlkAccountNotify_Vtbl,
0x9240a6c3_af41_11d2_8c3b_00104b2a6676
);
impl core::ops::Deref for IOlkAccountNotify {
type Target = IOlkErrorUnknown;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IOlkAccountNotify,
windows_core::IUnknown,
IOlkErrorUnknown
);
#[repr(C)]
pub struct IOlkAccountNotify_Vtbl {
pub base__: IOlkErrorUnknown_Vtbl,
}
pub trait IOlkAccountNotify_Impl: IOlkErrorUnknown_Impl {}
impl IOlkAccountNotify_Vtbl {
pub const fn new<Identity: IOlkAccountNotify_Impl, const OFFSET: isize>() -> Self {
Self {
base__: IOlkErrorUnknown_Vtbl::new::<Identity, OFFSET>(),
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkAccountNotify as windows_core::Interface>::IID
|| iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkAccountNotify {}
windows_core::imp::define_interface!(
IOlkEnum,
IOlkEnum_Vtbl,
0x9240a6c0_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkEnum, windows_core::IUnknown);
impl IOlkEnum {
pub unsafe fn GetCount(&self, pulcount: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetCount)(
windows_core::Interface::as_raw(self),
pulcount as _,
)
.ok()
}
}
pub unsafe fn Reset(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Reset)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn GetNext(&self) -> windows_core::Result<windows_core::IUnknown> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetNext)(
windows_core::Interface::as_raw(self),
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn Skip(&self, cskip: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Skip)(
windows_core::Interface::as_raw(self),
cskip,
)
.ok()
}
}
}
#[repr(C)]
pub struct IOlkEnum_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetCount:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub Reset: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub GetNext: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Skip: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
}
pub trait IOlkEnum_Impl: windows_core::IUnknownImpl {
fn GetCount(&self, pulcount: *mut u32) -> windows_core::Result<()>;
fn Reset(&self) -> windows_core::Result<()>;
fn GetNext(&self) -> windows_core::Result<windows_core::IUnknown>;
fn Skip(&self, cskip: u32) -> windows_core::Result<()>;
}
impl IOlkEnum_Vtbl {
pub const fn new<Identity: IOlkEnum_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetCount<Identity: IOlkEnum_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pulcount: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkEnum_Impl::GetCount(this, core::mem::transmute_copy(&pulcount)).into()
}
}
unsafe extern "system" fn Reset<Identity: IOlkEnum_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkEnum_Impl::Reset(this).into()
}
}
unsafe extern "system" fn GetNext<Identity: IOlkEnum_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ppunk: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IOlkEnum_Impl::GetNext(this) {
Ok(ok__) => {
ppunk.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn Skip<Identity: IOlkEnum_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
cskip: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkEnum_Impl::Skip(this, core::mem::transmute_copy(&cskip)).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetCount: GetCount::<Identity, OFFSET>,
Reset: Reset::<Identity, OFFSET>,
GetNext: GetNext::<Identity, OFFSET>,
Skip: Skip::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkEnum as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkEnum {}
windows_core::imp::define_interface!(
IOlkErrorUnknown,
IOlkErrorUnknown_Vtbl,
0x9240a6c0_af41_11d2_8c3b_00104b2a6676
);
windows_core::imp::interface_hierarchy!(IOlkErrorUnknown, windows_core::IUnknown);
impl IOlkErrorUnknown {
pub unsafe fn GetLastError(
&self,
hr: windows_core::HRESULT,
ppwszerror: *mut windows_core::PWSTR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hr,
ppwszerror as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IOlkErrorUnknown_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
*mut windows_core::PWSTR,
) -> windows_core::HRESULT,
}
pub trait IOlkErrorUnknown_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hr: windows_core::HRESULT,
ppwszerror: *mut windows_core::PWSTR,
) -> windows_core::Result<()>;
}
impl IOlkErrorUnknown_Vtbl {
pub const fn new<Identity: IOlkErrorUnknown_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IOlkErrorUnknown_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hr: windows_core::HRESULT,
ppwszerror: *mut windows_core::PWSTR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IOlkErrorUnknown_Impl::GetLastError(
this,
core::mem::transmute_copy(&hr),
core::mem::transmute_copy(&ppwszerror),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IOlkErrorUnknown as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IOlkErrorUnknown {}
pub const IPROP_CLEAN: u32 = 65536u32;
pub const IPROP_DIRTY: u32 = 131072u32;
pub const IPROP_READONLY: u32 = 1u32;
pub const IPROP_READWRITE: u32 = 2u32;
windows_core::imp::define_interface!(
IPersistMessage,
IPersistMessage_Vtbl,
0x0002032a_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IPersistMessage, windows_core::IUnknown);
impl IPersistMessage {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetClassID(
&self,
lpclassid: *mut windows_core::GUID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetClassID)(
windows_core::Interface::as_raw(self),
lpclassid as _,
)
.ok()
}
}
pub unsafe fn IsDirty(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).IsDirty)(windows_core::Interface::as_raw(self))
.ok()
}
}
pub unsafe fn InitNew<P0, P1>(&self, pmessagesite: P0, pmessage: P1) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIMessageSite>,
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).InitNew)(
windows_core::Interface::as_raw(self),
pmessagesite.param().abi(),
pmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn Load<P0, P1>(
&self,
pmessagesite: P0,
pmessage: P1,
ulmessagestatus: u32,
ulmessageflags: u32,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPIMessageSite>,
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).Load)(
windows_core::Interface::as_raw(self),
pmessagesite.param().abi(),
pmessage.param().abi(),
ulmessagestatus,
ulmessageflags,
)
.ok()
}
}
pub unsafe fn Save<P0>(&self, pmessage: P0, fsameasload: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).Save)(
windows_core::Interface::as_raw(self),
pmessage.param().abi(),
fsameasload,
)
.ok()
}
}
pub unsafe fn SaveCompleted<P0>(&self, pmessage: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).SaveCompleted)(
windows_core::Interface::as_raw(self),
pmessage.param().abi(),
)
.ok()
}
}
pub unsafe fn HandsOffMessage(&self) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HandsOffMessage)(
windows_core::Interface::as_raw(self),
)
.ok()
}
}
}
#[repr(C)]
pub struct IPersistMessage_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetClassID: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
) -> windows_core::HRESULT,
pub IsDirty: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
pub InitNew: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Load: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
u32,
) -> windows_core::HRESULT,
pub Save: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
pub SaveCompleted: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub HandsOffMessage: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
}
pub trait IPersistMessage_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetClassID(&self, lpclassid: *mut windows_core::GUID) -> windows_core::Result<()>;
fn IsDirty(&self) -> windows_core::Result<()>;
fn InitNew(
&self,
pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
pmessage: windows_core::Ref<'_, IMessage>,
) -> windows_core::Result<()>;
fn Load(
&self,
pmessagesite: windows_core::Ref<'_, IMAPIMessageSite>,
pmessage: windows_core::Ref<'_, IMessage>,
ulmessagestatus: u32,
ulmessageflags: u32,
) -> windows_core::Result<()>;
fn Save(
&self,
pmessage: windows_core::Ref<'_, IMessage>,
fsameasload: u32,
) -> windows_core::Result<()>;
fn SaveCompleted(&self, pmessage: windows_core::Ref<'_, IMessage>) -> windows_core::Result<()>;
fn HandsOffMessage(&self) -> windows_core::Result<()>;
}
impl IPersistMessage_Vtbl {
pub const fn new<Identity: IPersistMessage_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IPersistMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetClassID<
Identity: IPersistMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpclassid: *mut windows_core::GUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::GetClassID(this, core::mem::transmute_copy(&lpclassid)).into()
}
}
unsafe extern "system" fn IsDirty<Identity: IPersistMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::IsDirty(this).into()
}
}
unsafe extern "system" fn InitNew<Identity: IPersistMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmessagesite: *mut core::ffi::c_void,
pmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::InitNew(
this,
core::mem::transmute_copy(&pmessagesite),
core::mem::transmute_copy(&pmessage),
)
.into()
}
}
unsafe extern "system" fn Load<Identity: IPersistMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmessagesite: *mut core::ffi::c_void,
pmessage: *mut core::ffi::c_void,
ulmessagestatus: u32,
ulmessageflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::Load(
this,
core::mem::transmute_copy(&pmessagesite),
core::mem::transmute_copy(&pmessage),
core::mem::transmute_copy(&ulmessagestatus),
core::mem::transmute_copy(&ulmessageflags),
)
.into()
}
}
unsafe extern "system" fn Save<Identity: IPersistMessage_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmessage: *mut core::ffi::c_void,
fsameasload: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::Save(
this,
core::mem::transmute_copy(&pmessage),
core::mem::transmute_copy(&fsameasload),
)
.into()
}
}
unsafe extern "system" fn SaveCompleted<
Identity: IPersistMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
pmessage: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::SaveCompleted(this, core::mem::transmute_copy(&pmessage))
.into()
}
}
unsafe extern "system" fn HandsOffMessage<
Identity: IPersistMessage_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMessage_Impl::HandsOffMessage(this).into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetClassID: GetClassID::<Identity, OFFSET>,
IsDirty: IsDirty::<Identity, OFFSET>,
InitNew: InitNew::<Identity, OFFSET>,
Load: Load::<Identity, OFFSET>,
Save: Save::<Identity, OFFSET>,
SaveCompleted: SaveCompleted::<Identity, OFFSET>,
HandsOffMessage: HandsOffMessage::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IPersistMessage as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IPersistMessage {}
windows_core::imp::define_interface!(
IPersistMime,
IPersistMime_Vtbl,
0xde4ad8da_555f_11d1_8dd0_00c04fb951f9
);
impl core::ops::Deref for IPersistMime {
type Target = windows::Win32::System::Com::IPersist;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(
IPersistMime,
windows_core::IUnknown,
windows::Win32::System::Com::IPersist
);
impl IPersistMime {
pub unsafe fn Load<P0>(&self, pmsg: P0) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).Load)(
windows_core::Interface::as_raw(self),
pmsg.param().abi(),
)
.ok()
}
}
pub unsafe fn Save<P0>(&self, pmsg: P0, dwflags: u32) -> windows_core::Result<()>
where
P0: windows_core::Param<IMimeMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).Save)(
windows_core::Interface::as_raw(self),
pmsg.param().abi(),
dwflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IPersistMime_Vtbl {
pub base__: windows::Win32::System::Com::IPersist_Vtbl,
pub Load: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Save: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
u32,
) -> windows_core::HRESULT,
}
pub trait IPersistMime_Impl: windows::Win32::System::Com::IPersist_Impl {
fn Load(&self, pmsg: windows_core::Ref<'_, IMimeMessage>) -> windows_core::Result<()>;
fn Save(
&self,
pmsg: windows_core::Ref<'_, IMimeMessage>,
dwflags: u32,
) -> windows_core::Result<()>;
}
impl IPersistMime_Vtbl {
pub const fn new<Identity: IPersistMime_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Load<Identity: IPersistMime_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmsg: *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMime_Impl::Load(this, core::mem::transmute_copy(&pmsg)).into()
}
}
unsafe extern "system" fn Save<Identity: IPersistMime_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
pmsg: *mut core::ffi::c_void,
dwflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPersistMime_Impl::Save(
this,
core::mem::transmute_copy(&pmsg),
core::mem::transmute_copy(&dwflags),
)
.into()
}
}
Self {
base__: windows::Win32::System::Com::IPersist_Vtbl::new::<Identity, OFFSET>(),
Load: Load::<Identity, OFFSET>,
Save: Save::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IPersistMime as windows_core::Interface>::IID
|| iid == &<windows::Win32::System::Com::IPersist as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IPersistMime {}
windows_core::imp::define_interface!(
IProfAdmin,
IProfAdmin_Vtbl,
0x0002031c_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IProfAdmin, windows_core::IUnknown);
impl IProfAdmin {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetProfileTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetProfileTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn CreateProfile(
&self,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateProfile)(
windows_core::Interface::as_raw(self),
lpszprofilename as _,
lpszpassword as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn DeleteProfile(
&self,
lpszprofilename: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteProfile)(
windows_core::Interface::as_raw(self),
lpszprofilename as _,
ulflags,
)
.ok()
}
}
pub unsafe fn ChangeProfilePassword(
&self,
lpszprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewpassword: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ChangeProfilePassword)(
windows_core::Interface::as_raw(self),
lpszprofilename as _,
lpszoldpassword as _,
lpsznewpassword as _,
ulflags,
)
.ok()
}
}
pub unsafe fn CopyProfile(
&self,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CopyProfile)(
windows_core::Interface::as_raw(self),
lpszoldprofilename as _,
lpszoldpassword as _,
lpsznewprofilename as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn RenameProfile(
&self,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RenameProfile)(
windows_core::Interface::as_raw(self),
lpszoldprofilename as _,
lpszoldpassword as _,
lpsznewprofilename as _,
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn SetDefaultProfile(
&self,
lpszprofilename: *mut i8,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).SetDefaultProfile)(
windows_core::Interface::as_raw(self),
lpszprofilename as _,
ulflags,
)
.ok()
}
}
pub unsafe fn AdminServices(
&self,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
lppserviceadmin: *mut Option<IMsgServiceAdmin>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AdminServices)(
windows_core::Interface::as_raw(self),
lpszprofilename as _,
lpszpassword as _,
uluiparam,
ulflags,
core::mem::transmute(lppserviceadmin),
)
.ok()
}
}
}
#[repr(C)]
pub struct IProfAdmin_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetProfileTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateProfile: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
usize,
u32,
) -> windows_core::HRESULT,
pub DeleteProfile:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8, u32) -> windows_core::HRESULT,
pub ChangeProfilePassword: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
*mut i8,
u32,
) -> windows_core::HRESULT,
pub CopyProfile: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
*mut i8,
usize,
u32,
) -> windows_core::HRESULT,
pub RenameProfile: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
*mut i8,
usize,
u32,
) -> windows_core::HRESULT,
pub SetDefaultProfile:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut i8, u32) -> windows_core::HRESULT,
pub AdminServices: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
*mut i8,
usize,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IProfAdmin_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetProfileTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn CreateProfile(
&self,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn DeleteProfile(&self, lpszprofilename: *mut i8, ulflags: u32) -> windows_core::Result<()>;
fn ChangeProfilePassword(
&self,
lpszprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewpassword: *mut i8,
ulflags: u32,
) -> windows_core::Result<()>;
fn CopyProfile(
&self,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn RenameProfile(
&self,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::Result<()>;
fn SetDefaultProfile(&self, lpszprofilename: *mut i8, ulflags: u32)
-> windows_core::Result<()>;
fn AdminServices(
&self,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
lppserviceadmin: windows_core::OutRef<'_, IMsgServiceAdmin>,
) -> windows_core::Result<()>;
}
impl IProfAdmin_Vtbl {
pub const fn new<Identity: IProfAdmin_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetProfileTable<
Identity: IProfAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IProfAdmin_Impl::GetProfileTable(this, core::mem::transmute_copy(&ulflags)) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn CreateProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::CreateProfile(
this,
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&lpszpassword),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn DeleteProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszprofilename: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::DeleteProfile(
this,
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn ChangeProfilePassword<
Identity: IProfAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewpassword: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::ChangeProfilePassword(
this,
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&lpszoldpassword),
core::mem::transmute_copy(&lpsznewpassword),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn CopyProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::CopyProfile(
this,
core::mem::transmute_copy(&lpszoldprofilename),
core::mem::transmute_copy(&lpszoldpassword),
core::mem::transmute_copy(&lpsznewprofilename),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn RenameProfile<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszoldprofilename: *mut i8,
lpszoldpassword: *mut i8,
lpsznewprofilename: *mut i8,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::RenameProfile(
this,
core::mem::transmute_copy(&lpszoldprofilename),
core::mem::transmute_copy(&lpszoldpassword),
core::mem::transmute_copy(&lpsznewprofilename),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn SetDefaultProfile<
Identity: IProfAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszprofilename: *mut i8,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::SetDefaultProfile(
this,
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn AdminServices<Identity: IProfAdmin_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpszprofilename: *mut i8,
lpszpassword: *mut i8,
uluiparam: usize,
ulflags: u32,
lppserviceadmin: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProfAdmin_Impl::AdminServices(
this,
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&lpszpassword),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppserviceadmin),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetProfileTable: GetProfileTable::<Identity, OFFSET>,
CreateProfile: CreateProfile::<Identity, OFFSET>,
DeleteProfile: DeleteProfile::<Identity, OFFSET>,
ChangeProfilePassword: ChangeProfilePassword::<Identity, OFFSET>,
CopyProfile: CopyProfile::<Identity, OFFSET>,
RenameProfile: RenameProfile::<Identity, OFFSET>,
SetDefaultProfile: SetDefaultProfile::<Identity, OFFSET>,
AdminServices: AdminServices::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IProfAdmin as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IProfAdmin {}
windows_core::imp::define_interface!(
IProfSect,
IProfSect_Vtbl,
0x00020304_0000_0000_c000_000000000046
);
impl core::ops::Deref for IProfSect {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IProfSect, windows_core::IUnknown, IMAPIProp);
#[repr(C)]
pub struct IProfSect_Vtbl {
pub base__: IMAPIProp_Vtbl,
}
pub trait IProfSect_Impl: IMAPIProp_Impl {}
impl IProfSect_Vtbl {
pub const fn new<Identity: IProfSect_Impl, const OFFSET: isize>() -> Self {
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IProfSect as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IProfSect {}
windows_core::imp::define_interface!(IPropData, IPropData_Vtbl, 0);
impl core::ops::Deref for IPropData {
type Target = IMAPIProp;
fn deref(&self) -> &Self::Target {
unsafe { core::mem::transmute(self) }
}
}
windows_core::imp::interface_hierarchy!(IPropData, windows_core::IUnknown, IMAPIProp);
impl IPropData {
pub unsafe fn HrSetObjAccess(&self, ulaccess: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrSetObjAccess)(
windows_core::Interface::as_raw(self),
ulaccess,
)
.ok()
}
}
pub unsafe fn HrSetPropAccess(
&self,
lpproptagarray: *mut SPropTagArray,
rgulaccess: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrSetPropAccess)(
windows_core::Interface::as_raw(self),
lpproptagarray as _,
rgulaccess as _,
)
.ok()
}
}
pub unsafe fn HrGetPropAccess(
&self,
lppproptagarray: *mut *mut SPropTagArray,
lprgulaccess: *mut *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrGetPropAccess)(
windows_core::Interface::as_raw(self),
lppproptagarray as _,
lprgulaccess as _,
)
.ok()
}
}
pub unsafe fn HrAddObjProps(
&self,
lppproptagarray: *mut SPropTagArray,
lprgulaccess: *mut *mut SPropProblemArray,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrAddObjProps)(
windows_core::Interface::as_raw(self),
lppproptagarray as _,
lprgulaccess as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct IPropData_Vtbl {
pub base__: IMAPIProp_Vtbl,
pub HrSetObjAccess:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub HrSetPropAccess: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
*mut u32,
) -> windows_core::HRESULT,
pub HrGetPropAccess: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut *mut SPropTagArray,
*mut *mut u32,
) -> windows_core::HRESULT,
pub HrAddObjProps: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropTagArray,
*mut *mut SPropProblemArray,
) -> windows_core::HRESULT,
}
pub trait IPropData_Impl: IMAPIProp_Impl {
fn HrSetObjAccess(&self, ulaccess: u32) -> windows_core::Result<()>;
fn HrSetPropAccess(
&self,
lpproptagarray: *mut SPropTagArray,
rgulaccess: *mut u32,
) -> windows_core::Result<()>;
fn HrGetPropAccess(
&self,
lppproptagarray: *mut *mut SPropTagArray,
lprgulaccess: *mut *mut u32,
) -> windows_core::Result<()>;
fn HrAddObjProps(
&self,
lppproptagarray: *mut SPropTagArray,
lprgulaccess: *mut *mut SPropProblemArray,
) -> windows_core::Result<()>;
}
impl IPropData_Vtbl {
pub const fn new<Identity: IPropData_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn HrSetObjAccess<Identity: IPropData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulaccess: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPropData_Impl::HrSetObjAccess(this, core::mem::transmute_copy(&ulaccess)).into()
}
}
unsafe extern "system" fn HrSetPropAccess<Identity: IPropData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpproptagarray: *mut SPropTagArray,
rgulaccess: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPropData_Impl::HrSetPropAccess(
this,
core::mem::transmute_copy(&lpproptagarray),
core::mem::transmute_copy(&rgulaccess),
)
.into()
}
}
unsafe extern "system" fn HrGetPropAccess<Identity: IPropData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lppproptagarray: *mut *mut SPropTagArray,
lprgulaccess: *mut *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPropData_Impl::HrGetPropAccess(
this,
core::mem::transmute_copy(&lppproptagarray),
core::mem::transmute_copy(&lprgulaccess),
)
.into()
}
}
unsafe extern "system" fn HrAddObjProps<Identity: IPropData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lppproptagarray: *mut SPropTagArray,
lprgulaccess: *mut *mut SPropProblemArray,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IPropData_Impl::HrAddObjProps(
this,
core::mem::transmute_copy(&lppproptagarray),
core::mem::transmute_copy(&lprgulaccess),
)
.into()
}
}
Self {
base__: IMAPIProp_Vtbl::new::<Identity, OFFSET>(),
HrSetObjAccess: HrSetObjAccess::<Identity, OFFSET>,
HrSetPropAccess: HrSetPropAccess::<Identity, OFFSET>,
HrGetPropAccess: HrGetPropAccess::<Identity, OFFSET>,
HrAddObjProps: HrAddObjProps::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IPropData as windows_core::Interface>::IID
|| iid == &<IMAPIProp as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IPropData {}
windows_core::imp::define_interface!(
IProviderAdmin,
IProviderAdmin_Vtbl,
0x00020325_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IProviderAdmin, windows_core::IUnknown);
impl IProviderAdmin {
pub unsafe fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).GetLastError)(
windows_core::Interface::as_raw(self),
hresult,
ulflags,
lppmapierror as _,
)
.ok()
}
}
pub unsafe fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable> {
unsafe {
let mut result__ = core::mem::zeroed();
(windows_core::Interface::vtable(self).GetProviderTable)(
windows_core::Interface::as_raw(self),
ulflags,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
pub unsafe fn CreateProvider(
&self,
lpszprovider: *mut i8,
cvalues: u32,
lpprops: *mut SPropValue,
uluiparam: usize,
ulflags: u32,
lpuid: *mut MAPIUID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).CreateProvider)(
windows_core::Interface::as_raw(self),
lpszprovider as _,
cvalues,
lpprops as _,
uluiparam,
ulflags,
lpuid as _,
)
.ok()
}
}
pub unsafe fn DeleteProvider(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).DeleteProvider)(
windows_core::Interface::as_raw(self),
lpuid as _,
)
.ok()
}
}
pub unsafe fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut Option<IProfSect>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenProfileSection)(
windows_core::Interface::as_raw(self),
lpuid as _,
lpinterface as _,
ulflags,
core::mem::transmute(lppprofsect),
)
.ok()
}
}
}
#[repr(C)]
pub struct IProviderAdmin_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub GetLastError: unsafe extern "system" fn(
*mut core::ffi::c_void,
windows_core::HRESULT,
u32,
*mut *mut MAPIERROR,
) -> windows_core::HRESULT,
pub GetProviderTable: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub CreateProvider: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut i8,
u32,
*mut SPropValue,
usize,
u32,
*mut MAPIUID,
) -> windows_core::HRESULT,
pub DeleteProvider:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut MAPIUID) -> windows_core::HRESULT,
pub OpenProfileSection: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut MAPIUID,
*mut windows_core::GUID,
u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IProviderAdmin_Impl: windows_core::IUnknownImpl {
fn GetLastError(
&self,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::Result<()>;
fn GetProviderTable(&self, ulflags: u32) -> windows_core::Result<IMAPITable>;
fn CreateProvider(
&self,
lpszprovider: *mut i8,
cvalues: u32,
lpprops: *mut SPropValue,
uluiparam: usize,
ulflags: u32,
lpuid: *mut MAPIUID,
) -> windows_core::Result<()>;
fn DeleteProvider(&self, lpuid: *mut MAPIUID) -> windows_core::Result<()>;
fn OpenProfileSection(
&self,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: windows_core::OutRef<'_, IProfSect>,
) -> windows_core::Result<()>;
}
impl IProviderAdmin_Vtbl {
pub const fn new<Identity: IProviderAdmin_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn GetLastError<
Identity: IProviderAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
hresult: windows_core::HRESULT,
ulflags: u32,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProviderAdmin_Impl::GetLastError(
this,
core::mem::transmute_copy(&hresult),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppmapierror),
)
.into()
}
}
unsafe extern "system" fn GetProviderTable<
Identity: IProviderAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpptable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
match IProviderAdmin_Impl::GetProviderTable(
this,
core::mem::transmute_copy(&ulflags),
) {
Ok(ok__) => {
lpptable.write(core::mem::transmute(ok__));
windows_core::HRESULT(0)
}
Err(err) => err.into(),
}
}
}
unsafe extern "system" fn CreateProvider<
Identity: IProviderAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpszprovider: *mut i8,
cvalues: u32,
lpprops: *mut SPropValue,
uluiparam: usize,
ulflags: u32,
lpuid: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProviderAdmin_Impl::CreateProvider(
this,
core::mem::transmute_copy(&lpszprovider),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpprops),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpuid),
)
.into()
}
}
unsafe extern "system" fn DeleteProvider<
Identity: IProviderAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProviderAdmin_Impl::DeleteProvider(this, core::mem::transmute_copy(&lpuid)).into()
}
}
unsafe extern "system" fn OpenProfileSection<
Identity: IProviderAdmin_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpuid: *mut MAPIUID,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lppprofsect: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IProviderAdmin_Impl::OpenProfileSection(
this,
core::mem::transmute_copy(&lpuid),
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lppprofsect),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
GetLastError: GetLastError::<Identity, OFFSET>,
GetProviderTable: GetProviderTable::<Identity, OFFSET>,
CreateProvider: CreateProvider::<Identity, OFFSET>,
DeleteProvider: DeleteProvider::<Identity, OFFSET>,
OpenProfileSection: OpenProfileSection::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IProviderAdmin as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IProviderAdmin {}
windows_core::imp::define_interface!(
ISpoolerHook,
ISpoolerHook_Vtbl,
0x00020320_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(ISpoolerHook, windows_core::IUnknown);
impl ISpoolerHook {
pub unsafe fn InboundMsgHook<P0, P1, P2>(
&self,
lpmessage: P0,
lpfolder: P1,
lpmdb: P2,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
P1: windows_core::Param<IMAPIFolder>,
P2: windows_core::Param<IMsgStore>,
{
unsafe {
(windows_core::Interface::vtable(self).InboundMsgHook)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
lpfolder.param().abi(),
lpmdb.param().abi(),
lpulflags as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
pub unsafe fn OutboundMsgHook<P0, P1, P2>(
&self,
lpmessage: P0,
lpfolder: P1,
lpmdb: P2,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMessage>,
P1: windows_core::Param<IMAPIFolder>,
P2: windows_core::Param<IMsgStore>,
{
unsafe {
(windows_core::Interface::vtable(self).OutboundMsgHook)(
windows_core::Interface::as_raw(self),
lpmessage.param().abi(),
lpfolder.param().abi(),
lpmdb.param().abi(),
lpulflags as _,
lpcbentryid as _,
lppentryid as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct ISpoolerHook_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub InboundMsgHook: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut *mut u8,
) -> windows_core::HRESULT,
pub OutboundMsgHook: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut *mut u8,
) -> windows_core::HRESULT,
}
pub trait ISpoolerHook_Impl: windows_core::IUnknownImpl {
fn InboundMsgHook(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
lpfolder: windows_core::Ref<'_, IMAPIFolder>,
lpmdb: windows_core::Ref<'_, IMsgStore>,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::Result<()>;
fn OutboundMsgHook(
&self,
lpmessage: windows_core::Ref<'_, IMessage>,
lpfolder: windows_core::Ref<'_, IMAPIFolder>,
lpmdb: windows_core::Ref<'_, IMsgStore>,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::Result<()>;
}
impl ISpoolerHook_Vtbl {
pub const fn new<Identity: ISpoolerHook_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn InboundMsgHook<
Identity: ISpoolerHook_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
lpfolder: *mut core::ffi::c_void,
lpmdb: *mut core::ffi::c_void,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ISpoolerHook_Impl::InboundMsgHook(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpfolder),
core::mem::transmute_copy(&lpmdb),
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
unsafe extern "system" fn OutboundMsgHook<
Identity: ISpoolerHook_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmessage: *mut core::ffi::c_void,
lpfolder: *mut core::ffi::c_void,
lpmdb: *mut core::ffi::c_void,
lpulflags: *mut u32,
lpcbentryid: *mut u32,
lppentryid: *mut *mut u8,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ISpoolerHook_Impl::OutboundMsgHook(
this,
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpfolder),
core::mem::transmute_copy(&lpmdb),
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lpcbentryid),
core::mem::transmute_copy(&lppentryid),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
InboundMsgHook: InboundMsgHook::<Identity, OFFSET>,
OutboundMsgHook: OutboundMsgHook::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<ISpoolerHook as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for ISpoolerHook {}
pub const IStream_Clone: METHODS = METHODS(136i32);
pub const IStream_Commit: METHODS = METHODS(131i32);
pub const IStream_CopyTo: METHODS = METHODS(130i32);
pub const IStream_LockRegion: METHODS = METHODS(133i32);
pub const IStream_Revert: METHODS = METHODS(132i32);
pub const IStream_Seek: METHODS = METHODS(128i32);
pub const IStream_SetSize: METHODS = METHODS(129i32);
pub const IStream_Stat: METHODS = METHODS(135i32);
pub const IStream_UnlockRegion: METHODS = METHODS(134i32);
pub const IStream__Read: METHODS = METHODS(126i32);
pub const IStream__Write: METHODS = METHODS(127i32);
pub const ITEMPROC_FORCE: u32 = 2048u32;
pub const ITT_ENCRYPTION: u32 = 2u32;
pub const ITT_SIGNING: u32 = 1u32;
windows_core::imp::define_interface!(ITableData, ITableData_Vtbl, 0);
windows_core::imp::interface_hierarchy!(ITableData, windows_core::IUnknown);
impl ITableData {
pub unsafe fn HrGetView(
&self,
lpssortorderset: *mut SSortOrderSet,
lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
ulcallerdata: usize,
lppmapitable: *mut Option<IMAPITable>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrGetView)(
windows_core::Interface::as_raw(self),
lpssortorderset as _,
lpfcallerrelease as _,
ulcallerdata,
core::mem::transmute(lppmapitable),
)
.ok()
}
}
pub unsafe fn HrModifyRow(&self, param0: *mut SRow) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrModifyRow)(
windows_core::Interface::as_raw(self),
param0 as _,
)
.ok()
}
}
pub unsafe fn HrDeleteRow(&self, lpspropvalue: *mut SPropValue) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrDeleteRow)(
windows_core::Interface::as_raw(self),
lpspropvalue as _,
)
.ok()
}
}
pub unsafe fn HrQueryRow(
&self,
lpspropvalue: *mut SPropValue,
lppsrow: *mut *mut SRow,
lpulirow: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrQueryRow)(
windows_core::Interface::as_raw(self),
lpspropvalue as _,
lppsrow as _,
lpulirow as _,
)
.ok()
}
}
pub unsafe fn HrEnumRow(
&self,
ulrownumber: u32,
lppsrow: *mut *mut SRow,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrEnumRow)(
windows_core::Interface::as_raw(self),
ulrownumber,
lppsrow as _,
)
.ok()
}
}
pub unsafe fn HrNotify(
&self,
ulflags: u32,
cvalues: u32,
lpspropvalue: *mut SPropValue,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrNotify)(
windows_core::Interface::as_raw(self),
ulflags,
cvalues,
lpspropvalue as _,
)
.ok()
}
}
pub unsafe fn HrInsertRow(&self, ulirow: u32, lpsrow: *mut SRow) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrInsertRow)(
windows_core::Interface::as_raw(self),
ulirow,
lpsrow as _,
)
.ok()
}
}
pub unsafe fn HrModifyRows(
&self,
ulflags: u32,
lpsrowset: *mut SRowSet,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrModifyRows)(
windows_core::Interface::as_raw(self),
ulflags,
lpsrowset as _,
)
.ok()
}
}
pub unsafe fn HrDeleteRows(
&self,
ulflags: u32,
lprowsettodelete: *mut SRowSet,
crowsdeleted: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).HrDeleteRows)(
windows_core::Interface::as_raw(self),
ulflags,
lprowsettodelete as _,
crowsdeleted as _,
)
.ok()
}
}
}
#[repr(C)]
pub struct ITableData_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub HrGetView: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SSortOrderSet,
*mut windows::Win32::System::AddressBook::CALLERRELEASE,
usize,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub HrModifyRow:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut SRow) -> windows_core::HRESULT,
pub HrDeleteRow:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut SPropValue) -> windows_core::HRESULT,
pub HrQueryRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut SPropValue,
*mut *mut SRow,
*mut u32,
) -> windows_core::HRESULT,
pub HrEnumRow: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut *mut SRow,
) -> windows_core::HRESULT,
pub HrNotify: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
u32,
*mut SPropValue,
) -> windows_core::HRESULT,
pub HrInsertRow:
unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut SRow) -> windows_core::HRESULT,
pub HrModifyRows: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SRowSet,
) -> windows_core::HRESULT,
pub HrDeleteRows: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut SRowSet,
*mut u32,
) -> windows_core::HRESULT,
}
pub trait ITableData_Impl: windows_core::IUnknownImpl {
fn HrGetView(
&self,
lpssortorderset: *mut SSortOrderSet,
lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
ulcallerdata: usize,
lppmapitable: windows_core::OutRef<'_, IMAPITable>,
) -> windows_core::Result<()>;
fn HrModifyRow(&self, param0: *mut SRow) -> windows_core::Result<()>;
fn HrDeleteRow(&self, lpspropvalue: *mut SPropValue) -> windows_core::Result<()>;
fn HrQueryRow(
&self,
lpspropvalue: *mut SPropValue,
lppsrow: *mut *mut SRow,
lpulirow: *mut u32,
) -> windows_core::Result<()>;
fn HrEnumRow(&self, ulrownumber: u32, lppsrow: *mut *mut SRow) -> windows_core::Result<()>;
fn HrNotify(
&self,
ulflags: u32,
cvalues: u32,
lpspropvalue: *mut SPropValue,
) -> windows_core::Result<()>;
fn HrInsertRow(&self, ulirow: u32, lpsrow: *mut SRow) -> windows_core::Result<()>;
fn HrModifyRows(&self, ulflags: u32, lpsrowset: *mut SRowSet) -> windows_core::Result<()>;
fn HrDeleteRows(
&self,
ulflags: u32,
lprowsettodelete: *mut SRowSet,
crowsdeleted: *mut u32,
) -> windows_core::Result<()>;
}
impl ITableData_Vtbl {
pub const fn new<Identity: ITableData_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn HrGetView<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpssortorderset: *mut SSortOrderSet,
lpfcallerrelease: *mut windows::Win32::System::AddressBook::CALLERRELEASE,
ulcallerdata: usize,
lppmapitable: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrGetView(
this,
core::mem::transmute_copy(&lpssortorderset),
core::mem::transmute_copy(&lpfcallerrelease),
core::mem::transmute_copy(&ulcallerdata),
core::mem::transmute_copy(&lppmapitable),
)
.into()
}
}
unsafe extern "system" fn HrModifyRow<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
param0: *mut SRow,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrModifyRow(this, core::mem::transmute_copy(¶m0)).into()
}
}
unsafe extern "system" fn HrDeleteRow<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpspropvalue: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrDeleteRow(this, core::mem::transmute_copy(&lpspropvalue)).into()
}
}
unsafe extern "system" fn HrQueryRow<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpspropvalue: *mut SPropValue,
lppsrow: *mut *mut SRow,
lpulirow: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrQueryRow(
this,
core::mem::transmute_copy(&lpspropvalue),
core::mem::transmute_copy(&lppsrow),
core::mem::transmute_copy(&lpulirow),
)
.into()
}
}
unsafe extern "system" fn HrEnumRow<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulrownumber: u32,
lppsrow: *mut *mut SRow,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrEnumRow(
this,
core::mem::transmute_copy(&ulrownumber),
core::mem::transmute_copy(&lppsrow),
)
.into()
}
}
unsafe extern "system" fn HrNotify<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
cvalues: u32,
lpspropvalue: *mut SPropValue,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrNotify(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&cvalues),
core::mem::transmute_copy(&lpspropvalue),
)
.into()
}
}
unsafe extern "system" fn HrInsertRow<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulirow: u32,
lpsrow: *mut SRow,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrInsertRow(
this,
core::mem::transmute_copy(&ulirow),
core::mem::transmute_copy(&lpsrow),
)
.into()
}
}
unsafe extern "system" fn HrModifyRows<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpsrowset: *mut SRowSet,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrModifyRows(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpsrowset),
)
.into()
}
}
unsafe extern "system" fn HrDeleteRows<Identity: ITableData_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lprowsettodelete: *mut SRowSet,
crowsdeleted: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
ITableData_Impl::HrDeleteRows(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lprowsettodelete),
core::mem::transmute_copy(&crowsdeleted),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
HrGetView: HrGetView::<Identity, OFFSET>,
HrModifyRow: HrModifyRow::<Identity, OFFSET>,
HrDeleteRow: HrDeleteRow::<Identity, OFFSET>,
HrQueryRow: HrQueryRow::<Identity, OFFSET>,
HrEnumRow: HrEnumRow::<Identity, OFFSET>,
HrNotify: HrNotify::<Identity, OFFSET>,
HrInsertRow: HrInsertRow::<Identity, OFFSET>,
HrModifyRows: HrModifyRows::<Identity, OFFSET>,
HrDeleteRows: HrDeleteRows::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<ITableData as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for ITableData {}
pub const IUnknown_AddRef: METHODS = METHODS(1i32);
pub const IUnknown_QueryInterface: METHODS = METHODS(0i32);
pub const IUnknown_Release: METHODS = METHODS(2i32);
windows_core::imp::define_interface!(
IXPLogon,
IXPLogon_Vtbl,
0x00020315_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IXPLogon, windows_core::IUnknown);
impl IXPLogon {
pub unsafe fn AddressTypes(
&self,
lpulflags: *mut u32,
lpcadrtype: *mut u32,
lpppadrtypearray: *mut *mut *mut i8,
lpcmapiuid: *mut u32,
lpppuidarray: *mut *mut *mut MAPIUID,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).AddressTypes)(
windows_core::Interface::as_raw(self),
lpulflags as _,
lpcadrtype as _,
lpppadrtypearray as _,
lpcmapiuid as _,
lpppuidarray as _,
)
.ok()
}
}
pub unsafe fn RegisterOptions(
&self,
lpulflags: *mut u32,
lpcoptions: *mut u32,
lppoptions: *mut *mut OPTIONDATA,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).RegisterOptions)(
windows_core::Interface::as_raw(self),
lpulflags as _,
lpcoptions as _,
lppoptions as _,
)
.ok()
}
}
pub unsafe fn TransportNotify(
&self,
lpulflags: *mut u32,
lppvdata: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).TransportNotify)(
windows_core::Interface::as_raw(self),
lpulflags as _,
lppvdata as _,
)
.ok()
}
}
pub unsafe fn Idle(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Idle)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn TransportLogoff(&self, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).TransportLogoff)(
windows_core::Interface::as_raw(self),
ulflags,
)
.ok()
}
}
pub unsafe fn SubmitMessage<P1>(
&self,
ulflags: u32,
lpmessage: P1,
lpulmsgref: *mut usize,
lpulreturnparm: *mut usize,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).SubmitMessage)(
windows_core::Interface::as_raw(self),
ulflags,
lpmessage.param().abi(),
lpulmsgref as _,
lpulreturnparm as _,
)
.ok()
}
}
pub unsafe fn EndMessage(
&self,
ulmsgref: usize,
lpulflags: *mut u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).EndMessage)(
windows_core::Interface::as_raw(self),
ulmsgref,
lpulflags as _,
)
.ok()
}
}
pub unsafe fn Poll(&self, lpulincoming: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Poll)(
windows_core::Interface::as_raw(self),
lpulincoming as _,
)
.ok()
}
}
pub unsafe fn StartMessage<P1>(
&self,
ulflags: u32,
lpmessage: P1,
lpulmsgref: *mut usize,
) -> windows_core::Result<()>
where
P1: windows_core::Param<IMessage>,
{
unsafe {
(windows_core::Interface::vtable(self).StartMessage)(
windows_core::Interface::as_raw(self),
ulflags,
lpmessage.param().abi(),
lpulmsgref as _,
)
.ok()
}
}
pub unsafe fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut Option<IMAPIStatus>,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).OpenStatusEntry)(
windows_core::Interface::as_raw(self),
lpinterface as _,
ulflags,
lpulobjtype as _,
core::mem::transmute(lppentry),
)
.ok()
}
}
pub unsafe fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).ValidateState)(
windows_core::Interface::as_raw(self),
uluiparam,
ulflags,
)
.ok()
}
}
pub unsafe fn FlushQueues(
&self,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).FlushQueues)(
windows_core::Interface::as_raw(self),
uluiparam,
cbtargettransport,
lptargettransport as _,
ulflags,
)
.ok()
}
}
}
#[repr(C)]
pub struct IXPLogon_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub AddressTypes: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut *mut *mut i8,
*mut u32,
*mut *mut *mut MAPIUID,
) -> windows_core::HRESULT,
pub RegisterOptions: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut u32,
*mut *mut OPTIONDATA,
) -> windows_core::HRESULT,
pub TransportNotify: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub Idle: unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub TransportLogoff:
unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
pub SubmitMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut usize,
*mut usize,
) -> windows_core::HRESULT,
pub EndMessage:
unsafe extern "system" fn(*mut core::ffi::c_void, usize, *mut u32) -> windows_core::HRESULT,
pub Poll: unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub StartMessage: unsafe extern "system" fn(
*mut core::ffi::c_void,
u32,
*mut core::ffi::c_void,
*mut usize,
) -> windows_core::HRESULT,
pub OpenStatusEntry: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut windows_core::GUID,
u32,
*mut u32,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
pub ValidateState:
unsafe extern "system" fn(*mut core::ffi::c_void, usize, u32) -> windows_core::HRESULT,
pub FlushQueues: unsafe extern "system" fn(
*mut core::ffi::c_void,
usize,
u32,
*mut ENTRYID,
u32,
) -> windows_core::HRESULT,
}
pub trait IXPLogon_Impl: windows_core::IUnknownImpl {
fn AddressTypes(
&self,
lpulflags: *mut u32,
lpcadrtype: *mut u32,
lpppadrtypearray: *mut *mut *mut i8,
lpcmapiuid: *mut u32,
lpppuidarray: *mut *mut *mut MAPIUID,
) -> windows_core::Result<()>;
fn RegisterOptions(
&self,
lpulflags: *mut u32,
lpcoptions: *mut u32,
lppoptions: *mut *mut OPTIONDATA,
) -> windows_core::Result<()>;
fn TransportNotify(
&self,
lpulflags: *mut u32,
lppvdata: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
fn Idle(&self, ulflags: u32) -> windows_core::Result<()>;
fn TransportLogoff(&self, ulflags: u32) -> windows_core::Result<()>;
fn SubmitMessage(
&self,
ulflags: u32,
lpmessage: windows_core::Ref<'_, IMessage>,
lpulmsgref: *mut usize,
lpulreturnparm: *mut usize,
) -> windows_core::Result<()>;
fn EndMessage(&self, ulmsgref: usize, lpulflags: *mut u32) -> windows_core::Result<()>;
fn Poll(&self, lpulincoming: *mut u32) -> windows_core::Result<()>;
fn StartMessage(
&self,
ulflags: u32,
lpmessage: windows_core::Ref<'_, IMessage>,
lpulmsgref: *mut usize,
) -> windows_core::Result<()>;
fn OpenStatusEntry(
&self,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: windows_core::OutRef<'_, IMAPIStatus>,
) -> windows_core::Result<()>;
fn ValidateState(&self, uluiparam: usize, ulflags: u32) -> windows_core::Result<()>;
fn FlushQueues(
&self,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::Result<()>;
}
impl IXPLogon_Vtbl {
pub const fn new<Identity: IXPLogon_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn AddressTypes<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
lpcadrtype: *mut u32,
lpppadrtypearray: *mut *mut *mut i8,
lpcmapiuid: *mut u32,
lpppuidarray: *mut *mut *mut MAPIUID,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::AddressTypes(
this,
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lpcadrtype),
core::mem::transmute_copy(&lpppadrtypearray),
core::mem::transmute_copy(&lpcmapiuid),
core::mem::transmute_copy(&lpppuidarray),
)
.into()
}
}
unsafe extern "system" fn RegisterOptions<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
lpcoptions: *mut u32,
lppoptions: *mut *mut OPTIONDATA,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::RegisterOptions(
this,
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lpcoptions),
core::mem::transmute_copy(&lppoptions),
)
.into()
}
}
unsafe extern "system" fn TransportNotify<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
lppvdata: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::TransportNotify(
this,
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lppvdata),
)
.into()
}
}
unsafe extern "system" fn Idle<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::Idle(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn TransportLogoff<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::TransportLogoff(this, core::mem::transmute_copy(&ulflags)).into()
}
}
unsafe extern "system" fn SubmitMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmessage: *mut core::ffi::c_void,
lpulmsgref: *mut usize,
lpulreturnparm: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::SubmitMessage(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpulmsgref),
core::mem::transmute_copy(&lpulreturnparm),
)
.into()
}
}
unsafe extern "system" fn EndMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulmsgref: usize,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::EndMessage(
this,
core::mem::transmute_copy(&ulmsgref),
core::mem::transmute_copy(&lpulflags),
)
.into()
}
}
unsafe extern "system" fn Poll<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulincoming: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::Poll(this, core::mem::transmute_copy(&lpulincoming)).into()
}
}
unsafe extern "system" fn StartMessage<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
ulflags: u32,
lpmessage: *mut core::ffi::c_void,
lpulmsgref: *mut usize,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::StartMessage(
this,
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpmessage),
core::mem::transmute_copy(&lpulmsgref),
)
.into()
}
}
unsafe extern "system" fn OpenStatusEntry<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpinterface: *mut windows_core::GUID,
ulflags: u32,
lpulobjtype: *mut u32,
lppentry: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::OpenStatusEntry(
this,
core::mem::transmute_copy(&lpinterface),
core::mem::transmute_copy(&ulflags),
core::mem::transmute_copy(&lpulobjtype),
core::mem::transmute_copy(&lppentry),
)
.into()
}
}
unsafe extern "system" fn ValidateState<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::ValidateState(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
unsafe extern "system" fn FlushQueues<Identity: IXPLogon_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
uluiparam: usize,
cbtargettransport: u32,
lptargettransport: *mut ENTRYID,
ulflags: u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPLogon_Impl::FlushQueues(
this,
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&cbtargettransport),
core::mem::transmute_copy(&lptargettransport),
core::mem::transmute_copy(&ulflags),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
AddressTypes: AddressTypes::<Identity, OFFSET>,
RegisterOptions: RegisterOptions::<Identity, OFFSET>,
TransportNotify: TransportNotify::<Identity, OFFSET>,
Idle: Idle::<Identity, OFFSET>,
TransportLogoff: TransportLogoff::<Identity, OFFSET>,
SubmitMessage: SubmitMessage::<Identity, OFFSET>,
EndMessage: EndMessage::<Identity, OFFSET>,
Poll: Poll::<Identity, OFFSET>,
StartMessage: StartMessage::<Identity, OFFSET>,
OpenStatusEntry: OpenStatusEntry::<Identity, OFFSET>,
ValidateState: ValidateState::<Identity, OFFSET>,
FlushQueues: FlushQueues::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IXPLogon as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IXPLogon {}
pub const IXPLogon_AddressTypes: METHODS = METHODS(96i32);
pub const IXPLogon_EndMessage: METHODS = METHODS(102i32);
pub const IXPLogon_FlushQueues: METHODS = METHODS(107i32);
pub const IXPLogon_Idle: METHODS = METHODS(99i32);
pub const IXPLogon_OpenStatusEntry: METHODS = METHODS(105i32);
pub const IXPLogon_Poll: METHODS = METHODS(103i32);
pub const IXPLogon_RegisterOptions: METHODS = METHODS(97i32);
pub const IXPLogon_StartMessage: METHODS = METHODS(104i32);
pub const IXPLogon_SubmitMessage: METHODS = METHODS(101i32);
pub const IXPLogon_TransportLogoff: METHODS = METHODS(100i32);
pub const IXPLogon_TransportNotify: METHODS = METHODS(98i32);
pub const IXPLogon_ValidateState: METHODS = METHODS(106i32);
windows_core::imp::define_interface!(
IXPProvider,
IXPProvider_Vtbl,
0x00020312_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IXPProvider, windows_core::IUnknown);
impl IXPProvider {
pub unsafe fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()> {
unsafe {
(windows_core::Interface::vtable(self).Shutdown)(
windows_core::Interface::as_raw(self),
lpulflags as _,
)
.ok()
}
}
pub unsafe fn TransportLogon<P0>(
&self,
lpmapisup: P0,
uluiparam: usize,
lpszprofilename: *const i8,
lpulflags: *mut u32,
lppmapierror: *mut *mut MAPIERROR,
lppxplogon: *mut Option<IXPLogon>,
) -> windows_core::Result<()>
where
P0: windows_core::Param<IMAPISupport>,
{
unsafe {
(windows_core::Interface::vtable(self).TransportLogon)(
windows_core::Interface::as_raw(self),
lpmapisup.param().abi(),
uluiparam,
lpszprofilename,
lpulflags as _,
lppmapierror as _,
core::mem::transmute(lppxplogon),
)
.ok()
}
}
}
#[repr(C)]
pub struct IXPProvider_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub Shutdown:
unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
pub TransportLogon: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
usize,
*const i8,
*mut u32,
*mut *mut MAPIERROR,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
}
pub trait IXPProvider_Impl: windows_core::IUnknownImpl {
fn Shutdown(&self, lpulflags: *mut u32) -> windows_core::Result<()>;
fn TransportLogon(
&self,
lpmapisup: windows_core::Ref<'_, IMAPISupport>,
uluiparam: usize,
lpszprofilename: *const i8,
lpulflags: *mut u32,
lppmapierror: *mut *mut MAPIERROR,
lppxplogon: windows_core::OutRef<'_, IXPLogon>,
) -> windows_core::Result<()>;
}
impl IXPProvider_Vtbl {
pub const fn new<Identity: IXPProvider_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn Shutdown<Identity: IXPProvider_Impl, const OFFSET: isize>(
this: *mut core::ffi::c_void,
lpulflags: *mut u32,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPProvider_Impl::Shutdown(this, core::mem::transmute_copy(&lpulflags)).into()
}
}
unsafe extern "system" fn TransportLogon<
Identity: IXPProvider_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
lpmapisup: *mut core::ffi::c_void,
uluiparam: usize,
lpszprofilename: *const i8,
lpulflags: *mut u32,
lppmapierror: *mut *mut MAPIERROR,
lppxplogon: *mut *mut core::ffi::c_void,
) -> windows_core::HRESULT {
unsafe {
let this: &Identity =
&*((this as *const *const ()).offset(OFFSET) as *const Identity);
IXPProvider_Impl::TransportLogon(
this,
core::mem::transmute_copy(&lpmapisup),
core::mem::transmute_copy(&uluiparam),
core::mem::transmute_copy(&lpszprofilename),
core::mem::transmute_copy(&lpulflags),
core::mem::transmute_copy(&lppmapierror),
core::mem::transmute_copy(&lppxplogon),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
Shutdown: Shutdown::<Identity, OFFSET>,
TransportLogon: TransportLogon::<Identity, OFFSET>,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IXPProvider as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IXPProvider {}
pub const IXPProvider_Shutdown: METHODS = METHODS(94i32);
pub const IXPProvider_TransportLogon: METHODS = METHODS(95i32);
pub const KEEP_OPEN_READONLY: u32 = 1u32;
pub const KEEP_OPEN_READWRITE: u32 = 2u32;
pub type LAUNCHWIZARDENTRY = Option<
unsafe extern "system" fn(
hparentwnd: windows::Win32::Foundation::HWND,
ulflags: u32,
lppszservicenametoadd: *mut *mut i8,
cbbuffermax: u32,
lpsznewprofilename: *mut i8,
) -> windows_core::HRESULT,
>;
pub const LAUNCHWIZARDENTRYNAME: windows_core::PCSTR = windows_core::s!("LAUNCHWIZARD");
pub const LIBID_MIMEOLE: windows_core::GUID =
windows_core::GUID::from_u128(0xe4b28371_83b0_11d0_8259_00c04fd85ab4);
pub const LOCK_BLOCKING_MID_LOCK: u32 = 2u32;
pub const LOCK_NON_PERSISTENT: u32 = 1u32;
pub const LOCK_NULL_RESOURCE: u32 = 4u32;
pub const LOCK_READ_ACCESS_CHECK_ONLY: u32 = 8u32;
pub const LOCK_RESERVED: u32 = 2147483648u32;
pub const LOCK_WRITE_THROUGH_GOP: u32 = 65536u32;
pub const LOGOFF_ABORT: u32 = 8u32;
pub const LOGOFF_COMPLETE: u32 = 65536u32;
pub const LOGOFF_HURRY: u32 = 2147483648u32;
pub const LOGOFF_INBOUND: u32 = 131072u32;
pub const LOGOFF_NORMAL: u32 = 1u32;
pub const LOGOFF_NO_WAIT: u32 = 1u32;
pub const LOGOFF_ORDERLY: u32 = 2u32;
pub const LOGOFF_OUTBOUND: u32 = 262144u32;
pub const LOGOFF_OUTBOUND_QUEUE: u32 = 524288u32;
pub const LOGOFF_PURGE: u32 = 4u32;
pub const LOGOFF_QUIET: u32 = 16u32;
pub const LOGON_CHANGED: u32 = 8u32;
pub const LOGON_NO_CONNECT: u32 = 4u32;
pub const LOGON_NO_DIALOG: u32 = 1u32;
pub const LOGON_NO_INBOUND: u32 = 8u32;
pub const LOGON_NO_OUTBOUND: u32 = 16u32;
pub const LOGON_SP_IDLE: u32 = 65536u32;
pub const LOGON_SP_NEWPW: u32 = 4u32;
pub const LOGON_SP_POLL: u32 = 131072u32;
pub const LOGON_SP_PROMPT: u32 = 2u32;
pub const LOGON_SP_RESOLVE: u32 = 262144u32;
pub const LOGON_SP_TRANSPORT: u32 = 1u32;
pub type LPALLOCATEBUFFER =
Option<unsafe extern "system" fn(cbsize: u32, lppbuffer: *mut *mut core::ffi::c_void) -> i32>;
pub type LPALLOCATEMORE = Option<
unsafe extern "system" fn(
cbsize: u32,
lpobject: *mut core::ffi::c_void,
lppbuffer: *mut *mut core::ffi::c_void,
) -> i32,
>;
pub type LPCREATECONVERSATIONINDEX = Option<
unsafe extern "system" fn(
cbparent: u32,
lpbparent: *mut u8,
lpcbconvindex: *mut u32,
lppbconvindex: *mut *mut u8,
) -> i32,
>;
pub type LPDISPATCHNOTIFICATIONS =
Option<unsafe extern "system" fn(ulflags: u32) -> windows_core::HRESULT>;
pub type LPFGETCOMPONENTPATH =
Option<unsafe extern "system" fn() -> windows::Win32::Foundation::BOOL>;
pub type LPFNABSDI = Option<
unsafe extern "system" fn(
uluiparam: usize,
lpvmsg: *mut core::ffi::c_void,
) -> windows::Win32::Foundation::BOOL,
>;
pub type LPFNBUTTON = Option<
unsafe extern "system" fn(
uluiparam: usize,
lpvcontext: *mut core::ffi::c_void,
cbentryid: u32,
lpselection: *mut ENTRYID,
ulflags: u32,
) -> i32,
>;
pub type LPFNDISMISS =
Option<unsafe extern "system" fn(uluiparam: usize, lpvcontext: *mut core::ffi::c_void)>;
pub type LPFREEBUFFER = Option<unsafe extern "system" fn(lpbuffer: *mut core::ffi::c_void) -> u32>;
pub type LPLAUNCHWIZARDENTRY = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIADDRESS = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpszcaption: windows_core::PCSTR,
neditfields: u32,
lpszlabels: windows_core::PCSTR,
nrecips: u32,
lprecips: *mut MapiRecipDesc,
flflags: u32,
ulreserved: u32,
lpnnewrecips: *mut u32,
lppnewrecips: *mut *mut MapiRecipDesc,
) -> u32,
>;
pub type LPMAPIADMINPROFILES = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIALLOCATEBUFFER = Option<unsafe extern "system" fn() -> i32>;
pub type LPMAPIALLOCATEMORE = Option<unsafe extern "system" fn() -> i32>;
pub type LPMAPIDELETEMAIL = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpszmessageid: windows_core::PCSTR,
flflags: u32,
ulreserved: u32,
) -> u32,
>;
pub type LPMAPIDETAILS = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lprecip: *mut MapiRecipDesc,
flflags: u32,
ulreserved: u32,
) -> u32,
>;
pub type LPMAPIFINDNEXT = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpszmessagetype: windows_core::PCSTR,
lpszseedmessageid: windows_core::PCSTR,
flflags: u32,
ulreserved: u32,
lpszmessageid: windows_core::PCSTR,
) -> u32,
>;
pub type LPMAPIFREEBUFFER = Option<unsafe extern "system" fn() -> u32>;
pub type LPMAPIINITIALIZE = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPILOGOFF = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
flflags: u32,
ulreserved: u32,
) -> u32,
>;
pub type LPMAPILOGON = Option<
unsafe extern "system" fn(
uluiparam: usize,
lpszprofilename: windows_core::PCSTR,
lpszpassword: windows_core::PCSTR,
flflags: u32,
ulreserved: u32,
lplhsession: *mut usize,
) -> u32,
>;
pub type LPMAPILOGONEX = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPMAPIREADMAIL = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpszmessageid: windows_core::PCSTR,
flflags: u32,
ulreserved: u32,
lppmessage: *mut *mut MapiMessage,
) -> u32,
>;
pub type LPMAPIRESOLVENAME = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpszname: windows_core::PCSTR,
flflags: u32,
ulreserved: u32,
lpprecip: *mut *mut MapiRecipDesc,
) -> u32,
>;
pub type LPMAPISAVEMAIL = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpmessage: *mut MapiMessage,
flflags: u32,
ulreserved: u32,
lpszmessageid: windows_core::PCSTR,
) -> u32,
>;
pub type LPMAPISENDDOCUMENTS = Option<
unsafe extern "system" fn(
uluiparam: usize,
lpszdelimchar: windows_core::PCSTR,
lpszfilepaths: windows_core::PCSTR,
lpszfilenames: windows_core::PCSTR,
ulreserved: u32,
) -> u32,
>;
pub type LPMAPISENDMAIL = Option<
unsafe extern "system" fn(
lhsession: usize,
uluiparam: usize,
lpmessage: *mut MapiMessage,
flflags: u32,
ulreserved: u32,
) -> u32,
>;
pub type LPMAPIUNINITIALIZE = Option<unsafe extern "system" fn()>;
pub type LPMSGSERVICEENTRY = Option<unsafe extern "system" fn() -> windows_core::HRESULT>;
pub type LPNOTIFCALLBACK = Option<
unsafe extern "system" fn(
lpvcontext: *mut core::ffi::c_void,
cnotification: u32,
lpnotifications: *mut NOTIFICATION,
) -> i32,
>;
pub type LPOPENSTREAMONFILE = Option<
unsafe extern "system" fn(
lpallocatebuffer: LPALLOCATEBUFFER,
lpfreebuffer: LPFREEBUFFER,
ulflags: u32,
lpszfilename: *const i8,
lpszprefix: *const i8,
lppstream: *mut Option<windows::Win32::System::Com::IStream>,
) -> windows_core::HRESULT,
>;
pub type LPSERVICEWIZARDDLGPROC =
Option<unsafe extern "system" fn() -> windows::Win32::Foundation::BOOL>;
pub type LPWIZARDENTRY = Option<unsafe extern "system" fn() -> u32>;
pub type MAPIADMINPROFILES = Option<
unsafe extern "system" fn(
ulflags: u32,
lppprofadmin: *mut Option<IProfAdmin>,
) -> windows_core::HRESULT,
>;
pub type MAPIALLOCATEBUFFER =
Option<unsafe extern "system" fn(cbsize: u32, lppbuffer: *mut *mut core::ffi::c_void) -> i32>;
pub type MAPIALLOCATEMORE = Option<
unsafe extern "system" fn(
cbsize: u32,
lpobject: *mut core::ffi::c_void,
lppbuffer: *mut *mut core::ffi::c_void,
) -> i32,
>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIERROR {
pub ulVersion: u32,
pub lpszError: *mut i8,
pub lpszComponent: *mut i8,
pub ulLowLevelError: u32,
pub ulContext: u32,
}
impl Default for MAPIERROR {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const MAPIFORM_CPU_AXP: u32 = 3u32;
pub const MAPIFORM_CPU_M68: u32 = 5u32;
pub const MAPIFORM_CPU_MIP: u32 = 2u32;
pub const MAPIFORM_CPU_PPC: u32 = 4u32;
pub const MAPIFORM_CPU_X64: u32 = 6u32;
pub const MAPIFORM_CPU_X86: u32 = 1u32;
pub const MAPIFORM_EXACTMATCH: u32 = 32u32;
pub const MAPIFORM_INSTALL_DIALOG: u32 = 8u32;
pub const MAPIFORM_INSTALL_OVERWRITEONCONFLICT: u32 = 16u32;
pub const MAPIFORM_OS_MAC_7x: u32 = 4u32;
pub const MAPIFORM_OS_WINNT_35: u32 = 2u32;
pub const MAPIFORM_OS_WINNT_40: u32 = 5u32;
pub const MAPIFORM_OS_WINNT_50: u32 = 6u32;
pub const MAPIFORM_OS_WINNT_60: u32 = 7u32;
pub const MAPIFORM_OS_WIN_31: u32 = 1u32;
pub const MAPIFORM_OS_WIN_95: u32 = 3u32;
pub const MAPIFORM_SELECT_ALL_REGISTRIES: u32 = 0u32;
pub const MAPIFORM_SELECT_FOLDER_REGISTRY_ONLY: u32 = 1u32;
pub const MAPIFORM_SELECT_NON_FOLDER_REGISTRY_ONLY: u32 = 2u32;
pub type MAPIFREEBUFFER =
Option<unsafe extern "system" fn(lpbuffer: *mut core::ffi::c_void) -> u32>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIINIT {
pub ulVersion: u32,
pub ulFlags: u32,
}
impl Default for MAPIINIT {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub type MAPIINITIALIZE =
Option<unsafe extern "system" fn(lpmapiinit: *mut core::ffi::c_void) -> windows_core::HRESULT>;
pub type MAPILOGONEX = Option<
unsafe extern "system" fn(
uluiparam: usize,
lpszprofilename: *const i8,
lpszpassword: *const i8,
ulflags: u32,
lppsession: *mut Option<IMAPISession>,
) -> windows_core::HRESULT,
>;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct MAPINAMEID {
pub lpguid: *mut windows_core::GUID,
pub ulKind: u32,
pub Kind: MAPINAMEID_0,
}
impl Default for MAPINAMEID {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union MAPINAMEID_0 {
pub lID_Reserved: isize,
pub lID: i32,
pub lpwstrName: windows_core::PWSTR,
}
impl Default for MAPINAMEID_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MAPIUID {
pub ab: [u8; 16],
}
impl Default for MAPIUID {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub type MAPIUNINITIALIZE = Option<unsafe extern "system" fn()>;
pub const MAPI_AB: u32 = 34u32;
pub const MAPI_ABCONT: u32 = 4u32;
pub const MAPI_AB_NOMODIFY: u32 = 1024u32;
pub const MAPI_AB_PROVIDER: u32 = 35u32;
pub const MAPI_ACCESS_CREATE_ASSOCIATED: u32 = 32u32;
pub const MAPI_ACCESS_CREATE_CONTENTS: u32 = 16u32;
pub const MAPI_ACCESS_CREATE_HIERARCHY: u32 = 8u32;
pub const MAPI_ACCESS_DELETE: u32 = 4u32;
pub const MAPI_ACCESS_MODIFY: u32 = 1u32;
pub const MAPI_ACCESS_READ: u32 = 2u32;
pub const MAPI_ADDRBOOK: u32 = 2u32;
pub const MAPI_ALLOW_OTHERS: u32 = 8u32;
pub const MAPI_AMBIGUOUS: u32 = 1u32;
pub const MAPI_ASSOCIATED: u32 = 64u32;
pub const MAPI_ATTACH: u32 = 7u32;
pub const MAPI_BCC: u32 = 3u32;
pub const MAPI_BEST_ACCESS: u32 = 16u32;
pub const MAPI_BG_SESSION: u32 = 2097152u32;
pub const MAPI_BODY_AS_FILE: u32 = 512u32;
pub const MAPI_CACHE_ONLY: u32 = 16384u32;
pub const MAPI_CC: u32 = 2u32;
pub const MAPI_COMPOUND: u32 = 128u32;
pub const MAPI_CREATE: u32 = 2u32;
pub const MAPI_DECLINE_OK: u32 = 4u32;
pub const MAPI_DEFAULT_SERVICES: u32 = 1u32;
pub const MAPI_DEFAULT_STORE: u32 = 1u32;
pub const MAPI_DEFERRED_ERRORS: u32 = 8u32;
pub const MAPI_DIALOG: u32 = 8u32;
pub const MAPI_DIM: u32 = 1u32;
pub const MAPI_DISABLED: u32 = 1u32;
pub const MAPI_DISTLIST: u32 = 8u32;
pub const MAPI_ENABLED: u32 = 0u32;
pub const MAPI_ENVELOPE_ONLY: u32 = 64u32;
pub const MAPI_ERROR_VERSION: i32 = 0i32;
pub const MAPI_EXPLICIT_PROFILE: u32 = 16u32;
pub const MAPI_EXTENDED: u32 = 32u32;
pub const MAPI_EXTENDEDCALLBACKS: u32 = 1024u32;
pub const MAPI_E_ACCESS_DENIED: u32 = 6u32;
pub const MAPI_E_ACCOUNT_DISABLED: windows_core::HRESULT =
windows_core::HRESULT(0x80040124_u32 as _);
pub const MAPI_E_AMBIGUOUS_RECIP: windows_core::HRESULT =
windows_core::HRESULT(0x80040700_u32 as _);
pub const MAPI_E_AMBIGUOUS_RECIPIENT: u32 = 21u32;
pub const MAPI_E_AMBIG_RECIP: u32 = 21u32;
pub const MAPI_E_ATTACHMENT_NOT_FOUND: u32 = 11u32;
pub const MAPI_E_ATTACHMENT_OPEN_FAILURE: u32 = 12u32;
pub const MAPI_E_ATTACHMENT_WRITE_FAILURE: u32 = 13u32;
pub const MAPI_E_BAD_CHARWIDTH: windows_core::HRESULT = windows_core::HRESULT(0x80040103_u32 as _);
pub const MAPI_E_BAD_COLUMN: windows_core::HRESULT = windows_core::HRESULT(0x80040118_u32 as _);
pub const MAPI_E_BAD_RECIPTYPE: u32 = 15u32;
pub const MAPI_E_BAD_VALUE: windows_core::HRESULT = windows_core::HRESULT(0x80040301_u32 as _);
pub const MAPI_E_BUSY: windows_core::HRESULT = windows_core::HRESULT(0x8004010B_u32 as _);
pub const MAPI_E_CALL_FAILED: windows_core::HRESULT = windows_core::HRESULT(0x80004005_u32 as _);
pub const MAPI_E_CANCEL: windows_core::HRESULT = windows_core::HRESULT(0x80040501_u32 as _);
pub const MAPI_E_COLLISION: windows_core::HRESULT = windows_core::HRESULT(0x80040604_u32 as _);
pub const MAPI_E_COMPUTED: windows_core::HRESULT = windows_core::HRESULT(0x8004011A_u32 as _);
pub const MAPI_E_CORRUPT_DATA: windows_core::HRESULT = windows_core::HRESULT(0x8004011B_u32 as _);
pub const MAPI_E_CORRUPT_STORE: windows_core::HRESULT = windows_core::HRESULT(0x80040600_u32 as _);
pub const MAPI_E_DECLINE_COPY: windows_core::HRESULT = windows_core::HRESULT(0x80040306_u32 as _);
pub const MAPI_E_DISK_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040116_u32 as _);
pub const MAPI_E_DISK_FULL: u32 = 4u32;
pub const MAPI_E_END_OF_SESSION: windows_core::HRESULT = windows_core::HRESULT(0x80040200_u32 as _);
pub const MAPI_E_EXTENDED_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040119_u32 as _);
pub const MAPI_E_FAILONEPROVIDER: windows_core::HRESULT =
windows_core::HRESULT(0x8004011D_u32 as _);
pub const MAPI_E_FAILURE: u32 = 2u32;
pub const MAPI_E_FOLDER_CYCLE: windows_core::HRESULT = windows_core::HRESULT(0x8004060B_u32 as _);
pub const MAPI_E_HAS_FOLDERS: windows_core::HRESULT = windows_core::HRESULT(0x80040609_u32 as _);
pub const MAPI_E_HAS_MESSAGES: windows_core::HRESULT = windows_core::HRESULT(0x8004060A_u32 as _);
pub const MAPI_E_INSUFFICIENT_MEMORY: u32 = 5u32;
pub const MAPI_E_INTERFACE_NOT_SUPPORTED: windows_core::HRESULT =
windows_core::HRESULT(0x80004002_u32 as _);
pub const MAPI_E_INVALID_ACCESS_TIME: windows_core::HRESULT =
windows_core::HRESULT(0x80040123_u32 as _);
pub const MAPI_E_INVALID_BOOKMARK: windows_core::HRESULT =
windows_core::HRESULT(0x80040405_u32 as _);
pub const MAPI_E_INVALID_EDITFIELDS: u32 = 24u32;
pub const MAPI_E_INVALID_ENTRYID: windows_core::HRESULT =
windows_core::HRESULT(0x80040107_u32 as _);
pub const MAPI_E_INVALID_MESSAGE: u32 = 17u32;
pub const MAPI_E_INVALID_OBJECT: windows_core::HRESULT = windows_core::HRESULT(0x80040108_u32 as _);
pub const MAPI_E_INVALID_PARAMETER: windows_core::HRESULT =
windows_core::HRESULT(0x80070057_u32 as _);
pub const MAPI_E_INVALID_RECIPS: u32 = 25u32;
pub const MAPI_E_INVALID_SESSION: u32 = 19u32;
pub const MAPI_E_INVALID_TYPE: windows_core::HRESULT = windows_core::HRESULT(0x80040302_u32 as _);
pub const MAPI_E_INVALID_WORKSTATION_ACCOUNT: windows_core::HRESULT =
windows_core::HRESULT(0x80040122_u32 as _);
pub const MAPI_E_LOGIN_FAILURE: u32 = 3u32;
pub const MAPI_E_LOGON_FAILED: windows_core::HRESULT = windows_core::HRESULT(0x80040111_u32 as _);
pub const MAPI_E_LOGON_FAILURE: u32 = 3u32;
pub const MAPI_E_MESSAGE_IN_USE: u32 = 22u32;
pub const MAPI_E_MISSING_REQUIRED_COLUMN: windows_core::HRESULT =
windows_core::HRESULT(0x80040202_u32 as _);
pub const MAPI_E_NETWORK_ERROR: windows_core::HRESULT = windows_core::HRESULT(0x80040115_u32 as _);
pub const MAPI_E_NETWORK_FAILURE: u32 = 23u32;
pub const MAPI_E_NON_STANDARD: windows_core::HRESULT = windows_core::HRESULT(0x80040606_u32 as _);
pub const MAPI_E_NOT_ENOUGH_DISK: windows_core::HRESULT =
windows_core::HRESULT(0x8004010D_u32 as _);
pub const MAPI_E_NOT_ENOUGH_MEMORY: windows_core::HRESULT =
windows_core::HRESULT(0x8007000E_u32 as _);
pub const MAPI_E_NOT_ENOUGH_RESOURCES: windows_core::HRESULT =
windows_core::HRESULT(0x8004010E_u32 as _);
pub const MAPI_E_NOT_FOUND: windows_core::HRESULT = windows_core::HRESULT(0x8004010F_u32 as _);
pub const MAPI_E_NOT_INITIALIZED: windows_core::HRESULT =
windows_core::HRESULT(0x80040605_u32 as _);
pub const MAPI_E_NOT_IN_QUEUE: windows_core::HRESULT = windows_core::HRESULT(0x80040601_u32 as _);
pub const MAPI_E_NOT_ME: windows_core::HRESULT = windows_core::HRESULT(0x80040502_u32 as _);
pub const MAPI_E_NOT_SUPPORTED: u32 = 26u32;
pub const MAPI_E_NO_ACCESS: windows_core::HRESULT = windows_core::HRESULT(0x80070005_u32 as _);
pub const MAPI_E_NO_MESSAGES: u32 = 16u32;
pub const MAPI_E_NO_RECIPIENTS: windows_core::HRESULT = windows_core::HRESULT(0x80040607_u32 as _);
pub const MAPI_E_NO_SUPPORT: windows_core::HRESULT = windows_core::HRESULT(0x80040102_u32 as _);
pub const MAPI_E_NO_SUPPRESS: windows_core::HRESULT = windows_core::HRESULT(0x80040602_u32 as _);
pub const MAPI_E_OBJECT_CHANGED: windows_core::HRESULT = windows_core::HRESULT(0x80040109_u32 as _);
pub const MAPI_E_OBJECT_DELETED: windows_core::HRESULT = windows_core::HRESULT(0x8004010A_u32 as _);
pub const MAPI_E_PASSWORD_CHANGE_REQUIRED: windows_core::HRESULT =
windows_core::HRESULT(0x80040120_u32 as _);
pub const MAPI_E_PASSWORD_EXPIRED: windows_core::HRESULT =
windows_core::HRESULT(0x80040121_u32 as _);
pub const MAPI_E_SESSION_LIMIT: windows_core::HRESULT = windows_core::HRESULT(0x80040112_u32 as _);
pub const MAPI_E_STRING_TOO_LONG: windows_core::HRESULT =
windows_core::HRESULT(0x80040105_u32 as _);
pub const MAPI_E_SUBMITTED: windows_core::HRESULT = windows_core::HRESULT(0x80040608_u32 as _);
pub const MAPI_E_TABLE_EMPTY: windows_core::HRESULT = windows_core::HRESULT(0x80040402_u32 as _);
pub const MAPI_E_TABLE_TOO_BIG: windows_core::HRESULT = windows_core::HRESULT(0x80040403_u32 as _);
pub const MAPI_E_TEXT_TOO_LARGE: u32 = 18u32;
pub const MAPI_E_TIMEOUT: windows_core::HRESULT = windows_core::HRESULT(0x80040401_u32 as _);
pub const MAPI_E_TOO_BIG: windows_core::HRESULT = windows_core::HRESULT(0x80040305_u32 as _);
pub const MAPI_E_TOO_COMPLEX: windows_core::HRESULT = windows_core::HRESULT(0x80040117_u32 as _);
pub const MAPI_E_TOO_MANY_FILES: u32 = 9u32;
pub const MAPI_E_TOO_MANY_RECIPIENTS: u32 = 10u32;
pub const MAPI_E_TOO_MANY_SESSIONS: u32 = 8u32;
pub const MAPI_E_TYPE_NOT_SUPPORTED: u32 = 20u32;
pub const MAPI_E_TYPE_NO_SUPPORT: windows_core::HRESULT =
windows_core::HRESULT(0x80040303_u32 as _);
pub const MAPI_E_UNABLE_TO_ABORT: windows_core::HRESULT =
windows_core::HRESULT(0x80040114_u32 as _);
pub const MAPI_E_UNABLE_TO_COMPLETE: windows_core::HRESULT =
windows_core::HRESULT(0x80040400_u32 as _);
pub const MAPI_E_UNCONFIGURED: windows_core::HRESULT = windows_core::HRESULT(0x8004011C_u32 as _);
pub const MAPI_E_UNEXPECTED_ID: windows_core::HRESULT = windows_core::HRESULT(0x80040307_u32 as _);
pub const MAPI_E_UNEXPECTED_TYPE: windows_core::HRESULT =
windows_core::HRESULT(0x80040304_u32 as _);
pub const MAPI_E_UNKNOWN_CPID: windows_core::HRESULT = windows_core::HRESULT(0x8004011E_u32 as _);
pub const MAPI_E_UNKNOWN_ENTRYID: windows_core::HRESULT =
windows_core::HRESULT(0x80040201_u32 as _);
pub const MAPI_E_UNKNOWN_FLAGS: windows_core::HRESULT = windows_core::HRESULT(0x80040106_u32 as _);
pub const MAPI_E_UNKNOWN_LCID: windows_core::HRESULT = windows_core::HRESULT(0x8004011F_u32 as _);
pub const MAPI_E_UNKNOWN_RECIPIENT: u32 = 14u32;
pub const MAPI_E_USER_ABORT: u32 = 1u32;
pub const MAPI_E_USER_CANCEL: windows_core::HRESULT = windows_core::HRESULT(0x80040113_u32 as _);
pub const MAPI_E_VERSION: windows_core::HRESULT = windows_core::HRESULT(0x80040110_u32 as _);
pub const MAPI_E_WAIT: windows_core::HRESULT = windows_core::HRESULT(0x80040500_u32 as _);
pub const MAPI_FOLDER: u32 = 3u32;
pub const MAPI_FORCE_CREATE: u32 = 1u32;
pub const MAPI_FORCE_DOWNLOAD: u32 = 4096u32;
pub const MAPI_FORMINFO: u32 = 12u32;
pub const MAPI_FULL_IPM_TREE: u32 = 2u32;
pub const MAPI_GUARANTEE_FIFO: u32 = 256u32;
pub const MAPI_HOOK_PROVIDER: u32 = 40u32;
pub const MAPI_INIT_VERSION: u32 = 0u32;
pub const MAPI_LOGOFF_SHARED: u32 = 1u32;
pub const MAPI_LOGOFF_UI: u32 = 2u32;
pub const MAPI_LOGON_UI: u32 = 1u32;
pub const MAPI_LONG_MSGID: u32 = 16384u32;
pub const MAPI_MAILUSER: u32 = 6u32;
pub const MAPI_MESSAGE: u32 = 5u32;
pub const MAPI_MESSAGE_BEHAVIOR_FOLDER: u32 = 1u32;
pub const MAPI_MESSAGE_BEHAVIOR_IPM: u32 = 0u32;
pub const MAPI_MH_DP_ML: u32 = 3u32;
pub const MAPI_MH_DP_MS: u32 = 2u32;
pub const MAPI_MH_DP_OTHER_AU: u32 = 6u32;
pub const MAPI_MH_DP_PDAU: u32 = 4u32;
pub const MAPI_MH_DP_PDS_PATRON: u32 = 5u32;
pub const MAPI_MH_DP_PRIVATE_UA: u32 = 1u32;
pub const MAPI_MH_DP_PUBLIC_UA: u32 = 0u32;
pub const MAPI_MODIFY: u32 = 1u32;
pub const MAPI_MOVE: u32 = 1u32;
pub const MAPI_MULTITHREAD_NOTIFICATIONS: u32 = 1u32;
pub const MAPI_NEW_MESSAGE: u32 = 2u32;
pub const MAPI_NEW_SESSION: u32 = 2u32;
pub const MAPI_NON_READ: u32 = 1u32;
pub const MAPI_NOREPLACE: u32 = 2u32;
pub const MAPI_NOTRECIP: u32 = 64u32;
pub const MAPI_NOTRESERVED: u32 = 8u32;
pub const MAPI_NOW: u32 = 16u32;
pub const MAPI_NO_CACHE: u32 = 512u32;
pub const MAPI_NO_COINIT: u32 = 8u32;
pub const MAPI_NO_HBAR: u32 = 1u32;
pub const MAPI_NO_IDS: u32 = 2u32;
pub const MAPI_NO_MAIL: u32 = 32768u32;
pub const MAPI_NO_STRINGS: u32 = 1u32;
pub const MAPI_NO_VBAR: u32 = 2u32;
pub const MAPI_NT_SERVICE: u32 = 65536u32;
pub const MAPI_OLE: u32 = 1u32;
pub const MAPI_OLE_STATIC: u32 = 2u32;
pub const MAPI_ONE_OFF_NO_RICH_INFO: u32 = 1u32;
pub const MAPI_ONE_OFF_UNICODE: u32 = 32768u32;
pub const MAPI_ORIG: u32 = 0u32;
pub const MAPI_P1: u32 = 268435456u32;
pub const MAPI_PASSWORD_UI: u32 = 131072u32;
pub const MAPI_PEEK: u32 = 128u32;
pub const MAPI_POST_MESSAGE: u32 = 1u32;
pub const MAPI_PRIMARY_STORE: u32 = 4u32;
pub const MAPI_PROFILE_PROVIDER: u32 = 38u32;
pub const MAPI_PROFSECT: u32 = 9u32;
pub const MAPI_PW_ADD_SERVICE_ONLY: u32 = 4u32;
pub const MAPI_PW_FIRST_PROFILE: u32 = 1u32;
pub const MAPI_PW_HIDE_SERVICES_LIST: u32 = 16u32;
pub const MAPI_PW_LAUNCHED_BY_CONFIG: u32 = 2u32;
pub const MAPI_PW_PROVIDER_UI_ONLY: u32 = 8u32;
pub const MAPI_RECEIPT_REQUESTED: u32 = 2u32;
pub const MAPI_RESERVED1: u32 = 65536u32;
pub const MAPI_RESOLVED: u32 = 2u32;
pub const MAPI_SECONDARY_STORE: u32 = 5u32;
pub const MAPI_SEND_NO_RICH_INFO: u32 = 65536u32;
pub const MAPI_SENT: u32 = 4u32;
pub const MAPI_SERVICE_UI_ALWAYS: u32 = 8192u32;
pub const MAPI_SESSION: u32 = 11u32;
pub const MAPI_SHORTTERM: u32 = 128u32;
pub const MAPI_SIMPLE_STORE_PERMANENT: u32 = 3u32;
pub const MAPI_SIMPLE_STORE_TEMPORARY: u32 = 2u32;
pub const MAPI_SPOOLER: u32 = 37u32;
pub const MAPI_STATUS: u32 = 10u32;
pub const MAPI_STORE: u32 = 1u32;
pub const MAPI_STORE_PROVIDER: u32 = 33u32;
pub const MAPI_SUBMITTED: u32 = 2147483648u32;
pub const MAPI_SUBSYSTEM: u32 = 39u32;
pub const MAPI_SUPPRESS_ATTACH: u32 = 2048u32;
pub const MAPI_THISSESSION: u32 = 32u32;
pub const MAPI_TIMEOUT_SHORT: u32 = 1048576u32;
pub const MAPI_TO: u32 = 1u32;
pub const MAPI_TOP_LEVEL: u32 = 1u32;
pub const MAPI_TRANSPORT_PROVIDER: u32 = 36u32;
pub const MAPI_UNICODE: u32 = 2147483648u32;
pub const MAPI_UNREAD: u32 = 1u32;
pub const MAPI_UNREAD_ONLY: u32 = 32u32;
pub const MAPI_UNRESOLVED: u32 = 0u32;
pub const MAPI_USER_ABORT: u32 = 1u32;
pub const MAPI_USE_DEFAULT: u32 = 64u32;
pub const MAPI_W_APPROX_COUNT: windows_core::HRESULT = windows_core::HRESULT(0x40482_u32 as _);
pub const MAPI_W_CANCEL_MESSAGE: windows_core::HRESULT = windows_core::HRESULT(0x40580_u32 as _);
pub const MAPI_W_ERRORS_RETURNED: windows_core::HRESULT = windows_core::HRESULT(0x40380_u32 as _);
pub const MAPI_W_NO_SERVICE: windows_core::HRESULT = windows_core::HRESULT(0x40203_u32 as _);
pub const MAPI_W_PARTIAL_COMPLETION: windows_core::HRESULT =
windows_core::HRESULT(0x40680_u32 as _);
pub const MAPI_W_POSITION_CHANGED: windows_core::HRESULT = windows_core::HRESULT(0x40481_u32 as _);
pub const MAX_ADMD_NAME_SIZ: u32 = 17u32;
pub const MAX_CBMAX_BODY_LINE: u32 = 4294967295u32;
pub const MAX_CBMAX_HEADER_LINE: u32 = 4294967295u32;
pub const MAX_COUNTRY_NAME_SIZ: u32 = 4u32;
pub const MAX_MTA_NAME_SIZ: u32 = 33u32;
pub const MAX_PATH: u32 = 260u32;
pub const MAX_PRMD_NAME_SIZ: u32 = 17u32;
pub const MDB_FOLDER_IPM: u32 = 1u32;
pub const MDB_FOLDER_NORMAL: u32 = 4u32;
pub const MDB_FOLDER_RULES: u32 = 8u32;
pub const MDB_FOLDER_SEARCH: u32 = 2u32;
pub const MDB_IPM: u32 = 32u32;
pub const MDB_LIMIT_BELOW: u32 = 1u32;
pub const MDB_LIMIT_DISABLED: u32 = 16u32;
pub const MDB_LIMIT_ISSUE_WARNING: u32 = 2u32;
pub const MDB_LIMIT_NO_CHECK: u32 = 8u32;
pub const MDB_LIMIT_PROHIBIT_SEND: u32 = 4u32;
pub const MDB_NON_IPM: u32 = 16u32;
pub const MDB_NO_DIALOG: u32 = 1u32;
pub const MDB_NO_MAIL: u32 = 128u32;
pub const MDB_ONLINE: u32 = 256u32;
pub const MDB_OPEN_MSG_NO_BLOCK: u32 = 32u32;
pub const MDB_QUOTA_NOQUOTA: u32 = 4294967295u32;
pub const MDB_SAVE_MSG_UNLOCK: u32 = 64u32;
pub const MDB_TEMPORARY: u32 = 32u32;
pub const MDB_WRITE: u32 = 4u32;
pub const MEBF_FORMATBARSEP: u32 = 4u32;
pub const MEBF_INNERCLIENTEDGE: u32 = 2u32;
pub const MEBF_NOSCROLL: u32 = 8u32;
pub const MEBF_OUTERCLIENTEDGE: u32 = 1u32;
pub const MECD_ENCODEFILEURLSONLY: u32 = 8u32;
pub const MECD_ENCODEIMAGES: u32 = 4u32;
pub const MECD_ENCODEPLUGINS: u32 = 64u32;
pub const MECD_ENCODESOUNDS: u32 = 16u32;
pub const MECD_ENCODEVIDEO: u32 = 32u32;
pub const MECD_HTML: u32 = 1u32;
pub const MECD_PLAINTEXT: u32 = 2u32;
pub const MECMDID_APPLYDOCUMENT: u32 = 19u32;
pub const MECMDID_BACKGROUNDCOLOR: u32 = 18u32;
pub const MECMDID_BACKGROUNDIMAGE: u32 = 15u32;
pub const MECMDID_BACKGROUNDSOUND: u32 = 21u32;
pub const MECMDID_CHARSET: u32 = 13u32;
pub const MECMDID_DIRTY: u32 = 1u32;
pub const MECMDID_DOWNGRADEPLAINTEXT: u32 = 5u32;
pub const MECMDID_EDITHTML: u32 = 4u32;
pub const MECMDID_EDITMODE: u32 = 12u32;
pub const MECMDID_EMPTY: u32 = 2u32;
pub const MECMDID_FORMATFONT: u32 = 10u32;
pub const MECMDID_FORMATPARAGRAPH: u32 = 26u32;
pub const MECMDID_INSERTBGSOUND: u32 = 22u32;
pub const MECMDID_INSERTHTML: u32 = 17u32;
pub const MECMDID_INSERTTEXT: u32 = 16u32;
pub const MECMDID_INSERTTEXTFILE: u32 = 8u32;
pub const MECMDID_PREVIEWFORMAT: u32 = 11u32;
pub const MECMDID_ROT13: u32 = 7u32;
pub const MECMDID_SAVEASSTATIONERY: u32 = 14u32;
pub const MECMDID_SAVEATTACHMENTS: u32 = 20u32;
pub const MECMDID_SETSOURCETAB: u32 = 24u32;
pub const MECMDID_SETTEXT: u32 = 6u32;
pub const MECMDID_SHOWSOURCETABS: u32 = 23u32;
pub const MECMDID_STYLE: u32 = 3u32;
pub const MECMDID_TABLINKS: u32 = 25u32;
pub const MECMDID_VIEWSOURCE: u32 = 9u32;
pub const MECMD_VS_HTML: u32 = 1u32;
pub const MECMD_VS_MESSAGE: u32 = 2u32;
pub const MEHEADER_FORCE_ENGLISH: u32 = 4u32;
pub const MEHEADER_MAIL: u32 = 2u32;
pub const MEHEADER_NEWS: u32 = 1u32;
pub const MEHEADER_NONE: u32 = 0u32;
pub const MEHOSTCMDID_ADD_TO_ADDRESSBOOK: u32 = 10u32;
pub const MEHOSTCMDID_ADD_TO_FAVORITES: u32 = 11u32;
pub const MEHOSTCMDID_BORDERFLAGS: u32 = 14u32;
pub const MEHOSTCMDID_COMPOSE_FONT: u32 = 9u32;
pub const MEHOSTCMDID_FLAGS: u32 = 6u32;
pub const MEHOSTCMDID_FONTCACHE: u32 = 13u32;
pub const MEHOSTCMDID_HEADER_TYPE: u32 = 4u32;
pub const MEHOSTCMDID_ONPARSECOMPLETE: u32 = 5u32;
pub const MEHOSTCMDID_QUOTE_CHAR: u32 = 7u32;
pub const MEHOSTCMDID_REPLY_TICK_COLOR: u32 = 8u32;
pub const MEHOSTCMDID_SAVEATTACH_PATH: u32 = 17u32;
pub const MEHOSTCMDID_SECURITY_ZONE: u32 = 15u32;
pub const MEHOSTCMDID_SIGNATURE: u32 = 3u32;
pub const MEHOSTCMDID_SIGNATURE_ENABLED: u32 = 1u32;
pub const MEHOSTCMDID_SIGNATURE_OPTIONS: u32 = 2u32;
pub const MEHOSTCMDID_SLIDESHOW_DELAY: u32 = 12u32;
pub const MEHOSTCMDID_SOURCEEDIT_FLAGS: u32 = 18u32;
pub const MEHOSTCMDID_SPELL_LANGUAGE: u32 = 19u32;
pub const MEHOSTCMDID_SPELL_OPTIONS: u32 = 16u32;
pub const MEO_FLAGS_AUTOINLINE: u32 = 4u32;
pub const MEO_FLAGS_AUTOTEXT: u32 = 16u32;
pub const MEO_FLAGS_BLOCKQUOTE: u32 = 32u32;
pub const MEO_FLAGS_DONTSPELLCHECKQUOTED: u32 = 128u32;
pub const MEO_FLAGS_HTML: u32 = 2u32;
pub const MEO_FLAGS_INCLUDEMSG: u32 = 1u32;
pub const MEO_FLAGS_SENDEXTERNALIMGSRC: u32 = 256u32;
pub const MEO_FLAGS_SENDIMAGES: u32 = 64u32;
pub const MEO_FLAGS_SLIDESHOW: u32 = 8u32;
pub const MESIGOPT_BOTTOM: u32 = 8u32;
pub const MESIGOPT_HTML: u32 = 16u32;
pub const MESIGOPT_PLAIN: u32 = 1u32;
pub const MESIGOPT_PREFIX: u32 = 4u32;
pub const MESIGOPT_TOP: u32 = 2u32;
pub const MESIG_AUTO: u32 = 1u32;
pub const MESIG_MANUAL: u32 = 2u32;
pub const MESPELLOPT_ALWAYSSUGGEST: u32 = 32u32;
pub const MESPELLOPT_CHECKONSEND: u32 = 64u32;
pub const MESPELLOPT_CHECKONTYPE: u32 = 128u32;
pub const MESPELLOPT_IGNOREDBCS: u32 = 4u32;
pub const MESPELLOPT_IGNORENUMBER: u32 = 1u32;
pub const MESPELLOPT_IGNOREPROTECT: u32 = 8u32;
pub const MESPELLOPT_IGNOREUPPER: u32 = 2u32;
pub const MESPELLOPT_IGNOREURL: u32 = 16u32;
pub const MESRCFLAGS_COLOR: u32 = 1u32;
pub const MESSAGE_BEST_BODY: u32 = 16u32;
pub const MESSAGE_DIALOG: u32 = 2u32;
pub const MESSAGE_MOVE: u32 = 1u32;
pub const MESSAGE_SEND_ENTRYID: u32 = 32u32;
pub const MESTYLE_FORMATBAR: u32 = 2u32;
pub const MESTYLE_MINIHEADER: u32 = 3u32;
pub const MESTYLE_NOHEADER: u32 = 0u32;
pub const MESTYLE_PREVIEW: u32 = 1u32;
pub const MEST_EDIT: u32 = 0u32;
pub const MEST_NEXT: u32 = 3u32;
pub const MEST_PREVIEW: u32 = 2u32;
pub const MEST_PREVIOUS: u32 = 4u32;
pub const MEST_SOURCE: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct METHODS(pub i32);
pub const MIMEOLE_COMPAT_MLANG2: u32 = 2u32;
pub const MIMEOLE_COMPAT_OE5: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MIMEPARAMINFO {
pub pszName: windows_core::PSTR,
pub pszData: windows_core::PSTR,
}
impl Default for MIMEPARAMINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMEPROPFLAGS(pub i32);
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMEPROPID(pub i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MIMEPROPINFO {
pub dwMask: u32,
pub hCharset: *mut HCHARSET__,
pub ietEncoding: ENCODINGTYPE,
pub dwRowNumber: u32,
pub dwFlags: u32,
pub dwPropId: u32,
pub cValues: u32,
pub vtDefault: u16,
pub vtCurrent: u16,
}
impl Default for MIMEPROPINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MIMESAVETYPE(pub i32);
pub const MIN_CBMAX_BODY_LINE: u32 = 30u32;
pub const MIN_CBMAX_HEADER_LINE: u32 = 76u32;
pub const MIN_EMS_AB_CONSTRUCTED_PROP_ID: u32 = 65528u32;
pub const MNID_ID: u32 = 0u32;
pub const MNID_STRING: u32 = 1u32;
pub const MODRECIP_ADD: u32 = 2u32;
pub const MODRECIP_MODIFY: u32 = 4u32;
pub const MODRECIP_REMOVE: u32 = 8u32;
pub const MPF_ADDRESS: MIMEPROPFLAGS = MIMEPROPFLAGS(4i32);
pub const MPF_HASPARAMS: MIMEPROPFLAGS = MIMEPROPFLAGS(8i32);
pub const MPF_INETCSET: MIMEPROPFLAGS = MIMEPROPFLAGS(1i32);
pub const MPF_MIME: MIMEPROPFLAGS = MIMEPROPFLAGS(16i32);
pub const MPF_READONLY: MIMEPROPFLAGS = MIMEPROPFLAGS(32i32);
pub const MPF_RFC1522: MIMEPROPFLAGS = MIMEPROPFLAGS(2i32);
pub const MSCAP_RES_ANNOTATION: u32 = 1u32;
pub const MSCAP_SECURE_FOLDER_HOMEPAGES: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MSCAP_SELECTOR(pub i32);
pub const MSCAP_SEL_FOLDER: MSCAP_SELECTOR = MSCAP_SELECTOR(2i32);
pub const MSCAP_SEL_RESERVED1: MSCAP_SELECTOR = MSCAP_SELECTOR(0i32);
pub const MSCAP_SEL_RESERVED2: MSCAP_SELECTOR = MSCAP_SELECTOR(1i32);
pub const MSCAP_SEL_RESERVED3: MSCAP_SELECTOR = MSCAP_SELECTOR(3i32);
pub const MSCAP_SEL_RESTRICTION: MSCAP_SELECTOR = MSCAP_SELECTOR(4i32);
pub type MSGCALLRELEASE =
Option<unsafe extern "system" fn(ulcallerdata: u32, lpmessage: Option<IMessage>)>;
pub const MSGFLAG_ASSOCIATED: u32 = 64u32;
pub const MSGFLAG_FROMME: u32 = 32u32;
pub const MSGFLAG_HASATTACH: u32 = 16u32;
pub const MSGFLAG_NRN_PENDING: u32 = 512u32;
pub const MSGFLAG_READ: u32 = 1u32;
pub const MSGFLAG_RESEND: u32 = 128u32;
pub const MSGFLAG_RN_PENDING: u32 = 256u32;
pub const MSGFLAG_SUBMIT: u32 = 4u32;
pub const MSGFLAG_UNMODIFIED: u32 = 2u32;
pub const MSGFLAG_UNSENT: u32 = 8u32;
pub type MSGSERVICEENTRY = Option<
unsafe extern "system" fn(
hinstance: windows::Win32::Foundation::HINSTANCE,
lpmalloc: Option<windows::Win32::System::Com::IMalloc>,
lpmapisup: Option<IMAPISupport>,
uluiparam: usize,
ulflags: u32,
ulcontext: u32,
cvalues: u32,
lpprops: *mut SPropValue,
lpprovideradmin: Option<IProviderAdmin>,
lppmapierror: *mut *mut MAPIERROR,
) -> windows_core::HRESULT,
>;
pub const MSGSTATUS_DELMARKED: u32 = 8u32;
pub const MSGSTATUS_HIDDEN: u32 = 4u32;
pub const MSGSTATUS_HIGHLIGHTED: u32 = 1u32;
pub const MSGSTATUS_IN_CONFLICT: u32 = 2048u32;
pub const MSGSTATUS_MDNSENT: u32 = 16384u32;
pub const MSGSTATUS_REMOTE_DELETE: u32 = 8192u32;
pub const MSGSTATUS_REMOTE_DOWNLOAD: u32 = 4096u32;
pub const MSGSTATUS_TAGGED: u32 = 2u32;
pub const MSG_LOCKED: u32 = 1u32;
pub const MSG_SERVICE_CONFIGURE: u32 = 3u32;
pub const MSG_SERVICE_CREATE: u32 = 2u32;
pub const MSG_SERVICE_DELETE: u32 = 4u32;
pub const MSG_SERVICE_INSTALL: u32 = 1u32;
pub const MSG_SERVICE_PROVIDER_CREATE: u32 = 6u32;
pub const MSG_SERVICE_PROVIDER_DELETE: u32 = 7u32;
pub const MSG_SERVICE_UI_READ_ONLY: u32 = 8u32;
pub const MSG_SERVICE_UNINSTALL: u32 = 5u32;
pub const MSG_UNLOCKED: u32 = 0u32;
pub type MSPROVIDERINIT = Option<
unsafe extern "system" fn(
hinstance: windows::Win32::Foundation::HINSTANCE,
lpmalloc: Option<windows::Win32::System::Com::IMalloc>,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
ulflags: u32,
ulmapiver: u32,
lpulproviderver: *mut u32,
lppmsprovider: *mut Option<IMSProvider>,
) -> windows_core::HRESULT,
>;
pub const MST_BLOB_FLAG: u32 = 4u32;
pub const MST_CHILD_ENCRYPT: u32 = 512u32;
pub const MST_CHILD_MASK: u32 = 3840u32;
pub const MST_CHILD_SIGN: u32 = 256u32;
pub const MST_CLASS_MASK: u32 = 4278190080u32;
pub const MST_CLASS_PGP: u32 = 16777216u32;
pub const MST_CLASS_SMIME_V1: u32 = 0u32;
pub const MST_DESCENDENT_MASK: u32 = 65280u32;
pub const MST_ENCRYPT_MASK: u32 = 8706u32;
pub const MST_NONE: u32 = 0u32;
pub const MST_RECEIPT_REQUEST: u32 = 65536u32;
pub const MST_SIGN_MASK: u32 = 4353u32;
pub const MST_SUBMSG_ENCRYPT: u32 = 8192u32;
pub const MST_SUBMSG_MASK: u32 = 61440u32;
pub const MST_SUBMSG_SIGN: u32 = 4096u32;
pub const MST_THIS_BLOBSIGN: u32 = 5u32;
pub const MST_THIS_ENCRYPT: u32 = 2u32;
pub const MST_THIS_MASK: u32 = 255u32;
pub const MST_THIS_SIGN: u32 = 1u32;
pub const MST_TYPE_MASK: u32 = 65535u32;
pub const MSV_BADSIGNATURE: u32 = 1u32;
pub const MSV_CANTDECRYPT: u32 = 4096u32;
pub const MSV_ENCRYPT_MASK: u32 = 1044480u32;
pub const MSV_ENC_FOR_EXPIREDCERT: u32 = 8192u32;
pub const MSV_EXPIRED_SIGNINGCERT: u32 = 256u32;
pub const MSV_INVALID: u32 = 16777216u32;
pub const MSV_MALFORMEDSIG: u32 = 128u32;
pub const MSV_MSG_MASK: u32 = 251658240u32;
pub const MSV_OK: u32 = 0u32;
pub const MSV_SIGNATURE_MASK: u32 = 255u32;
pub const MSV_SIGNING_MASK: u32 = 3840u32;
pub const MSV_UNKHASH: u32 = 4u32;
pub const MSV_UNVERIFIABLE: u32 = 2u32;
pub const MTA_PAD: u32 = 3u32;
pub const MTA_PAD_FOR_ACTIONS: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MTSID {
pub cb: u32,
pub ab: [u8; 1],
}
impl Default for MTSID {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const MUID_PROFILE_INSTANCE: windows_core::GUID =
windows_core::GUID::from_u128(0x00020385_0000_0000_c000_000000000046);
pub const MV_FLAG: u32 = 4096u32;
pub const MV_INSTANCE: u32 = 8192u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiFileDesc {
pub ulReserved: u32,
pub flFlags: u32,
pub nPosition: u32,
pub lpszPathName: windows_core::PSTR,
pub lpszFileName: windows_core::PSTR,
pub lpFileType: *mut core::ffi::c_void,
}
impl Default for MapiFileDesc {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiFileTagExt {
pub ulReserved: u32,
pub cbTag: u32,
pub lpTag: *mut u8,
pub cbEncoding: u32,
pub lpEncoding: *mut u8,
}
impl Default for MapiFileTagExt {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiMessage {
pub ulReserved: u32,
pub lpszSubject: windows_core::PSTR,
pub lpszNoteText: windows_core::PSTR,
pub lpszMessageType: windows_core::PSTR,
pub lpszDateReceived: windows_core::PSTR,
pub lpszConversationID: windows_core::PSTR,
pub flFlags: u32,
pub lpOriginator: *mut MapiRecipDesc,
pub nRecipCount: u32,
pub lpRecips: *mut MapiRecipDesc,
pub nFileCount: u32,
pub lpFiles: *mut MapiFileDesc,
}
impl Default for MapiMessage {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MapiRecipDesc {
pub ulReserved: u32,
pub ulRecipClass: u32,
pub lpszName: windows_core::PSTR,
pub lpszAddress: windows_core::PSTR,
pub ulEIDSize: u32,
pub lpEntryID: *mut core::ffi::c_void,
}
impl Default for MapiRecipDesc {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const NEEDS_PREPROCESSING: u32 = 1u32;
pub const NEEDS_SPOOLER: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NEWMAIL_NOTIFICATION {
pub cbEntryID: u32,
pub lpEntryID: *mut ENTRYID,
pub cbParentID: u32,
pub lpParentID: *mut ENTRYID,
pub ulFlags: u32,
pub lpszMessageClass: *mut i8,
pub ulMessageFlags: u32,
}
impl Default for NEWMAIL_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const NOFLAGS: u32 = 0u32;
pub const NON_EMS_XP_SAVE: u32 = 4096u32;
pub const NON_STANDARD: u32 = 65536u32;
pub const NORM_IGNORECASE: u32 = 1u32;
pub const NORM_IGNOREKANATYPE: u32 = 65536u32;
pub const NORM_IGNORENONSPACE: u32 = 2u32;
pub const NORM_IGNORESYMBOLS: u32 = 4u32;
pub const NORM_IGNOREWIDTH: u32 = 131072u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct NOTIFICATION {
pub ulEventType: u32,
pub ulAlignPad: u32,
pub info: NOTIFICATION_0,
}
impl Default for NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union NOTIFICATION_0 {
pub err: ERROR_NOTIFICATION,
pub newmail: NEWMAIL_NOTIFICATION,
pub obj: OBJECT_NOTIFICATION,
pub tab: TABLE_NOTIFICATION,
pub ext: EXTENDED_NOTIFICATION,
pub statobj: STATUS_OBJECT_NOTIFICATION,
}
impl Default for NOTIFICATION_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NOTIFKEY {
pub cb: u32,
pub ab: [u8; 1],
}
impl Default for NOTIFKEY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const NOTIFY_ABORT_DEFERRED: u32 = 1073741824u32;
pub const NOTIFY_ACCT_CHANGED: u32 = 1u32;
pub const NOTIFY_ACCT_CREATED: u32 = 2u32;
pub const NOTIFY_ACCT_DELETED: u32 = 3u32;
pub const NOTIFY_ACCT_ORDER_CHANGED: u32 = 4u32;
pub const NOTIFY_ACCT_PREDELETED: u32 = 5u32;
pub const NOTIFY_BEGIN_INBOUND: u32 = 1u32;
pub const NOTIFY_BEGIN_INBOUND_FLUSH: u32 = 4u32;
pub const NOTIFY_BEGIN_OUTBOUND: u32 = 2u32;
pub const NOTIFY_BEGIN_OUTBOUND_FLUSH: u32 = 8u32;
pub const NOTIFY_CANCELED: u32 = 2147483648u32;
pub const NOTIFY_CANCEL_MESSAGE: u32 = 2147483648u32;
pub const NOTIFY_CONFIG_CHANGE: u32 = 16384u32;
pub const NOTIFY_CRITICAL_ERROR: u32 = 268435456u32;
pub const NOTIFY_CRITSEC: u32 = 4096u32;
pub const NOTIFY_END_INBOUND: u32 = 65536u32;
pub const NOTIFY_END_INBOUND_FLUSH: u32 = 262144u32;
pub const NOTIFY_END_OUTBOUND: u32 = 131072u32;
pub const NOTIFY_END_OUTBOUND_FLUSH: u32 = 524288u32;
pub const NOTIFY_NEWMAIL: u32 = 1u32;
pub const NOTIFY_NEWMAIL_RECEIVED: u32 = 536870912u32;
pub const NOTIFY_NONCRIT: u32 = 8192u32;
pub const NOTIFY_READYTOSEND: u32 = 2u32;
pub const NOTIFY_SENTDEFERRED: u32 = 4u32;
pub const NOTIFY_SYNC: u32 = 1073741824u32;
pub const NO_ATTACHMENT: u32 = 0u32;
pub const NO_OST_DEFAULT: u32 = 0u32;
pub const NO_OST_FLAG_ALLOWED: u32 = 0u32;
pub const NO_OST_FLAG_CACHE_ONLY: u32 = 1u32;
pub const NO_OST_FLAG_NOT_ALLOWED: u32 = 2u32;
pub const NO_OST_FLAG_NO_CACHE: u32 = 3u32;
pub const NULL_RESTRICTION: u32 = 255u32;
pub const NUM_AG_TYPES: u32 = 3u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OBJECT_NOTIFICATION {
pub cbEntryID: u32,
pub lpEntryID: *mut ENTRYID,
pub ulObjType: u32,
pub cbParentID: u32,
pub lpParentID: *mut ENTRYID,
pub cbOldID: u32,
pub lpOldID: *mut ENTRYID,
pub cbOldParentID: u32,
pub lpOldParentID: *mut ENTRYID,
pub lpPropTagArray: *mut SPropTagArray,
}
impl Default for OBJECT_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const OF_AVAILABLE_OFFLINE: u32 = 1u32;
pub const OF_FORCE: u32 = 2147483648u32;
pub const OID: CERTNAMETYPE = CERTNAMETYPE(1i32);
pub const OID_ENCODING: u32 = 11u32;
pub const OID_TAG: u32 = 10u32;
pub const OLK_ACCOUNT_NO_FLAGS: u32 = 0u32;
pub const OPENSTORE_ALTERNATE_SERVER: u32 = 256u32;
pub const OPENSTORE_CACHE_EXCHANGE: u32 = 32768u32;
pub const OPENSTORE_CALLBACK_LOGON: u32 = 4096u32;
pub const OPENSTORE_CLI_WITH_NAMEDPROP_FIX: u32 = 65536u32;
pub const OPENSTORE_CLI_WITH_REPLID_GUID_MAPPING_FIX: u32 = 262144u32;
pub const OPENSTORE_ENABLE_LAZY_LOGGING: u32 = 131072u32;
pub const OPENSTORE_FAIL_IF_NO_MAILBOX: u32 = 16384u32;
pub const OPENSTORE_HOME_LOGON: u32 = 4u32;
pub const OPENSTORE_IGNORE_HOME_MDB: u32 = 512u32;
pub const OPENSTORE_INTERNET_ANONYMOUS: u32 = 128u32;
pub const OPENSTORE_LOCAL: u32 = 8192u32;
pub const OPENSTORE_NO_LOCALIZATION: u32 = 524288u32;
pub const OPENSTORE_NO_MAIL: u32 = 1024u32;
pub const OPENSTORE_OVERRIDE_HOME_MDB: u32 = 16u32;
pub const OPENSTORE_OVERRIDE_LAST_MODIFIER: u32 = 2048u32;
pub const OPENSTORE_PUBLIC: u32 = 2u32;
pub const OPENSTORE_REMOTE_TRANSPORT: u32 = 64u32;
pub const OPENSTORE_RESTORE_DATABASE: u32 = 1048576u32;
pub const OPENSTORE_TAKE_OWNERSHIP: u32 = 8u32;
pub const OPENSTORE_TRANSPORT: u32 = 32u32;
pub const OPENSTORE_USE_ADMIN_PRIVILEGE: u32 = 1u32;
pub const OPENSTORE_XFOREST_MOVE: u32 = 2097152u32;
pub const OPENSTREAMONFILE: windows_core::PCSTR = windows_core::s!("OpenStreamOnFile");
pub const OPEN_ALWAYS: u32 = 4u32;
pub const OPEN_EXISTING: u32 = 3u32;
pub const OPEN_IF_EXISTS: u32 = 1u32;
pub type OPTIONCALLBACK = Option<
unsafe extern "system" fn(
hinst: windows::Win32::Foundation::HINSTANCE,
lpmalloc: Option<windows::Win32::System::Com::IMalloc>,
ulflags: u32,
cboptiondata: u32,
lpboptiondata: *mut u8,
lpmapisup: Option<IMAPISupport>,
lpdatasource: Option<IMAPIProp>,
lppwrappedsource: *mut Option<IMAPIProp>,
lppmapierror: *mut *mut MAPIERROR,
) -> i32,
>;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OPTIONDATA {
pub ulFlags: u32,
pub lpRecipGUID: *mut windows_core::GUID,
pub lpszAdrType: *mut i8,
pub lpszDLLName: *mut i8,
pub ulOrdinal: u32,
pub cbOptionsData: u32,
pub lpbOptionsData: *mut u8,
pub cOptionsProps: u32,
pub lpOptionsProps: *mut SPropValue,
}
impl Default for OPTIONDATA {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const OPTION_TYPE_MESSAGE: u32 = 2u32;
pub const OPTION_TYPE_RECIPIENT: u32 = 1u32;
pub const OP_BOUNCE: ACTTYPE = ACTTYPE(6i32);
pub const OP_COPY: ACTTYPE = ACTTYPE(2i32);
pub const OP_DEFER_ACTION: ACTTYPE = ACTTYPE(5i32);
pub const OP_DELEGATE: ACTTYPE = ACTTYPE(8i32);
pub const OP_DELETE: ACTTYPE = ACTTYPE(10i32);
pub const OP_FORWARD: ACTTYPE = ACTTYPE(7i32);
pub const OP_MARK_AS_READ: ACTTYPE = ACTTYPE(11i32);
pub const OP_MOVE: ACTTYPE = ACTTYPE(1i32);
pub const OP_OOF_REPLY: ACTTYPE = ACTTYPE(4i32);
pub const OP_REPLY: ACTTYPE = ACTTYPE(3i32);
pub const OP_TAG: ACTTYPE = ACTTYPE(9i32);
pub const OSTF_BEST_ENCRYPTION: u32 = 536870912u32;
pub const OSTF_COMPRESSABLE_ENCRYPTION: u32 = 1073741824u32;
pub const OSTF_NO_ENCRYPTION: u32 = 2147483648u32;
pub const PDF_ENCODED: u32 = 1u32;
pub const PDF_NAMEINDATA: u32 = 2u32;
pub const PDF_NOCOMMENTS: u32 = 8u32;
pub const PDF_SAVENOENCODE: u32 = 16u32;
pub const PDF_VECTOR: u32 = 32u32;
pub const PDK1_SPI_VERSION: i32 = 65536i32;
pub const PDK2_SPI_VERSION: i32 = 65544i32;
pub const PDK3_SPI_VERSION: i32 = 65552i32;
pub type PFNIDLE = Option<
unsafe extern "system" fn(param0: *mut core::ffi::c_void) -> windows::Win32::Foundation::BOOL,
>;
pub const PID_ATT_ACCOUNT: MIMEPROPID = MIMEPROPID(63i32);
pub const PID_ATT_AUTOINLINED: MIMEPROPID = MIMEPROPID(72i32);
pub const PID_ATT_COMBINED: MIMEPROPID = MIMEPROPID(71i32);
pub const PID_ATT_FILENAME: MIMEPROPID = MIMEPROPID(45i32);
pub const PID_ATT_FORWARDTO: MIMEPROPID = MIMEPROPID(67i32);
pub const PID_ATT_GENFNAME: MIMEPROPID = MIMEPROPID(46i32);
pub const PID_ATT_GHOSTED: MIMEPROPID = MIMEPROPID(69i32);
pub const PID_ATT_ILLEGAL: MIMEPROPID = MIMEPROPID(50i32);
pub const PID_ATT_NORMSUBJ: MIMEPROPID = MIMEPROPID(49i32);
pub const PID_ATT_PRIORITY: MIMEPROPID = MIMEPROPID(54i32);
pub const PID_ATT_PRITYPE: MIMEPROPID = MIMEPROPID(47i32);
pub const PID_ATT_RECVTIME: MIMEPROPID = MIMEPROPID(53i32);
pub const PID_ATT_RENDERED: MIMEPROPID = MIMEPROPID(51i32);
pub const PID_ATT_SENTTIME: MIMEPROPID = MIMEPROPID(52i32);
pub const PID_ATT_SERVER: MIMEPROPID = MIMEPROPID(62i32);
pub const PID_ATT_STOREFOLDERID: MIMEPROPID = MIMEPROPID(68i32);
pub const PID_ATT_STOREMSGID: MIMEPROPID = MIMEPROPID(65i32);
pub const PID_ATT_SUBTYPE: MIMEPROPID = MIMEPROPID(48i32);
pub const PID_ATT_UIDL: MIMEPROPID = MIMEPROPID(64i32);
pub const PID_ATT_UNCACHEDSIZE: MIMEPROPID = MIMEPROPID(70i32);
pub const PID_ATT_USERNAME: MIMEPROPID = MIMEPROPID(66i32);
pub const PID_BASE: u32 = 2u32;
pub const PID_HDR_APPARTO: MIMEPROPID = MIMEPROPID(11i32);
pub const PID_HDR_APPROVED: MIMEPROPID = MIMEPROPID(34i32);
pub const PID_HDR_ARTICLEID: MIMEPROPID = MIMEPROPID(60i32);
pub const PID_HDR_BCC: MIMEPROPID = MIMEPROPID(16i32);
pub const PID_HDR_CC: MIMEPROPID = MIMEPROPID(29i32);
pub const PID_HDR_CNTBASE: MIMEPROPID = MIMEPROPID(23i32);
pub const PID_HDR_CNTDESC: MIMEPROPID = MIMEPROPID(21i32);
pub const PID_HDR_CNTDISP: MIMEPROPID = MIMEPROPID(22i32);
pub const PID_HDR_CNTID: MIMEPROPID = MIMEPROPID(20i32);
pub const PID_HDR_CNTLOC: MIMEPROPID = MIMEPROPID(24i32);
pub const PID_HDR_CNTTYPE: MIMEPROPID = MIMEPROPID(18i32);
pub const PID_HDR_CNTXFER: MIMEPROPID = MIMEPROPID(19i32);
pub const PID_HDR_COMMENT: MIMEPROPID = MIMEPROPID(55i32);
pub const PID_HDR_CONTROL: MIMEPROPID = MIMEPROPID(30i32);
pub const PID_HDR_DATE: MIMEPROPID = MIMEPROPID(12i32);
pub const PID_HDR_DISTRIB: MIMEPROPID = MIMEPROPID(31i32);
pub const PID_HDR_ENCODING: MIMEPROPID = MIMEPROPID(56i32);
pub const PID_HDR_ENCRYPTED: MIMEPROPID = MIMEPROPID(57i32);
pub const PID_HDR_EXPIRES: MIMEPROPID = MIMEPROPID(28i32);
pub const PID_HDR_FOLLOWUPTO: MIMEPROPID = MIMEPROPID(27i32);
pub const PID_HDR_FROM: MIMEPROPID = MIMEPROPID(6i32);
pub const PID_HDR_KEYWORDS: MIMEPROPID = MIMEPROPID(32i32);
pub const PID_HDR_LINES: MIMEPROPID = MIMEPROPID(35i32);
pub const PID_HDR_MESSAGEID: MIMEPROPID = MIMEPROPID(7i32);
pub const PID_HDR_MIMEVER: MIMEPROPID = MIMEPROPID(17i32);
pub const PID_HDR_NEWSGROUP: MIMEPROPID = MIMEPROPID(2i32);
pub const PID_HDR_NEWSGROUPS: MIMEPROPID = MIMEPROPID(3i32);
pub const PID_HDR_OFFSETS: MIMEPROPID = MIMEPROPID(58i32);
pub const PID_HDR_ORG: MIMEPROPID = MIMEPROPID(37i32);
pub const PID_HDR_PATH: MIMEPROPID = MIMEPROPID(26i32);
pub const PID_HDR_RECEIVED: MIMEPROPID = MIMEPROPID(13i32);
pub const PID_HDR_REFS: MIMEPROPID = MIMEPROPID(4i32);
pub const PID_HDR_REPLYTO: MIMEPROPID = MIMEPROPID(14i32);
pub const PID_HDR_RETRCPTTO: MIMEPROPID = MIMEPROPID(10i32);
pub const PID_HDR_RETURNPATH: MIMEPROPID = MIMEPROPID(8i32);
pub const PID_HDR_RR: MIMEPROPID = MIMEPROPID(9i32);
pub const PID_HDR_SENDER: MIMEPROPID = MIMEPROPID(61i32);
pub const PID_HDR_SUBJECT: MIMEPROPID = MIMEPROPID(5i32);
pub const PID_HDR_SUMMARY: MIMEPROPID = MIMEPROPID(33i32);
pub const PID_HDR_TO: MIMEPROPID = MIMEPROPID(25i32);
pub const PID_HDR_XMAILER: MIMEPROPID = MIMEPROPID(15i32);
pub const PID_HDR_XMSPRI: MIMEPROPID = MIMEPROPID(40i32);
pub const PID_HDR_XNEWSRDR: MIMEPROPID = MIMEPROPID(38i32);
pub const PID_HDR_XPRI: MIMEPROPID = MIMEPROPID(39i32);
pub const PID_HDR_XREF: MIMEPROPID = MIMEPROPID(36i32);
pub const PID_HDR_XUNSENT: MIMEPROPID = MIMEPROPID(59i32);
pub const PID_LAST: MIMEPROPID = MIMEPROPID(73i32);
pub const PID_PAR_BOUNDARY: MIMEPROPID = MIMEPROPID(42i32);
pub const PID_PAR_CHARSET: MIMEPROPID = MIMEPROPID(43i32);
pub const PID_PAR_FILENAME: MIMEPROPID = MIMEPROPID(41i32);
pub const PID_PAR_NAME: MIMEPROPID = MIMEPROPID(44i32);
pub const PIM_CHARSET: PROPINFOMASK = PROPINFOMASK(1i32);
pub const PIM_ENCODINGTYPE: PROPINFOMASK = PROPINFOMASK(2i32);
pub const PIM_FLAGS: PROPINFOMASK = PROPINFOMASK(8i32);
pub const PIM_PROPID: PROPINFOMASK = PROPINFOMASK(16i32);
pub const PIM_ROWNUMBER: PROPINFOMASK = PROPINFOMASK(4i32);
pub const PIM_VALUES: PROPINFOMASK = PROPINFOMASK(32i32);
pub const PIM_VTCURRENT: PROPINFOMASK = PROPINFOMASK(128i32);
pub const PIM_VTDEFAULT: PROPINFOMASK = PROPINFOMASK(64i32);
pub const PMS_HTML: u32 = 1u32;
pub const PMS_TEXT: u32 = 2u32;
pub type PREPROCESSMESSAGE = Option<
unsafe extern "system" fn(
lpvsession: *mut core::ffi::c_void,
lpmessage: Option<IMessage>,
lpadrbook: Option<IAddrBook>,
lpfolder: Option<IMAPIFolder>,
allocatebuffer: LPALLOCATEBUFFER,
allocatemore: LPALLOCATEMORE,
freebuffer: LPFREEBUFFER,
lpcoutbound: *mut u32,
lpppmessage: *mut *mut Option<IMessage>,
lppreciplist: *mut *mut ADRLIST,
) -> windows_core::HRESULT,
>;
pub const PRIHIGHEST: u32 = 32767u32;
pub const PRILOWEST: i32 = -32768i32;
pub const PRIO_NONURGENT: u32 = 4294967295u32;
pub const PRIO_NORMAL: u32 = 0u32;
pub const PRIO_URGENT: u32 = 1u32;
pub const PRIUSER: u32 = 0u32;
pub const PRIV_DL_ALLOW_OOF: u32 = 8u32;
pub const PRIV_DL_HIDE_MEMBERS: u32 = 1u32;
pub const PRIV_DL_REPORT_TO_ORIG: u32 = 2u32;
pub const PRIV_DL_REPORT_TO_OWNER: u32 = 4u32;
pub const PRMD_PAD: u32 = 3u32;
pub const PRMD_PAD_FOR_ACTIONS: u32 = 2u32;
pub const PROCESS_XP_HEADER_CACHE: u32 = 131072u32;
pub const PROFILE_DELEGATE: u32 = 2u32;
pub const PROFILE_PRIMARY_USER: u32 = 1u32;
pub const PROFILE_PUBLIC_STORE: u32 = 3u32;
pub const PROFILE_SUBSCRIPTION: u32 = 4u32;
pub const PROFILE_VERSION: u32 = 1281u32;
pub const PROPATTR_MANDATORY: u32 = 1u32;
pub const PROPATTR_NOT_PRESENT: u32 = 8u32;
pub const PROPATTR_READABLE: u32 = 2u32;
pub const PROPATTR_WRITEABLE: u32 = 4u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PROPINFOMASK(pub i32);
pub const PROP_ACCT_DELIVERY_FOLDER: u32 = 1638658u32;
pub const PROP_ACCT_DELIVERY_STORE: u32 = 1573122u32;
pub const PROP_ACCT_ID: u32 = 65539u32;
pub const PROP_ACCT_IS_EXCH: u32 = 1310723u32;
pub const PROP_ACCT_MINI_UID: u32 = 196611u32;
pub const PROP_ACCT_NAME: u32 = 131103u32;
pub const PROP_ACCT_PREFERENCES_UID: u32 = 2228482u32;
pub const PROP_ACCT_SEND_STAMP: u32 = 917535u32;
pub const PROP_ACCT_SENTITEMS_EID: u32 = 2097410u32;
pub const PROP_ACCT_STAMP: u32 = 851999u32;
pub const PROP_ACCT_USER_DISPLAY_NAME: u32 = 720927u32;
pub const PROP_ACCT_USER_EMAIL_ADDR: u32 = 786463u32;
pub const PROP_ID_INVALID: u32 = 65535u32;
pub const PROP_ID_NULL: u32 = 0u32;
pub const PROP_ID_SECURE_MAX: u32 = 26623u32;
pub const PROP_ID_SECURE_MIN: u32 = 26608u32;
pub const PROP_INET_PASSWORD: u32 = 16908319u32;
pub const PROP_INET_PORT: u32 = 17039363u32;
pub const PROP_INET_SERVER: u32 = 16777247u32;
pub const PROP_INET_SSL: u32 = 17104899u32;
pub const PROP_INET_USER: u32 = 16842783u32;
pub const PROP_INET_USE_SPA: u32 = 17301507u32;
pub const PROP_MAPI_EMSMDB_UID: u32 = 537460994u32;
pub const PROP_MAPI_IDENTITY_ENTRYID: u32 = 537002242u32;
pub const PROP_MAPI_TRANSPORT_FLAGS: u32 = 537919746u32;
pub const PROP_POP_LEAVE_ON_SERVER: u32 = 268435459u32;
pub const PROP_SMTP_AUTH_METHOD: u32 = 34078723u32;
pub const PROP_SMTP_PASSWORD: u32 = 33882143u32;
pub const PROP_SMTP_PORT: u32 = 33619971u32;
pub const PROP_SMTP_SECURE_CONNECTION: u32 = 34209795u32;
pub const PROP_SMTP_SERVER: u32 = 33554463u32;
pub const PROP_SMTP_SSL: u32 = 33685507u32;
pub const PROP_SMTP_USER: u32 = 33816607u32;
pub const PROP_SMTP_USE_AUTH: u32 = 33751043u32;
pub const PROP_SMTP_USE_SPA: u32 = 34013187u32;
pub const PROP_TYPE_MASK: u32 = 65535u32;
pub const PR_7BIT_DISPLAY_NAME: u32 = 973013022u32;
pub const PR_ABSTRACT: u32 = 1071251486u32;
pub const PR_ABSTRACT_A: u32 = 1071251486u32;
pub const PR_ABSTRACT_W: u32 = 1071251487u32;
pub const PR_AB_DEFAULT_DIR: u32 = 1023803650u32;
pub const PR_AB_DEFAULT_PAB: u32 = 1023869186u32;
pub const PR_AB_PROVIDERS: u32 = 1023475970u32;
pub const PR_AB_PROVIDER_ID: u32 = 907346178u32;
pub const PR_AB_SEARCH_PATH: u32 = 1023742210u32;
pub const PR_AB_SEARCH_PATH_UPDATE: u32 = 1024524546u32;
pub const PR_ACCESS: u32 = 267649027u32;
pub const PR_ACCESS_LEVEL: u32 = 267845635u32;
pub const PR_ACCOUNT: u32 = 973078558u32;
pub const PR_ACCOUNT_A: u32 = 973078558u32;
pub const PR_ACCOUNT_W: u32 = 973078559u32;
pub const PR_ACKNOWLEDGEMENT_MODE: u32 = 65539u32;
pub const PR_ACL_DATA: u32 = 1071644930u32;
pub const PR_ACL_TABLE: u32 = 1071644685u32;
pub const PR_ACTIVE_USER_ENTRYID: u32 = 1716650242u32;
pub const PR_ADDRBOOK_FOR_LOCAL_SITE_ENTRYID: u32 = 1713766658u32;
pub const PR_ADDRESS_BOOK_DISPLAY_NAME: u32 = 1072168990u32;
pub const PR_ADDRESS_BOOK_ENTRYID: u32 = 1715142914u32;
pub const PR_ADDRTYPE: u32 = 805437470u32;
pub const PR_ADDRTYPE_A: u32 = 805437470u32;
pub const PR_ADDRTYPE_W: u32 = 805437471u32;
pub const PR_ADDR_CC: u32 = 244842526u32;
pub const PR_ADDR_CC_A: u32 = 244842526u32;
pub const PR_ADDR_CC_W: u32 = 244842527u32;
pub const PR_ADDR_TO: u32 = 244776990u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR: u32 = 1025573122u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML: u32 = 241893406u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML_A: u32 = 241893406u32;
pub const PR_ADMIN_SECURITY_DESCRIPTOR_AS_XML_W: u32 = 241893407u32;
pub const PR_ALTERNATE_RECIPIENT: u32 = 973144322u32;
pub const PR_ALTERNATE_RECIPIENT_ALLOWED: u32 = 131083u32;
pub const PR_ANR: u32 = 906756126u32;
pub const PR_ANR_A: u32 = 906756126u32;
pub const PR_ANR_W: u32 = 906756127u32;
pub const PR_ANTIVIRUS_SCAN_INFO: u32 = 243793950u32;
pub const PR_ANTIVIRUS_SCAN_STATUS: u32 = 243728387u32;
pub const PR_ANTIVIRUS_VENDOR: u32 = 243597342u32;
pub const PR_ANTIVIRUS_VERSION: u32 = 243662851u32;
pub const PR_ARCHIVE_DATE: u32 = 807338048u32;
pub const PR_ARCHIVE_PERIOD: u32 = 807272451u32;
pub const PR_ARCHIVE_TAG: u32 = 806879490u32;
pub const PR_ARRIVAL_TIME: u32 = 1717502016u32;
pub const PR_ASSISTANT: u32 = 976224286u32;
pub const PR_ASSISTANT_A: u32 = 976224286u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER: u32 = 976093214u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER_A: u32 = 976093214u32;
pub const PR_ASSISTANT_TELEPHONE_NUMBER_W: u32 = 976093215u32;
pub const PR_ASSISTANT_W: u32 = 976224287u32;
pub const PR_ASSOC_CONTENT_COUNT: u32 = 907476995u32;
pub const PR_ASSOC_MESSAGE_SIZE: u32 = 1723072515u32;
pub const PR_ASSOC_MESSAGE_SIZE_EXTENDED: u32 = 1723072532u32;
pub const PR_ASSOC_MSG_W_ATTACH_COUNT: u32 = 1722679299u32;
pub const PR_ATTACHMENT_X400_PARAMETERS: u32 = 922747138u32;
pub const PR_ATTACH_ADDITIONAL_INFO: u32 = 923730178u32;
pub const PR_ATTACH_CONTENT_ID: u32 = 923926558u32;
pub const PR_ATTACH_CONTENT_ID_A: u32 = 923926558u32;
pub const PR_ATTACH_CONTENT_ID_W: u32 = 923926559u32;
pub const PR_ATTACH_DATA_BIN: u32 = 922812674u32;
pub const PR_ATTACH_DATA_OBJ: u32 = 922812429u32;
pub const PR_ATTACH_ENCODING: u32 = 922878210u32;
pub const PR_ATTACH_EXTENSION: u32 = 922943518u32;
pub const PR_ATTACH_EXTENSION_A: u32 = 922943518u32;
pub const PR_ATTACH_EXTENSION_W: u32 = 922943519u32;
pub const PR_ATTACH_FILENAME: u32 = 923009054u32;
pub const PR_ATTACH_FILENAME_A: u32 = 923009054u32;
pub const PR_ATTACH_FILENAME_W: u32 = 923009055u32;
pub const PR_ATTACH_LONG_FILENAME: u32 = 923205662u32;
pub const PR_ATTACH_LONG_FILENAME_A: u32 = 923205662u32;
pub const PR_ATTACH_LONG_FILENAME_W: u32 = 923205663u32;
pub const PR_ATTACH_LONG_PATHNAME: u32 = 923598878u32;
pub const PR_ATTACH_LONG_PATHNAME_A: u32 = 923598878u32;
pub const PR_ATTACH_LONG_PATHNAME_W: u32 = 923598879u32;
pub const PR_ATTACH_METHOD: u32 = 923074563u32;
pub const PR_ATTACH_MIME_TAG: u32 = 923664414u32;
pub const PR_ATTACH_MIME_TAG_A: u32 = 923664414u32;
pub const PR_ATTACH_MIME_TAG_W: u32 = 923664415u32;
pub const PR_ATTACH_NUM: u32 = 237043715u32;
pub const PR_ATTACH_ON_ASSOC_MSG_COUNT: u32 = 1722941443u32;
pub const PR_ATTACH_ON_NORMAL_MSG_COUNT: u32 = 1722875907u32;
pub const PR_ATTACH_PATHNAME: u32 = 923271198u32;
pub const PR_ATTACH_PATHNAME_A: u32 = 923271198u32;
pub const PR_ATTACH_PATHNAME_W: u32 = 923271199u32;
pub const PR_ATTACH_RENDERING: u32 = 923336962u32;
pub const PR_ATTACH_SIZE: u32 = 236978179u32;
pub const PR_ATTACH_TAG: u32 = 923402498u32;
pub const PR_ATTACH_TRANSPORT_NAME: u32 = 923533342u32;
pub const PR_ATTACH_TRANSPORT_NAME_A: u32 = 923533342u32;
pub const PR_ATTACH_TRANSPORT_NAME_W: u32 = 923533343u32;
pub const PR_ATTR_HIDDEN: u32 = 284426251u32;
pub const PR_ATTR_READONLY: u32 = 284557323u32;
pub const PR_ATTR_SYSTEM: u32 = 284491787u32;
pub const PR_AUTHORIZING_USERS: u32 = 196866u32;
pub const PR_AUTO_ADD_NEW_SUBS: u32 = 1709506571u32;
pub const PR_AUTO_FORWARDED: u32 = 327691u32;
pub const PR_AUTO_FORWARD_COMMENT: u32 = 262174u32;
pub const PR_AUTO_FORWARD_COMMENT_A: u32 = 262174u32;
pub const PR_AUTO_FORWARD_COMMENT_W: u32 = 262175u32;
pub const PR_AUTO_RESET: u32 = 1728843848u32;
pub const PR_AUTO_RESPONSE_SUPPRESS: u32 = 1071579139u32;
pub const PR_BEEPER_TELEPHONE_NUMBER: u32 = 975241246u32;
pub const PR_BEEPER_TELEPHONE_NUMBER_A: u32 = 975241246u32;
pub const PR_BEEPER_TELEPHONE_NUMBER_W: u32 = 975241247u32;
pub const PR_BILATERAL_INFO: u32 = 1071382786u32;
pub const PR_BIRTHDAY: u32 = 977403968u32;
pub const PR_BLOCK_STATUS: u32 = 278265859u32;
pub const PR_BODY: u32 = 268435486u32;
pub const PR_BODY_A: u32 = 268435486u32;
pub const PR_BODY_CRC: u32 = 236716035u32;
pub const PR_BODY_W: u32 = 268435487u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER: u32 = 974848030u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER_A: u32 = 974848030u32;
pub const PR_BUSINESS2_TELEPHONE_NUMBER_W: u32 = 974848031u32;
pub const PR_BUSINESS_ADDRESS_CITY: u32 = 975634462u32;
pub const PR_BUSINESS_ADDRESS_CITY_A: u32 = 975634462u32;
pub const PR_BUSINESS_ADDRESS_CITY_W: u32 = 975634463u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY: u32 = 975568926u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY_A: u32 = 975568926u32;
pub const PR_BUSINESS_ADDRESS_COUNTRY_W: u32 = 975568927u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE: u32 = 975831070u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE_A: u32 = 975831070u32;
pub const PR_BUSINESS_ADDRESS_POSTAL_CODE_W: u32 = 975831071u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX: u32 = 975896606u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_A: u32 = 975896606u32;
pub const PR_BUSINESS_ADDRESS_POST_OFFICE_BOX_W: u32 = 975896607u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE: u32 = 975699998u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_A: u32 = 975699998u32;
pub const PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE_W: u32 = 975699999u32;
pub const PR_BUSINESS_ADDRESS_STREET: u32 = 975765534u32;
pub const PR_BUSINESS_ADDRESS_STREET_A: u32 = 975765534u32;
pub const PR_BUSINESS_ADDRESS_STREET_W: u32 = 975765535u32;
pub const PR_BUSINESS_FAX_NUMBER: u32 = 975437854u32;
pub const PR_BUSINESS_FAX_NUMBER_A: u32 = 975437854u32;
pub const PR_BUSINESS_FAX_NUMBER_W: u32 = 975437855u32;
pub const PR_BUSINESS_HOME_PAGE: u32 = 978386974u32;
pub const PR_BUSINESS_HOME_PAGE_A: u32 = 978386974u32;
pub const PR_BUSINESS_HOME_PAGE_W: u32 = 978386975u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER: u32 = 973602846u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER_A: u32 = 973602846u32;
pub const PR_BUSINESS_TELEPHONE_NUMBER_W: u32 = 973602847u32;
pub const PR_CACHED_COLUMN_COUNT: u32 = 1722548227u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER: u32 = 973209630u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER_A: u32 = 973209630u32;
pub const PR_CALLBACK_TELEPHONE_NUMBER_W: u32 = 973209631u32;
pub const PR_CAR_TELEPHONE_NUMBER: u32 = 975044638u32;
pub const PR_CAR_TELEPHONE_NUMBER_A: u32 = 975044638u32;
pub const PR_CAR_TELEPHONE_NUMBER_W: u32 = 975044639u32;
pub const PR_CATALOG: u32 = 240845058u32;
pub const PR_CATEG_COUNT: u32 = 1722482691u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER: u32 = 974913566u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER_A: u32 = 974913566u32;
pub const PR_CELLULAR_TELEPHONE_NUMBER_W: u32 = 974913567u32;
pub const PR_CHANGE_ADVISOR: u32 = 1714683917u32;
pub const PR_CHANGE_KEY: u32 = 1709310210u32;
pub const PR_CHANGE_NOTIFICATION_GUID: u32 = 1714880584u32;
pub const PR_CHILDRENS_NAMES: u32 = 978849822u32;
pub const PR_CHILDRENS_NAMES_A: u32 = 978849822u32;
pub const PR_CHILDRENS_NAMES_W: u32 = 978849823u32;
pub const PR_CI_NOTIFICATION_ENABLED: u32 = 240975883u32;
pub const PR_CI_SEARCH_ENABLED: u32 = 240910347u32;
pub const PR_CLIENT_ACTIONS: u32 = 1715798274u32;
pub const PR_CLIENT_SUBMIT_TIME: u32 = 3735616u32;
pub const PR_CODE_PAGE_ID: u32 = 1724055555u32;
pub const PR_COLLECTOR: u32 = 1714290701u32;
pub const PR_COMMENT: u32 = 805568542u32;
pub const PR_COMMENT_A: u32 = 805568542u32;
pub const PR_COMMENT_W: u32 = 805568543u32;
pub const PR_COMMON_VIEWS_ENTRYID: u32 = 904265986u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER: u32 = 978780190u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER_A: u32 = 978780190u32;
pub const PR_COMPANY_MAIN_PHONE_NUMBER_W: u32 = 978780191u32;
pub const PR_COMPANY_NAME: u32 = 974520350u32;
pub const PR_COMPANY_NAME_A: u32 = 974520350u32;
pub const PR_COMPANY_NAME_W: u32 = 974520351u32;
pub const PR_COMPUTER_NETWORK_NAME: u32 = 977862686u32;
pub const PR_COMPUTER_NETWORK_NAME_A: u32 = 977862686u32;
pub const PR_COMPUTER_NETWORK_NAME_W: u32 = 977862687u32;
pub const PR_CONFLICT_ENTRYID: u32 = 1072693506u32;
pub const PR_CONTACT_ADDRTYPES: u32 = 978587678u32;
pub const PR_CONTACT_ADDRTYPES_A: u32 = 978587678u32;
pub const PR_CONTACT_ADDRTYPES_W: u32 = 978587679u32;
pub const PR_CONTACT_COUNT: u32 = 1723269123u32;
pub const PR_CONTACT_DEFAULT_ADDRESS_INDEX: u32 = 978649091u32;
pub const PR_CONTACT_EMAIL_ADDRESSES: u32 = 978718750u32;
pub const PR_CONTACT_EMAIL_ADDRESSES_A: u32 = 978718750u32;
pub const PR_CONTACT_EMAIL_ADDRESSES_W: u32 = 978718751u32;
pub const PR_CONTACT_ENTRYIDS: u32 = 978522370u32;
pub const PR_CONTACT_VERSION: u32 = 978452552u32;
pub const PR_CONTAINER_CLASS: u32 = 907214878u32;
pub const PR_CONTAINER_CLASS_A: u32 = 907214878u32;
pub const PR_CONTAINER_CLASS_W: u32 = 907214879u32;
pub const PR_CONTAINER_CONTENTS: u32 = 906952717u32;
pub const PR_CONTAINER_FLAGS: u32 = 905969667u32;
pub const PR_CONTAINER_HIERARCHY: u32 = 906887181u32;
pub const PR_CONTAINER_MODIFY_VERSION: u32 = 907280404u32;
pub const PR_CONTENTS_SORT_ORDER: u32 = 906825731u32;
pub const PR_CONTENTS_SYNCHRONIZER: u32 = 1714225165u32;
pub const PR_CONTENT_CONFIDENTIALITY_ALGORITHM_ID: u32 = 393474u32;
pub const PR_CONTENT_CORRELATOR: u32 = 459010u32;
pub const PR_CONTENT_COUNT: u32 = 906100739u32;
pub const PR_CONTENT_IDENTIFIER: u32 = 524318u32;
pub const PR_CONTENT_IDENTIFIER_A: u32 = 524318u32;
pub const PR_CONTENT_IDENTIFIER_W: u32 = 524319u32;
pub const PR_CONTENT_INTEGRITY_CHECK: u32 = 201326850u32;
pub const PR_CONTENT_LENGTH: u32 = 589827u32;
pub const PR_CONTENT_RETURN_REQUESTED: u32 = 655371u32;
pub const PR_CONTENT_SEARCH_KEY: u32 = 1717960962u32;
pub const PR_CONTENT_UNREAD: u32 = 906166275u32;
pub const PR_CONTROL_FLAGS: u32 = 1056964611u32;
pub const PR_CONTROL_ID: u32 = 1057423618u32;
pub const PR_CONTROL_STRUCTURE: u32 = 1057030402u32;
pub const PR_CONTROL_TYPE: u32 = 1057095683u32;
pub const PR_CONVERSATION_ID: u32 = 806551810u32;
pub const PR_CONVERSATION_INDEX: u32 = 7405826u32;
pub const PR_CONVERSATION_KEY: u32 = 721154u32;
pub const PR_CONVERSATION_TOPIC: u32 = 7340062u32;
pub const PR_CONVERSATION_TOPIC_A: u32 = 7340062u32;
pub const PR_CONVERSATION_TOPIC_W: u32 = 7340063u32;
pub const PR_CONVERSION_EITS: u32 = 786690u32;
pub const PR_CONVERSION_PROHIBITED: u32 = 973275147u32;
pub const PR_CONVERSION_WITH_LOSS_PROHIBITED: u32 = 851979u32;
pub const PR_CONVERTED_EITS: u32 = 917762u32;
pub const PR_CORRELATE: u32 = 235667467u32;
pub const PR_CORRELATE_MTSID: u32 = 235733250u32;
pub const PR_COUNTRY: u32 = 975568926u32;
pub const PR_COUNTRY_A: u32 = 975568926u32;
pub const PR_COUNTRY_W: u32 = 975568927u32;
pub const PR_CREATE_TEMPLATES: u32 = 906231821u32;
pub const PR_CREATION_TIME: u32 = 805765184u32;
pub const PR_CREATION_VERSION: u32 = 236519444u32;
pub const PR_CREATOR_ENTRYID: u32 = 1073283330u32;
pub const PR_CREATOR_NAME: u32 = 1073217566u32;
pub const PR_CREATOR_SID: u32 = 240648450u32;
pub const PR_CREATOR_SID_AS_XML: u32 = 241958942u32;
pub const PR_CURRENT_VERSION: u32 = 234881044u32;
pub const PR_CUSTOMER_ID: u32 = 977928222u32;
pub const PR_CUSTOMER_ID_A: u32 = 977928222u32;
pub const PR_CUSTOMER_ID_W: u32 = 977928223u32;
pub const PR_DAM_BACK_PATCHED: u32 = 1715929099u32;
pub const PR_DAM_ORIGINAL_ENTRYID: u32 = 1715863810u32;
pub const PR_DAV_TRANSFER_SECURITY_DESCRIPTOR: u32 = 243532034u32;
pub const PR_DEFAULT_PROFILE: u32 = 1023672331u32;
pub const PR_DEFAULT_STORE: u32 = 872415243u32;
pub const PR_DEFAULT_VIEW_ENTRYID: u32 = 907411714u32;
pub const PR_DEFERRED_DELIVERY_TIME: u32 = 983104u32;
pub const PR_DEFERRED_SEND_NUMBER: u32 = 1072365571u32;
pub const PR_DEFERRED_SEND_TIME: u32 = 1072627776u32;
pub const PR_DEFERRED_SEND_UNITS: u32 = 1072431107u32;
pub const PR_DEF_CREATE_DL: u32 = 907084034u32;
pub const PR_DEF_CREATE_MAILUSER: u32 = 907149570u32;
pub const PR_DELEGATED_BY_RULE: u32 = 1071841291u32;
pub const PR_DELEGATION: u32 = 8257794u32;
pub const PR_DELETED_ASSOC_MESSAGE_SIZE_EXTENDED: u32 = 1721565204u32;
pub const PR_DELETED_ASSOC_MSG_COUNT: u32 = 1715666947u32;
pub const PR_DELETED_COUNT_TOTAL: u32 = 1728774147u32;
pub const PR_DELETED_FOLDER_COUNT: u32 = 1715535875u32;
pub const PR_DELETED_MESSAGE_SIZE_EXTENDED: u32 = 1721434132u32;
pub const PR_DELETED_MSG_COUNT: u32 = 1715470339u32;
pub const PR_DELETED_NORMAL_MESSAGE_SIZE_EXTENDED: u32 = 1721499668u32;
pub const PR_DELETED_ON: u32 = 1720647744u32;
pub const PR_DELETE_AFTER_SUBMIT: u32 = 234946571u32;
pub const PR_DELIVERY_POINT: u32 = 201785347u32;
pub const PR_DELIVER_TIME: u32 = 1048640u32;
pub const PR_DELTAX: u32 = 1057161219u32;
pub const PR_DELTAY: u32 = 1057226755u32;
pub const PR_DEPARTMENT_NAME: u32 = 974651422u32;
pub const PR_DEPARTMENT_NAME_A: u32 = 974651422u32;
pub const PR_DEPARTMENT_NAME_W: u32 = 974651423u32;
pub const PR_DEPTH: u32 = 805634051u32;
pub const PR_DESIGN_IN_PROGRESS: u32 = 1071906827u32;
pub const PR_DETAILS_TABLE: u32 = 906297357u32;
pub const PR_DISABLE_FULL_FIDELITY: u32 = 284295179u32;
pub const PR_DISABLE_PERUSER_READ: u32 = 1724186635u32;
pub const PR_DISABLE_WINSOCK: u32 = 1712848899u32;
pub const PR_DISCARD_REASON: u32 = 1114115u32;
pub const PR_DISCLOSE_RECIPIENTS: u32 = 973340683u32;
pub const PR_DISCLOSURE_OF_RECIPIENTS: u32 = 1179659u32;
pub const PR_DISCRETE_VALUES: u32 = 235798539u32;
pub const PR_DISC_VAL: u32 = 4849675u32;
pub const PR_DISPLAY_BCC: u32 = 235012126u32;
pub const PR_DISPLAY_BCC_A: u32 = 235012126u32;
pub const PR_DISPLAY_BCC_W: u32 = 235012127u32;
pub const PR_DISPLAY_CC: u32 = 235077662u32;
pub const PR_DISPLAY_CC_A: u32 = 235077662u32;
pub const PR_DISPLAY_CC_W: u32 = 235077663u32;
pub const PR_DISPLAY_NAME: u32 = 805371934u32;
pub const PR_DISPLAY_NAME_A: u32 = 805371934u32;
pub const PR_DISPLAY_NAME_PREFIX: u32 = 977600542u32;
pub const PR_DISPLAY_NAME_PREFIX_A: u32 = 977600542u32;
pub const PR_DISPLAY_NAME_PREFIX_W: u32 = 977600543u32;
pub const PR_DISPLAY_NAME_W: u32 = 805371935u32;
pub const PR_DISPLAY_TO: u32 = 235143198u32;
pub const PR_DISPLAY_TO_A: u32 = 235143198u32;
pub const PR_DISPLAY_TO_W: u32 = 235143199u32;
pub const PR_DISPLAY_TYPE: u32 = 956301315u32;
pub const PR_DISPLAY_TYPE_EX: u32 = 956628995u32;
pub const PR_DL_EXPANSION_HISTORY: u32 = 1245442u32;
pub const PR_DL_EXPANSION_PROHIBITED: u32 = 1310731u32;
pub const PR_DL_REPORT_FLAGS: u32 = 1071316995u32;
pub const PR_EFORMS_FOR_LOCALE_ENTRYID: u32 = 1713635586u32;
pub const PR_EFORMS_LOCALE_ID: u32 = 1072234499u32;
pub const PR_EFORMS_REGISTRY_ENTRYID: u32 = 1713438978u32;
pub const PR_EMAIL_ADDRESS: u32 = 805503006u32;
pub const PR_EMAIL_ADDRESS_A: u32 = 805503006u32;
pub const PR_EMAIL_ADDRESS_W: u32 = 805503007u32;
pub const PR_EMS_AB_ACCESS_CATEGORY: u32 = 2151940099u32;
pub const PR_EMS_AB_ACTIVATION_SCHEDULE: u32 = 2152005890u32;
pub const PR_EMS_AB_ACTIVATION_STYLE: u32 = 2152071171u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES: u32 = 2356154398u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES_A: u32 = 2356154398u32;
pub const PR_EMS_AB_ADC_GLOBAL_NAMES_W: u32 = 2356154399u32;
pub const PR_EMS_AB_ADDRESS_ENTRY_DISPLAY_TABLE: u32 = 2148991234u32;
pub const PR_EMS_AB_ADDRESS_ENTRY_DISPLAY_TABLE_MSDOS: u32 = 2152136962u32;
pub const PR_EMS_AB_ADDRESS_SYNTAX: u32 = 2149056770u32;
pub const PR_EMS_AB_ADDRESS_TYPE: u32 = 2152202270u32;
pub const PR_EMS_AB_ADDRESS_TYPE_A: u32 = 2152202270u32;
pub const PR_EMS_AB_ADDRESS_TYPE_W: u32 = 2152202271u32;
pub const PR_EMS_AB_ADMD: u32 = 2152267806u32;
pub const PR_EMS_AB_ADMD_A: u32 = 2152267806u32;
pub const PR_EMS_AB_ADMD_W: u32 = 2152267807u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION: u32 = 2152333342u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION_A: u32 = 2152333342u32;
pub const PR_EMS_AB_ADMIN_DESCRIPTION_W: u32 = 2152333343u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME: u32 = 2152398878u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME_A: u32 = 2152398878u32;
pub const PR_EMS_AB_ADMIN_DISPLAY_NAME_W: u32 = 2152398879u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL: u32 = 2152464414u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL_A: u32 = 2152464414u32;
pub const PR_EMS_AB_ADMIN_EXTENSION_DLL_W: u32 = 2152464415u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_A: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_O: u32 = 2152529933u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_T: u32 = 2152529950u32;
pub const PR_EMS_AB_ALIASED_OBJECT_NAME_W: u32 = 2152529951u32;
pub const PR_EMS_AB_ALT_RECIPIENT: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_A: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_A: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_O: u32 = 2152661005u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_T: u32 = 2152665118u32;
pub const PR_EMS_AB_ALT_RECIPIENT_BL_W: u32 = 2152665119u32;
pub const PR_EMS_AB_ALT_RECIPIENT_O: u32 = 2152595469u32;
pub const PR_EMS_AB_ALT_RECIPIENT_T: u32 = 2152595486u32;
pub const PR_EMS_AB_ALT_RECIPIENT_W: u32 = 2152595487u32;
pub const PR_EMS_AB_ANCESTOR_ID: u32 = 2152726786u32;
pub const PR_EMS_AB_ANONYMOUS_ACCESS: u32 = 2173108235u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT: u32 = 2351300638u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT_A: u32 = 2351300638u32;
pub const PR_EMS_AB_ANONYMOUS_ACCOUNT_W: u32 = 2351300639u32;
pub const PR_EMS_AB_ASSOCIATION_LIFETIME: u32 = 2152857603u32;
pub const PR_EMS_AB_ASSOC_NT_ACCOUNT: u32 = 2150039810u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_A: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_O: u32 = 2175074317u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_T: u32 = 2175074334u32;
pub const PR_EMS_AB_ASSOC_PROTOCOL_CFG_NNTP_W: u32 = 2175074335u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_A: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_O: u32 = 2152792077u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_T: u32 = 2152796190u32;
pub const PR_EMS_AB_ASSOC_REMOTE_DXA_W: u32 = 2152796191u32;
pub const PR_EMS_AB_ATTRIBUTE_CERTIFICATE: u32 = 2353336578u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE: u32 = 2174353438u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE_A: u32 = 2174353438u32;
pub const PR_EMS_AB_AUTHENTICATION_TO_USE_W: u32 = 2174353439u32;
pub const PR_EMS_AB_AUTHORITY_REVOCATION_LIST: u32 = 2149978370u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN: u32 = 2152988702u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN_A: u32 = 2152988702u32;
pub const PR_EMS_AB_AUTHORIZED_DOMAIN_W: u32 = 2152988703u32;
pub const PR_EMS_AB_AUTHORIZED_PASSWORD: u32 = 2153054466u32;
pub const PR_EMS_AB_AUTHORIZED_PASSWORD_CONFIRM: u32 = 2173829378u32;
pub const PR_EMS_AB_AUTHORIZED_USER: u32 = 2153119774u32;
pub const PR_EMS_AB_AUTHORIZED_USER_A: u32 = 2153119774u32;
pub const PR_EMS_AB_AUTHORIZED_USER_W: u32 = 2153119775u32;
pub const PR_EMS_AB_AUTH_ORIG_BL: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_A: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_O: u32 = 2152923149u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_T: u32 = 2152927262u32;
pub const PR_EMS_AB_AUTH_ORIG_BL_W: u32 = 2152927263u32;
pub const PR_EMS_AB_AUTOREPLY: u32 = 2148204555u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE: u32 = 2148139038u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE_A: u32 = 2148139038u32;
pub const PR_EMS_AB_AUTOREPLY_MESSAGE_W: u32 = 2148139039u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT: u32 = 2151546910u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT_A: u32 = 2151546910u32;
pub const PR_EMS_AB_AUTOREPLY_SUBJECT_W: u32 = 2151546911u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES: u32 = 2172719134u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES_A: u32 = 2172719134u32;
pub const PR_EMS_AB_AVAILABLE_AUTHORIZATION_PACKAGES_W: u32 = 2172719135u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS: u32 = 2173370398u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS_A: u32 = 2173370398u32;
pub const PR_EMS_AB_AVAILABLE_DISTRIBUTIONS_W: u32 = 2173370399u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_A: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_O: u32 = 2171863053u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_T: u32 = 2171867166u32;
pub const PR_EMS_AB_BRIDGEHEAD_SERVERS_W: u32 = 2171867167u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY: u32 = 2153189406u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY_A: u32 = 2153189406u32;
pub const PR_EMS_AB_BUSINESS_CATEGORY_W: u32 = 2153189407u32;
pub const PR_EMS_AB_BUSINESS_ROLES: u32 = 2149777666u32;
pub const PR_EMS_AB_CAN_CREATE_PF: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_A: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_A: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_O: u32 = 2153316365u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_T: u32 = 2153320478u32;
pub const PR_EMS_AB_CAN_CREATE_PF_BL_W: u32 = 2153320479u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_A: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_A: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_O: u32 = 2153447437u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_T: u32 = 2153451550u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_BL_W: u32 = 2153451551u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_O: u32 = 2153381901u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_T: u32 = 2153386014u32;
pub const PR_EMS_AB_CAN_CREATE_PF_DL_W: u32 = 2153386015u32;
pub const PR_EMS_AB_CAN_CREATE_PF_O: u32 = 2153250829u32;
pub const PR_EMS_AB_CAN_CREATE_PF_T: u32 = 2153254942u32;
pub const PR_EMS_AB_CAN_CREATE_PF_W: u32 = 2153254943u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_A: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_A: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_O: u32 = 2153578509u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_T: u32 = 2153582622u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_BL_W: u32 = 2153582623u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_A: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_A: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_O: u32 = 2153709581u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_T: u32 = 2153713694u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_BL_W: u32 = 2153713695u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_O: u32 = 2153644045u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_T: u32 = 2153648158u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_DL_W: u32 = 2153648159u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_O: u32 = 2153512973u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_T: u32 = 2153517086u32;
pub const PR_EMS_AB_CAN_NOT_CREATE_PF_W: u32 = 2153517087u32;
pub const PR_EMS_AB_CAN_PRESERVE_DNS: u32 = 2153775115u32;
pub const PR_EMS_AB_CA_CERTIFICATE: u32 = 2147684610u32;
pub const PR_EMS_AB_CERTIFICATE_CHAIN_V3: u32 = 2351366402u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST: u32 = 2148925698u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST_V1: u32 = 2351497474u32;
pub const PR_EMS_AB_CERTIFICATE_REVOCATION_LIST_V3: u32 = 2351431938u32;
pub const PR_EMS_AB_CHARACTER_SET: u32 = 2172977182u32;
pub const PR_EMS_AB_CHARACTER_SET_A: u32 = 2172977182u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST: u32 = 2172784670u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST_A: u32 = 2172784670u32;
pub const PR_EMS_AB_CHARACTER_SET_LIST_W: u32 = 2172784671u32;
pub const PR_EMS_AB_CHARACTER_SET_W: u32 = 2172977183u32;
pub const PR_EMS_AB_CHILD_RDNS: u32 = 4294447134u32;
pub const PR_EMS_AB_CLIENT_ACCESS_ENABLED: u32 = 2351169547u32;
pub const PR_EMS_AB_CLOCK_ALERT_OFFSET: u32 = 2153840643u32;
pub const PR_EMS_AB_CLOCK_ALERT_REPAIR: u32 = 2153906187u32;
pub const PR_EMS_AB_CLOCK_WARNING_OFFSET: u32 = 2153971715u32;
pub const PR_EMS_AB_CLOCK_WARNING_REPAIR: u32 = 2154037259u32;
pub const PR_EMS_AB_COMPROMISED_KEY_LIST: u32 = 2177106178u32;
pub const PR_EMS_AB_COMPUTER_NAME: u32 = 2154102814u32;
pub const PR_EMS_AB_COMPUTER_NAME_A: u32 = 2154102814u32;
pub const PR_EMS_AB_COMPUTER_NAME_W: u32 = 2154102815u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS: u32 = 2154172446u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS_A: u32 = 2154172446u32;
pub const PR_EMS_AB_CONNECTED_DOMAINS_W: u32 = 2154172447u32;
pub const PR_EMS_AB_CONNECTION_LIST_FILTER: u32 = 2172649730u32;
pub const PR_EMS_AB_CONNECTION_LIST_FILTER_TYPE: u32 = 2176057347u32;
pub const PR_EMS_AB_CONNECTION_TYPE: u32 = 2175991819u32;
pub const PR_EMS_AB_CONTAINERID: u32 = 4294770691u32;
pub const PR_EMS_AB_CONTAINER_INFO: u32 = 2154233859u32;
pub const PR_EMS_AB_CONTENT_TYPE: u32 = 2173042691u32;
pub const PR_EMS_AB_CONTROL_MSG_FOLDER_ID: u32 = 2173174018u32;
pub const PR_EMS_AB_CONTROL_MSG_RULES: u32 = 2173305090u32;
pub const PR_EMS_AB_COST: u32 = 2154299395u32;
pub const PR_EMS_AB_COUNTRY_NAME: u32 = 2154364958u32;
pub const PR_EMS_AB_COUNTRY_NAME_A: u32 = 2154364958u32;
pub const PR_EMS_AB_COUNTRY_NAME_W: u32 = 2154364959u32;
pub const PR_EMS_AB_CROSS_CERTIFICATE_CRL: u32 = 2351960322u32;
pub const PR_EMS_AB_CROSS_CERTIFICATE_PAIR: u32 = 2149912834u32;
pub const PR_EMS_AB_DEFAULT_MESSAGE_FORMAT: u32 = 2352414731u32;
pub const PR_EMS_AB_DELEGATE_USER: u32 = 2353594379u32;
pub const PR_EMS_AB_DELIVERY_MECHANISM: u32 = 2154692611u32;
pub const PR_EMS_AB_DELIVER_AND_REDIRECT: u32 = 2154627083u32;
pub const PR_EMS_AB_DELIV_CONT_LENGTH: u32 = 2154430467u32;
pub const PR_EMS_AB_DELIV_EITS: u32 = 2154500354u32;
pub const PR_EMS_AB_DELIV_EXT_CONT_TYPES: u32 = 2154565890u32;
pub const PR_EMS_AB_DELTA_REVOCATION_LIST: u32 = 2353402114u32;
pub const PR_EMS_AB_DESCRIPTION: u32 = 2154762270u32;
pub const PR_EMS_AB_DESCRIPTION_A: u32 = 2154762270u32;
pub const PR_EMS_AB_DESCRIPTION_W: u32 = 2154762271u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR: u32 = 2154827806u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR_A: u32 = 2154827806u32;
pub const PR_EMS_AB_DESTINATION_INDICATOR_W: u32 = 2154827807u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY: u32 = 2154889246u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY_A: u32 = 2154889246u32;
pub const PR_EMS_AB_DIAGNOSTIC_REG_KEY_W: u32 = 2154889247u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY: u32 = 2177044510u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY_A: u32 = 2177044510u32;
pub const PR_EMS_AB_DISABLED_GATEWAY_PROXY_W: u32 = 2177044511u32;
pub const PR_EMS_AB_DISABLE_DEFERRED_COMMIT: u32 = 2351104011u32;
pub const PR_EMS_AB_DISPLAY_NAME_OVERRIDE: u32 = 2147549195u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE: u32 = 973013022u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE_A: u32 = 973013022u32;
pub const PR_EMS_AB_DISPLAY_NAME_PRINTABLE_W: u32 = 973013023u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX: u32 = 2353266718u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX_A: u32 = 2353266718u32;
pub const PR_EMS_AB_DISPLAY_NAME_SUFFIX_W: u32 = 2353266719u32;
pub const PR_EMS_AB_DL_EXTERNAL_MEMBER_COUNT: u32 = 2363686915u32;
pub const PR_EMS_AB_DL_MEMBER_RULE: u32 = 2155090178u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_A: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_O: u32 = 2154954765u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_T: u32 = 2154958878u32;
pub const PR_EMS_AB_DL_MEM_REJECT_PERMS_BL_W: u32 = 2154958879u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_A: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_O: u32 = 2155020301u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_T: u32 = 2155024414u32;
pub const PR_EMS_AB_DL_MEM_SUBMIT_PERMS_BL_W: u32 = 2155024415u32;
pub const PR_EMS_AB_DMD_NAME: u32 = 2354446366u32;
pub const PR_EMS_AB_DMD_NAME_A: u32 = 2354446366u32;
pub const PR_EMS_AB_DMD_NAME_W: u32 = 2354446367u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_A: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_O: u32 = 2155151373u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_T: u32 = 2155151390u32;
pub const PR_EMS_AB_DOMAIN_DEF_ALT_RECIP_W: u32 = 2155151391u32;
pub const PR_EMS_AB_DOMAIN_NAME: u32 = 2155216926u32;
pub const PR_EMS_AB_DOMAIN_NAME_A: u32 = 2155216926u32;
pub const PR_EMS_AB_DOMAIN_NAME_W: u32 = 2155216927u32;
pub const PR_EMS_AB_DO_OAB_VERSION: u32 = 2352611331u32;
pub const PR_EMS_AB_DSA_SIGNATURE: u32 = 2155282690u32;
pub const PR_EMS_AB_DXA_ADMIN_COPY: u32 = 2155347979u32;
pub const PR_EMS_AB_DXA_ADMIN_FORWARD: u32 = 2155413515u32;
pub const PR_EMS_AB_DXA_ADMIN_UPDATE: u32 = 2155479043u32;
pub const PR_EMS_AB_DXA_APPEND_REQCN: u32 = 2155544587u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_A: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_A: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_O: u32 = 2356543501u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_T: u32 = 2356547614u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_BL_W: u32 = 2356547615u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_A: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_O: u32 = 2356215821u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_T: u32 = 2356219934u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_LINKED_W: u32 = 2356219935u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_O: u32 = 2155610125u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_T: u32 = 2155614238u32;
pub const PR_EMS_AB_DXA_CONF_CONTAINER_LIST_W: u32 = 2155614239u32;
pub const PR_EMS_AB_DXA_CONF_REQ_TIME: u32 = 2155675712u32;
pub const PR_EMS_AB_DXA_CONF_SEQ: u32 = 2155741214u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_A: u32 = 2155741214u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_USN: u32 = 2155806723u32;
pub const PR_EMS_AB_DXA_CONF_SEQ_W: u32 = 2155741215u32;
pub const PR_EMS_AB_DXA_EXCHANGE_OPTIONS: u32 = 2155872259u32;
pub const PR_EMS_AB_DXA_EXPORT_NOW: u32 = 2155937803u32;
pub const PR_EMS_AB_DXA_FLAGS: u32 = 2156003331u32;
pub const PR_EMS_AB_DXA_IMPORT_NOW: u32 = 2156265483u32;
pub const PR_EMS_AB_DXA_IMP_SEQ: u32 = 2156068894u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_A: u32 = 2156068894u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_TIME: u32 = 2156134464u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_USN: u32 = 2156199939u32;
pub const PR_EMS_AB_DXA_IMP_SEQ_W: u32 = 2156068895u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP: u32 = 2156335134u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP_A: u32 = 2156335134u32;
pub const PR_EMS_AB_DXA_IN_TEMPLATE_MAP_W: u32 = 2156335135u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_A: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_O: u32 = 2156396557u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_T: u32 = 2156396574u32;
pub const PR_EMS_AB_DXA_LOCAL_ADMIN_W: u32 = 2156396575u32;
pub const PR_EMS_AB_DXA_LOGGING_LEVEL: u32 = 2156462083u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE: u32 = 2156527646u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE_A: u32 = 2156527646u32;
pub const PR_EMS_AB_DXA_NATIVE_ADDRESS_TYPE_W: u32 = 2156527647u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP: u32 = 2156597278u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP_A: u32 = 2156597278u32;
pub const PR_EMS_AB_DXA_OUT_TEMPLATE_MAP_W: u32 = 2156597279u32;
pub const PR_EMS_AB_DXA_PASSWORD: u32 = 2156658718u32;
pub const PR_EMS_AB_DXA_PASSWORD_A: u32 = 2156658718u32;
pub const PR_EMS_AB_DXA_PASSWORD_W: u32 = 2156658719u32;
pub const PR_EMS_AB_DXA_PREV_EXCHANGE_OPTIONS: u32 = 2156724227u32;
pub const PR_EMS_AB_DXA_PREV_EXPORT_NATIVE_ONLY: u32 = 2156789771u32;
pub const PR_EMS_AB_DXA_PREV_IN_EXCHANGE_SENSITIVITY: u32 = 2156855299u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_A: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_O: u32 = 2156920845u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_T: u32 = 2156920862u32;
pub const PR_EMS_AB_DXA_PREV_REMOTE_ENTRIES_W: u32 = 2156920863u32;
pub const PR_EMS_AB_DXA_PREV_REPLICATION_SENSITIVITY: u32 = 2156986371u32;
pub const PR_EMS_AB_DXA_PREV_TEMPLATE_OPTIONS: u32 = 2157051907u32;
pub const PR_EMS_AB_DXA_PREV_TYPES: u32 = 2157117443u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP: u32 = 2157183006u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP_A: u32 = 2157183006u32;
pub const PR_EMS_AB_DXA_RECIPIENT_CP_W: u32 = 2157183007u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_A: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_O: u32 = 2157248525u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_T: u32 = 2157248542u32;
pub const PR_EMS_AB_DXA_REMOTE_CLIENT_W: u32 = 2157248543u32;
pub const PR_EMS_AB_DXA_REQNAME: u32 = 2157510686u32;
pub const PR_EMS_AB_DXA_REQNAME_A: u32 = 2157510686u32;
pub const PR_EMS_AB_DXA_REQNAME_W: u32 = 2157510687u32;
pub const PR_EMS_AB_DXA_REQ_SEQ: u32 = 2157314078u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_A: u32 = 2157314078u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_TIME: u32 = 2157379648u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_USN: u32 = 2157445123u32;
pub const PR_EMS_AB_DXA_REQ_SEQ_W: u32 = 2157314079u32;
pub const PR_EMS_AB_DXA_SVR_SEQ: u32 = 2157576222u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_A: u32 = 2157576222u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_TIME: u32 = 2157641792u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_USN: u32 = 2157707267u32;
pub const PR_EMS_AB_DXA_SVR_SEQ_W: u32 = 2157576223u32;
pub const PR_EMS_AB_DXA_TASK: u32 = 2157772803u32;
pub const PR_EMS_AB_DXA_TEMPLATE_OPTIONS: u32 = 2157838339u32;
pub const PR_EMS_AB_DXA_TEMPLATE_TIMESTAMP: u32 = 2157903936u32;
pub const PR_EMS_AB_DXA_TYPES: u32 = 2157969411u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_A: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_A: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_O: u32 = 2356609037u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_T: u32 = 2356613150u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_BL_W: u32 = 2356613151u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_A: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_O: u32 = 2356281357u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_T: u32 = 2356285470u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_LINKED_W: u32 = 2356285471u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_O: u32 = 2158034957u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_T: u32 = 2158039070u32;
pub const PR_EMS_AB_DXA_UNCONF_CONTAINER_LIST_W: u32 = 2158039071u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER: u32 = 2355560478u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER_A: u32 = 2355560478u32;
pub const PR_EMS_AB_EMPLOYEE_NUMBER_W: u32 = 2355560479u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE: u32 = 2355691550u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE_A: u32 = 2355691550u32;
pub const PR_EMS_AB_EMPLOYEE_TYPE_W: u32 = 2355691551u32;
pub const PR_EMS_AB_ENABLED: u32 = 2350972939u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES: u32 = 2172915742u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES_A: u32 = 2172915742u32;
pub const PR_EMS_AB_ENABLED_AUTHORIZATION_PACKAGES_W: u32 = 2172915743u32;
pub const PR_EMS_AB_ENABLED_PROTOCOLS: u32 = 2172583939u32;
pub const PR_EMS_AB_ENABLED_PROTOCOL_CFG: u32 = 2175270923u32;
pub const PR_EMS_AB_ENABLE_COMPATIBILITY: u32 = 2352087051u32;
pub const PR_EMS_AB_ENCAPSULATION_METHOD: u32 = 2158100483u32;
pub const PR_EMS_AB_ENCRYPT: u32 = 2158166027u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA: u32 = 2151682078u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA_A: u32 = 2151682078u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_NA_W: u32 = 2151682079u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER: u32 = 2151747614u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER_A: u32 = 2151747614u32;
pub const PR_EMS_AB_ENCRYPT_ALG_LIST_OTHER_W: u32 = 2151747615u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA: u32 = 2151874590u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA_A: u32 = 2151874590u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_NA_W: u32 = 2151874591u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER: u32 = 2151481374u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER_A: u32 = 2151481374u32;
pub const PR_EMS_AB_ENCRYPT_ALG_SELECTED_OTHER_W: u32 = 2151481375u32;
pub const PR_EMS_AB_EXPAND_DLS_LOCALLY: u32 = 2158231563u32;
pub const PR_EMS_AB_EXPIRATION_TIME: u32 = 2150105152u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_A: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_O: u32 = 2158297101u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_T: u32 = 2158301214u32;
pub const PR_EMS_AB_EXPORT_CONTAINERS_W: u32 = 2158301215u32;
pub const PR_EMS_AB_EXPORT_CUSTOM_RECIPIENTS: u32 = 2158362635u32;
pub const PR_EMS_AB_EXTENDED_CHARS_ALLOWED: u32 = 2158428171u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1: u32 = 2150432798u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10: u32 = 2151022622u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10_A: u32 = 2151022622u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_10_W: u32 = 2151022623u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11: u32 = 2354511902u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11_A: u32 = 2354511902u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_11_W: u32 = 2354511903u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12: u32 = 2354577438u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12_A: u32 = 2354577438u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_12_W: u32 = 2354577439u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13: u32 = 2354642974u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13_A: u32 = 2354642974u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_13_W: u32 = 2354642975u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14: u32 = 2355101726u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14_A: u32 = 2355101726u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_14_W: u32 = 2355101727u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15: u32 = 2355167262u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15_A: u32 = 2355167262u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_15_W: u32 = 2355167263u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1_A: u32 = 2150432798u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_1_W: u32 = 2150432799u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2: u32 = 2150498334u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2_A: u32 = 2150498334u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_2_W: u32 = 2150498335u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3: u32 = 2150563870u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3_A: u32 = 2150563870u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_3_W: u32 = 2150563871u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4: u32 = 2150629406u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4_A: u32 = 2150629406u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_4_W: u32 = 2150629407u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5: u32 = 2150694942u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5_A: u32 = 2150694942u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_5_W: u32 = 2150694943u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6: u32 = 2150760478u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6_A: u32 = 2150760478u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_6_W: u32 = 2150760479u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7: u32 = 2150826014u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7_A: u32 = 2150826014u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_7_W: u32 = 2150826015u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8: u32 = 2150891550u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8_A: u32 = 2150891550u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_8_W: u32 = 2150891551u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9: u32 = 2150957086u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9_A: u32 = 2150957086u32;
pub const PR_EMS_AB_EXTENSION_ATTRIBUTE_9_W: u32 = 2150957087u32;
pub const PR_EMS_AB_EXTENSION_DATA: u32 = 2158498050u32;
pub const PR_EMS_AB_EXTENSION_NAME: u32 = 2158563358u32;
pub const PR_EMS_AB_EXTENSION_NAME_A: u32 = 2158563358u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED: u32 = 2158628894u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED_A: u32 = 2158628894u32;
pub const PR_EMS_AB_EXTENSION_NAME_INHERITED_W: u32 = 2158628895u32;
pub const PR_EMS_AB_EXTENSION_NAME_W: u32 = 2158563359u32;
pub const PR_EMS_AB_FACSIMILE_TELEPHONE_NUMBER: u32 = 2158694658u32;
pub const PR_EMS_AB_FILE_VERSION: u32 = 2158756098u32;
pub const PR_EMS_AB_FILTER_LOCAL_ADDRESSES: u32 = 2158821387u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_A: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_O: u32 = 2158886925u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_T: u32 = 2158886942u32;
pub const PR_EMS_AB_FOLDERS_CONTAINER_W: u32 = 2158886943u32;
pub const PR_EMS_AB_FOLDER_PATHNAME: u32 = 2147745822u32;
pub const PR_EMS_AB_FOLDER_PATHNAME_A: u32 = 2147745822u32;
pub const PR_EMS_AB_FOLDER_PATHNAME_W: u32 = 2147745823u32;
pub const PR_EMS_AB_FORM_DATA: u32 = 2355429634u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS: u32 = 2355363870u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS_A: u32 = 2355363870u32;
pub const PR_EMS_AB_FORWARDING_ADDRESS_W: u32 = 2355363871u32;
pub const PR_EMS_AB_GARBAGE_COLL_PERIOD: u32 = 2158952451u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED: u32 = 2159018014u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED_A: u32 = 2159018014u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_CRED_W: u32 = 2159018015u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG: u32 = 2159083550u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG_A: u32 = 2159083550u32;
pub const PR_EMS_AB_GATEWAY_LOCAL_DESIG_W: u32 = 2159083551u32;
pub const PR_EMS_AB_GATEWAY_PROXY: u32 = 2159153182u32;
pub const PR_EMS_AB_GATEWAY_PROXY_A: u32 = 2159153182u32;
pub const PR_EMS_AB_GATEWAY_PROXY_W: u32 = 2159153183u32;
pub const PR_EMS_AB_GATEWAY_ROUTING_TREE: u32 = 2159214850u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER: u32 = 2354249758u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER_A: u32 = 2354249758u32;
pub const PR_EMS_AB_GENERATION_QUALIFIER_W: u32 = 2354249759u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1: u32 = 2176253982u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1_A: u32 = 2176253982u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_1_W: u32 = 2176253983u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2: u32 = 2176319518u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2_A: u32 = 2176319518u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_2_W: u32 = 2176319519u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3: u32 = 2176385054u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3_A: u32 = 2176385054u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_3_W: u32 = 2176385055u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4: u32 = 2176450590u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4_A: u32 = 2176450590u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_4_W: u32 = 2176450591u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_A: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_O: u32 = 2350514189u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_T: u32 = 2350514206u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_DN_W: u32 = 2350514207u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR: u32 = 2350448670u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR_A: u32 = 2350448670u32;
pub const PR_EMS_AB_GROUP_BY_ATTR_VALUE_STR_W: u32 = 2350448671u32;
pub const PR_EMS_AB_GWART_LAST_MODIFIED: u32 = 2159280192u32;
pub const PR_EMS_AB_HAB_CHILD_DEPARTMENTS: u32 = 2358902797u32;
pub const PR_EMS_AB_HAB_DEPARTMENT_MEMBERS: u32 = 2358706189u32;
pub const PR_EMS_AB_HAB_IS_HIERARCHICAL_GROUP: u32 = 2363293707u32;
pub const PR_EMS_AB_HAB_PARENT_DEPARTMENT: u32 = 2358837261u32;
pub const PR_EMS_AB_HAB_ROOT_DEPARTMENT: u32 = 2358771725u32;
pub const PR_EMS_AB_HAB_SHOW_IN_DEPARTMENTS: u32 = 2358509581u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_A: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_O: u32 = 2159345677u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_T: u32 = 2159349790u32;
pub const PR_EMS_AB_HAS_FULL_REPLICA_NCS_W: u32 = 2159349791u32;
pub const PR_EMS_AB_HAS_MASTER_NCS: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_A: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_O: u32 = 2159411213u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_T: u32 = 2159415326u32;
pub const PR_EMS_AB_HAS_MASTER_NCS_W: u32 = 2159415327u32;
pub const PR_EMS_AB_HELP_DATA16: u32 = 2151284994u32;
pub const PR_EMS_AB_HELP_DATA32: u32 = 2148532482u32;
pub const PR_EMS_AB_HELP_FILE_NAME: u32 = 2151350302u32;
pub const PR_EMS_AB_HELP_FILE_NAME_A: u32 = 2151350302u32;
pub const PR_EMS_AB_HELP_FILE_NAME_W: u32 = 2151350303u32;
pub const PR_EMS_AB_HEURISTICS: u32 = 2159476739u32;
pub const PR_EMS_AB_HIDE_DL_MEMBERSHIP: u32 = 2159542283u32;
pub const PR_EMS_AB_HIDE_FROM_ADDRESS_BOOK: u32 = 2159607819u32;
pub const PR_EMS_AB_HIERARCHY_PATH: u32 = 4294508574u32;
pub const PR_EMS_AB_HIERARCHY_PATH_A: u32 = 4294508574u32;
pub const PR_EMS_AB_HIERARCHY_PATH_W: u32 = 4294508575u32;
pub const PR_EMS_AB_HOME_MDB: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_A: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_BL: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_A: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_O: u32 = 2148794381u32;
pub const PR_EMS_AB_HOME_MDB_BL_T: u32 = 2148798494u32;
pub const PR_EMS_AB_HOME_MDB_BL_W: u32 = 2148798495u32;
pub const PR_EMS_AB_HOME_MDB_O: u32 = 2147876877u32;
pub const PR_EMS_AB_HOME_MDB_T: u32 = 2147876894u32;
pub const PR_EMS_AB_HOME_MDB_W: u32 = 2147876895u32;
pub const PR_EMS_AB_HOME_MTA: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_A: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_O: u32 = 2147942413u32;
pub const PR_EMS_AB_HOME_MTA_T: u32 = 2147942430u32;
pub const PR_EMS_AB_HOME_MTA_W: u32 = 2147942431u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_A: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_O: u32 = 2151612429u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_T: u32 = 2151612446u32;
pub const PR_EMS_AB_HOME_PUBLIC_SERVER_W: u32 = 2151612447u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER: u32 = 2354315294u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER_A: u32 = 2354315294u32;
pub const PR_EMS_AB_HOUSE_IDENTIFIER_W: u32 = 2354315295u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES: u32 = 2175340574u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES_A: u32 = 2175340574u32;
pub const PR_EMS_AB_HTTP_PUB_AB_ATTRIBUTES_W: u32 = 2175340575u32;
pub const PR_EMS_AB_HTTP_PUB_GAL: u32 = 2174418955u32;
pub const PR_EMS_AB_HTTP_PUB_GAL_LIMIT: u32 = 2174484483u32;
pub const PR_EMS_AB_HTTP_PUB_PF: u32 = 2174619906u32;
pub const PR_EMS_AB_HTTP_SERVERS: u32 = 2175471646u32;
pub const PR_EMS_AB_HTTP_SERVERS_A: u32 = 2175471646u32;
pub const PR_EMS_AB_HTTP_SERVERS_W: u32 = 2175471647u32;
pub const PR_EMS_AB_IMPORTED_FROM: u32 = 2151809054u32;
pub const PR_EMS_AB_IMPORTED_FROM_A: u32 = 2151809054u32;
pub const PR_EMS_AB_IMPORTED_FROM_W: u32 = 2151809055u32;
pub const PR_EMS_AB_IMPORT_CONTAINER: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_A: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_O: u32 = 2159673357u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_T: u32 = 2159673374u32;
pub const PR_EMS_AB_IMPORT_CONTAINER_W: u32 = 2159673375u32;
pub const PR_EMS_AB_IMPORT_SENSITIVITY: u32 = 2159738883u32;
pub const PR_EMS_AB_INBOUND_ACCEPT_ALL: u32 = 2350907403u32;
pub const PR_EMS_AB_INBOUND_DN: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_A: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_O: u32 = 2350776333u32;
pub const PR_EMS_AB_INBOUND_DN_T: u32 = 2350776350u32;
pub const PR_EMS_AB_INBOUND_DN_W: u32 = 2350776351u32;
pub const PR_EMS_AB_INBOUND_HOST: u32 = 2173571102u32;
pub const PR_EMS_AB_INBOUND_HOST_A: u32 = 2173571102u32;
pub const PR_EMS_AB_INBOUND_HOST_W: u32 = 2173571103u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED: u32 = 2173894686u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_A: u32 = 2173894686u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_TYPE: u32 = 2350841867u32;
pub const PR_EMS_AB_INBOUND_NEWSFEED_W: u32 = 2173894687u32;
pub const PR_EMS_AB_INBOUND_SITES: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_A: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_O: u32 = 2159804429u32;
pub const PR_EMS_AB_INBOUND_SITES_T: u32 = 2159808542u32;
pub const PR_EMS_AB_INBOUND_SITES_W: u32 = 2159808543u32;
pub const PR_EMS_AB_INCOMING_MSG_SIZE_LIMIT: u32 = 2173698051u32;
pub const PR_EMS_AB_INCOMING_PASSWORD: u32 = 2175729922u32;
pub const PR_EMS_AB_INSADMIN: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_A: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_O: u32 = 2177171469u32;
pub const PR_EMS_AB_INSADMIN_T: u32 = 2177171486u32;
pub const PR_EMS_AB_INSADMIN_W: u32 = 2177171487u32;
pub const PR_EMS_AB_INSTANCE_TYPE: u32 = 2159869955u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER: u32 = 2159939614u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER_A: u32 = 2159939614u32;
pub const PR_EMS_AB_INTERNATIONAL_ISDN_NUMBER_W: u32 = 2159939615u32;
pub const PR_EMS_AB_INVOCATION_ID: u32 = 2160001282u32;
pub const PR_EMS_AB_IS_DELETED: u32 = 2160066571u32;
pub const PR_EMS_AB_IS_MASTER: u32 = 4294639627u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL: u32 = 2148007949u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_A: u32 = 2148012062u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_O: u32 = 2148007949u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_T: u32 = 2148012062u32;
pub const PR_EMS_AB_IS_MEMBER_OF_DL_W: u32 = 2148012063u32;
pub const PR_EMS_AB_IS_SINGLE_VALUED: u32 = 2160132107u32;
pub const PR_EMS_AB_KCC_STATUS: u32 = 2160201986u32;
pub const PR_EMS_AB_KM_SERVER: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_A: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_O: u32 = 2148335629u32;
pub const PR_EMS_AB_KM_SERVER_T: u32 = 2148335646u32;
pub const PR_EMS_AB_KM_SERVER_W: u32 = 2148335647u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION: u32 = 2160267294u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION_A: u32 = 2160267294u32;
pub const PR_EMS_AB_KNOWLEDGE_INFORMATION_W: u32 = 2160267295u32;
pub const PR_EMS_AB_LABELEDURI: u32 = 2354118686u32;
pub const PR_EMS_AB_LABELEDURI_A: u32 = 2354118686u32;
pub const PR_EMS_AB_LABELEDURI_W: u32 = 2354118687u32;
pub const PR_EMS_AB_LANGUAGE: u32 = 2172125187u32;
pub const PR_EMS_AB_LANGUAGE_ISO639: u32 = 2355888158u32;
pub const PR_EMS_AB_LANGUAGE_ISO639_A: u32 = 2355888158u32;
pub const PR_EMS_AB_LANGUAGE_ISO639_W: u32 = 2355888159u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME: u32 = 2171670558u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME_A: u32 = 2171670558u32;
pub const PR_EMS_AB_LDAP_DISPLAY_NAME_W: u32 = 2171670559u32;
pub const PR_EMS_AB_LDAP_SEARCH_CFG: u32 = 2350710787u32;
pub const PR_EMS_AB_LINE_WRAP: u32 = 2160328707u32;
pub const PR_EMS_AB_LINK_ID: u32 = 2160394243u32;
pub const PR_EMS_AB_LIST_PUBLIC_FOLDERS: u32 = 2354053131u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD: u32 = 2160459806u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_A: u32 = 2160459806u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS: u32 = 2160525342u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS_A: u32 = 2160525342u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_ADDRESS_W: u32 = 2160525343u32;
pub const PR_EMS_AB_LOCAL_BRIDGE_HEAD_W: u32 = 2160459807u32;
pub const PR_EMS_AB_LOCAL_INITIAL_TURN: u32 = 2160590859u32;
pub const PR_EMS_AB_LOCAL_SCOPE: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_A: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_O: u32 = 2160656397u32;
pub const PR_EMS_AB_LOCAL_SCOPE_T: u32 = 2160660510u32;
pub const PR_EMS_AB_LOCAL_SCOPE_W: u32 = 2160660511u32;
pub const PR_EMS_AB_LOG_FILENAME: u32 = 2160721950u32;
pub const PR_EMS_AB_LOG_FILENAME_A: u32 = 2160721950u32;
pub const PR_EMS_AB_LOG_FILENAME_W: u32 = 2160721951u32;
pub const PR_EMS_AB_LOG_ROLLOVER_INTERVAL: u32 = 2160787459u32;
pub const PR_EMS_AB_MAIL_DROP: u32 = 2355298334u32;
pub const PR_EMS_AB_MAIL_DROP_A: u32 = 2355298334u32;
pub const PR_EMS_AB_MAIL_DROP_W: u32 = 2355298335u32;
pub const PR_EMS_AB_MAINTAIN_AUTOREPLY_HISTORY: u32 = 2160853003u32;
pub const PR_EMS_AB_MANAGER: u32 = 2147811341u32;
pub const PR_EMS_AB_MANAGER_A: u32 = 2147811358u32;
pub const PR_EMS_AB_MANAGER_O: u32 = 2147811341u32;
pub const PR_EMS_AB_MANAGER_T: u32 = 2147811358u32;
pub const PR_EMS_AB_MANAGER_W: u32 = 2147811359u32;
pub const PR_EMS_AB_MAPI_DISPLAY_TYPE: u32 = 2160918531u32;
pub const PR_EMS_AB_MAPI_ID: u32 = 2160984067u32;
pub const PR_EMS_AB_MAXIMUM_OBJECT_ID: u32 = 2171142402u32;
pub const PR_EMS_AB_MDB_BACKOFF_INTERVAL: u32 = 2161049603u32;
pub const PR_EMS_AB_MDB_MSG_TIME_OUT_PERIOD: u32 = 2161115139u32;
pub const PR_EMS_AB_MDB_OVER_QUOTA_LIMIT: u32 = 2161180675u32;
pub const PR_EMS_AB_MDB_STORAGE_QUOTA: u32 = 2161246211u32;
pub const PR_EMS_AB_MDB_UNREAD_LIMIT: u32 = 2161311747u32;
pub const PR_EMS_AB_MDB_USE_DEFAULTS: u32 = 2161377291u32;
pub const PR_EMS_AB_MEMBER: u32 = 2148073485u32;
pub const PR_EMS_AB_MEMBER_A: u32 = 2148077598u32;
pub const PR_EMS_AB_MEMBER_O: u32 = 2148073485u32;
pub const PR_EMS_AB_MEMBER_T: u32 = 2148077598u32;
pub const PR_EMS_AB_MEMBER_W: u32 = 2148077599u32;
pub const PR_EMS_AB_MESSAGE_TRACKING_ENABLED: u32 = 2161442827u32;
pub const PR_EMS_AB_MIME_TYPES: u32 = 2350645506u32;
pub const PR_EMS_AB_MODERATED: u32 = 2175533067u32;
pub const PR_EMS_AB_MODERATOR: u32 = 2174287902u32;
pub const PR_EMS_AB_MODERATOR_A: u32 = 2174287902u32;
pub const PR_EMS_AB_MODERATOR_W: u32 = 2174287903u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_A: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_O: u32 = 2161704973u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_T: u32 = 2161709086u32;
pub const PR_EMS_AB_MONITORED_CONFIGURATIONS_W: u32 = 2161709087u32;
pub const PR_EMS_AB_MONITORED_SERVERS: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_A: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_O: u32 = 2161770509u32;
pub const PR_EMS_AB_MONITORED_SERVERS_T: u32 = 2161774622u32;
pub const PR_EMS_AB_MONITORED_SERVERS_W: u32 = 2161774623u32;
pub const PR_EMS_AB_MONITORED_SERVICES: u32 = 2161840158u32;
pub const PR_EMS_AB_MONITORED_SERVICES_A: u32 = 2161840158u32;
pub const PR_EMS_AB_MONITORED_SERVICES_W: u32 = 2161840159u32;
pub const PR_EMS_AB_MONITORING_ALERT_DELAY: u32 = 2161901571u32;
pub const PR_EMS_AB_MONITORING_ALERT_UNITS: u32 = 2161967107u32;
pub const PR_EMS_AB_MONITORING_AVAILABILITY_STYLE: u32 = 2162032643u32;
pub const PR_EMS_AB_MONITORING_AVAILABILITY_WINDOW: u32 = 2162098434u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_A: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_O: u32 = 2162163725u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_T: u32 = 2162167838u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_MAIL_W: u32 = 2162167839u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_A: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_O: u32 = 2162229261u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_T: u32 = 2162233374u32;
pub const PR_EMS_AB_MONITORING_CACHED_VIA_RPC_W: u32 = 2162233375u32;
pub const PR_EMS_AB_MONITORING_ESCALATION_PROCEDURE: u32 = 2162299138u32;
pub const PR_EMS_AB_MONITORING_HOTSITE_POLL_INTERVAL: u32 = 2162360323u32;
pub const PR_EMS_AB_MONITORING_HOTSITE_POLL_UNITS: u32 = 2162425859u32;
pub const PR_EMS_AB_MONITORING_MAIL_UPDATE_INTERVAL: u32 = 2162491395u32;
pub const PR_EMS_AB_MONITORING_MAIL_UPDATE_UNITS: u32 = 2162556931u32;
pub const PR_EMS_AB_MONITORING_NORMAL_POLL_INTERVAL: u32 = 2162622467u32;
pub const PR_EMS_AB_MONITORING_NORMAL_POLL_UNITS: u32 = 2162688003u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_A: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_A: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_O: u32 = 2162819085u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_T: u32 = 2162823198u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_NDR_W: u32 = 2162823199u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_O: u32 = 2162753549u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_T: u32 = 2162757662u32;
pub const PR_EMS_AB_MONITORING_RECIPIENTS_W: u32 = 2162757663u32;
pub const PR_EMS_AB_MONITORING_RPC_UPDATE_INTERVAL: u32 = 2162884611u32;
pub const PR_EMS_AB_MONITORING_RPC_UPDATE_UNITS: u32 = 2162950147u32;
pub const PR_EMS_AB_MONITORING_WARNING_DELAY: u32 = 2163015683u32;
pub const PR_EMS_AB_MONITORING_WARNING_UNITS: u32 = 2163081219u32;
pub const PR_EMS_AB_MONITOR_CLOCK: u32 = 2161508363u32;
pub const PR_EMS_AB_MONITOR_SERVERS: u32 = 2161573899u32;
pub const PR_EMS_AB_MONITOR_SERVICES: u32 = 2161639435u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED: u32 = 2163146782u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED_A: u32 = 2163146782u32;
pub const PR_EMS_AB_MTA_LOCAL_CRED_W: u32 = 2163146783u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG: u32 = 2163212318u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG_A: u32 = 2163212318u32;
pub const PR_EMS_AB_MTA_LOCAL_DESIG_W: u32 = 2163212319u32;
pub const PR_EMS_AB_NETWORK_ADDRESS: u32 = 2171605022u32;
pub const PR_EMS_AB_NETWORK_ADDRESS_A: u32 = 2171605022u32;
pub const PR_EMS_AB_NETWORK_ADDRESS_W: u32 = 2171605023u32;
pub const PR_EMS_AB_NEWSFEED_TYPE: u32 = 2173960195u32;
pub const PR_EMS_AB_NEWSGROUP: u32 = 2174222366u32;
pub const PR_EMS_AB_NEWSGROUP_A: u32 = 2174222366u32;
pub const PR_EMS_AB_NEWSGROUP_LIST: u32 = 2174091522u32;
pub const PR_EMS_AB_NEWSGROUP_W: u32 = 2174222367u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET: u32 = 2172452894u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET_A: u32 = 2172452894u32;
pub const PR_EMS_AB_NNTP_CHARACTER_SET_W: u32 = 2172452895u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT: u32 = 2171994142u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT_A: u32 = 2171994142u32;
pub const PR_EMS_AB_NNTP_CONTENT_FORMAT_W: u32 = 2171994143u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS: u32 = 2174160926u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_A: u32 = 2174160926u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_FLAG: u32 = 2175008779u32;
pub const PR_EMS_AB_NNTP_DISTRIBUTIONS_W: u32 = 2174160927u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_A: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_O: u32 = 2175139853u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_T: u32 = 2175143966u32;
pub const PR_EMS_AB_NNTP_NEWSFEEDS_W: u32 = 2175143967u32;
pub const PR_EMS_AB_NT_MACHINE_NAME: u32 = 2163408926u32;
pub const PR_EMS_AB_NT_MACHINE_NAME_A: u32 = 2163408926u32;
pub const PR_EMS_AB_NT_MACHINE_NAME_W: u32 = 2163408927u32;
pub const PR_EMS_AB_NT_SECURITY_DESCRIPTOR: u32 = 2148729090u32;
pub const PR_EMS_AB_NUM_OF_OPEN_RETRIES: u32 = 2163474435u32;
pub const PR_EMS_AB_NUM_OF_TRANSFER_RETRIES: u32 = 2163539971u32;
pub const PR_EMS_AB_N_ADDRESS: u32 = 2163278082u32;
pub const PR_EMS_AB_N_ADDRESS_TYPE: u32 = 2163343363u32;
pub const PR_EMS_AB_OBJECT_CLASS_CATEGORY: u32 = 2163605507u32;
pub const PR_EMS_AB_OBJECT_GUID: u32 = 2355953922u32;
pub const PR_EMS_AB_OBJECT_OID: u32 = 4294574338u32;
pub const PR_EMS_AB_OBJECT_VERSION: u32 = 2163671043u32;
pub const PR_EMS_AB_OBJ_DIST_NAME: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_A: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_O: u32 = 2151415821u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_T: u32 = 2151415838u32;
pub const PR_EMS_AB_OBJ_DIST_NAME_W: u32 = 2151415839u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_A: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_O: u32 = 2177302541u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_T: u32 = 2177306654u32;
pub const PR_EMS_AB_OBJ_VIEW_CONTAINERS_W: u32 = 2177306655u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_A: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_O: u32 = 2163736589u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_T: u32 = 2163740702u32;
pub const PR_EMS_AB_OFF_LINE_AB_CONTAINERS_W: u32 = 2163740703u32;
pub const PR_EMS_AB_OFF_LINE_AB_SCHEDULE: u32 = 2163802370u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_A: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_O: u32 = 2163867661u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_T: u32 = 2163867678u32;
pub const PR_EMS_AB_OFF_LINE_AB_SERVER_W: u32 = 2163867679u32;
pub const PR_EMS_AB_OFF_LINE_AB_STYLE: u32 = 2163933187u32;
pub const PR_EMS_AB_OID_TYPE: u32 = 2163998723u32;
pub const PR_EMS_AB_OM_OBJECT_CLASS: u32 = 2164064514u32;
pub const PR_EMS_AB_OM_SYNTAX: u32 = 2164129795u32;
pub const PR_EMS_AB_OOF_REPLY_TO_ORIGINATOR: u32 = 2164195339u32;
pub const PR_EMS_AB_OPEN_RETRY_INTERVAL: u32 = 2164260867u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME: u32 = 2164396062u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME_A: u32 = 2164396062u32;
pub const PR_EMS_AB_ORGANIZATIONAL_UNIT_NAME_W: u32 = 2164396063u32;
pub const PR_EMS_AB_ORGANIZATION_NAME: u32 = 2164330526u32;
pub const PR_EMS_AB_ORGANIZATION_NAME_A: u32 = 2164330526u32;
pub const PR_EMS_AB_ORGANIZATION_NAME_W: u32 = 2164330527u32;
pub const PR_EMS_AB_ORG_UNIT_ROOT_DN: u32 = 2359820318u32;
pub const PR_EMS_AB_ORIGINAL_DISPLAY_TABLE: u32 = 2164457730u32;
pub const PR_EMS_AB_ORIGINAL_DISPLAY_TABLE_MSDOS: u32 = 2164523266u32;
pub const PR_EMS_AB_OTHER_RECIPS: u32 = 4026531853u32;
pub const PR_EMS_AB_OUTBOUND_HOST: u32 = 2173501698u32;
pub const PR_EMS_AB_OUTBOUND_HOST_TYPE: u32 = 2175795211u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED: u32 = 2174025758u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED_A: u32 = 2174025758u32;
pub const PR_EMS_AB_OUTBOUND_NEWSFEED_W: u32 = 2174025759u32;
pub const PR_EMS_AB_OUTBOUND_SITES: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_A: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_O: u32 = 2164588557u32;
pub const PR_EMS_AB_OUTBOUND_SITES_T: u32 = 2164592670u32;
pub const PR_EMS_AB_OUTBOUND_SITES_W: u32 = 2164592671u32;
pub const PR_EMS_AB_OUTGOING_MSG_SIZE_LIMIT: u32 = 2173632515u32;
pub const PR_EMS_AB_OVERRIDE_NNTP_CONTENT_FORMAT: u32 = 2177237003u32;
pub const PR_EMS_AB_OWA_SERVER: u32 = 2355494942u32;
pub const PR_EMS_AB_OWA_SERVER_A: u32 = 2355494942u32;
pub const PR_EMS_AB_OWA_SERVER_W: u32 = 2355494943u32;
pub const PR_EMS_AB_OWNER: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_A: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_BL: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_A: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_O: u32 = 2149842957u32;
pub const PR_EMS_AB_OWNER_BL_T: u32 = 2149847070u32;
pub const PR_EMS_AB_OWNER_BL_W: u32 = 2149847071u32;
pub const PR_EMS_AB_OWNER_O: u32 = 2148270093u32;
pub const PR_EMS_AB_OWNER_T: u32 = 2148270110u32;
pub const PR_EMS_AB_OWNER_W: u32 = 2148270111u32;
pub const PR_EMS_AB_PARENT_ENTRYID: u32 = 4294705410u32;
pub const PR_EMS_AB_PERIOD_REPL_STAGGER: u32 = 2164981763u32;
pub const PR_EMS_AB_PERIOD_REP_SYNC_TIMES: u32 = 2164916482u32;
pub const PR_EMS_AB_PERSONAL_TITLE: u32 = 2355822622u32;
pub const PR_EMS_AB_PERSONAL_TITLE_A: u32 = 2355822622u32;
pub const PR_EMS_AB_PERSONAL_TITLE_W: u32 = 2355822623u32;
pub const PR_EMS_AB_PER_MSG_DIALOG_DISPLAY_TABLE: u32 = 2164785410u32;
pub const PR_EMS_AB_PER_RECIP_DIALOG_DISPLAY_TABLE: u32 = 2164850946u32;
pub const PR_EMS_AB_PF_CONTACTS: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_A: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_O: u32 = 2151153677u32;
pub const PR_EMS_AB_PF_CONTACTS_T: u32 = 2151157790u32;
pub const PR_EMS_AB_PF_CONTACTS_W: u32 = 2151157791u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME: u32 = 2358312990u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME_A: u32 = 2358312990u32;
pub const PR_EMS_AB_PHONETIC_COMPANY_NAME_W: u32 = 2358312991u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME: u32 = 2358247454u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME_A: u32 = 2358247454u32;
pub const PR_EMS_AB_PHONETIC_DEPARTMENT_NAME_W: u32 = 2358247455u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME: u32 = 2358378526u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME_A: u32 = 2358378526u32;
pub const PR_EMS_AB_PHONETIC_DISPLAY_NAME_W: u32 = 2358378527u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME: u32 = 2358116382u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME_A: u32 = 2358116382u32;
pub const PR_EMS_AB_PHONETIC_GIVEN_NAME_W: u32 = 2358116383u32;
pub const PR_EMS_AB_PHONETIC_SURNAME: u32 = 2358181918u32;
pub const PR_EMS_AB_PHONETIC_SURNAME_A: u32 = 2358181918u32;
pub const PR_EMS_AB_PHONETIC_SURNAME_W: u32 = 2358181919u32;
pub const PR_EMS_AB_POP_CHARACTER_SET: u32 = 2172190750u32;
pub const PR_EMS_AB_POP_CHARACTER_SET_A: u32 = 2172190750u32;
pub const PR_EMS_AB_POP_CHARACTER_SET_W: u32 = 2172190751u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT: u32 = 2172059678u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT_A: u32 = 2172059678u32;
pub const PR_EMS_AB_POP_CONTENT_FORMAT_W: u32 = 2172059679u32;
pub const PR_EMS_AB_PORT_NUMBER: u32 = 2176122883u32;
pub const PR_EMS_AB_POSTAL_ADDRESS: u32 = 2165051650u32;
pub const PR_EMS_AB_PREFERRED_DELIVERY_METHOD: u32 = 2165116931u32;
pub const PR_EMS_AB_PRESERVE_INTERNET_CONTENT: u32 = 2351038475u32;
pub const PR_EMS_AB_PRMD: u32 = 2165178398u32;
pub const PR_EMS_AB_PRMD_A: u32 = 2165178398u32;
pub const PR_EMS_AB_PRMD_W: u32 = 2165178399u32;
pub const PR_EMS_AB_PROMO_EXPIRATION: u32 = 2176974912u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS: u32 = 2176192542u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS_A: u32 = 2176192542u32;
pub const PR_EMS_AB_PROTOCOL_SETTINGS_W: u32 = 2176192543u32;
pub const PR_EMS_AB_PROXY_ADDRESSES: u32 = 2148470814u32;
pub const PR_EMS_AB_PROXY_ADDRESSES_A: u32 = 2148470814u32;
pub const PR_EMS_AB_PROXY_ADDRESSES_W: u32 = 2148470815u32;
pub const PR_EMS_AB_PROXY_GENERATION_ENABLED: u32 = 2175860747u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL: u32 = 2165243934u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL_A: u32 = 2165243934u32;
pub const PR_EMS_AB_PROXY_GENERATOR_DLL_W: u32 = 2165243935u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES: u32 = 2148859917u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_A: u32 = 2148864030u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_A: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_O: u32 = 2165309453u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_T: u32 = 2165313566u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_BL_W: u32 = 2165313567u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_O: u32 = 2148859917u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_T: u32 = 2148864030u32;
pub const PR_EMS_AB_PUBLIC_DELEGATES_W: u32 = 2148864031u32;
pub const PR_EMS_AB_P_SELECTOR: u32 = 2164654338u32;
pub const PR_EMS_AB_P_SELECTOR_INBOUND: u32 = 2164719874u32;
pub const PR_EMS_AB_QUOTA_NOTIFICATION_SCHEDULE: u32 = 2165375234u32;
pub const PR_EMS_AB_QUOTA_NOTIFICATION_STYLE: u32 = 2165440515u32;
pub const PR_EMS_AB_RANGE_LOWER: u32 = 2165506051u32;
pub const PR_EMS_AB_RANGE_UPPER: u32 = 2165571587u32;
pub const PR_EMS_AB_RAS_ACCOUNT: u32 = 2175598622u32;
pub const PR_EMS_AB_RAS_ACCOUNT_A: u32 = 2175598622u32;
pub const PR_EMS_AB_RAS_ACCOUNT_W: u32 = 2175598623u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER: u32 = 2165637150u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER_A: u32 = 2165637150u32;
pub const PR_EMS_AB_RAS_CALLBACK_NUMBER_W: u32 = 2165637151u32;
pub const PR_EMS_AB_RAS_PASSWORD: u32 = 2175664386u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME: u32 = 2165768222u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME_A: u32 = 2165768222u32;
pub const PR_EMS_AB_RAS_PHONEBOOK_ENTRY_NAME_W: u32 = 2165768223u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER: u32 = 2165702686u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER_A: u32 = 2165702686u32;
pub const PR_EMS_AB_RAS_PHONE_NUMBER_W: u32 = 2165702687u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME: u32 = 2165833758u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME_A: u32 = 2165833758u32;
pub const PR_EMS_AB_RAS_REMOTE_SRVR_NAME_W: u32 = 2165833759u32;
pub const PR_EMS_AB_REFERRAL_LIST: u32 = 2174947358u32;
pub const PR_EMS_AB_REFERRAL_LIST_A: u32 = 2174947358u32;
pub const PR_EMS_AB_REFERRAL_LIST_W: u32 = 2174947359u32;
pub const PR_EMS_AB_REGISTERED_ADDRESS: u32 = 2165903618u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD: u32 = 2165964830u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_A: u32 = 2165964830u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS: u32 = 2166030366u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS_A: u32 = 2166030366u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_ADDRESS_W: u32 = 2166030367u32;
pub const PR_EMS_AB_REMOTE_BRIDGE_HEAD_W: u32 = 2165964831u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_A: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_O: u32 = 2166095885u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_T: u32 = 2166095902u32;
pub const PR_EMS_AB_REMOTE_OUT_BH_SERVER_W: u32 = 2166095903u32;
pub const PR_EMS_AB_REMOTE_SITE: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_A: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_O: u32 = 2166161421u32;
pub const PR_EMS_AB_REMOTE_SITE_T: u32 = 2166161438u32;
pub const PR_EMS_AB_REMOTE_SITE_W: u32 = 2166161439u32;
pub const PR_EMS_AB_REPLICATED_OBJECT_VERSION: u32 = 2355232771u32;
pub const PR_EMS_AB_REPLICATION_MAIL_MSG_SIZE: u32 = 2171076611u32;
pub const PR_EMS_AB_REPLICATION_SENSITIVITY: u32 = 2166226947u32;
pub const PR_EMS_AB_REPLICATION_SIGNATURE: u32 = 2356019458u32;
pub const PR_EMS_AB_REPLICATION_STAGGER: u32 = 2166292483u32;
pub const PR_EMS_AB_REPORTS: u32 = 2148401165u32;
pub const PR_EMS_AB_REPORTS_A: u32 = 2148405278u32;
pub const PR_EMS_AB_REPORTS_O: u32 = 2148401165u32;
pub const PR_EMS_AB_REPORTS_T: u32 = 2148405278u32;
pub const PR_EMS_AB_REPORTS_W: u32 = 2148405279u32;
pub const PR_EMS_AB_REPORT_TO_ORIGINATOR: u32 = 2166358027u32;
pub const PR_EMS_AB_REPORT_TO_OWNER: u32 = 2166423563u32;
pub const PR_EMS_AB_REQUIRE_SSL: u32 = 2351235083u32;
pub const PR_EMS_AB_REQ_SEQ: u32 = 2166489091u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_A: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_O: u32 = 2166554637u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_T: u32 = 2166554654u32;
pub const PR_EMS_AB_RESPONSIBLE_LOCAL_DXA_W: u32 = 2166554655u32;
pub const PR_EMS_AB_RETURN_EXACT_MSG_SIZE: u32 = 2354184203u32;
pub const PR_EMS_AB_RID_SERVER: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_A: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_O: u32 = 2166620173u32;
pub const PR_EMS_AB_RID_SERVER_T: u32 = 2166620190u32;
pub const PR_EMS_AB_RID_SERVER_W: u32 = 2166620191u32;
pub const PR_EMS_AB_ROLE_OCCUPANT: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_A: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_O: u32 = 2166685709u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_T: u32 = 2166689822u32;
pub const PR_EMS_AB_ROLE_OCCUPANT_W: u32 = 2166689823u32;
pub const PR_EMS_AB_ROOM_CAPACITY: u32 = 134676483u32;
pub const PR_EMS_AB_ROOM_CONTAINERS: u32 = 2358644766u32;
pub const PR_EMS_AB_ROOM_CONTAINERS_A: u32 = 2358644766u32;
pub const PR_EMS_AB_ROOM_CONTAINERS_W: u32 = 2358644767u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION: u32 = 134807582u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION_A: u32 = 134807582u32;
pub const PR_EMS_AB_ROOM_DESCRIPTION_W: u32 = 134807583u32;
pub const PR_EMS_AB_ROOT_NEWSGROUPS_FOLDER_ID: u32 = 2175926530u32;
pub const PR_EMS_AB_ROUTING_LIST: u32 = 2166755358u32;
pub const PR_EMS_AB_ROUTING_LIST_A: u32 = 2166755358u32;
pub const PR_EMS_AB_ROUTING_LIST_W: u32 = 2166755359u32;
pub const PR_EMS_AB_RTS_CHECKPOINT_SIZE: u32 = 2166816771u32;
pub const PR_EMS_AB_RTS_RECOVERY_TIMEOUT: u32 = 2166882307u32;
pub const PR_EMS_AB_RTS_WINDOW_SIZE: u32 = 2166947843u32;
pub const PR_EMS_AB_RUNS_ON: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_A: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_O: u32 = 2167013389u32;
pub const PR_EMS_AB_RUNS_ON_T: u32 = 2167017502u32;
pub const PR_EMS_AB_RUNS_ON_W: u32 = 2167017503u32;
pub const PR_EMS_AB_SCHEMA_FLAGS: u32 = 2171797507u32;
pub const PR_EMS_AB_SCHEMA_VERSION: u32 = 2172391427u32;
pub const PR_EMS_AB_SEARCH_FLAGS: u32 = 2167209987u32;
pub const PR_EMS_AB_SEARCH_GUIDE: u32 = 2167279874u32;
pub const PR_EMS_AB_SECURITY_POLICY: u32 = 2353467650u32;
pub const PR_EMS_AB_SECURITY_PROTOCOL: u32 = 2151092482u32;
pub const PR_EMS_AB_SEE_ALSO: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_A: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_O: u32 = 2167341069u32;
pub const PR_EMS_AB_SEE_ALSO_T: u32 = 2167345182u32;
pub const PR_EMS_AB_SEE_ALSO_W: u32 = 2167345183u32;
pub const PR_EMS_AB_SEND_EMAIL_MESSAGE: u32 = 2352021515u32;
pub const PR_EMS_AB_SEND_TNEF: u32 = 2173763595u32;
pub const PR_EMS_AB_SENIORITY_INDEX: u32 = 2359296003u32;
pub const PR_EMS_AB_SERIAL_NUMBER: u32 = 2167410718u32;
pub const PR_EMS_AB_SERIAL_NUMBER_A: u32 = 2167410718u32;
pub const PR_EMS_AB_SERIAL_NUMBER_W: u32 = 2167410719u32;
pub const PR_EMS_AB_SERVER: u32 = 4294836254u32;
pub const PR_EMS_AB_SERVER_A: u32 = 4294836254u32;
pub const PR_EMS_AB_SERVER_W: u32 = 4294836255u32;
pub const PR_EMS_AB_SERVICE_ACTION_FIRST: u32 = 2167472131u32;
pub const PR_EMS_AB_SERVICE_ACTION_OTHER: u32 = 2167537667u32;
pub const PR_EMS_AB_SERVICE_ACTION_SECOND: u32 = 2167603203u32;
pub const PR_EMS_AB_SERVICE_RESTART_DELAY: u32 = 2167668739u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE: u32 = 2167734302u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE_A: u32 = 2167734302u32;
pub const PR_EMS_AB_SERVICE_RESTART_MESSAGE_W: u32 = 2167734303u32;
pub const PR_EMS_AB_SESSION_DISCONNECT_TIMER: u32 = 2167799811u32;
pub const PR_EMS_AB_SITE_AFFINITY: u32 = 2167869470u32;
pub const PR_EMS_AB_SITE_AFFINITY_A: u32 = 2167869470u32;
pub const PR_EMS_AB_SITE_AFFINITY_W: u32 = 2167869471u32;
pub const PR_EMS_AB_SITE_FOLDER_GUID: u32 = 2170945794u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_A: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_O: u32 = 2171011085u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_T: u32 = 2171011102u32;
pub const PR_EMS_AB_SITE_FOLDER_SERVER_W: u32 = 2171011103u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE: u32 = 2167935006u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE_A: u32 = 2167935006u32;
pub const PR_EMS_AB_SITE_PROXY_SPACE_W: u32 = 2167935007u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA: u32 = 2352156702u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA_A: u32 = 2352156702u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_NA_W: u32 = 2352156703u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER: u32 = 2352222238u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER_A: u32 = 2352222238u32;
pub const PR_EMS_AB_SMIME_ALG_LIST_OTHER_W: u32 = 2352222239u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA: u32 = 2352283678u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA_A: u32 = 2352283678u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_NA_W: u32 = 2352283679u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER: u32 = 2352349214u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER_A: u32 = 2352349214u32;
pub const PR_EMS_AB_SMIME_ALG_SELECTED_OTHER_W: u32 = 2352349215u32;
pub const PR_EMS_AB_SPACE_LAST_COMPUTED: u32 = 2167996480u32;
pub const PR_EMS_AB_STREET_ADDRESS: u32 = 2168061982u32;
pub const PR_EMS_AB_STREET_ADDRESS_A: u32 = 2168061982u32;
pub const PR_EMS_AB_STREET_ADDRESS_W: u32 = 2168061983u32;
pub const PR_EMS_AB_SUBMISSION_CONT_LENGTH: u32 = 2168193027u32;
pub const PR_EMS_AB_SUB_REFS: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_A: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_O: u32 = 2168127501u32;
pub const PR_EMS_AB_SUB_REFS_T: u32 = 2168131614u32;
pub const PR_EMS_AB_SUB_REFS_W: u32 = 2168131615u32;
pub const PR_EMS_AB_SUB_SITE: u32 = 2172321822u32;
pub const PR_EMS_AB_SUB_SITE_A: u32 = 2172321822u32;
pub const PR_EMS_AB_SUB_SITE_W: u32 = 2172321823u32;
pub const PR_EMS_AB_SUPPORTED_ALGORITHMS: u32 = 2354381058u32;
pub const PR_EMS_AB_SUPPORTED_APPLICATION_CONTEXT: u32 = 2168262914u32;
pub const PR_EMS_AB_SUPPORTING_STACK: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_A: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_A: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_O: u32 = 2168389645u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_T: u32 = 2168393758u32;
pub const PR_EMS_AB_SUPPORTING_STACK_BL_W: u32 = 2168393759u32;
pub const PR_EMS_AB_SUPPORTING_STACK_O: u32 = 2168324109u32;
pub const PR_EMS_AB_SUPPORTING_STACK_T: u32 = 2168328222u32;
pub const PR_EMS_AB_SUPPORTING_STACK_W: u32 = 2168328223u32;
pub const PR_EMS_AB_SUPPORT_SMIME_SIGNATURES: u32 = 2353528843u32;
pub const PR_EMS_AB_S_SELECTOR: u32 = 2167079170u32;
pub const PR_EMS_AB_S_SELECTOR_INBOUND: u32 = 2167144706u32;
pub const PR_EMS_AB_TARGET_ADDRESS: u32 = 2148597790u32;
pub const PR_EMS_AB_TARGET_ADDRESS_A: u32 = 2148597790u32;
pub const PR_EMS_AB_TARGET_ADDRESS_W: u32 = 2148597791u32;
pub const PR_EMS_AB_TARGET_MTAS: u32 = 2168590366u32;
pub const PR_EMS_AB_TARGET_MTAS_A: u32 = 2168590366u32;
pub const PR_EMS_AB_TARGET_MTAS_W: u32 = 2168590367u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER: u32 = 2148667422u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER_A: u32 = 2148667422u32;
pub const PR_EMS_AB_TELEPHONE_NUMBER_W: u32 = 2148667423u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER: u32 = 2355626014u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER_A: u32 = 2355626014u32;
pub const PR_EMS_AB_TELEPHONE_PERSONAL_PAGER_W: u32 = 2355626015u32;
pub const PR_EMS_AB_TELETEX_TERMINAL_IDENTIFIER: u32 = 2168656130u32;
pub const PR_EMS_AB_TEMP_ASSOC_THRESHOLD: u32 = 2168717315u32;
pub const PR_EMS_AB_TOMBSTONE_LIFETIME: u32 = 2168782851u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME: u32 = 2168848414u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME_A: u32 = 2168848414u32;
pub const PR_EMS_AB_TRACKING_LOG_PATH_NAME_W: u32 = 2168848415u32;
pub const PR_EMS_AB_TRANSFER_RETRY_INTERVAL: u32 = 2169044995u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_NON_URGENT: u32 = 2169110531u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_NORMAL: u32 = 2169176067u32;
pub const PR_EMS_AB_TRANSFER_TIMEOUT_URGENT: u32 = 2169241603u32;
pub const PR_EMS_AB_TRANSLATION_TABLE_USED: u32 = 2169307139u32;
pub const PR_EMS_AB_TRANSPORT_EXPEDITED_DATA: u32 = 2169372683u32;
pub const PR_EMS_AB_TRANS_RETRY_MINS: u32 = 2168913923u32;
pub const PR_EMS_AB_TRANS_TIMEOUT_MINS: u32 = 2168979459u32;
pub const PR_EMS_AB_TRUST_LEVEL: u32 = 2169438211u32;
pub const PR_EMS_AB_TURN_REQUEST_THRESHOLD: u32 = 2169503747u32;
pub const PR_EMS_AB_TWO_WAY_ALTERNATE_FACILITY: u32 = 2169569291u32;
pub const PR_EMS_AB_TYPE: u32 = 2352480286u32;
pub const PR_EMS_AB_TYPE_A: u32 = 2352480286u32;
pub const PR_EMS_AB_TYPE_W: u32 = 2352480287u32;
pub const PR_EMS_AB_T_SELECTOR: u32 = 2168455426u32;
pub const PR_EMS_AB_T_SELECTOR_INBOUND: u32 = 2168520962u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_A: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_O: u32 = 2169634829u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_T: u32 = 2169638942u32;
pub const PR_EMS_AB_UNAUTH_ORIG_BL_W: u32 = 2169638943u32;
pub const PR_EMS_AB_UNMERGED_ATTRIBUTES: u32 = 2356089090u32;
pub const PR_EMS_AB_USENET_SITE_NAME: u32 = 2173239326u32;
pub const PR_EMS_AB_USENET_SITE_NAME_A: u32 = 2173239326u32;
pub const PR_EMS_AB_USENET_SITE_NAME_W: u32 = 2173239327u32;
pub const PR_EMS_AB_USER_PASSWORD: u32 = 2169704706u32;
pub const PR_EMS_AB_USE_SERVER_VALUES: u32 = 2172518411u32;
pub const PR_EMS_AB_USE_SITE_VALUES: u32 = 2172846091u32;
pub const PR_EMS_AB_USN_CHANGED: u32 = 2150170627u32;
pub const PR_EMS_AB_USN_CREATED: u32 = 2169765891u32;
pub const PR_EMS_AB_USN_DSA_LAST_OBJ_REMOVED: u32 = 2169831427u32;
pub const PR_EMS_AB_USN_INTERSITE: u32 = 2172256259u32;
pub const PR_EMS_AB_USN_LAST_OBJ_REM: u32 = 2169896963u32;
pub const PR_EMS_AB_USN_SOURCE: u32 = 2169962499u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1: u32 = 2176778270u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1_A: u32 = 2176778270u32;
pub const PR_EMS_AB_VIEW_CONTAINER_1_W: u32 = 2176778271u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2: u32 = 2176843806u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2_A: u32 = 2176843806u32;
pub const PR_EMS_AB_VIEW_CONTAINER_2_W: u32 = 2176843807u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3: u32 = 2176909342u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3_A: u32 = 2176909342u32;
pub const PR_EMS_AB_VIEW_CONTAINER_3_W: u32 = 2176909343u32;
pub const PR_EMS_AB_VIEW_DEFINITION: u32 = 2350584066u32;
pub const PR_EMS_AB_VIEW_FLAGS: u32 = 2350383107u32;
pub const PR_EMS_AB_VIEW_SITE: u32 = 2176712734u32;
pub const PR_EMS_AB_VIEW_SITE_A: u32 = 2176712734u32;
pub const PR_EMS_AB_VIEW_SITE_W: u32 = 2176712735u32;
pub const PR_EMS_AB_VOICE_MAIL_FLAGS: u32 = 2353008898u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS: u32 = 2352943134u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS_A: u32 = 2352943134u32;
pub const PR_EMS_AB_VOICE_MAIL_GREETINGS_W: u32 = 2352943135u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD: u32 = 2352807966u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD_A: u32 = 2352807966u32;
pub const PR_EMS_AB_VOICE_MAIL_PASSWORD_W: u32 = 2352807967u32;
pub const PR_EMS_AB_VOICE_MAIL_RECORDED_NAME: u32 = 2352873730u32;
pub const PR_EMS_AB_VOICE_MAIL_RECORDING_LENGTH: u32 = 2353205251u32;
pub const PR_EMS_AB_VOICE_MAIL_SPEED: u32 = 2353135619u32;
pub const PR_EMS_AB_VOICE_MAIL_SYSTEM_GUID: u32 = 2352677122u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID: u32 = 2352742430u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID_A: u32 = 2352742430u32;
pub const PR_EMS_AB_VOICE_MAIL_USER_ID_W: u32 = 2352742431u32;
pub const PR_EMS_AB_VOICE_MAIL_VOLUME: u32 = 2353070083u32;
pub const PR_EMS_AB_WWW_HOME_PAGE: u32 = 2171928606u32;
pub const PR_EMS_AB_WWW_HOME_PAGE_A: u32 = 2171928606u32;
pub const PR_EMS_AB_WWW_HOME_PAGE_W: u32 = 2171928607u32;
pub const PR_EMS_AB_X121_ADDRESS: u32 = 2170032158u32;
pub const PR_EMS_AB_X121_ADDRESS_A: u32 = 2170032158u32;
pub const PR_EMS_AB_X121_ADDRESS_W: u32 = 2170032159u32;
pub const PR_EMS_AB_X25_CALL_USER_DATA_INCOMING: u32 = 2170093826u32;
pub const PR_EMS_AB_X25_CALL_USER_DATA_OUTGOING: u32 = 2170159362u32;
pub const PR_EMS_AB_X25_FACILITIES_DATA_INCOMING: u32 = 2170224898u32;
pub const PR_EMS_AB_X25_FACILITIES_DATA_OUTGOING: u32 = 2170290434u32;
pub const PR_EMS_AB_X25_LEASED_LINE_PORT: u32 = 2170355970u32;
pub const PR_EMS_AB_X25_LEASED_OR_SWITCHED: u32 = 2170421259u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE: u32 = 2170486814u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE_A: u32 = 2170486814u32;
pub const PR_EMS_AB_X25_REMOTE_MTA_PHONE_W: u32 = 2170486815u32;
pub const PR_EMS_AB_X400_ATTACHMENT_TYPE: u32 = 2170552578u32;
pub const PR_EMS_AB_X400_SELECTOR_SYNTAX: u32 = 2170617859u32;
pub const PR_EMS_AB_X500_ACCESS_CONTROL_LIST: u32 = 2170683650u32;
pub const PR_EMS_AB_X500_NC: u32 = 2174877726u32;
pub const PR_EMS_AB_X500_NC_A: u32 = 2174877726u32;
pub const PR_EMS_AB_X500_NC_W: u32 = 2174877727u32;
pub const PR_EMS_AB_X500_RDN: u32 = 2174812190u32;
pub const PR_EMS_AB_X500_RDN_A: u32 = 2174812190u32;
pub const PR_EMS_AB_X500_RDN_W: u32 = 2174812191u32;
pub const PR_EMS_AB_X509_CERT: u32 = 2355761410u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_NON_URGENT: u32 = 2170748931u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_NORMAL: u32 = 2170814467u32;
pub const PR_EMS_AB_XMIT_TIMEOUT_URGENT: u32 = 2170880003u32;
pub const PR_END_DATE: u32 = 6357056u32;
pub const PR_ENTRYID: u32 = 268370178u32;
pub const PR_EVENTS_ROOT_FOLDER_ENTRYID: u32 = 1719271682u32;
pub const PR_EXCESS_STORAGE_USED: u32 = 1073086467u32;
pub const PR_EXPIRY_NUMBER: u32 = 1072496643u32;
pub const PR_EXPIRY_TIME: u32 = 1376320u32;
pub const PR_EXPIRY_UNITS: u32 = 1072562179u32;
pub const PR_EXPLICIT_CONVERSION: u32 = 201392131u32;
pub const PR_EXTENDED_ACL_DATA: u32 = 1073611010u32;
pub const PR_EXTENDED_RULE_ACTIONS: u32 = 244908290u32;
pub const PR_EXTENDED_RULE_CONDITION: u32 = 244973826u32;
pub const PR_EXTENDED_RULE_MSG_ACTIONS: u32 = 244908290u32;
pub const PR_EXTENDED_RULE_MSG_CONDITION: u32 = 244973826u32;
pub const PR_EXTENDED_RULE_SIZE_LIMIT: u32 = 245039107u32;
pub const PR_FAST_TRANSFER: u32 = 1714356237u32;
pub const PR_FAVORITES_DEFAULT_NAME: u32 = 1714749470u32;
pub const PR_FAVORITES_DEFAULT_NAME_W: u32 = 1714749471u32;
pub const PR_FID_VID: u32 = 1716257026u32;
pub const PR_FILE_SIZE: u32 = 1732706307u32;
pub const PR_FILE_SIZE_EXTENDED: u32 = 1732706324u32;
pub const PR_FILTERING_HOOKS: u32 = 1023934722u32;
pub const PR_FINDER_ENTRYID: u32 = 904331522u32;
pub const PR_FLAG_STATUS: u32 = 277872643u32;
pub const PR_FLAT_URL_NAME: u32 = 1728970782u32;
pub const PR_FLAT_URL_NAME_A: u32 = 1728970782u32;
pub const PR_FLAT_URL_NAME_W: u32 = 1728970783u32;
pub const PR_FOLDER_ASSOCIATED_CONTENTS: u32 = 907018253u32;
pub const PR_FOLDER_CHILD_COUNT: u32 = 1714946051u32;
pub const PR_FOLDER_DESIGN_FLAGS: u32 = 1071775747u32;
pub const PR_FOLDER_FLAGS: u32 = 1722286083u32;
pub const PR_FOLDER_PATHNAME: u32 = 1723138078u32;
pub const PR_FOLDER_PATHNAME_A: u32 = 1723138078u32;
pub const PR_FOLDER_PATHNAME_W: u32 = 1723138079u32;
pub const PR_FOLDER_TYPE: u32 = 906035203u32;
pub const PR_FORCE_CLIENT_REFRESH: u32 = 1705050123u32;
pub const PR_FOREIGN_ID: u32 = 1718026498u32;
pub const PR_FOREIGN_REPORT_ID: u32 = 1718092034u32;
pub const PR_FOREIGN_SUBJECT_ID: u32 = 1718157570u32;
pub const PR_FORM_CATEGORY: u32 = 855900190u32;
pub const PR_FORM_CATEGORY_A: u32 = 855900190u32;
pub const PR_FORM_CATEGORY_SUB: u32 = 855965726u32;
pub const PR_FORM_CATEGORY_SUB_A: u32 = 855965726u32;
pub const PR_FORM_CATEGORY_SUB_W: u32 = 855965727u32;
pub const PR_FORM_CATEGORY_W: u32 = 855900191u32;
pub const PR_FORM_CLSID: u32 = 855769160u32;
pub const PR_FORM_CONTACT_NAME: u32 = 855834654u32;
pub const PR_FORM_CONTACT_NAME_A: u32 = 855834654u32;
pub const PR_FORM_CONTACT_NAME_W: u32 = 855834655u32;
pub const PR_FORM_DESIGNER_GUID: u32 = 856227912u32;
pub const PR_FORM_DESIGNER_NAME: u32 = 856162334u32;
pub const PR_FORM_DESIGNER_NAME_A: u32 = 856162334u32;
pub const PR_FORM_DESIGNER_NAME_W: u32 = 856162335u32;
pub const PR_FORM_HIDDEN: u32 = 856096779u32;
pub const PR_FORM_HOST_MAP: u32 = 856035331u32;
pub const PR_FORM_MESSAGE_BEHAVIOR: u32 = 856293379u32;
pub const PR_FORM_VERSION: u32 = 855703582u32;
pub const PR_FORM_VERSION_A: u32 = 855703582u32;
pub const PR_FORM_VERSION_W: u32 = 855703583u32;
pub const PR_FREE_BUSY_FOR_LOCAL_SITE_ENTRYID: u32 = 1713701122u32;
pub const PR_FTP_SITE: u32 = 978059294u32;
pub const PR_FTP_SITE_A: u32 = 978059294u32;
pub const PR_FTP_SITE_W: u32 = 978059295u32;
pub const PR_GENDER: u32 = 978124802u32;
pub const PR_GENERATION: u32 = 973406238u32;
pub const PR_GENERATION_A: u32 = 973406238u32;
pub const PR_GENERATION_W: u32 = 973406239u32;
pub const PR_GET_PROPS_EXCLUDE_PROP_ID_LIST: u32 = 1719533826u32;
pub const PR_GIVEN_NAME: u32 = 973471774u32;
pub const PR_GIVEN_NAME_A: u32 = 973471774u32;
pub const PR_GIVEN_NAME_W: u32 = 973471775u32;
pub const PR_GOVERNMENT_ID_NUMBER: u32 = 973537310u32;
pub const PR_GOVERNMENT_ID_NUMBER_A: u32 = 973537310u32;
pub const PR_GOVERNMENT_ID_NUMBER_W: u32 = 973537311u32;
pub const PR_GW_ADMIN_OPERATIONS: u32 = 1717043203u32;
pub const PR_GW_MTSIN_ENTRYID: u32 = 1713897730u32;
pub const PR_GW_MTSOUT_ENTRYID: u32 = 1713963266u32;
pub const PR_HASATTACH: u32 = 236650507u32;
pub const PR_HAS_DAMS: u32 = 1072300043u32;
pub const PR_HAS_MODERATOR_RULES: u32 = 1715404811u32;
pub const PR_HAS_NAMED_PROPERTIES: u32 = 1716125707u32;
pub const PR_HAS_RULES: u32 = 1715077131u32;
pub const PR_HEADER_FOLDER_ENTRYID: u32 = 1040843010u32;
pub const PR_HIERARCHY_CHANGE_NUM: u32 = 1715339267u32;
pub const PR_HIERARCHY_SERVER: u32 = 1714618398u32;
pub const PR_HIERARCHY_SYNCHRONIZER: u32 = 1714159629u32;
pub const PR_HOBBIES: u32 = 977469470u32;
pub const PR_HOBBIES_A: u32 = 977469470u32;
pub const PR_HOBBIES_W: u32 = 977469471u32;
pub const PR_HOME2_TELEPHONE_NUMBER: u32 = 976158750u32;
pub const PR_HOME2_TELEPHONE_NUMBER_A: u32 = 976158750u32;
pub const PR_HOME2_TELEPHONE_NUMBER_W: u32 = 976158751u32;
pub const PR_HOME_ADDRESS_CITY: u32 = 978911262u32;
pub const PR_HOME_ADDRESS_CITY_A: u32 = 978911262u32;
pub const PR_HOME_ADDRESS_CITY_W: u32 = 978911263u32;
pub const PR_HOME_ADDRESS_COUNTRY: u32 = 978976798u32;
pub const PR_HOME_ADDRESS_COUNTRY_A: u32 = 978976798u32;
pub const PR_HOME_ADDRESS_COUNTRY_W: u32 = 978976799u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE: u32 = 979042334u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE_A: u32 = 979042334u32;
pub const PR_HOME_ADDRESS_POSTAL_CODE_W: u32 = 979042335u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX: u32 = 979238942u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX_A: u32 = 979238942u32;
pub const PR_HOME_ADDRESS_POST_OFFICE_BOX_W: u32 = 979238943u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE: u32 = 979107870u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE_A: u32 = 979107870u32;
pub const PR_HOME_ADDRESS_STATE_OR_PROVINCE_W: u32 = 979107871u32;
pub const PR_HOME_ADDRESS_STREET: u32 = 979173406u32;
pub const PR_HOME_ADDRESS_STREET_A: u32 = 979173406u32;
pub const PR_HOME_ADDRESS_STREET_W: u32 = 979173407u32;
pub const PR_HOME_FAX_NUMBER: u32 = 975503390u32;
pub const PR_HOME_FAX_NUMBER_A: u32 = 975503390u32;
pub const PR_HOME_FAX_NUMBER_W: u32 = 975503391u32;
pub const PR_HOME_TELEPHONE_NUMBER: u32 = 973668382u32;
pub const PR_HOME_TELEPHONE_NUMBER_A: u32 = 973668382u32;
pub const PR_HOME_TELEPHONE_NUMBER_W: u32 = 973668383u32;
pub const PR_HTML: u32 = 269680898u32;
pub const PR_ICON: u32 = 268239106u32;
pub const PR_ICON_INDEX: u32 = 276824067u32;
pub const PR_ICS_CHANGE_KEY: u32 = 1716846850u32;
pub const PR_IDENTITY_DISPLAY: u32 = 1040187422u32;
pub const PR_IDENTITY_DISPLAY_A: u32 = 1040187422u32;
pub const PR_IDENTITY_DISPLAY_W: u32 = 1040187423u32;
pub const PR_IDENTITY_ENTRYID: u32 = 1040253186u32;
pub const PR_IDENTITY_SEARCH_KEY: u32 = 1040515330u32;
pub const PR_IMAP_INTERNAL_DATE: u32 = 1710555200u32;
pub const PR_IMPLICIT_CONVERSION_PROHIBITED: u32 = 1441803u32;
pub const PR_IMPLIED_RESTRICTIONS: u32 = 1719603458u32;
pub const PR_IMPORTANCE: u32 = 1507331u32;
pub const PR_INBOUND_NEWSFEED_DN: u32 = 1720516638u32;
pub const PR_INCOMPLETE_COPY: u32 = 3473419u32;
pub const PR_INITIALS: u32 = 973733918u32;
pub const PR_INITIALS_A: u32 = 973733918u32;
pub const PR_INITIALS_W: u32 = 973733919u32;
pub const PR_INITIAL_DETAILS_PANE: u32 = 1057488899u32;
pub const PR_INSTANCE_KEY: u32 = 267780354u32;
pub const PR_INTERNAL_TRACE_INFO: u32 = 1718223106u32;
pub const PR_INTERNET_CHARSET: u32 = 1721368606u32;
pub const PR_INTERNET_CONTENT: u32 = 1717108994u32;
pub const PR_INTERNET_CONTENT_EA: u32 = 1717108996u32;
pub const PR_INTERNET_CONTENT_HANDLE: u32 = 1717108995u32;
pub const PR_INTERNET_CPID: u32 = 1071513603u32;
pub const PR_INTERNET_MDNS: u32 = 1722089483u32;
pub const PR_INTERNET_MESSAGE_ID: u32 = 271908894u32;
pub const PR_INTERNET_MESSAGE_ID_A: u32 = 271908894u32;
pub const PR_INTERNET_MESSAGE_ID_W: u32 = 271908895u32;
pub const PR_INTERNET_NEWSGROUP_NAME: u32 = 1722220574u32;
pub const PR_INTERNET_NEWSGROUP_NAME_A: u32 = 1722220574u32;
pub const PR_INTERNET_NEWSGROUP_NAME_W: u32 = 1722220575u32;
pub const PR_INTERNET_REFERENCES: u32 = 272171038u32;
pub const PR_INTERNET_REFERENCES_A: u32 = 272171038u32;
pub const PR_INTERNET_REFERENCES_W: u32 = 272171039u32;
pub const PR_IN_CONFLICT: u32 = 1718353931u32;
pub const PR_IN_REPLY_TO: u32 = 272760862u32;
pub const PR_IN_REPLY_TO_A: u32 = 272760862u32;
pub const PR_IN_REPLY_TO_W: u32 = 272760863u32;
pub const PR_IN_TRANSIT: u32 = 1712848907u32;
pub const PR_IPM_APPOINTMENT_ENTRYID: u32 = 919601410u32;
pub const PR_IPM_ARCHIVE_ENTRYID: u32 = 905904386u32;
pub const PR_IPM_CONTACT_ENTRYID: u32 = 919666946u32;
pub const PR_IPM_DAF_ENTRYID: u32 = 1713307906u32;
pub const PR_IPM_DRAFTS_ENTRYID: u32 = 920060162u32;
pub const PR_IPM_FAVORITES_ENTRYID: u32 = 1714422018u32;
pub const PR_IPM_ID: u32 = 1573122u32;
pub const PR_IPM_OUTBOX_ENTRYID: u32 = 904003842u32;
pub const PR_IPM_OUTBOX_SEARCH_KEY: u32 = 873529602u32;
pub const PR_IPM_PUBLIC_FOLDERS_ENTRYID: u32 = 1714487554u32;
pub const PR_IPM_RETURN_REQUESTED: u32 = 201457675u32;
pub const PR_IPM_SENTMAIL_ENTRYID: u32 = 904134914u32;
pub const PR_IPM_SENTMAIL_SEARCH_KEY: u32 = 873660674u32;
pub const PR_IPM_SUBTREE_ENTRYID: u32 = 903872770u32;
pub const PR_IPM_SUBTREE_SEARCH_KEY: u32 = 873464066u32;
pub const PR_IPM_TASK_ENTRYID: u32 = 919863554u32;
pub const PR_IPM_WASTEBASKET_ENTRYID: u32 = 904069378u32;
pub const PR_IPM_WASTEBASKET_SEARCH_KEY: u32 = 873595138u32;
pub const PR_ISDN_NUMBER: u32 = 976027678u32;
pub const PR_ISDN_NUMBER_A: u32 = 976027678u32;
pub const PR_ISDN_NUMBER_W: u32 = 976027679u32;
pub const PR_IS_NEWSGROUP: u32 = 1721171979u32;
pub const PR_IS_NEWSGROUP_ANCHOR: u32 = 1721106443u32;
pub const PR_ITEM_LEVEL_ACL: u32 = 1025769483u32;
pub const PR_KEYWORD: u32 = 973799454u32;
pub const PR_KEYWORD_A: u32 = 973799454u32;
pub const PR_KEYWORD_W: u32 = 973799455u32;
pub const PR_LANGUAGE: u32 = 973864990u32;
pub const PR_LANGUAGES: u32 = 3080222u32;
pub const PR_LANGUAGES_A: u32 = 3080222u32;
pub const PR_LANGUAGES_W: u32 = 3080223u32;
pub const PR_LANGUAGE_A: u32 = 973864990u32;
pub const PR_LANGUAGE_W: u32 = 973864991u32;
pub const PR_LAST_ACCESS_TIME: u32 = 1722351680u32;
pub const PR_LAST_FULL_BACKUP: u32 = 1719992384u32;
pub const PR_LAST_LOGOFF_TIME: u32 = 1721958464u32;
pub const PR_LAST_LOGON_TIME: u32 = 1721892928u32;
pub const PR_LAST_MODIFICATION_TIME: u32 = 805830720u32;
pub const PR_LAST_MODIFIER_ENTRYID: u32 = 1073414402u32;
pub const PR_LAST_MODIFIER_NAME: u32 = 1073348638u32;
pub const PR_LAST_MODIFIER_NAME_A: u32 = 1073348638u32;
pub const PR_LAST_MODIFIER_NAME_W: u32 = 1073348639u32;
pub const PR_LAST_MODIFIER_SID: u32 = 240713986u32;
pub const PR_LAST_MODIFIER_SID_AS_XML: u32 = 242024478u32;
pub const PR_LATEST_DELIVERY_TIME: u32 = 1638464u32;
pub const PR_LOCALE_ID: u32 = 1721827331u32;
pub const PR_LOCALITY: u32 = 975634462u32;
pub const PR_LOCALITY_A: u32 = 975634462u32;
pub const PR_LOCALITY_W: u32 = 975634463u32;
pub const PR_LOCAL_COMMIT_TIME: u32 = 1728643136u32;
pub const PR_LOCAL_COMMIT_TIME_MAX: u32 = 1728708672u32;
pub const PR_LOCATION: u32 = 973930526u32;
pub const PR_LOCATION_A: u32 = 973930526u32;
pub const PR_LOCATION_W: u32 = 973930527u32;
pub const PR_LOCK_BRANCH_ID: u32 = 939524116u32;
pub const PR_LOCK_DEPTH: u32 = 940048387u32;
pub const PR_LOCK_ENLISTMENT_CONTEXT: u32 = 939786498u32;
pub const PR_LOCK_EXPIRY_TIME: u32 = 940179520u32;
pub const PR_LOCK_GLID: u32 = 940245250u32;
pub const PR_LOCK_NULL_URL_W: u32 = 940310559u32;
pub const PR_LOCK_RESOURCE_DID: u32 = 939655188u32;
pub const PR_LOCK_RESOURCE_FID: u32 = 939589652u32;
pub const PR_LOCK_RESOURCE_VID: u32 = 939720724u32;
pub const PR_LOCK_SCOPE: u32 = 939917314u32;
pub const PR_LOCK_TIMEOUT: u32 = 940113923u32;
pub const PR_LOCK_TRANSIENT_ID: u32 = 939983106u32;
pub const PR_LOCK_TYPE: u32 = 939851778u32;
pub const PR_LONGTERM_ENTRYID_FROM_TABLE: u32 = 1718616322u32;
pub const PR_MAILBOX_OWNER_ENTRYID: u32 = 1713045762u32;
pub const PR_MAILBOX_OWNER_NAME: u32 = 1713111070u32;
pub const PR_MAILBOX_OWNER_NAME_A: u32 = 1713111070u32;
pub const PR_MAILBOX_OWNER_NAME_W: u32 = 1713111071u32;
pub const PR_MAIL_PERMISSION: u32 = 973996043u32;
pub const PR_MANAGER_NAME: u32 = 978190366u32;
pub const PR_MANAGER_NAME_A: u32 = 978190366u32;
pub const PR_MANAGER_NAME_W: u32 = 978190367u32;
pub const PR_MAPPING_SIGNATURE: u32 = 267911426u32;
pub const PR_MAX_CACHED_VIEWS: u32 = 241696771u32;
pub const PR_MAX_INDICES: u32 = 241041411u32;
pub const PR_MAX_SUBMIT_MESSAGE_SIZE: u32 = 1718419459u32;
pub const PR_MDB_PROVIDER: u32 = 873726210u32;
pub const PR_MEMBER_ID: u32 = 1718681620u32;
pub const PR_MEMBER_NAME: u32 = 1718747166u32;
pub const PR_MEMBER_NAME_A: u32 = 1718747166u32;
pub const PR_MEMBER_NAME_W: u32 = 1718747167u32;
pub const PR_MEMBER_RIGHTS: u32 = 1718812675u32;
pub const PR_MERGE_MIDSET_DELETED: u32 = 242876674u32;
pub const PR_MESSAGE_ATTACHMENTS: u32 = 236126221u32;
pub const PR_MESSAGE_CC_ME: u32 = 5767179u32;
pub const PR_MESSAGE_CLASS: u32 = 1703966u32;
pub const PR_MESSAGE_CLASS_A: u32 = 1703966u32;
pub const PR_MESSAGE_CLASS_W: u32 = 1703967u32;
pub const PR_MESSAGE_CODEPAGE: u32 = 1073545219u32;
pub const PR_MESSAGE_DELIVERY_ID: u32 = 1769730u32;
pub const PR_MESSAGE_DELIVERY_TIME: u32 = 235274304u32;
pub const PR_MESSAGE_DOWNLOAD_TIME: u32 = 236453891u32;
pub const PR_MESSAGE_FLAGS: u32 = 235339779u32;
pub const PR_MESSAGE_LOCALE_ID: u32 = 1072758787u32;
pub const PR_MESSAGE_PROCESSED: u32 = 1709703179u32;
pub const PR_MESSAGE_RECIPIENTS: u32 = 236060685u32;
pub const PR_MESSAGE_RECIP_ME: u32 = 5832715u32;
pub const PR_MESSAGE_SECURITY_LABEL: u32 = 1966338u32;
pub const PR_MESSAGE_SITE_NAME: u32 = 1709637662u32;
pub const PR_MESSAGE_SITE_NAME_A: u32 = 1709637662u32;
pub const PR_MESSAGE_SITE_NAME_W: u32 = 1709637663u32;
pub const PR_MESSAGE_SIZE: u32 = 235405315u32;
pub const PR_MESSAGE_SIZE_EXTENDED: u32 = 235405332u32;
pub const PR_MESSAGE_SUBMISSION_ID: u32 = 4653314u32;
pub const PR_MESSAGE_TOKEN: u32 = 201523458u32;
pub const PR_MESSAGE_TO_ME: u32 = 5701643u32;
pub const PR_MHS_COMMON_NAME: u32 = 974061598u32;
pub const PR_MHS_COMMON_NAME_A: u32 = 974061598u32;
pub const PR_MHS_COMMON_NAME_W: u32 = 974061599u32;
pub const PR_MIDDLE_NAME: u32 = 977535006u32;
pub const PR_MIDDLE_NAME_A: u32 = 977535006u32;
pub const PR_MIDDLE_NAME_W: u32 = 977535007u32;
pub const PR_MIME_SIZE: u32 = 1732640771u32;
pub const PR_MIME_SIZE_EXTENDED: u32 = 1732640788u32;
pub const PR_MINI_ICON: u32 = 268173570u32;
pub const PR_MOBILE_TELEPHONE_NUMBER: u32 = 974913566u32;
pub const PR_MOBILE_TELEPHONE_NUMBER_A: u32 = 974913566u32;
pub const PR_MOBILE_TELEPHONE_NUMBER_W: u32 = 974913567u32;
pub const PR_MODIFY_VERSION: u32 = 236584980u32;
pub const PR_MOVE_TO_FOLDER_ENTRYID: u32 = 1072955650u32;
pub const PR_MOVE_TO_STORE_ENTRYID: u32 = 1072890114u32;
pub const PR_MSG_BODY_ID: u32 = 1071448067u32;
pub const PR_MSG_EDITOR_FORMAT: u32 = 1493762051u32;
pub const PR_MSG_FOLD_TIME: u32 = 1716781120u32;
pub const PR_MSG_STATUS: u32 = 236388355u32;
pub const PR_MTS_SUBJECT_ID: u32 = 1717764354u32;
pub const PR_NATIVE_BODY_INFO: u32 = 269877251u32;
pub const PR_NDR_DIAG_CODE: u32 = 201654275u32;
pub const PR_NDR_REASON_CODE: u32 = 201588739u32;
pub const PR_NEWSFEED_INFO: u32 = 1722155266u32;
pub const PR_NEWSGROUP_COMPONENT: u32 = 1722089502u32;
pub const PR_NEWSGROUP_ROOT_FOLDER_ENTRYID: u32 = 1720451330u32;
pub const PR_NEW_SUBS_GET_AUTO_ADD: u32 = 1709572107u32;
pub const PR_NEXT_SEND_ACCT: u32 = 237568031u32;
pub const PR_NICKNAME: u32 = 978255902u32;
pub const PR_NICKNAME_A: u32 = 978255902u32;
pub const PR_NICKNAME_W: u32 = 978255903u32;
pub const PR_NNTP_ARTICLE_FOLDER_ENTRYID: u32 = 1720320258u32;
pub const PR_NNTP_CONTROL_FOLDER_ENTRYID: u32 = 1720385794u32;
pub const PR_NON_IPM_SUBTREE_ENTRYID: u32 = 1713373442u32;
pub const PR_NON_RECEIPT_NOTIFICATION_REQUESTED: u32 = 201719819u32;
pub const PR_NON_RECEIPT_REASON: u32 = 4063235u32;
pub const PR_NON_WIN32_ACL: u32 = 1025703947u32;
pub const PR_NON_XMT_SECURITY_ROLE_1: u32 = 243007746u32;
pub const PR_NON_XMT_SECURITY_ROLE_1_AS_XML: u32 = 243007518u32;
pub const PR_NON_XMT_SECURITY_ROLE_2: u32 = 243073282u32;
pub const PR_NON_XMT_SECURITY_ROLE_2_AS_XML: u32 = 243073054u32;
pub const PR_NON_XMT_SECURITY_ROLE_3: u32 = 243138818u32;
pub const PR_NON_XMT_SECURITY_ROLE_3_AS_XML: u32 = 243138590u32;
pub const PR_NON_XMT_SECURITY_ROLE_4: u32 = 243204354u32;
pub const PR_NON_XMT_SECURITY_ROLE_4_AS_XML: u32 = 243204126u32;
pub const PR_NON_XMT_SECURITY_ROLE_5: u32 = 243269890u32;
pub const PR_NON_XMT_SECURITY_ROLE_5_AS_XML: u32 = 243269662u32;
pub const PR_NON_XMT_SECURITY_ROLE_6: u32 = 243335426u32;
pub const PR_NON_XMT_SECURITY_ROLE_6_AS_XML: u32 = 243335198u32;
pub const PR_NON_XMT_SECURITY_ROLE_7: u32 = 243400962u32;
pub const PR_NON_XMT_SECURITY_ROLE_7_AS_XML: u32 = 243400734u32;
pub const PR_NON_XMT_SECURITY_ROLE_8: u32 = 243466498u32;
pub const PR_NON_XMT_SECURITY_ROLE_8_AS_XML: u32 = 243466270u32;
pub const PR_NORMALIZED_SUBJECT: u32 = 236781598u32;
pub const PR_NORMALIZED_SUBJECT_A: u32 = 236781598u32;
pub const PR_NORMALIZED_SUBJECT_W: u32 = 236781599u32;
pub const PR_NORMAL_MESSAGE_SIZE: u32 = 1723006979u32;
pub const PR_NORMAL_MESSAGE_SIZE_EXTENDED: u32 = 1723006996u32;
pub const PR_NORMAL_MSG_W_ATTACH_COUNT: u32 = 1722613763u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML: u32 = 241827870u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML_A: u32 = 241827870u32;
pub const PR_NT_SECURITY_DESCRIPTOR_AS_XML_W: u32 = 241827871u32;
pub const PR_NT_USER_NAME: u32 = 1721761822u32;
pub const PR_NULL: u32 = 1u32;
pub const PR_OBJECT_TYPE: u32 = 268304387u32;
pub const PR_OBSOLETED_IPMS: u32 = 2031874u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER: u32 = 974848030u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER_A: u32 = 974848030u32;
pub const PR_OFFICE2_TELEPHONE_NUMBER_W: u32 = 974848031u32;
pub const PR_OFFICE_LOCATION: u32 = 974716958u32;
pub const PR_OFFICE_LOCATION_A: u32 = 974716958u32;
pub const PR_OFFICE_LOCATION_W: u32 = 974716959u32;
pub const PR_OFFICE_TELEPHONE_NUMBER: u32 = 973602846u32;
pub const PR_OFFICE_TELEPHONE_NUMBER_A: u32 = 973602846u32;
pub const PR_OFFICE_TELEPHONE_NUMBER_W: u32 = 973602847u32;
pub const PR_OFFLINE_ADDRBOOK_ENTRYID: u32 = 1713570050u32;
pub const PR_OFFLINE_FLAGS: u32 = 1715273731u32;
pub const PR_OFFLINE_MESSAGE_ENTRYID: u32 = 1713832194u32;
pub const PR_OLDEST_DELETED_ON: u32 = 1715601472u32;
pub const PR_OOF_STATE: u32 = 1713176587u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER: u32 = 974127134u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER_A: u32 = 974127134u32;
pub const PR_ORGANIZATIONAL_ID_NUMBER_W: u32 = 974127135u32;
pub const PR_ORIGINALLY_INTENDED_RECIPIENT_NAME: u32 = 2097410u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE: u32 = 8060958u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_A: u32 = 8060958u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ADDRTYPE_W: u32 = 8060959u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS: u32 = 8126494u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_A: u32 = 8126494u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_EMAIL_ADDRESS_W: u32 = 8126495u32;
pub const PR_ORIGINALLY_INTENDED_RECIP_ENTRYID: u32 = 269615362u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE: u32 = 7929886u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE_A: u32 = 7929886u32;
pub const PR_ORIGINAL_AUTHOR_ADDRTYPE_W: u32 = 7929887u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS: u32 = 7995422u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_A: u32 = 7995422u32;
pub const PR_ORIGINAL_AUTHOR_EMAIL_ADDRESS_W: u32 = 7995423u32;
pub const PR_ORIGINAL_AUTHOR_ENTRYID: u32 = 4980994u32;
pub const PR_ORIGINAL_AUTHOR_NAME: u32 = 5046302u32;
pub const PR_ORIGINAL_AUTHOR_NAME_A: u32 = 5046302u32;
pub const PR_ORIGINAL_AUTHOR_NAME_W: u32 = 5046303u32;
pub const PR_ORIGINAL_AUTHOR_SEARCH_KEY: u32 = 5636354u32;
pub const PR_ORIGINAL_AUTHOR_SID: u32 = 240451842u32;
pub const PR_ORIGINAL_AUTHOR_SID_AS_XML: u32 = 242614302u32;
pub const PR_ORIGINAL_DELIVERY_TIME: u32 = 5570624u32;
pub const PR_ORIGINAL_DISPLAY_BCC: u32 = 7471134u32;
pub const PR_ORIGINAL_DISPLAY_BCC_A: u32 = 7471134u32;
pub const PR_ORIGINAL_DISPLAY_BCC_W: u32 = 7471135u32;
pub const PR_ORIGINAL_DISPLAY_CC: u32 = 7536670u32;
pub const PR_ORIGINAL_DISPLAY_CC_A: u32 = 7536670u32;
pub const PR_ORIGINAL_DISPLAY_CC_W: u32 = 7536671u32;
pub const PR_ORIGINAL_DISPLAY_NAME: u32 = 974323742u32;
pub const PR_ORIGINAL_DISPLAY_NAME_A: u32 = 974323742u32;
pub const PR_ORIGINAL_DISPLAY_NAME_W: u32 = 974323743u32;
pub const PR_ORIGINAL_DISPLAY_TO: u32 = 7602206u32;
pub const PR_ORIGINAL_DISPLAY_TO_A: u32 = 7602206u32;
pub const PR_ORIGINAL_DISPLAY_TO_W: u32 = 7602207u32;
pub const PR_ORIGINAL_EITS: u32 = 2162946u32;
pub const PR_ORIGINAL_ENTRYID: u32 = 974258434u32;
pub const PR_ORIGINAL_SEARCH_KEY: u32 = 974389506u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE: u32 = 6684702u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE_A: u32 = 6684702u32;
pub const PR_ORIGINAL_SENDER_ADDRTYPE_W: u32 = 6684703u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS: u32 = 6750238u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS_A: u32 = 6750238u32;
pub const PR_ORIGINAL_SENDER_EMAIL_ADDRESS_W: u32 = 6750239u32;
pub const PR_ORIGINAL_SENDER_ENTRYID: u32 = 5964034u32;
pub const PR_ORIGINAL_SENDER_NAME: u32 = 5898270u32;
pub const PR_ORIGINAL_SENDER_NAME_A: u32 = 5898270u32;
pub const PR_ORIGINAL_SENDER_NAME_W: u32 = 5898271u32;
pub const PR_ORIGINAL_SENDER_SEARCH_KEY: u32 = 6029570u32;
pub const PR_ORIGINAL_SENDER_SID: u32 = 240058626u32;
pub const PR_ORIGINAL_SENDER_SID_AS_XML: u32 = 242221086u32;
pub const PR_ORIGINAL_SENSITIVITY: u32 = 3014659u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE: u32 = 6815774u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_A: u32 = 6815774u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ADDRTYPE_W: u32 = 6815775u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS: u32 = 6881310u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_A: u32 = 6881310u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_EMAIL_ADDRESS_W: u32 = 6881311u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_ENTRYID: u32 = 6160642u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME: u32 = 6094878u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME_A: u32 = 6094878u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_NAME_W: u32 = 6094879u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SEARCH_KEY: u32 = 6226178u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SID: u32 = 240124162u32;
pub const PR_ORIGINAL_SENT_REPRESENTING_SID_AS_XML: u32 = 242286622u32;
pub const PR_ORIGINAL_SUBJECT: u32 = 4784158u32;
pub const PR_ORIGINAL_SUBJECT_A: u32 = 4784158u32;
pub const PR_ORIGINAL_SUBJECT_W: u32 = 4784159u32;
pub const PR_ORIGINAL_SUBMIT_TIME: u32 = 5111872u32;
pub const PR_ORIGINATING_MTA_CERTIFICATE: u32 = 237306114u32;
pub const PR_ORIGINATOR_ADDR: u32 = 1717305374u32;
pub const PR_ORIGINATOR_ADDRTYPE: u32 = 1717370910u32;
pub const PR_ORIGINATOR_AND_DL_EXPANSION_HISTORY: u32 = 268566786u32;
pub const PR_ORIGINATOR_CERTIFICATE: u32 = 2228482u32;
pub const PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED: u32 = 2293771u32;
pub const PR_ORIGINATOR_ENTRYID: u32 = 1717436674u32;
pub const PR_ORIGINATOR_NAME: u32 = 1717239838u32;
pub const PR_ORIGINATOR_NON_DELIVERY_REPORT_REQUESTED: u32 = 201850891u32;
pub const PR_ORIGINATOR_REQUESTED_ALTERNATE_RECIPIENT: u32 = 201916674u32;
pub const PR_ORIGINATOR_RETURN_ADDRESS: u32 = 2359554u32;
pub const PR_ORIGINATOR_SID: u32 = 240320770u32;
pub const PR_ORIGINATOR_SID_AS_XML: u32 = 242483230u32;
pub const PR_ORIGIN_CHECK: u32 = 2556162u32;
pub const PR_ORIGIN_ID: u32 = 1716322562u32;
pub const PR_ORIG_MESSAGE_CLASS: u32 = 4915230u32;
pub const PR_ORIG_MESSAGE_CLASS_A: u32 = 4915230u32;
pub const PR_ORIG_MESSAGE_CLASS_W: u32 = 4915231u32;
pub const PR_OST_ENCRYPTION: u32 = 1728184323u32;
pub const PR_OTHER_ADDRESS_CITY: u32 = 979304478u32;
pub const PR_OTHER_ADDRESS_CITY_A: u32 = 979304478u32;
pub const PR_OTHER_ADDRESS_CITY_W: u32 = 979304479u32;
pub const PR_OTHER_ADDRESS_COUNTRY: u32 = 979370014u32;
pub const PR_OTHER_ADDRESS_COUNTRY_A: u32 = 979370014u32;
pub const PR_OTHER_ADDRESS_COUNTRY_W: u32 = 979370015u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE: u32 = 979435550u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE_A: u32 = 979435550u32;
pub const PR_OTHER_ADDRESS_POSTAL_CODE_W: u32 = 979435551u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX: u32 = 979632158u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX_A: u32 = 979632158u32;
pub const PR_OTHER_ADDRESS_POST_OFFICE_BOX_W: u32 = 979632159u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE: u32 = 979501086u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE_A: u32 = 979501086u32;
pub const PR_OTHER_ADDRESS_STATE_OR_PROVINCE_W: u32 = 979501087u32;
pub const PR_OTHER_ADDRESS_STREET: u32 = 979566622u32;
pub const PR_OTHER_ADDRESS_STREET_A: u32 = 979566622u32;
pub const PR_OTHER_ADDRESS_STREET_W: u32 = 979566623u32;
pub const PR_OTHER_TELEPHONE_NUMBER: u32 = 975110174u32;
pub const PR_OTHER_TELEPHONE_NUMBER_A: u32 = 975110174u32;
pub const PR_OTHER_TELEPHONE_NUMBER_W: u32 = 975110175u32;
pub const PR_OUTBOUND_NEWSFEED_DN: u32 = 1720582174u32;
pub const PR_OVERALL_AGE_LIMIT: u32 = 1721303043u32;
pub const PR_OVERALL_MSG_AGE_LIMIT: u32 = 1720909827u32;
pub const PR_OWNER_APPT_ID: u32 = 6422531u32;
pub const PR_OWNER_COUNT: u32 = 1723203587u32;
pub const PR_OWN_STORE_ENTRYID: u32 = 1040580866u32;
pub const PR_P1_CONTENT: u32 = 285212930u32;
pub const PR_P1_CONTENT_TYPE: u32 = 285278466u32;
pub const PR_PAGER_TELEPHONE_NUMBER: u32 = 975241246u32;
pub const PR_PAGER_TELEPHONE_NUMBER_A: u32 = 975241246u32;
pub const PR_PAGER_TELEPHONE_NUMBER_W: u32 = 975241247u32;
pub const PR_PARENT_DISPLAY: u32 = 235208734u32;
pub const PR_PARENT_DISPLAY_A: u32 = 235208734u32;
pub const PR_PARENT_DISPLAY_W: u32 = 235208735u32;
pub const PR_PARENT_ENTRYID: u32 = 235471106u32;
pub const PR_PARENT_KEY: u32 = 2425090u32;
pub const PR_PARENT_SOURCE_KEY: u32 = 1709244674u32;
pub const PR_PARENT_URL_NAME: u32 = 1728905246u32;
pub const PR_PARENT_URL_NAME_A: u32 = 1728905246u32;
pub const PR_PARENT_URL_NAME_W: u32 = 1728905247u32;
pub const PR_PERSONAL_HOME_PAGE: u32 = 978321438u32;
pub const PR_PERSONAL_HOME_PAGE_A: u32 = 978321438u32;
pub const PR_PERSONAL_HOME_PAGE_W: u32 = 978321439u32;
pub const PR_PF_DISALLOW_MDB_WIDE_EXPIRY: u32 = 1730347019u32;
pub const PR_PF_MSG_SIZE_LIMIT: u32 = 1730281492u32;
pub const PR_PF_OVER_HARD_QUOTA_LIMIT: u32 = 1730215956u32;
pub const PR_PHYSICAL_DELIVERY_BUREAU_FAX_DELIVERY: u32 = 201981963u32;
pub const PR_PHYSICAL_DELIVERY_MODE: u32 = 202047491u32;
pub const PR_PHYSICAL_DELIVERY_REPORT_REQUEST: u32 = 202113027u32;
pub const PR_PHYSICAL_FORWARDING_ADDRESS: u32 = 202178818u32;
pub const PR_PHYSICAL_FORWARDING_ADDRESS_REQUESTED: u32 = 202244107u32;
pub const PR_PHYSICAL_FORWARDING_PROHIBITED: u32 = 202309643u32;
pub const PR_PHYSICAL_RENDITION_ATTRIBUTES: u32 = 202375426u32;
pub const PR_POLICY_TAG: u32 = 806945026u32;
pub const PR_POSTAL_ADDRESS: u32 = 974454814u32;
pub const PR_POSTAL_ADDRESS_A: u32 = 974454814u32;
pub const PR_POSTAL_ADDRESS_W: u32 = 974454815u32;
pub const PR_POSTAL_CODE: u32 = 975831070u32;
pub const PR_POSTAL_CODE_A: u32 = 975831070u32;
pub const PR_POSTAL_CODE_W: u32 = 975831071u32;
pub const PR_POST_OFFICE_BOX: u32 = 975896606u32;
pub const PR_POST_OFFICE_BOX_A: u32 = 975896606u32;
pub const PR_POST_OFFICE_BOX_W: u32 = 975896607u32;
pub const PR_PREDECESSOR_CHANGE_LIST: u32 = 1709375746u32;
pub const PR_PREFERRED_BY_NAME: u32 = 977731614u32;
pub const PR_PREFERRED_BY_NAME_A: u32 = 977731614u32;
pub const PR_PREFERRED_BY_NAME_W: u32 = 977731615u32;
pub const PR_PREPROCESS: u32 = 237109259u32;
pub const PR_PREVENT_MSG_CREATE: u32 = 1710489611u32;
pub const PR_PREVIEW: u32 = 1071185950u32;
pub const PR_PREVIEW_A: u32 = 1071185950u32;
pub const PR_PREVIEW_UNREAD: u32 = 1071120414u32;
pub const PR_PREVIEW_UNREAD_A: u32 = 1071120414u32;
pub const PR_PREVIEW_UNREAD_W: u32 = 1071120415u32;
pub const PR_PREVIEW_W: u32 = 1071185951u32;
pub const PR_PRIMARY_CAPABILITY: u32 = 956563714u32;
pub const PR_PRIMARY_FAX_NUMBER: u32 = 975372318u32;
pub const PR_PRIMARY_FAX_NUMBER_A: u32 = 975372318u32;
pub const PR_PRIMARY_FAX_NUMBER_W: u32 = 975372319u32;
pub const PR_PRIMARY_SEND_ACCT: u32 = 237502495u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER: u32 = 974782494u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER_A: u32 = 974782494u32;
pub const PR_PRIMARY_TELEPHONE_NUMBER_W: u32 = 974782495u32;
pub const PR_PRIORITY: u32 = 2490371u32;
pub const PR_PROFESSION: u32 = 977666078u32;
pub const PR_PROFESSION_A: u32 = 977666078u32;
pub const PR_PROFESSION_W: u32 = 977666079u32;
pub const PR_PROFILE_ABP_ALLOW_RECONNECT: u32 = 1715011587u32;
pub const PR_PROFILE_ABP_MTHREAD_TIMEOUT_SECS: u32 = 1715077123u32;
pub const PR_PROFILE_AB_FILES_PATH: u32 = 1712193566u32;
pub const PR_PROFILE_AB_FILES_PATH_W: u32 = 1712193567u32;
pub const PR_PROFILE_ADDR_INFO: u32 = 1720123650u32;
pub const PR_PROFILE_ALLPUB_COMMENT: u32 = 1712783390u32;
pub const PR_PROFILE_ALLPUB_COMMENT_W: u32 = 1712783391u32;
pub const PR_PROFILE_ALLPUB_DISPLAY_NAME: u32 = 1712717854u32;
pub const PR_PROFILE_ALLPUB_DISPLAY_NAME_W: u32 = 1712717855u32;
pub const PR_PROFILE_ALTERNATE_STORE_TYPE_W: u32 = 1708130335u32;
pub const PR_PROFILE_AUTH_PACKAGE: u32 = 1712914435u32;
pub const PR_PROFILE_BINDING_ORDER: u32 = 1711865886u32;
pub const PR_PROFILE_CONFIG_FLAGS: u32 = 1711341571u32;
pub const PR_PROFILE_CONNECT_FLAGS: u32 = 1711538179u32;
pub const PR_PROFILE_FAVFLD_COMMENT: u32 = 1712652318u32;
pub const PR_PROFILE_FAVFLD_COMMENT_W: u32 = 1712652319u32;
pub const PR_PROFILE_FAVFLD_DISPLAY_NAME: u32 = 1712259102u32;
pub const PR_PROFILE_FAVFLD_DISPLAY_NAME_W: u32 = 1712259103u32;
pub const PR_PROFILE_HOME_SERVER: u32 = 1711407134u32;
pub const PR_PROFILE_HOME_SERVER_ADDRS: u32 = 1712525342u32;
pub const PR_PROFILE_HOME_SERVER_DN: u32 = 1712455710u32;
pub const PR_PROFILE_MAILBOX: u32 = 1711996958u32;
pub const PR_PROFILE_MAX_RESTRICT: u32 = 1712128003u32;
pub const PR_PROFILE_MOAB: u32 = 1719336990u32;
pub const PR_PROFILE_MOAB_GUID: u32 = 1719402526u32;
pub const PR_PROFILE_MOAB_SEQ: u32 = 1719468035u32;
pub const PR_PROFILE_MOAB_W: u32 = 1719336991u32;
pub const PR_PROFILE_NAME: u32 = 1024589854u32;
pub const PR_PROFILE_NAME_A: u32 = 1024589854u32;
pub const PR_PROFILE_NAME_W: u32 = 1024589855u32;
pub const PR_PROFILE_OFFLINE_INFO: u32 = 1712390402u32;
pub const PR_PROFILE_OFFLINE_STORE_PATH: u32 = 1712324638u32;
pub const PR_PROFILE_OFFLINE_STORE_PATH_W: u32 = 1712324639u32;
pub const PR_PROFILE_OPEN_FLAGS: u32 = 1711865859u32;
pub const PR_PROFILE_OPTIONS_DATA: u32 = 1720254722u32;
pub const PR_PROFILE_RECONNECT_INTERVAL: u32 = 1712979971u32;
pub const PR_PROFILE_SECURE_MAILBOX: u32 = 1743782146u32;
pub const PR_PROFILE_SERVER: u32 = 1712062494u32;
pub const PR_PROFILE_SERVER_DN: u32 = 1712586782u32;
pub const PR_PROFILE_SERVER_FULL_VERSION: u32 = 1715142914u32;
pub const PR_PROFILE_SERVER_VERSION: u32 = 1713045507u32;
pub const PR_PROFILE_TRANSPORT_FLAGS: u32 = 1711603715u32;
pub const PR_PROFILE_TYPE: u32 = 1711931395u32;
pub const PR_PROFILE_UI_STATE: u32 = 1711669251u32;
pub const PR_PROFILE_UNRESOLVED_NAME: u32 = 1711734814u32;
pub const PR_PROFILE_UNRESOLVED_NAME_A: u32 = 1711734814u32;
pub const PR_PROFILE_UNRESOLVED_NAME_W: u32 = 1711734815u32;
pub const PR_PROFILE_UNRESOLVED_SERVER: u32 = 1711800350u32;
pub const PR_PROFILE_USER: u32 = 1711472670u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS: u32 = 1715535902u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS_A: u32 = 1715535902u32;
pub const PR_PROFILE_USER_SMTP_EMAIL_ADDRESS_W: u32 = 1715535903u32;
pub const PR_PROFILE_VERSION: u32 = 1711276035u32;
pub const PR_PROHIBIT_RECEIVE_QUOTA: u32 = 1718222851u32;
pub const PR_PROHIBIT_SEND_QUOTA: u32 = 1718484995u32;
pub const PR_PROMOTE_PROP_ID_LIST: u32 = 1718288642u32;
pub const PR_PROOF_OF_DELIVERY: u32 = 202440962u32;
pub const PR_PROOF_OF_DELIVERY_REQUESTED: u32 = 202506251u32;
pub const PR_PROOF_OF_SUBMISSION: u32 = 237371650u32;
pub const PR_PROOF_OF_SUBMISSION_REQUESTED: u32 = 2621451u32;
pub const PR_PROVIDER_DISPLAY: u32 = 805699614u32;
pub const PR_PROVIDER_DISPLAY_A: u32 = 805699614u32;
pub const PR_PROVIDER_DISPLAY_W: u32 = 805699615u32;
pub const PR_PROVIDER_DLL_NAME: u32 = 805961758u32;
pub const PR_PROVIDER_DLL_NAME_A: u32 = 805961758u32;
pub const PR_PROVIDER_DLL_NAME_W: u32 = 805961759u32;
pub const PR_PROVIDER_ORDINAL: u32 = 806158339u32;
pub const PR_PROVIDER_SUBMIT_TIME: u32 = 4718656u32;
pub const PR_PROVIDER_UID: u32 = 806093058u32;
pub const PR_PST_ENCRYPTION: u32 = 1728184323u32;
pub const PR_PST_PATH: u32 = 1728053278u32;
pub const PR_PST_PW_SZ_NEW: u32 = 1728315422u32;
pub const PR_PST_PW_SZ_OLD: u32 = 1728249886u32;
pub const PR_PST_REMEMBER_PW: u32 = 1728118795u32;
pub const PR_PUBLIC_FOLDER_ENTRYID: u32 = 1715208450u32;
pub const PR_PUBLISH_IN_ADDRESS_BOOK: u32 = 1072037899u32;
pub const PR_QUOTA_RECEIVE_THRESHOLD: u32 = 1730347011u32;
pub const PR_QUOTA_SEND_THRESHOLD: u32 = 1730281475u32;
pub const PR_QUOTA_WARNING_THRESHOLD: u32 = 1730215939u32;
pub const PR_RADIO_TELEPHONE_NUMBER: u32 = 974979102u32;
pub const PR_RADIO_TELEPHONE_NUMBER_A: u32 = 974979102u32;
pub const PR_RADIO_TELEPHONE_NUMBER_W: u32 = 974979103u32;
pub const PR_RANK: u32 = 1729232899u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE: u32 = 7798814u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE_A: u32 = 7798814u32;
pub const PR_RCVD_REPRESENTING_ADDRTYPE_W: u32 = 7798815u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS: u32 = 7864350u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS_A: u32 = 7864350u32;
pub const PR_RCVD_REPRESENTING_EMAIL_ADDRESS_W: u32 = 7864351u32;
pub const PR_RCVD_REPRESENTING_ENTRYID: u32 = 4391170u32;
pub const PR_RCVD_REPRESENTING_NAME: u32 = 4456478u32;
pub const PR_RCVD_REPRESENTING_NAME_A: u32 = 4456478u32;
pub const PR_RCVD_REPRESENTING_NAME_W: u32 = 4456479u32;
pub const PR_RCVD_REPRESENTING_SEARCH_KEY: u32 = 5374210u32;
pub const PR_RCVD_REPRESENTING_SID: u32 = 240582914u32;
pub const PR_RCVD_REPRESENTING_SID_AS_XML: u32 = 242745374u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS: u32 = 1560805406u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS_A: u32 = 1560805406u32;
pub const PR_RCVD_REPRESENTING_SMTP_ADDRESS_W: u32 = 1560805407u32;
pub const PR_READ: u32 = 241762315u32;
pub const PR_READ_RECEIPT_ENTRYID: u32 = 4587778u32;
pub const PR_READ_RECEIPT_REQUESTED: u32 = 2686987u32;
pub const PR_READ_RECEIPT_SEARCH_KEY: u32 = 5439746u32;
pub const PR_READ_RECEIPT_SID: u32 = 240189698u32;
pub const PR_READ_RECEIPT_SID_AS_XML: u32 = 242352158u32;
pub const PR_RECEIPT_TIME: u32 = 2752576u32;
pub const PR_RECEIVED_BY_ADDRTYPE: u32 = 7667742u32;
pub const PR_RECEIVED_BY_ADDRTYPE_A: u32 = 7667742u32;
pub const PR_RECEIVED_BY_ADDRTYPE_W: u32 = 7667743u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS: u32 = 7733278u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS_A: u32 = 7733278u32;
pub const PR_RECEIVED_BY_EMAIL_ADDRESS_W: u32 = 7733279u32;
pub const PR_RECEIVED_BY_ENTRYID: u32 = 4129026u32;
pub const PR_RECEIVED_BY_NAME: u32 = 4194334u32;
pub const PR_RECEIVED_BY_NAME_A: u32 = 4194334u32;
pub const PR_RECEIVED_BY_NAME_W: u32 = 4194335u32;
pub const PR_RECEIVED_BY_SEARCH_KEY: u32 = 5308674u32;
pub const PR_RECEIVED_BY_SID: u32 = 240517378u32;
pub const PR_RECEIVED_BY_SID_AS_XML: u32 = 242679838u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS: u32 = 1560739870u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS_A: u32 = 1560739870u32;
pub const PR_RECEIVED_BY_SMTP_ADDRESS_W: u32 = 1560739871u32;
pub const PR_RECEIVE_FOLDER_SETTINGS: u32 = 873791501u32;
pub const PR_RECIPIENT_CERTIFICATE: u32 = 202572034u32;
pub const PR_RECIPIENT_NUMBER: u32 = 1717698563u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE: u32 = 202637342u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE_A: u32 = 202637342u32;
pub const PR_RECIPIENT_NUMBER_FOR_ADVICE_W: u32 = 202637343u32;
pub const PR_RECIPIENT_ON_ASSOC_MSG_COUNT: u32 = 1722810371u32;
pub const PR_RECIPIENT_ON_NORMAL_MSG_COUNT: u32 = 1722744835u32;
pub const PR_RECIPIENT_REASSIGNMENT_PROHIBITED: u32 = 2818059u32;
pub const PR_RECIPIENT_STATUS: u32 = 236257283u32;
pub const PR_RECIPIENT_TYPE: u32 = 202702851u32;
pub const PR_RECORD_KEY: u32 = 267976962u32;
pub const PR_REDIRECTION_HISTORY: u32 = 2883842u32;
pub const PR_REGISTERED_MAIL_TYPE: u32 = 202768387u32;
pub const PR_RELATED_IPMS: u32 = 2949378u32;
pub const PR_REMOTE_PROGRESS: u32 = 1040908291u32;
pub const PR_REMOTE_PROGRESS_TEXT: u32 = 1040973854u32;
pub const PR_REMOTE_PROGRESS_TEXT_A: u32 = 1040973854u32;
pub const PR_REMOTE_PROGRESS_TEXT_W: u32 = 1040973855u32;
pub const PR_REMOTE_VALIDATE_OK: u32 = 1041039371u32;
pub const PR_RENDERING_POSITION: u32 = 923467779u32;
pub const PR_REPLICATION_ALWAYS_INTERVAL: u32 = 1720975363u32;
pub const PR_REPLICATION_MESSAGE_PRIORITY: u32 = 1720844291u32;
pub const PR_REPLICATION_MSG_SIZE: u32 = 1721040899u32;
pub const PR_REPLICATION_SCHEDULE: u32 = 1720779010u32;
pub const PR_REPLICATION_STYLE: u32 = 1720713219u32;
pub const PR_REPLICA_LIST: u32 = 1721237762u32;
pub const PR_REPLICA_SERVER: u32 = 1715732510u32;
pub const PR_REPLICA_SERVER_W: u32 = 1715732511u32;
pub const PR_REPLICA_VERSION: u32 = 1716191252u32;
pub const PR_REPLY_RECIPIENT_ENTRIES: u32 = 5177602u32;
pub const PR_REPLY_RECIPIENT_NAMES: u32 = 5242910u32;
pub const PR_REPLY_RECIPIENT_NAMES_A: u32 = 5242910u32;
pub const PR_REPLY_RECIPIENT_NAMES_W: u32 = 5242911u32;
pub const PR_REPLY_RECIPIENT_SMTP_PROXIES: u32 = 1073479710u32;
pub const PR_REPLY_REQUESTED: u32 = 202833931u32;
pub const PR_REPLY_TIME: u32 = 3145792u32;
pub const PR_REPORTING_DL_NAME: u32 = 268632322u32;
pub const PR_REPORTING_MTA_CERTIFICATE: u32 = 268697858u32;
pub const PR_REPORT_DESTINATION_ENTRYID: u32 = 1717895426u32;
pub const PR_REPORT_DESTINATION_NAME: u32 = 1717829662u32;
pub const PR_REPORT_DESTINATION_SID: u32 = 240386306u32;
pub const PR_REPORT_DESTINATION_SID_AS_XML: u32 = 242548766u32;
pub const PR_REPORT_ENTRYID: u32 = 4522242u32;
pub const PR_REPORT_NAME: u32 = 3801118u32;
pub const PR_REPORT_NAME_A: u32 = 3801118u32;
pub const PR_REPORT_NAME_W: u32 = 3801119u32;
pub const PR_REPORT_SEARCH_KEY: u32 = 5505282u32;
pub const PR_REPORT_SID: u32 = 240255234u32;
pub const PR_REPORT_SID_AS_XML: u32 = 242417694u32;
pub const PR_REPORT_TAG: u32 = 3211522u32;
pub const PR_REPORT_TEXT: u32 = 268501022u32;
pub const PR_REPORT_TEXT_A: u32 = 268501022u32;
pub const PR_REPORT_TEXT_W: u32 = 268501023u32;
pub const PR_REPORT_TIME: u32 = 3276864u32;
pub const PR_REQUESTED_DELIVERY_METHOD: u32 = 202899459u32;
pub const PR_RESERVE_RANGE_OF_IDS: u32 = 242942210u32;
pub const PR_RESOLVE_METHOD: u32 = 1072103427u32;
pub const PR_RESOURCE_FLAGS: u32 = 805896195u32;
pub const PR_RESOURCE_METHODS: u32 = 1040318467u32;
pub const PR_RESOURCE_PATH: u32 = 1040646174u32;
pub const PR_RESOURCE_PATH_A: u32 = 1040646174u32;
pub const PR_RESOURCE_PATH_W: u32 = 1040646175u32;
pub const PR_RESOURCE_TYPE: u32 = 1040384003u32;
pub const PR_RESPONSE_REQUESTED: u32 = 6488075u32;
pub const PR_RESPONSIBILITY: u32 = 235864075u32;
pub const PR_RESTRICTION_COUNT: u32 = 1722417155u32;
pub const PR_RETENTION_AGE_LIMIT: u32 = 1724121091u32;
pub const PR_RETENTION_DATE: u32 = 807141440u32;
pub const PR_RETENTION_FLAGS: u32 = 807206915u32;
pub const PR_RETENTION_PERIOD: u32 = 807010307u32;
pub const PR_RETURNED_IPM: u32 = 3342347u32;
pub const PR_RIGHTS: u32 = 1715011587u32;
pub const PR_ROH_FLAGS: u32 = 1713569795u32;
pub const PR_ROH_PROXY_AUTH_SCHEME: u32 = 1713831939u32;
pub const PR_ROWID: u32 = 805306371u32;
pub const PR_ROW_TYPE: u32 = 267714563u32;
pub const PR_RTF_COMPRESSED: u32 = 269025538u32;
pub const PR_RTF_IN_SYNC: u32 = 236912651u32;
pub const PR_RTF_SYNC_BODY_COUNT: u32 = 268894211u32;
pub const PR_RTF_SYNC_BODY_CRC: u32 = 268828675u32;
pub const PR_RTF_SYNC_BODY_TAG: u32 = 268959774u32;
pub const PR_RTF_SYNC_BODY_TAG_A: u32 = 268959774u32;
pub const PR_RTF_SYNC_BODY_TAG_W: u32 = 268959775u32;
pub const PR_RTF_SYNC_PREFIX_COUNT: u32 = 269484035u32;
pub const PR_RTF_SYNC_TRAILING_COUNT: u32 = 269549571u32;
pub const PR_RULES_DATA: u32 = 1071710466u32;
pub const PR_RULES_TABLE: u32 = 1071710221u32;
pub const PR_RULE_ACTIONS: u32 = 1719664894u32;
pub const PR_RULE_ACTION_NUMBER: u32 = 1716518915u32;
pub const PR_RULE_ACTION_TYPE: u32 = 1716060163u32;
pub const PR_RULE_CONDITION: u32 = 1719206141u32;
pub const PR_RULE_ERROR: u32 = 1715994627u32;
pub const PR_RULE_FOLDER_ENTRYID: u32 = 1716584706u32;
pub const PR_RULE_ID: u32 = 1718878228u32;
pub const PR_RULE_IDS: u32 = 1718944002u32;
pub const PR_RULE_LEVEL: u32 = 1719861251u32;
pub const PR_RULE_MSG_LEVEL: u32 = 1710030851u32;
pub const PR_RULE_MSG_NAME_W: u32 = 1709965343u32;
pub const PR_RULE_MSG_PROVIDER_DATA: u32 = 1710096642u32;
pub const PR_RULE_MSG_PROVIDER_W: u32 = 1709899807u32;
pub const PR_RULE_MSG_SEQUENCE: u32 = 1710424067u32;
pub const PR_RULE_MSG_STATE: u32 = 1709768707u32;
pub const PR_RULE_MSG_USER_FLAGS: u32 = 1709834243u32;
pub const PR_RULE_NAME: u32 = 1719795742u32;
pub const PR_RULE_PROVIDER: u32 = 1719730206u32;
pub const PR_RULE_PROVIDER_DATA: u32 = 1719927042u32;
pub const PR_RULE_SEQUENCE: u32 = 1719009283u32;
pub const PR_RULE_SERVER_RULE_ID: u32 = 1704984596u32;
pub const PR_RULE_STATE: u32 = 1719074819u32;
pub const PR_RULE_TRIGGER_HISTORY: u32 = 1072824578u32;
pub const PR_RULE_USER_FLAGS: u32 = 1719140355u32;
pub const PR_SCHEDULE_FOLDER_ENTRYID: u32 = 1713242370u32;
pub const PR_SEARCH: u32 = 906428429u32;
pub const PR_SEARCH_KEY: u32 = 806027522u32;
pub const PR_SECURE_IN_SITE: u32 = 1721630731u32;
pub const PR_SECURE_ORIGINATION: u32 = 1071972363u32;
pub const PR_SECURITY: u32 = 3407875u32;
pub const PR_SELECTABLE: u32 = 906559499u32;
pub const PR_SENDER_ADDRTYPE: u32 = 203292702u32;
pub const PR_SENDER_ADDRTYPE_A: u32 = 203292702u32;
pub const PR_SENDER_ADDRTYPE_W: u32 = 203292703u32;
pub const PR_SENDER_EMAIL_ADDRESS: u32 = 203358238u32;
pub const PR_SENDER_EMAIL_ADDRESS_A: u32 = 203358238u32;
pub const PR_SENDER_EMAIL_ADDRESS_W: u32 = 203358239u32;
pub const PR_SENDER_ENTRYID: u32 = 202965250u32;
pub const PR_SENDER_NAME: u32 = 203030558u32;
pub const PR_SENDER_NAME_A: u32 = 203030558u32;
pub const PR_SENDER_NAME_W: u32 = 203030559u32;
pub const PR_SENDER_SEARCH_KEY: u32 = 203227394u32;
pub const PR_SENDER_SID: u32 = 239927554u32;
pub const PR_SENDER_SID_AS_XML: u32 = 242090014u32;
pub const PR_SENDER_SMTP_ADDRESS: u32 = 1560346654u32;
pub const PR_SENDER_SMTP_ADDRESS_A: u32 = 1560346654u32;
pub const PR_SENDER_SMTP_ADDRESS_W: u32 = 1560346655u32;
pub const PR_SEND_RICH_INFO: u32 = 977272843u32;
pub const PR_SENSITIVITY: u32 = 3538947u32;
pub const PR_SENTMAIL_ENTRYID: u32 = 235536642u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE: u32 = 6553630u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE_A: u32 = 6553630u32;
pub const PR_SENT_REPRESENTING_ADDRTYPE_W: u32 = 6553631u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS: u32 = 6619166u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS_A: u32 = 6619166u32;
pub const PR_SENT_REPRESENTING_EMAIL_ADDRESS_W: u32 = 6619167u32;
pub const PR_SENT_REPRESENTING_ENTRYID: u32 = 4260098u32;
pub const PR_SENT_REPRESENTING_NAME: u32 = 4325406u32;
pub const PR_SENT_REPRESENTING_NAME_A: u32 = 4325406u32;
pub const PR_SENT_REPRESENTING_NAME_W: u32 = 4325407u32;
pub const PR_SENT_REPRESENTING_SEARCH_KEY: u32 = 3866882u32;
pub const PR_SENT_REPRESENTING_SID: u32 = 239993090u32;
pub const PR_SENT_REPRESENTING_SID_AS_XML: u32 = 242155550u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS: u32 = 1560412190u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS_A: u32 = 1560412190u32;
pub const PR_SENT_REPRESENTING_SMTP_ADDRESS_W: u32 = 1560412191u32;
pub const PR_SERVICES: u32 = 1024327938u32;
pub const PR_SERVICE_DELETE_FILES: u32 = 1024462878u32;
pub const PR_SERVICE_DELETE_FILES_A: u32 = 1024462878u32;
pub const PR_SERVICE_DELETE_FILES_W: u32 = 1024462879u32;
pub const PR_SERVICE_DLL_NAME: u32 = 1024065566u32;
pub const PR_SERVICE_DLL_NAME_A: u32 = 1024065566u32;
pub const PR_SERVICE_DLL_NAME_W: u32 = 1024065567u32;
pub const PR_SERVICE_ENTRY_NAME: u32 = 1024131102u32;
pub const PR_SERVICE_EXTRA_UIDS: u32 = 1024262402u32;
pub const PR_SERVICE_NAME: u32 = 1024000030u32;
pub const PR_SERVICE_NAME_A: u32 = 1024000030u32;
pub const PR_SERVICE_NAME_W: u32 = 1024000031u32;
pub const PR_SERVICE_SUPPORT_FILES: u32 = 1024397342u32;
pub const PR_SERVICE_SUPPORT_FILES_A: u32 = 1024397342u32;
pub const PR_SERVICE_SUPPORT_FILES_W: u32 = 1024397343u32;
pub const PR_SERVICE_UID: u32 = 1024196866u32;
pub const PR_SHORTTERM_ENTRYID_FROM_OBJECT: u32 = 1718747394u32;
pub const PR_SHORTTERM_PARENT_ENTRYID_FROM_OBJECT: u32 = 1718681858u32;
pub const PR_SMTP_ADDRESS: u32 = 972947486u32;
pub const PR_SMTP_ADDRESS_A: u32 = 972947486u32;
pub const PR_SMTP_ADDRESS_W: u32 = 972947487u32;
pub const PR_SORT_LOCALE_ID: u32 = 1728380931u32;
pub const PR_SORT_PARENTID: u32 = 807469314u32;
pub const PR_SORT_POSITION: u32 = 807403778u32;
pub const PR_SOURCE_FID: u32 = 241106964u32;
pub const PR_SOURCE_KEY: u32 = 1709179138u32;
pub const PR_SPLUS_FREE_BUSY_ENTRYID: u32 = 1713504514u32;
pub const PR_SPOOLER_STATUS: u32 = 235929603u32;
pub const PR_SPOUSE_NAME: u32 = 977797150u32;
pub const PR_SPOUSE_NAME_A: u32 = 977797150u32;
pub const PR_SPOUSE_NAME_W: u32 = 977797151u32;
pub const PR_SRC_URL_NAME: u32 = 1729036318u32;
pub const PR_SRC_URL_NAME_A: u32 = 1729036318u32;
pub const PR_SRC_URL_NAME_W: u32 = 1729036319u32;
pub const PR_START_DATE: u32 = 6291520u32;
pub const PR_START_DATE_ETC: u32 = 807076098u32;
pub const PR_STATE_OR_PROVINCE: u32 = 975699998u32;
pub const PR_STATE_OR_PROVINCE_A: u32 = 975699998u32;
pub const PR_STATE_OR_PROVINCE_W: u32 = 975699999u32;
pub const PR_STATUS: u32 = 906690563u32;
pub const PR_STATUS_CODE: u32 = 1040449539u32;
pub const PR_STATUS_STRING: u32 = 1040711710u32;
pub const PR_STATUS_STRING_A: u32 = 1040711710u32;
pub const PR_STATUS_STRING_W: u32 = 1040711711u32;
pub const PR_STORAGE_LIMIT_INFORMATION: u32 = 1722023939u32;
pub const PR_STORAGE_QUOTA_LIMIT: u32 = 1073020931u32;
pub const PR_STORE_ENTRYID: u32 = 268108034u32;
pub const PR_STORE_OFFLINE: u32 = 1714552843u32;
pub const PR_STORE_PROVIDERS: u32 = 1023410434u32;
pub const PR_STORE_RECORD_KEY: u32 = 268042498u32;
pub const PR_STORE_SLOWLINK: u32 = 2081030155u32;
pub const PR_STORE_STATE: u32 = 873332739u32;
pub const PR_STORE_SUPPORT_MASK: u32 = 873267203u32;
pub const PR_STREET_ADDRESS: u32 = 975765534u32;
pub const PR_STREET_ADDRESS_A: u32 = 975765534u32;
pub const PR_STREET_ADDRESS_W: u32 = 975765535u32;
pub const PR_SUBFOLDER: u32 = 1728577547u32;
pub const PR_SUBFOLDERS: u32 = 906625035u32;
pub const PR_SUBJECT: u32 = 3604510u32;
pub const PR_SUBJECT_A: u32 = 3604510u32;
pub const PR_SUBJECT_IPM: u32 = 3670274u32;
pub const PR_SUBJECT_PREFIX: u32 = 3997726u32;
pub const PR_SUBJECT_PREFIX_A: u32 = 3997726u32;
pub const PR_SUBJECT_PREFIX_W: u32 = 3997727u32;
pub const PR_SUBJECT_TRACE_INFO: u32 = 1717633282u32;
pub const PR_SUBJECT_W: u32 = 3604511u32;
pub const PR_SUBMIT_FLAGS: u32 = 236191747u32;
pub const PR_SUPPLEMENTARY_INFO: u32 = 203096094u32;
pub const PR_SUPPLEMENTARY_INFO_A: u32 = 203096094u32;
pub const PR_SUPPLEMENTARY_INFO_W: u32 = 203096095u32;
pub const PR_SURNAME: u32 = 974192670u32;
pub const PR_SURNAME_A: u32 = 974192670u32;
pub const PR_SURNAME_W: u32 = 974192671u32;
pub const PR_SVR_GENERATING_QUOTA_MSG: u32 = 1073152030u32;
pub const PR_SYNCEVENT_FIRED: u32 = 1716453387u32;
pub const PR_SYNCEVENT_SUPPRESS_GUID: u32 = 947912962u32;
pub const PR_SYNCHRONIZE_FLAGS: u32 = 1709441027u32;
pub const PR_SYS_CONFIG_FOLDER_ENTRYID: u32 = 1714815234u32;
pub const PR_TELEX_NUMBER: u32 = 975962142u32;
pub const PR_TELEX_NUMBER_A: u32 = 975962142u32;
pub const PR_TELEX_NUMBER_W: u32 = 975962143u32;
pub const PR_TEMPLATEID: u32 = 956432642u32;
pub const PR_TEST_LINE_SPEED: u32 = 1714094338u32;
pub const PR_TITLE: u32 = 974585886u32;
pub const PR_TITLE_A: u32 = 974585886u32;
pub const PR_TITLE_W: u32 = 974585887u32;
pub const PR_TNEF_CORRELATION_KEY: u32 = 8323330u32;
pub const PR_TNEF_UNPROCESSED_PROPS: u32 = 245104898u32;
pub const PR_TRACE_INFO: u32 = 1717567746u32;
pub const PR_TRANSFER_ENABLED: u32 = 1714028555u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME: u32 = 975175710u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME_A: u32 = 975175710u32;
pub const PR_TRANSMITABLE_DISPLAY_NAME_W: u32 = 975175711u32;
pub const PR_TRANSPORT_KEY: u32 = 236322819u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS: u32 = 8192030u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS_A: u32 = 8192030u32;
pub const PR_TRANSPORT_MESSAGE_HEADERS_W: u32 = 8192031u32;
pub const PR_TRANSPORT_PROVIDERS: u32 = 1023541506u32;
pub const PR_TRANSPORT_STATUS: u32 = 235995139u32;
pub const PR_TRUST_SENDER: u32 = 242810883u32;
pub const PR_TRUST_SENDER_NO: i32 = 0i32;
pub const PR_TRUST_SENDER_YES: i32 = 1i32;
pub const PR_TTYTDD_PHONE_NUMBER: u32 = 977993758u32;
pub const PR_TTYTDD_PHONE_NUMBER_A: u32 = 977993758u32;
pub const PR_TTYTDD_PHONE_NUMBER_W: u32 = 977993759u32;
pub const PR_TYPE_OF_MTS_USER: u32 = 203161603u32;
pub const PR_URL_COMP_NAME: u32 = 284360734u32;
pub const PR_URL_COMP_NAME_A: u32 = 284360734u32;
pub const PR_URL_COMP_NAME_W: u32 = 284360735u32;
pub const PR_URL_NAME: u32 = 1728512030u32;
pub const PR_URL_NAME_A: u32 = 1728512030u32;
pub const PR_URL_NAME_W: u32 = 1728512031u32;
pub const PR_USER_CERTIFICATE: u32 = 975307010u32;
pub const PR_USER_ENTRYID: u32 = 1712914690u32;
pub const PR_USER_NAME: u32 = 1712979998u32;
pub const PR_VALID_FOLDER_MASK: u32 = 903806979u32;
pub const PR_VIEWS_ENTRYID: u32 = 904200450u32;
pub const PR_WEDDING_ANNIVERSARY: u32 = 977338432u32;
pub const PR_WIN32_SECURITY_DESCRIPTOR: u32 = 1025638658u32;
pub const PR_WIZARD_NO_PAB_PAGE: u32 = 1728118795u32;
pub const PR_WIZARD_NO_PST_PAGE: u32 = 1728053259u32;
pub const PR_X400_CONTENT_TYPE: u32 = 3932418u32;
pub const PR_X400_DEFERRED_DELIVERY_CANCEL: u32 = 1040777227u32;
pub const PR_X400_ENVELOPE_TYPE: u32 = 1716715523u32;
pub const PR_XMT_SECURITY_ROLE_1: u32 = 1025835266u32;
pub const PR_XMT_SECURITY_ROLE_1_AS_XML: u32 = 1025835038u32;
pub const PR_XMT_SECURITY_ROLE_2: u32 = 1025900802u32;
pub const PR_XMT_SECURITY_ROLE_2_AS_XML: u32 = 1025900574u32;
pub const PR_XMT_SECURITY_ROLE_3: u32 = 1025966338u32;
pub const PR_XMT_SECURITY_ROLE_3_AS_XML: u32 = 1025966110u32;
pub const PR_XMT_SECURITY_ROLE_4: u32 = 1026031874u32;
pub const PR_XMT_SECURITY_ROLE_4_AS_XML: u32 = 1026031646u32;
pub const PR_XMT_SECURITY_ROLE_5: u32 = 1026097410u32;
pub const PR_XMT_SECURITY_ROLE_5_AS_XML: u32 = 1026097182u32;
pub const PR_XMT_SECURITY_ROLE_6: u32 = 1026162946u32;
pub const PR_XMT_SECURITY_ROLE_6_AS_XML: u32 = 1026162718u32;
pub const PR_XMT_SECURITY_ROLE_7: u32 = 1026228482u32;
pub const PR_XMT_SECURITY_ROLE_7_AS_XML: u32 = 1026228254u32;
pub const PR_XMT_SECURITY_ROLE_8: u32 = 1026294018u32;
pub const PR_XMT_SECURITY_ROLE_8_AS_XML: u32 = 1026293790u32;
pub const PR_XPOS: u32 = 1057292291u32;
pub const PR_YPOS: u32 = 1057357827u32;
pub const PSETID_Address: windows_core::GUID =
windows_core::GUID::from_u128(0x00062004_0000_0000_c000_000000000046);
pub const PSETID_Appointment: windows_core::GUID =
windows_core::GUID::from_u128(0x00062002_0000_0000_c000_000000000046);
pub const PSETID_Attachment: windows_core::GUID =
windows_core::GUID::from_u128(0x96357f7f_59e1_47d0_99a7_46515c183b54);
pub const PSETID_Common: windows_core::GUID =
windows_core::GUID::from_u128(0x00062008_0000_0000_c000_000000000046);
pub const PSETID_Log: windows_core::GUID =
windows_core::GUID::from_u128(0x0006200a_0000_0000_c000_000000000046);
pub const PSETID_Meeting: windows_core::GUID =
windows_core::GUID::from_u128(0x6ed8da90_450b_101b_98da_00aa003f1305);
pub const PSETID_Messaging: windows_core::GUID =
windows_core::GUID::from_u128(0x41f28f13_83f4_4114_a584_eedb5a6b0bff);
pub const PSETID_Note: windows_core::GUID =
windows_core::GUID::from_u128(0x0006200e_0000_0000_c000_000000000046);
pub const PSETID_PostRss: windows_core::GUID =
windows_core::GUID::from_u128(0x00062041_0000_0000_c000_000000000046);
pub const PSETID_Remote: windows_core::GUID =
windows_core::GUID::from_u128(0x00062014_0000_0000_c000_000000000046);
pub const PSETID_Report: windows_core::GUID =
windows_core::GUID::from_u128(0x00062013_0000_0000_c000_000000000046);
pub const PSETID_Sharing: windows_core::GUID =
windows_core::GUID::from_u128(0x00062040_0000_0000_c000_000000000046);
pub const PSETID_Task: windows_core::GUID =
windows_core::GUID::from_u128(0x00062003_0000_0000_c000_000000000046);
pub const PSETID_UnifiedMessaging: windows_core::GUID =
windows_core::GUID::from_u128(0x4442858e_a9e3_4e80_b900_317a210cc15b);
pub const PSETID_XmlExtractedEntities: windows_core::GUID =
windows_core::GUID::from_u128(0x23239608_685d_4732_9c55_4c95cb4e8e33);
pub const PSTF_BEST_ENCRYPTION: u32 = 536870912u32;
pub const PSTF_COMPRESSABLE_ENCRYPTION: u32 = 1073741824u32;
pub const PSTF_NO_ENCRYPTION: u32 = 2147483648u32;
pub const PST_EXTERN_PROPID_BASE: u32 = 26368u32;
pub const PS_INTERNET_HEADERS: windows_core::GUID =
windows_core::GUID::from_u128(0x00020386_0000_0000_c000_000000000046);
pub const PS_MAPI: windows_core::GUID =
windows_core::GUID::from_u128(0x00020328_0000_0000_c000_000000000046);
pub const PS_PUBLIC_STRINGS: windows_core::GUID =
windows_core::GUID::from_u128(0x00020329_0000_0000_c000_000000000046);
pub const PS_ROUTING_ADDRTYPE: windows_core::GUID =
windows_core::GUID::from_u128(0x00020381_0000_0000_c000_000000000046);
pub const PS_ROUTING_DISPLAY_NAME: windows_core::GUID =
windows_core::GUID::from_u128(0x00020382_0000_0000_c000_000000000046);
pub const PS_ROUTING_EMAIL_ADDRESSES: windows_core::GUID =
windows_core::GUID::from_u128(0x00020380_0000_0000_c000_000000000046);
pub const PS_ROUTING_ENTRYID: windows_core::GUID =
windows_core::GUID::from_u128(0x00020383_0000_0000_c000_000000000046);
pub const PS_ROUTING_SEARCH_KEY: windows_core::GUID =
windows_core::GUID::from_u128(0x00020384_0000_0000_c000_000000000046);
pub const PT_ACTIONS: u32 = 254u32;
pub const PT_APPTIME: u32 = 7u32;
pub const PT_BINARY: u32 = 258u32;
pub const PT_BOOLEAN: u32 = 11u32;
pub const PT_CLSID: u32 = 72u32;
pub const PT_CURRENCY: u32 = 6u32;
pub const PT_DOUBLE: u32 = 5u32;
pub const PT_ERROR: u32 = 10u32;
pub const PT_FILE_EA: u32 = 260u32;
pub const PT_FILE_HANDLE: u32 = 259u32;
pub const PT_FLOAT: u32 = 4u32;
pub const PT_I2: u32 = 2u32;
pub const PT_I4: u32 = 3u32;
pub const PT_I8: u32 = 20u32;
pub const PT_LONG: u32 = 3u32;
pub const PT_LONGLONG: u32 = 20u32;
pub const PT_MV_APPTIME: u32 = 4103u32;
pub const PT_MV_BINARY: u32 = 4354u32;
pub const PT_MV_CLSID: u32 = 4168u32;
pub const PT_MV_CURRENCY: u32 = 4102u32;
pub const PT_MV_DOUBLE: u32 = 4101u32;
pub const PT_MV_FLOAT: u32 = 4100u32;
pub const PT_MV_I2: u32 = 4098u32;
pub const PT_MV_I4: u32 = 4099u32;
pub const PT_MV_I8: u32 = 4116u32;
pub const PT_MV_LONG: u32 = 4099u32;
pub const PT_MV_LONGLONG: u32 = 4116u32;
pub const PT_MV_R4: u32 = 4100u32;
pub const PT_MV_R8: u32 = 4101u32;
pub const PT_MV_SHORT: u32 = 4098u32;
pub const PT_MV_STRING8: u32 = 4126u32;
pub const PT_MV_SYSTIME: u32 = 4160u32;
pub const PT_MV_TSTRING: u32 = 4126u32;
pub const PT_MV_UNICODE: u32 = 4127u32;
pub const PT_NULL: u32 = 1u32;
pub const PT_OBJECT: u32 = 13u32;
pub const PT_PTR: u32 = 259u32;
pub const PT_R4: u32 = 4u32;
pub const PT_R8: u32 = 5u32;
pub const PT_SHORT: u32 = 2u32;
pub const PT_SRESTRICTION: u32 = 253u32;
pub const PT_STRING8: u32 = 30u32;
pub const PT_SYSTIME: u32 = 64u32;
pub const PT_TSTRING: u32 = 31u32;
pub const PT_UNICODE: u32 = 31u32;
pub const PT_UNSPECIFIED: u32 = 0u32;
pub const PT_VIRTUAL: u32 = 261u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct READSTATE {
pub cbSourceKey: u32,
pub pbSourceKey: *mut u8,
pub ulFlags: u32,
}
impl Default for READSTATE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const RECURSIVE_SEARCH: u32 = 4u32;
pub const RECURSIVE_SORT: u32 = 2u32;
pub const REFRESH_XP_HEADER_CACHE: u32 = 65536u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct RELOADTYPE(pub i32);
pub const RELOAD_HEADER_APPEND: RELOADTYPE = RELOADTYPE(2i32);
pub const RELOAD_HEADER_NONE: RELOADTYPE = RELOADTYPE(0i32);
pub const RELOAD_HEADER_REPLACE: RELOADTYPE = RELOADTYPE(3i32);
pub const RELOAD_HEADER_RESET: RELOADTYPE = RELOADTYPE(1i32);
pub const RELOP_EQ: u32 = 4u32;
pub const RELOP_GE: u32 = 3u32;
pub const RELOP_GT: u32 = 2u32;
pub const RELOP_LE: u32 = 1u32;
pub const RELOP_LT: u32 = 0u32;
pub const RELOP_MEMBER_OF_DL: u32 = 100u32;
pub const RELOP_NE: u32 = 5u32;
pub const RELOP_RE: u32 = 6u32;
pub type REMOVEPREPROCESSINFO =
Option<unsafe extern "system" fn(lpmessage: Option<IMessage>) -> windows_core::HRESULT>;
pub const RESOLVE_METHOD_DEFAULT: u32 = 0u32;
pub const RESOLVE_METHOD_LAST_WRITER_WINS: u32 = 1u32;
pub const RESOLVE_METHOD_NO_CONFLICT_NOTIFICATION: u32 = 2u32;
pub const RESTART_SEARCH: u32 = 2u32;
pub const RES_AND: u32 = 0u32;
pub const RES_ANNOTATION: u32 = 12u32;
pub const RES_BITMASK: u32 = 6u32;
pub const RES_COMMENT: u32 = 10u32;
pub const RES_COMPAREPROPS: u32 = 5u32;
pub const RES_CONTENT: u32 = 3u32;
pub const RES_COUNT: u32 = 11u32;
pub const RES_EXIST: u32 = 8u32;
pub const RES_NOT: u32 = 2u32;
pub const RES_OR: u32 = 1u32;
pub const RES_PROPERTY: u32 = 4u32;
pub const RES_SIZE: u32 = 7u32;
pub const RES_SUBRESTRICTION: u32 = 9u32;
pub const RETENTION_FLAGS_AUTOTAG: u32 = 4u32;
pub const RETENTION_FLAGS_EXPLICIT: u32 = 1u32;
pub const RETENTION_FLAGS_EXPLICIT_ARCHIVE: u32 = 16u32;
pub const RETENTION_FLAGS_PERSONAL: u32 = 8u32;
pub const RETENTION_FLAGS_TAG_CHANGED: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RFC1522INFO {
pub fRfc1522Allowed: windows::Win32::Foundation::BOOL,
pub fRfc1522Used: windows::Win32::Foundation::BOOL,
pub fAllow8bit: windows::Win32::Foundation::BOOL,
pub hRfc1522Cset: *mut HCHARSET__,
}
impl Default for RFC1522INFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ROHAUTH_BASIC: u32 = 1u32;
pub const ROHAUTH_NTLM: u32 = 2u32;
pub const ROHFLAGS_HTTP_FIRST_ON_FAST: u32 = 8u32;
pub const ROHFLAGS_HTTP_FIRST_ON_SLOW: u32 = 32u32;
pub const ROHFLAGS_MUTUAL_AUTH: u32 = 4u32;
pub const ROHFLAGS_SSL_ONLY: u32 = 2u32;
pub const ROHFLAGS_USE_ROH: u32 = 1u32;
pub const ROLESCOPE_FOLDER: u32 = 1u32;
pub const ROLESCOPE_MAX: u32 = 1u32;
pub const ROLESCOPE_OBJECT: u32 = 0u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ROWENTRY {
pub ulRowFlags: u32,
pub cValues: u32,
pub rgPropVals: *mut SPropValue,
}
impl Default for ROWENTRY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ROWLIST {
pub cEntries: u32,
pub aEntries: [ROWENTRY; 1],
}
impl Default for ROWLIST {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const ROWLIST_REPLACE: u32 = 1u32;
pub const ROW_ADD: u32 = 1u32;
pub const ROW_MODIFY: u32 = 2u32;
pub const ROW_REMOVE: u32 = 4u32;
pub const RTF_SYNC_BODY_CHANGED: u32 = 2u32;
pub const RTF_SYNC_RTF_CHANGED: u32 = 1u32;
pub const RULE_ERR_CREATE_DAE: u32 = 5u32;
pub const RULE_ERR_CREATE_DAM: u32 = 8u32;
pub const RULE_ERR_DELIVERY: u32 = 3u32;
pub const RULE_ERR_EXECUTION: u32 = 11u32;
pub const RULE_ERR_FIRST: u32 = 1u32;
pub const RULE_ERR_LAST: u32 = 13u32;
pub const RULE_ERR_LOAD: u32 = 2u32;
pub const RULE_ERR_NO_FOLDER: u32 = 6u32;
pub const RULE_ERR_NO_RIGHTS: u32 = 7u32;
pub const RULE_ERR_NO_SENDAS: u32 = 9u32;
pub const RULE_ERR_NO_TEMPLATE: u32 = 10u32;
pub const RULE_ERR_PARSING: u32 = 4u32;
pub const RULE_ERR_QUOTA_EXCEEDED: u32 = 12u32;
pub const RULE_ERR_TOO_MANY_RECIPS: u32 = 13u32;
pub const RULE_ERR_UNKNOWN: u32 = 1u32;
pub const SAVEBODY_KEEPBOUNDARY: u32 = 1u32;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SAVEOPTS(pub i32);
pub const SAVEOPTS_NOSAVE: SAVEOPTS = SAVEOPTS(1i32);
pub const SAVEOPTS_PROMPTSAVE: SAVEOPTS = SAVEOPTS(2i32);
pub const SAVEOPTS_SAVEIFDIRTY: SAVEOPTS = SAVEOPTS(0i32);
pub const SAVE_FORMAT_RICHTEXT: u32 = 2u32;
pub const SAVE_FORMAT_TEXT: u32 = 1u32;
pub const SAVE_RFC1521: MIMESAVETYPE = MIMESAVETYPE(1i32);
pub const SAVE_RFC822: MIMESAVETYPE = MIMESAVETYPE(0i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAndRestriction {
pub cRes: u32,
pub lpRes: *mut SRestriction,
}
impl Default for SAndRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAnnotationRestriction {
pub cValues: u32,
pub lpRes: *mut SRestriction,
pub lpProp: *mut SPropValue,
}
impl Default for SAnnotationRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SAppTimeArray {
pub cValues: u32,
pub lpat: *mut f64,
}
impl Default for SAppTimeArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBinary {
pub cb: u32,
pub lpb: *mut u8,
}
impl Default for SBinary {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBinaryArray {
pub cValues: u32,
pub lpbin: *mut SBinary,
}
impl Default for SBinaryArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SBitMaskRestriction {
pub relBMR: u32,
pub ulPropTag: u32,
pub ulMask: u32,
}
impl Default for SBitMaskRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCommentRestriction {
pub cValues: u32,
pub lpRes: *mut SRestriction,
pub lpProp: *mut SPropValue,
}
impl Default for SCommentRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SComparePropsRestriction {
pub relop: u32,
pub ulPropTag1: u32,
pub ulPropTag2: u32,
}
impl Default for SComparePropsRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SContentRestriction {
pub ulFuzzyLevel: u32,
pub ulPropTag: u32,
pub lpProp: *mut SPropValue,
}
impl Default for SContentRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCountRestriction {
pub ulCount: u32,
pub lpRes: *mut SRestriction,
}
impl Default for SCountRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SCurrencyArray {
pub cValues: u32,
pub lpcur: *mut windows::Win32::System::Com::CY,
}
impl Default for SCurrencyArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SDateTimeArray {
pub cValues: u32,
pub lpft: *mut windows::Win32::Foundation::FILETIME,
}
impl Default for SDateTimeArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SDoubleArray {
pub cValues: u32,
pub lpdbl: *mut f64,
}
impl Default for SDoubleArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SEARCH_FOREGROUND: u32 = 8u32;
pub const SEARCH_REBUILD: u32 = 2u32;
pub const SEARCH_RECURSIVE: u32 = 4u32;
pub const SEARCH_RUNNING: u32 = 1u32;
pub const SECURITY_DESCRIPTOR_TRANSFER_VERSION: u32 = 3u32;
pub const SECURITY_ENCRYPTED: u32 = 2u32;
pub const SECURITY_SIGNED: u32 = 1u32;
pub const SEF_ENCRYPTWITHNOSENDERCERT: u32 = 1u32;
pub const SEF_MASK: u32 = 65535u32;
pub const SEF_SENDERSCERTPROVIDED: u32 = 2u32;
pub const SENSITIVITY_COMPANY_CONFIDENTIAL: u32 = 3u32;
pub const SENSITIVITY_NONE: u32 = 0u32;
pub const SENSITIVITY_PERSONAL: u32 = 1u32;
pub const SENSITIVITY_PRIVATE: u32 = 2u32;
pub type SERVICEWIZARDDLGPROC = Option<
unsafe extern "system" fn(
hdlg: windows::Win32::Foundation::HWND,
wmsgid: u32,
wparam: windows::Win32::Foundation::WPARAM,
lparam: windows::Win32::Foundation::LPARAM,
) -> windows::Win32::Foundation::BOOL,
>;
pub const SERVICE_CREATE_WITH_STORE: u32 = 4u32;
pub const SERVICE_DEFAULT_STORE: u32 = 1u32;
pub const SERVICE_LOGON_FAILED: u32 = 32u32;
pub const SERVICE_NO_PRIMARY_IDENTITY: u32 = 32u32;
pub const SERVICE_PRIMARY_IDENTITY: u32 = 8u32;
pub const SERVICE_SINGLE_COPY: u32 = 2u32;
pub const SERVICE_UI_ALLOWED: u32 = 16u32;
pub const SERVICE_UI_ALWAYS: u32 = 2u32;
pub const SETID_AirSync: windows_core::GUID =
windows_core::GUID::from_u128(0x71035549_0739_4dcb_9163_00f0580dbbdf);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SExistRestriction {
pub ulReserved1: u32,
pub ulPropTag: u32,
pub ulReserved2: u32,
}
impl Default for SExistRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SF_DISABLE_STARTUP_SYNC: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SGuidArray {
pub cValues: u32,
pub lpguid: *mut windows_core::GUID,
}
impl Default for SGuidArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SHALLOW_SEARCH: u32 = 8u32;
pub const SHOW_SOFT_DELETES: u32 = 2u32;
pub const SHOW_SUBFOLDERS: u32 = 4u32;
pub const SHOW_XP_SESSION_UI: u32 = 4194304u32;
pub const SIMPLE: CERTNAMETYPE = CERTNAMETYPE(0i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLPSTRArray {
pub cValues: u32,
pub lppszA: *mut windows_core::PSTR,
}
impl Default for SLPSTRArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLargeIntegerArray {
pub cValues: u32,
pub lpli: *mut i64,
}
impl Default for SLargeIntegerArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SLongArray {
pub cValues: u32,
pub lpl: *mut i32,
}
impl Default for SLongArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Debug, PartialEq)]
pub struct SMAPIFormInfoArray {
pub cForms: u32,
pub aFormInfo: [core::mem::ManuallyDrop<Option<IMAPIFormInfo>>; 1],
}
impl Default for SMAPIFormInfoArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormProp {
pub ulFlags: u32,
pub nPropType: u32,
pub nmid: MAPINAMEID,
pub pszDisplayName: *mut i8,
pub nSpecialType: u32,
pub u: SMAPIFormProp_0,
}
impl Default for SMAPIFormProp {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union SMAPIFormProp_0 {
pub s1: SMAPIFormProp_0_0,
}
impl Default for SMAPIFormProp_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormProp_0_0 {
pub nmidIdx: MAPINAMEID,
pub cfpevAvailable: u32,
pub pfpevAvailable: *mut SMAPIFormPropEnumVal,
}
impl Default for SMAPIFormProp_0_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SMAPIFormPropArray {
pub cProps: u32,
pub ulPad: u32,
pub aFormProp: [SMAPIFormProp; 1],
}
impl Default for SMAPIFormPropArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIFormPropEnumVal {
pub pszDisplayName: *mut i8,
pub nVal: u32,
}
impl Default for SMAPIFormPropEnumVal {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIVerb {
pub lVerb: i32,
pub szVerbname: *mut i8,
pub fuFlags: u32,
pub grfAttribs: u32,
pub ulFlags: u32,
}
impl Default for SMAPIVerb {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMAPIVerbArray {
pub cMAPIVerb: u32,
pub aMAPIVerb: [SMAPIVerb; 1],
}
impl Default for SMAPIVerbArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SMessageClassArray {
pub cValues: u32,
pub aMessageClass: [windows_core::PSTR; 1],
}
impl Default for SMessageClassArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SNotRestriction {
pub ulReserved: u32,
pub lpRes: *mut SRestriction,
}
impl Default for SNotRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SOF_UNIQUEFILENAME: u32 = 2147483648u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SOrRestriction {
pub cRes: u32,
pub lpRes: *mut SRestriction,
}
impl Default for SOrRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SPAMFILTER_ONSAVE: u32 = 128u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropAttrArray {
pub cValues: u32,
pub aPropAttr: [u32; 1],
}
impl Default for SPropAttrArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropProblem {
pub ulIndex: u32,
pub ulPropTag: u32,
pub scode: i32,
}
impl Default for SPropProblem {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropProblemArray {
pub cProblem: u32,
pub aProblem: [SPropProblem; 1],
}
impl Default for SPropProblemArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropTagArray {
pub cValues: u32,
pub aulPropTag: [u32; 1],
}
impl Default for SPropTagArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SPropValue {
pub ulPropTag: u32,
pub dwAlignPad: u32,
pub Value: __UPV,
}
impl Default for SPropValue {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SPropertyRestriction {
pub relop: u32,
pub ulPropTag: u32,
pub lpProp: *mut SPropValue,
}
impl Default for SPropertyRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRealArray {
pub cValues: u32,
pub lpflt: *mut f32,
}
impl Default for SRealArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct SRestriction {
pub rt: u32,
pub res: SRestriction_0,
}
impl Default for SRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy)]
pub union SRestriction_0 {
pub resCompareProps: SComparePropsRestriction,
pub resAnd: SAndRestriction,
pub resOr: SOrRestriction,
pub resNot: SNotRestriction,
pub resContent: SContentRestriction,
pub resProperty: SPropertyRestriction,
pub resBitMask: SBitMaskRestriction,
pub resSize: SSizeRestriction,
pub resExist: SExistRestriction,
pub resSub: SSubRestriction,
pub resComment: SCommentRestriction,
pub resAnnotation: SAnnotationRestriction,
pub resCount: SCountRestriction,
}
impl Default for SRestriction_0 {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRow {
pub ulAdrEntryPad: u32,
pub cValues: u32,
pub lpProps: *mut SPropValue,
}
impl Default for SRow {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRowSet {
pub cRows: u32,
pub aRow: [SRow; 1],
}
impl Default for SRowSet {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SShortArray {
pub cValues: u32,
pub lpi: *mut i16,
}
impl Default for SShortArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSizeRestriction {
pub relop: u32,
pub ulPropTag: u32,
pub cb: u32,
}
impl Default for SSizeRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSortOrder {
pub ulPropTag: u32,
pub ulOrder: u32,
}
impl Default for SSortOrder {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSortOrderSet {
pub cSorts: u32,
pub cCategories: u32,
pub cExpanded: u32,
pub aSort: [SSortOrder; 1],
}
impl Default for SSortOrderSet {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SSubRestriction {
pub ulSubObject: u32,
pub lpRes: *mut SRestriction,
}
impl Default for SSubRestriction {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const STATUSROW_UPDATE: u32 = 268435456u32;
pub const STATUS_AVAILABLE: u32 = 1u32;
pub const STATUS_CHANGE_PASSWORD: u32 = 4u32;
pub const STATUS_DEFAULT_OUTBOUND: u32 = 1u32;
pub const STATUS_DEFAULT_STORE: u32 = 2u32;
pub const STATUS_FAILURE: u32 = 4u32;
pub const STATUS_FLUSH_QUEUES: u32 = 8u32;
pub const STATUS_INBOUND_ACTIVE: u32 = 131072u32;
pub const STATUS_INBOUND_ENABLED: u32 = 65536u32;
pub const STATUS_INBOUND_FLUSH: u32 = 262144u32;
pub const STATUS_NEED_IPM_TREE: u32 = 2048u32;
pub const STATUS_NO_DEFAULT_STORE: u32 = 64u32;
pub const STATUS_NO_PRIMARY_IDENTITY: u32 = 32u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct STATUS_OBJECT_NOTIFICATION {
pub cbEntryID: u32,
pub lpEntryID: *mut ENTRYID,
pub cValues: u32,
pub lpPropVals: *mut SPropValue,
}
impl Default for STATUS_OBJECT_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const STATUS_OFFLINE: u32 = 2u32;
pub const STATUS_OUTBOUND_ACTIVE: u32 = 2097152u32;
pub const STATUS_OUTBOUND_ENABLED: u32 = 1048576u32;
pub const STATUS_OUTBOUND_FLUSH: u32 = 4194304u32;
pub const STATUS_OWN_STORE: u32 = 256u32;
pub const STATUS_PRIMARY_IDENTITY: u32 = 4u32;
pub const STATUS_PRIMARY_STORE: u32 = 4096u32;
pub const STATUS_REMOTE_ACCESS: u32 = 8388608u32;
pub const STATUS_SECONDARY_STORE: u32 = 8192u32;
pub const STATUS_SETTINGS_DIALOG: u32 = 2u32;
pub const STATUS_SIMPLE_STORE: u32 = 8u32;
pub const STATUS_TEMP_SECTION: u32 = 128u32;
pub const STATUS_VALIDATE_STATE: u32 = 1u32;
pub const STATUS_XP_PREFER_LAST: u32 = 16u32;
pub const STGSTRM_CREATE: u32 = 4096u32;
pub const STGSTRM_CURRENT: u32 = 268435456u32;
pub const STGSTRM_MODIFY: u32 = 2u32;
pub const STGSTRM_RESET: u32 = 0u32;
pub const STOCK_REPLY_TEMPLATE: u32 = 2u32;
pub const STOP_SEARCH: u32 = 1u32;
pub const STORE_ATTACH_OK: u32 = 32u32;
pub const STORE_CATEGORIZE_OK: u32 = 1024u32;
pub const STORE_CREATE_OK: u32 = 16u32;
pub const STORE_ENTRYID_UNIQUE: u32 = 1u32;
pub const STORE_HAS_SEARCHES: u32 = 16777216u32;
pub const STORE_ITEMPROC: u32 = 2097152u32;
pub const STORE_MODIFY_OK: u32 = 8u32;
pub const STORE_MV_PROPS_OK: u32 = 512u32;
pub const STORE_NOTIFY_OK: u32 = 256u32;
pub const STORE_OLE_OK: u32 = 64u32;
pub const STORE_PUBLIC_FOLDERS: u32 = 16384u32;
pub const STORE_READONLY: u32 = 2u32;
pub const STORE_RESTRICTION_OK: u32 = 4096u32;
pub const STORE_RTF_OK: u32 = 2048u32;
pub const STORE_SEARCH_OK: u32 = 4u32;
pub const STORE_SORT_OK: u32 = 8192u32;
pub const STORE_SUBMIT_OK: u32 = 128u32;
pub const STORE_UNCOMPRESSED_RTF: u32 = 32768u32;
pub const STORE_UNICODE_OK: u32 = 262144u32;
pub const STREAM_APPEND: u32 = 4u32;
pub const ST_CLEAR_OOF_HIST: u32 = 2147483648u32;
pub const ST_DISABLED: u32 = 0u32;
pub const ST_ENABLED: u32 = 1u32;
pub const ST_ERROR: u32 = 2u32;
pub const ST_EXIT_LEVEL: u32 = 16u32;
pub const ST_KEEP_OOF_HIST: u32 = 8u32;
pub const ST_ONLY_WHEN_OOF: u32 = 4u32;
pub const ST_RULE_PARSE_ERROR: u32 = 64u32;
pub const ST_SKIP_IF_SCL_IS_SAFE: u32 = 32u32;
pub const SUBMITFLAG_LOCKED: u32 = 1u32;
pub const SUBMITFLAG_PREPROCESS: u32 = 2u32;
pub const SUCCESS_SUCCESS: u32 = 0u32;
pub const SUPPRESS_RECEIPT: u32 = 1u32;
pub const SUPPRESS_UI: u32 = 1u32;
pub const SUPRESS_NOTIFICATIONS_ON_MY_ACTIONS: u32 = 4096u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SWStringArray {
pub cValues: u32,
pub lppszW: *mut windows_core::PWSTR,
}
impl Default for SWStringArray {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const SYNC_ASSOCIATED: u32 = 16u32;
pub const SYNC_BEST_BODY: u32 = 8192u32;
pub const SYNC_CATCHUP: u32 = 1024u32;
pub const SYNC_DEFER_CONFIG: u32 = 262144u32;
pub const SYNC_EXPIRY: u32 = 2u32;
pub const SYNC_FORCE_UNICODE: u32 = 262144u32;
pub const SYNC_FXRECOVERMODE: u32 = 65536u32;
pub const SYNC_IGNORE_SPECIFIED_ON_ASSOCIATED: u32 = 16384u32;
pub const SYNC_LIMITED_IMESSAGE: u32 = 512u32;
pub const SYNC_MSG_SELECTIVE: u32 = 4096u32;
pub const SYNC_NEW_MESSAGE: u32 = 2048u32;
pub const SYNC_NORMAL: u32 = 32u32;
pub const SYNC_NO_CONFLICTS: u32 = 64u32;
pub const SYNC_NO_DELETIONS: u32 = 2u32;
pub const SYNC_NO_FOREIGN_KEYS: u32 = 256u32;
pub const SYNC_NO_SOFT_DELETIONS: u32 = 4u32;
pub const SYNC_ONLY_SPECIFIED_PROPS: u32 = 128u32;
pub const SYNC_PROGRESS_MODE: u32 = 32768u32;
pub const SYNC_READ: u32 = 1u32;
pub const SYNC_READ_STATE: u32 = 8u32;
pub const SYNC_SOFT_DELETE: u32 = 1u32;
pub const SYNC_UNICODE: u32 = 1u32;
pub const SZ_HPC_V1: windows_core::PCSTR = windows_core::s!("Software\\Microsoft\\Pegasus");
pub const SZ_HPC_V1_0: windows_core::PCSTR = windows_core::s!("InstalledDir");
pub const SZ_HPC_V1_MAJOR: windows_core::PCSTR = windows_core::s!("MajorVersion");
pub const SZ_HPC_V1_MINOR: windows_core::PCSTR = windows_core::s!("MinorVersion");
pub const SZ_HPC_V2: windows_core::PCSTR =
windows_core::s!("Software\\Microsoft\\Windows CE Services");
pub const SZ_HPC_V2_MAJOR: windows_core::PCSTR = windows_core::s!("MajorVersion");
pub const SZ_HPC_V2_MINOR: windows_core::PCSTR = windows_core::s!("MinorVersion");
pub const SZ_NO_OST: windows_core::PCSTR = windows_core::s!("NoOST");
pub const SZ_OUTL_OST_OPTIONS: windows_core::PCSTR =
windows_core::s!("Software\\Microsoft\\Office\\8.0\\Outlook\\OST");
pub const TABLE_CHANGED: u32 = 1u32;
pub const TABLE_ERROR: u32 = 2u32;
#[repr(C)]
#[derive(Clone, Copy)]
pub struct TABLE_NOTIFICATION {
pub ulTableEvent: u32,
pub hResult: windows_core::HRESULT,
pub propIndex: SPropValue,
pub propPrior: SPropValue,
pub row: SRow,
pub ulPad: u32,
}
impl Default for TABLE_NOTIFICATION {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const TABLE_RELOAD: u32 = 9u32;
pub const TABLE_RESTRICT_DONE: u32 = 7u32;
pub const TABLE_ROW_ADDED: u32 = 3u32;
pub const TABLE_ROW_DELETED: u32 = 4u32;
pub const TABLE_ROW_MODIFIED: u32 = 5u32;
pub const TABLE_SETCOL_DONE: u32 = 8u32;
pub const TABLE_SORT_ASCEND: u32 = 0u32;
pub const TABLE_SORT_CATEG_MAX: u32 = 4u32;
pub const TABLE_SORT_CATEG_MIN: u32 = 8u32;
pub const TABLE_SORT_COMBINE: u32 = 2u32;
pub const TABLE_SORT_DESCEND: u32 = 1u32;
pub const TABLE_SORT_DONE: u32 = 6u32;
pub const TAD_ALL_ROWS: u32 = 1u32;
pub const TBLSTAT_COMPLETE: u32 = 0u32;
pub const TBLSTAT_QCHANGED: u32 = 7u32;
pub const TBLSTAT_RESTRICTING: u32 = 14u32;
pub const TBLSTAT_RESTRICT_ERROR: u32 = 15u32;
pub const TBLSTAT_SETCOL_ERROR: u32 = 13u32;
pub const TBLSTAT_SETTING_COLS: u32 = 11u32;
pub const TBLSTAT_SORTING: u32 = 9u32;
pub const TBLSTAT_SORT_ERROR: u32 = 10u32;
pub const TBLTYPE_DYNAMIC: u32 = 2u32;
pub const TBLTYPE_KEYSET: u32 = 1u32;
pub const TBLTYPE_SNAPSHOT: u32 = 0u32;
pub const TBL_ALL_COLUMNS: u32 = 1u32;
pub const TBL_ASYNC: u32 = 1u32;
pub const TBL_BATCH: u32 = 2u32;
pub const TBL_COLLAPSED_CATEGORY: u32 = 4u32;
pub const TBL_EMPTY_CATEGORY: u32 = 2u32;
pub const TBL_EXPANDED_CATEGORY: u32 = 3u32;
pub const TBL_LEAF_ROW: u32 = 1u32;
pub const TBL_NOADVANCE: u32 = 1u32;
pub const TBL_NOWAIT: u32 = 1u32;
pub const TIME_ZONE_ID_DAYLIGHT: u32 = 2u32;
pub const TIME_ZONE_ID_STANDARD: u32 = 1u32;
pub const TIME_ZONE_ID_UNKNOWN: u32 = 0u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRACEENTRY {
pub lAction: i32,
pub ftArrivalTime: windows::Win32::Foundation::FILETIME,
pub ftDeferredTime: windows::Win32::Foundation::FILETIME,
pub rgchADMDName: [i8; 20],
pub rgchCountryName: [i8; 4],
pub rgchPRMDId: [i8; 20],
pub rgchAttADMDName: [i8; 20],
pub rgchAttCountryName: [i8; 4],
pub rgchAttPRMDId: [i8; 19],
pub bAdditionalActions: u8,
}
impl Default for TRACEENTRY {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRACEINFO {
pub cEntries: u32,
pub rgtraceentry: [TRACEENTRY; 1],
}
impl Default for TRACEINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const TRANSFER_COPYFOLDER: u32 = 4u32;
pub const TRANSFER_COPYMESSAGES: u32 = 3u32;
pub const TRANSFER_COPYPROPS: u32 = 2u32;
pub const TRANSFER_COPYTO: u32 = 1u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TRANSMITINFO {
pub ietCurrent: ENCODINGTYPE,
pub ietXmitMime: ENCODINGTYPE,
pub ietXmit822: ENCODINGTYPE,
pub cbLongestLine: u32,
pub cExtended: u32,
pub ulPercentExt: u32,
pub cbSize: u32,
pub cLines: u32,
}
impl Default for TRANSMITINFO {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const TRANSPORT_DOWNLOAD: u32 = 1u32;
pub const TRANSPORT_UPLOAD: u32 = 2u32;
pub const TRUNCATE_EXISTING: u32 = 5u32;
pub const TXT_HTML: u32 = 2u32;
pub const TXT_PLAIN: u32 = 1u32;
pub const TYPEDID_MASK: u32 = 65535u32;
pub const UI_CURRENT_PROVIDER_FIRST: u32 = 4u32;
pub const UI_READONLY: u32 = 1u32;
pub const UI_SERVICE: u32 = 2u32;
pub const UNLOCK_BLOCKING_MID_LOCK_ALL: u32 = 4u32;
pub const UNLOCK_BLOCKING_MID_LOCK_LOGON_ONLY: u32 = 8u32;
pub const UNLOCK_CHECKIN_ABORT: u32 = 1u32;
pub const UNLOCK_CHECKIN_KEEP_LOCKED: u32 = 2u32;
pub const UNLOCK_NULL_RESOURCE: u32 = 16u32;
pub const UNLOCK_WRITE_THROUGH_GOP: u32 = 65536u32;
pub const URL_ATTACH_GENERATE_CID: u32 = 2u32;
pub const URL_ATTACH_INTO_MIXED: u32 = 1u32;
pub const URL_ATTACH_SET_CNTTYPE: u32 = 4u32;
pub const URL_RESOLVE_RENDERED: u32 = 1u32;
pub const URL_RESULVE_NO_BASE: u32 = 2u32;
pub const VCDIR_DELETE: u32 = 65536u32;
pub const VCDIR_MOVE: u32 = 262144u32;
pub const VCDIR_NEXT: u32 = 1u32;
pub const VCDIR_PREV: u32 = 2u32;
pub const VCSTATUS_COPY: u32 = 131072u32;
pub const VCSTATUS_DELETE: u32 = 65536u32;
pub const VCSTATUS_DELETE_IS_MOVE: u32 = 1048576u32;
pub const VCSTATUS_INTERACTIVE: u32 = 8u32;
pub const VCSTATUS_MODAL: u32 = 4u32;
pub const VCSTATUS_MOVE: u32 = 262144u32;
pub const VCSTATUS_NEW_MESSAGE: u32 = 4194304u32;
pub const VCSTATUS_NEXT: u32 = 1u32;
pub const VCSTATUS_PREV: u32 = 2u32;
pub const VCSTATUS_READONLY: u32 = 16u32;
pub const VCSTATUS_SAVE: u32 = 2097152u32;
pub const VCSTATUS_SUBMIT: u32 = 524288u32;
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct WEBPAGEOPTIONS {
pub cbSize: u32,
pub dwFlags: u32,
pub dwDelay: u32,
pub wchQuote: u16,
}
impl Default for WEBPAGEOPTIONS {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub type WIZARDENTRY = Option<
unsafe extern "system" fn(
hproviderdllinstance: windows::Win32::Foundation::HINSTANCE,
lppcsresourcename: *mut *mut i8,
lppdlgproc: *mut windows::Win32::UI::WindowsAndMessaging::DLGPROC,
lpmapiprop: Option<IMAPIProp>,
lpmapisupportobject: *mut core::ffi::c_void,
) -> u32,
>;
pub const WIZ_NEXT: u32 = 1035u32;
pub const WIZ_PREV: u32 = 1036u32;
pub const WIZ_QUERYNUMPAGES: u32 = 1034u32;
pub const WPF_ATTACHLINKS: u32 = 8u32;
pub const WPF_AUTOINLINE: u32 = 2u32;
pub const WPF_HTML: u32 = 1u32;
pub const WPF_IMAGESONLY: u32 = 16u32;
pub const WPF_NOMETACHARSET: u32 = 32u32;
pub const WPF_SLIDESHOW: u32 = 4u32;
pub const WSZ_URL_FLAT_FOLDER_SPACE: windows_core::PCWSTR = windows_core::w!("/-FlatUrlSpace-/");
pub const X500: CERTNAMETYPE = CERTNAMETYPE(2i32);
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct X509CERTRESULT {
pub cEntries: u32,
pub rgcs: *mut CERTSTATE,
pub rgpCert: *mut *mut windows::Win32::Security::Cryptography::CERT_CONTEXT,
}
impl Default for X509CERTRESULT {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub type XPPROVIDERINIT = Option<
unsafe extern "system" fn(
hinstance: windows::Win32::Foundation::HINSTANCE,
lpmalloc: Option<windows::Win32::System::Com::IMalloc>,
lpallocatebuffer: LPALLOCATEBUFFER,
lpallocatemore: LPALLOCATEMORE,
lpfreebuffer: LPFREEBUFFER,
ulflags: u32,
ulmapiver: u32,
lpulproviderver: *mut u32,
lppxpprovider: *mut Option<IXPProvider>,
) -> windows_core::HRESULT,
>;
#[repr(C)]
#[derive(Clone, Copy)]
pub union __UPV {
pub i: i16,
pub l: i32,
pub ul: u32,
pub lpv: *mut core::ffi::c_void,
pub flt: f32,
pub dbl: f64,
pub b: u16,
pub cur: windows::Win32::System::Com::CY,
pub at: f64,
pub ft: windows::Win32::Foundation::FILETIME,
pub lpszA: windows_core::PSTR,
pub bin: SBinary,
pub lpszW: windows_core::PWSTR,
pub lpguid: *mut windows_core::GUID,
pub li: i64,
pub MVi: SShortArray,
pub MVl: SLongArray,
pub MVflt: SRealArray,
pub MVdbl: SDoubleArray,
pub MVcur: SCurrencyArray,
pub MVat: SAppTimeArray,
pub MVft: SDateTimeArray,
pub MVbin: SBinaryArray,
pub MVszA: SLPSTRArray,
pub MVszW: SWStringArray,
pub MVguid: SGuidArray,
pub MVli: SLargeIntegerArray,
pub err: i32,
pub x: i32,
}
impl Default for __UPV {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
pub const cchProfileNameMax: u32 = 64u32;
pub const cchProfilePassMax: u32 = 64u32;
pub const cwchUrlFlatFolderSpace: u32 = 16u32;
pub const fMapiUnicode: u32 = 2147483648u32;
pub const fVersionedDelete: u32 = 1u32;
pub const fVersionedMoveIn: u32 = 16u32;
pub const fVersionedMoveOut: u32 = 32u32;
pub const fVersionedPin: u32 = 4u32;
pub const fVersionedUnDelete: u32 = 2u32;
pub const fVersionedUnPin: u32 = 8u32;
pub const fnevCriticalError: u32 = 1u32;
pub const fnevExtended: u32 = 2147483648u32;
pub const fnevNewMail: u32 = 2u32;
pub const fnevObjectCopied: u32 = 64u32;
pub const fnevObjectCreated: u32 = 4u32;
pub const fnevObjectDeleted: u32 = 8u32;
pub const fnevObjectModified: u32 = 16u32;
pub const fnevObjectMoved: u32 = 32u32;
pub const fnevReservedForMapi: u32 = 1073741824u32;
pub const fnevSearchComplete: u32 = 128u32;
pub const fnevStatusObjectModified: u32 = 512u32;
pub const fnevTableModified: u32 = 256u32;
pub const frightsContact: i32 = 512i32;
pub const frightsCreate: i32 = 2i32;
pub const frightsCreateSubfolder: i32 = 128i32;
pub const frightsDeleteAny: i32 = 64i32;
pub const frightsDeleteOwned: i32 = 16i32;
pub const frightsEditAny: i32 = 32i32;
pub const frightsEditOwned: i32 = 8i32;
pub const frightsFreeBusyDetailed: i32 = 4096i32;
pub const frightsFreeBusySimple: i32 = 2048i32;
pub const frightsOwner: i32 = 256i32;
pub const frightsReadAny: i32 = 1i32;
pub const frightsVisible: i32 = 1024i32;
pub const fsdpermUserMailboxOwner: u32 = 1u32;
pub const fsdpermUserPrimaryUser: u32 = 4u32;
pub const fsdpermUserSendAs: u32 = 2u32;
pub const fsdrightAppendMsg: u32 = 4u32;
pub const fsdrightContact: u32 = 32768u32;
pub const fsdrightCreateContainer: u32 = 4u32;
pub const fsdrightCreateItem: u32 = 2u32;
pub const fsdrightDeleteOwnItem: u32 = 1024u32;
pub const fsdrightExecute: u32 = 32u32;
pub const fsdrightFreeBusyDetailed: u32 = 2u32;
pub const fsdrightFreeBusySimple: u32 = 1u32;
pub const fsdrightListContents: u32 = 1u32;
pub const fsdrightOwner: u32 = 16384u32;
pub const fsdrightReadAttributes: u32 = 128u32;
pub const fsdrightReadBody: u32 = 1u32;
pub const fsdrightReadProperty: u32 = 8u32;
pub const fsdrightReserved1: u32 = 64u32;
pub const fsdrightViewItem: u32 = 2048u32;
pub const fsdrightWriteAttributes: u32 = 256u32;
pub const fsdrightWriteBody: u32 = 2u32;
pub const fsdrightWriteOwnProperty: u32 = 512u32;
pub const fsdrightWriteProperty: u32 = 16u32;
pub const hrSuccess: u32 = 0u32;
pub const ichOpMapForward: u32 = 4u32;
pub const ichOpMapOpen: u32 = 1u32;
pub const ichOpMapPrint: u32 = 5u32;
pub const ichOpMapReplyToAll: u32 = 3u32;
pub const ichOpMapReplyToFolder: u32 = 8u32;
pub const ichOpMapReplyToSender: u32 = 2u32;
pub const ichOpMapReservedCompose: u32 = 0u32;
pub const ichOpMapReservedDelivery: u32 = 7u32;
pub const ichOpMapSaveAs: u32 = 6u32;
pub const lidOpMap: u32 = 1u32;
pub const pbExchangeProviderDelegateGuid: windows_core::PCSTR =
windows_core::s!("\u{9e}\u{b4}w\u{0}t\u{e4}\u{11}\u{ce}\u{8c}^\u{0}\u{aa}\u{0}BT\u{e2}");
pub const pbExchangeProviderLocalStoreGuid: windows_core::PCSTR =
windows_core::s!("-\u{e5}k\u{a1}dn\u{11}\u{d2}\u{8d}N\u{0}\u{c0}O\u{ae}#q");
pub const pbExchangeProviderPersistStoreGuid: windows_core::PCSTR =
windows_core::s!("\u{98}\u{a2}=gb\u{cf}M4\u{82}y\u{db}\u{fa}jP\u{8b}1");
pub const pbExchangeProviderPrimaryUserGuid: windows_core::PCSTR =
windows_core::s!("T\u{94}\u{a1}\u{c0})\u{7f}\u{10}\u{1b}\u{a5}\u{87}\u{8}\u{0}+*%\u{17}");
pub const pbExchangeProviderPublicGuid: windows_core::PCSTR =
windows_core::s!("x\u{b2}\u{fa}p\u{af}\u{f7}\u{11}\u{cd}\u{9b}\u{c8}\u{0}\u{aa}\u{0}/\u{c4}Z");
pub const pbExchangeProviderXportGuid: windows_core::PCSTR = windows_core::s!(
"\u{a9}\u{6}@\u{e0}\u{d6}\u{93}\u{11}\u{cd}\u{af}\u{95}\u{0}\u{aa}\u{0}J5\u{c3}"
);
pub const pbGlobalProfileSectionGuid: windows_core::PCSTR = windows_core::s!(
"\u{13}\u{db}\u{b0}\u{c8}\u{aa}\u{5}\u{10}\u{1a}\u{9b}\u{b0}\u{0}\u{aa}\u{0}/\u{c4}Z"
);
pub const pidAdminMin: u32 = 26256u32;
pub const pidAttachReadOnlyMin: u32 = 26220u32;
pub const pidExchangeNonXmitReservedMin: u32 = 26080u32;
pub const pidExchangeXmitReservedMin: u32 = 16352u32;
pub const pidFolderMin: u32 = 26168u32;
pub const pidLISErrorCodeMax: u32 = 26032u32;
pub const pidLISErrorCodeMin: u32 = 26026u32;
pub const pidLISInterfacePropMax: u32 = 26080u32;
pub const pidLISInterfacePropMin: u32 = 26064u32;
pub const pidLISMsgFolderPropMax: u32 = 26048u32;
pub const pidLISMsgFolderPropMin: u32 = 26016u32;
pub const pidLocalStoreInternalMax: u32 = 26048u32;
pub const pidLocalStoreInternalMin: u32 = 25856u32;
pub const pidMAPIMin: u32 = 12288u32;
pub const pidMessageReadOnlyMin: u32 = 26176u32;
pub const pidMessageWriteableMin: u32 = 26200u32;
pub const pidProfileMin: u32 = 26112u32;
pub const pidRenMsgFldMin: u32 = 4224u32;
pub const pidSpecialMin: u32 = 26224u32;
pub const pidStoreMin: u32 = 26136u32;
pub const pidStoreNonTransMin: u32 = 3648u32;
pub const ptagLISErrorCode: u32 = 1705639939u32;
pub const ptagLISErrorItemType: u32 = 1705705475u32;
pub const ptagLISErrorItemUrl: u32 = 1705836575u32;
pub const ptagLISErrorLogUrl: u32 = 1701838879u32;
pub const ptagLISErrorOperation: u32 = 1705771011u32;
pub const ptagLISErrorSourceUrl: u32 = 1705902111u32;
pub const ptagLISExtendedErrorinfo: u32 = 1706033155u32;
pub const ptagLISModifiedPropertyList: u32 = 1705967647u32;
pub const ptagLISNewMail: u32 = 1707409419u32;
pub const ptagLISSubfolders: u32 = 1694498827u32;
pub const ptagLISUnreadCount: u32 = 1694564355u32;
pub const ptagSql: u32 = 1708130335u32;
pub const ptagSqlFrom: u32 = 1708261407u32;
pub const ptagSqlGroup: u32 = 1708458015u32;
pub const ptagSqlOrder: u32 = 1708392479u32;
pub const ptagSqlSelect: u32 = 1708195871u32;
pub const ptagSqlWhere: u32 = 1708326943u32;
pub const rightsAll: i32 = 1531i32;
pub const rightsNone: u32 = 0u32;
pub const rightsReadOnly: i32 = 1i32;
pub const sdrightsNone: u32 = 0u32;
pub const szDamMsgClass: windows_core::PCSTR =
windows_core::s!("IPC.Microsoft Exchange 4.0.Deferred Action");
pub const szDemMsgClass: windows_core::PCSTR =
windows_core::s!("IPC.Microsoft Exchange 4.0.Deferred Error");
pub const szExRuleMsgClass: windows_core::PCSTR = windows_core::s!("IPM.ExtendedRule.Message");
pub const szHrDispatchNotifications: windows_core::PCSTR =
windows_core::s!("HrDispatchNotifications");
pub const szMAPIDLLSuffix: windows_core::PCSTR = windows_core::s!("32");
pub const szMAPINotificationMsg: windows_core::PCSTR =
windows_core::s!("MAPI Notify window message");
pub const szOID_Microsoft_Encryption_Cert: windows_core::PCSTR =
windows_core::s!("1.3.6.1.4.1.311.16.4");
pub const szOofTemplateMsgClassPrefix: windows_core::PCSTR =
windows_core::s!("IPM.Note.Rules.OofTemplate.");
pub const szProviderModeratorRule: windows_core::PCSTR = windows_core::s!("MSFT:MR");
pub const szReplyTemplateMsgClassPrefix: windows_core::PCSTR =
windows_core::s!("IPM.Note.Rules.ReplyTemplate.");
pub const szScCreateConversationIndex: windows_core::PCSTR =
windows_core::s!("ScCreateConversationIndex");
pub const ulHierChanged: u32 = 1u32;
pub const wszExRuleMsgClass: windows_core::PCWSTR = windows_core::w!("IPM.ExtendedRule.Message");
pub const wszProviderModeratorRule: windows_core::PCWSTR = windows_core::w!("MSFT:MR");