#![allow(
non_snake_case,
non_upper_case_globals,
non_camel_case_types,
dead_code,
clippy::all
)]
#[inline]
pub unsafe fn GetProcAddress<P1>(hmodule: HMODULE, lpprocname: P1) -> FARPROC
where
P1: windows_core::Param<windows_core::PCSTR>,
{
windows_targets::link!("kernel32.dll" "system" fn GetProcAddress(hmodule : HMODULE, lpprocname : windows_core::PCSTR) -> FARPROC);
unsafe { GetProcAddress(hmodule, lpprocname.param().abi()) }
}
#[inline]
pub unsafe fn LoadLibraryExA<P0>(
lplibfilename: P0,
hfile: Option<HANDLE>,
dwflags: LOAD_LIBRARY_FLAGS,
) -> windows_core::Result<HMODULE>
where
P0: windows_core::Param<windows_core::PCSTR>,
{
windows_targets::link!("kernel32.dll" "system" fn LoadLibraryExA(lplibfilename : windows_core::PCSTR, hfile : HANDLE, dwflags : LOAD_LIBRARY_FLAGS) -> HMODULE);
let result__ = unsafe {
LoadLibraryExA(
lplibfilename.param().abi(),
hfile.unwrap_or(core::mem::zeroed()) as _,
dwflags,
)
};
(!result__.is_invalid())
.then_some(result__)
.ok_or_else(windows_core::Error::from_win32)
}
pub type FARPROC = Option<unsafe extern "system" fn() -> isize>;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct HANDLE(pub *mut core::ffi::c_void);
impl HANDLE {
pub fn is_invalid(&self) -> bool {
self.0 == -1 as _ || self.0 == 0 as _
}
}
impl windows_core::Free for HANDLE {
#[inline]
unsafe fn free(&mut self) {
if !self.is_invalid() {
windows_targets::link!("kernel32.dll" "system" fn CloseHandle(hobject : *mut core::ffi::c_void) -> i32);
unsafe {
CloseHandle(self.0);
}
}
}
}
impl Default for HANDLE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct HINSTANCE(pub *mut core::ffi::c_void);
impl HINSTANCE {
pub fn is_invalid(&self) -> bool {
self.0.is_null()
}
}
impl windows_core::Free for HINSTANCE {
#[inline]
unsafe fn free(&mut self) {
if !self.is_invalid() {
windows_targets::link!("kernel32.dll" "system" fn FreeLibrary(hlibmodule : *mut core::ffi::c_void) -> i32);
unsafe {
FreeLibrary(self.0);
}
}
}
}
impl Default for HINSTANCE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
impl windows_core::imp::CanInto<HMODULE> for HINSTANCE {}
impl From<HINSTANCE> for HMODULE {
fn from(value: HINSTANCE) -> Self {
Self(value.0)
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct HMODULE(pub *mut core::ffi::c_void);
impl HMODULE {
pub fn is_invalid(&self) -> bool {
self.0.is_null()
}
}
impl windows_core::Free for HMODULE {
#[inline]
unsafe fn free(&mut self) {
if !self.is_invalid() {
windows_targets::link!("kernel32.dll" "system" fn FreeLibrary(hlibmodule : *mut core::ffi::c_void) -> i32);
unsafe {
FreeLibrary(self.0);
}
}
}
}
impl Default for HMODULE {
fn default() -> Self {
unsafe { core::mem::zeroed() }
}
}
impl windows_core::imp::CanInto<HINSTANCE> for HMODULE {}
impl From<HMODULE> for HINSTANCE {
fn from(value: HMODULE) -> Self {
Self(value.0)
}
}
windows_core::imp::define_interface!(
IClassFactory,
IClassFactory_Vtbl,
0x00000001_0000_0000_c000_000000000046
);
windows_core::imp::interface_hierarchy!(IClassFactory, windows_core::IUnknown);
impl IClassFactory {
pub unsafe fn CreateInstance<P0, T>(&self, punkouter: P0) -> windows_core::Result<T>
where
P0: windows_core::Param<windows_core::IUnknown>,
T: windows_core::Interface,
{
let mut result__ = core::ptr::null_mut();
unsafe {
(windows_core::Interface::vtable(self).CreateInstance)(
windows_core::Interface::as_raw(self),
punkouter.param().abi(),
&T::IID,
&mut result__,
)
.and_then(|| windows_core::Type::from_abi(result__))
}
}
}
#[repr(C)]
pub struct IClassFactory_Vtbl {
pub base__: windows_core::IUnknown_Vtbl,
pub CreateInstance: unsafe extern "system" fn(
*mut core::ffi::c_void,
*mut core::ffi::c_void,
*const windows_core::GUID,
*mut *mut core::ffi::c_void,
) -> windows_core::HRESULT,
LockServer: usize,
}
pub trait IClassFactory_Impl: windows_core::IUnknownImpl {
fn CreateInstance(
&self,
punkouter: windows_core::Ref<'_, windows_core::IUnknown>,
riid: *const windows_core::GUID,
ppvobject: *mut *mut core::ffi::c_void,
) -> windows_core::Result<()>;
}
impl IClassFactory_Vtbl {
pub const fn new<Identity: IClassFactory_Impl, const OFFSET: isize>() -> Self {
unsafe extern "system" fn CreateInstance<
Identity: IClassFactory_Impl,
const OFFSET: isize,
>(
this: *mut core::ffi::c_void,
punkouter: *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);
IClassFactory_Impl::CreateInstance(
this,
core::mem::transmute_copy(&punkouter),
core::mem::transmute_copy(&riid),
core::mem::transmute_copy(&ppvobject),
)
.into()
}
}
Self {
base__: windows_core::IUnknown_Vtbl::new::<Identity, OFFSET>(),
CreateInstance: CreateInstance::<Identity, OFFSET>,
LockServer: 0,
}
}
pub fn matches(iid: &windows_core::GUID) -> bool {
iid == &<IClassFactory as windows_core::Interface>::IID
}
}
impl windows_core::RuntimeName for IClassFactory {}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct LOAD_LIBRARY_FLAGS(pub u32);
impl LOAD_LIBRARY_FLAGS {
pub const fn contains(&self, other: Self) -> bool {
self.0 & other.0 == other.0
}
}
impl core::ops::BitOr for LOAD_LIBRARY_FLAGS {
type Output = Self;
fn bitor(self, other: Self) -> Self {
Self(self.0 | other.0)
}
}
impl core::ops::BitAnd for LOAD_LIBRARY_FLAGS {
type Output = Self;
fn bitand(self, other: Self) -> Self {
Self(self.0 & other.0)
}
}
impl core::ops::BitOrAssign for LOAD_LIBRARY_FLAGS {
fn bitor_assign(&mut self, other: Self) {
self.0.bitor_assign(other.0)
}
}
impl core::ops::BitAndAssign for LOAD_LIBRARY_FLAGS {
fn bitand_assign(&mut self, other: Self) {
self.0.bitand_assign(other.0)
}
}
impl core::ops::Not for LOAD_LIBRARY_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const LOAD_WITH_ALTERED_SEARCH_PATH: LOAD_LIBRARY_FLAGS = LOAD_LIBRARY_FLAGS(8u32);