module System.Win32.Com.Automation.Base where
import System.Win32.Com (checkHR, marshallIUnknown, IUnknown, mkIID, IID, LCID)
import System.Win32.Com.HDirect.HDirect (Ptr, allocBytes, marshallBool, readref, readStablePtr,
marshallPtr, readPtr, unmarshallref, trivialFree, doThenFree, free,
sizeofInt32, readInt32, unmarshallString, freeString, sizeofInt16,
readInt16, sizeofDouble, readDouble, sizeofFloat, readFloat, Octet,
readBool, sizeofChar, readChar, unmarshallBool,
freeref, sizeofWord8, readWord8, sizeofWord32, readWord32,
StablePtr, sizeofPtr, readPtr, writePtr, sizeofForeignPtr )
import System.Win32.Com.Automation.SafeArray ( SAFEARRAY, marshallSAFEARRAY, unmarshallSAFEARRAY, readSAFEARRAY, sizeofSAFEARRAY )
import System.Win32.Com.HDirect.Pointer ( allocMemory )
import System.IO.Unsafe (unsafePerformIO)
import Data.Int (Int32, Int16)
import Data.Word (Word8, Word32)
import Foreign.ForeignPtr ( ForeignPtr, withForeignPtr )
import Foreign.Ptr ( castPtr )
data VARIANT_ = VARIANT_
type VARIANT = Ptr VARIANT_
sizeofBSTR = sizeofPtr
iidIDispatch :: IID (IDispatch ())
iidIDispatch = mkIID "{00020400-0000-0000-C000-000000000046}"
sizeofVARIANT :: Word32
sizeofVARIANT = 16
marshallVARIANT :: VARIANT -> IO VARIANT
marshallVARIANT m = return m
unmarshallVARIANT :: Ptr a -> IO VARIANT
unmarshallVARIANT v = return (castPtr v)
readVARIANT :: Ptr VARIANT -> IO VARIANT
readVARIANT ptr =
readPtr ptr
writeVARIANT :: Ptr VARIANT -> VARIANT -> IO ()
writeVARIANT ptr v = writePtr ptr v
copyVARIANT :: VARIANT -> VARIANT -> IO ()
copyVARIANT ptr v = do
primCopyVARIANT (castPtr ptr) (castPtr v)
allocVARIANT :: IO VARIANT
allocVARIANT = do
x <- allocMemory (fromIntegral sizeofVARIANT)
variantInit x
return x
foreign import ccall "writeVarInt" writeVarStablePtr
:: StablePtr a -> Ptr (StablePtr a) -> IO ()
foreign import ccall "readVarInt" prim_readVarStablePtr
:: Ptr (StablePtr a) -> Ptr b -> IO Int32
readVarStablePtr :: VARIANT -> IO (StablePtr a)
readVarStablePtr p = do
i <- allocBytes (fromIntegral sizeofInt32)
o_readVarInt <- prim_readVarStablePtr (castPtr p) i
checkHR o_readVarInt
doThenFree (freeref trivialFree) (unmarshallref readStablePtr) i
type DISPID = Int32
type PEXCEPINFO = Ptr ()
data IDispatch_ a = IDispatch__
type IDispatch a = IUnknown (IDispatch_ a)
dispatchInvoke :: IDispatch a0
-> DISPID
-> LCID
-> Bool
-> Word32
-> Word32
-> Word32
-> VARIANT
-> VARIANT
-> IO (PEXCEPINFO, Int32)
dispatchInvoke obj dispid lcid isfunction flags cargs cargsout args argsout =
do
info <- allocBytes (fromIntegral sizeofPtr)
obj <- marshallIUnknown obj
isfunction <- marshallBool isfunction
o_dispatchInvoke <- withForeignPtr obj (\ obj -> prim_System_Win32_Com_Automation_Base_dispatchInvoke obj dispid lcid isfunction flags cargs cargsout args argsout info)
info <- doThenFree free readPtr info
return (info, o_dispatchInvoke)
foreign import ccall "dispatchInvoke" prim_System_Win32_Com_Automation_Base_dispatchInvoke :: Ptr (IDispatch a) -> Int32 -> Word32 -> Int32 -> Word32 -> Word32 -> Word32 -> VARIANT -> VARIANT -> Ptr (Ptr ()) -> IO Int32
dispatchGetMemberID :: IDispatch a0
-> Ptr String
-> LCID
-> IO (DISPID, Int32)
dispatchGetMemberID obj name lcid =
do
dispid <- allocBytes (fromIntegral sizeofInt32)
obj <- marshallIUnknown obj
o_dispatchGetMemberID <- withForeignPtr obj (\ obj -> prim_System_Win32_Com_Automation_Base_dispatchGetMemberID obj name lcid dispid)
dispid <- doThenFree free readInt32 dispid
return (dispid, o_dispatchGetMemberID)
foreign import ccall "dispatchGetMemberID" prim_System_Win32_Com_Automation_Base_dispatchGetMemberID :: Ptr (IDispatch a) -> Ptr String -> Word32 -> Ptr Int32 -> IO Int32
freeExcepInfo :: PEXCEPINFO
-> IO ()
freeExcepInfo einfo =
prim_System_Win32_Com_Automation_Base_freeExcepInfo einfo
foreign import ccall "freeExcepInfo" prim_System_Win32_Com_Automation_Base_freeExcepInfo :: Ptr () -> IO ()
getExcepInfoMessage :: PEXCEPINFO
-> IO (Ptr Char)
getExcepInfoMessage info =
prim_System_Win32_Com_Automation_Base_getExcepInfoMessage info
foreign import ccall "getExcepInfoMessage" prim_System_Win32_Com_Automation_Base_getExcepInfoMessage :: Ptr () -> IO (Ptr Char)
freeVariants :: Word32
-> VARIANT
-> IO ()
freeVariants count p =
prim_System_Win32_Com_Automation_Base_freeVariants count
p
foreign import ccall "freeVariants" prim_System_Win32_Com_Automation_Base_freeVariants :: Word32 -> VARIANT -> IO ()
readVariantTag :: VARIANT
-> IO Int32
readVariantTag p =
prim_System_Win32_Com_Automation_Base_readVariantTag p
foreign import ccall "readVariantTag" prim_System_Win32_Com_Automation_Base_readVariantTag :: VARIANT -> IO Int32
variantInit :: VARIANT
-> IO ()
variantInit p =
prim_System_Win32_Com_Automation_Base_variantInit p
foreign import stdcall "VariantInit" prim_System_Win32_Com_Automation_Base_variantInit :: VARIANT -> IO ()
writeVarShort :: Int16
-> VARIANT
-> IO ()
writeVarShort i p =
prim_System_Win32_Com_Automation_Base_writeVarShort i
p
foreign import ccall "writeVarShort" prim_System_Win32_Com_Automation_Base_writeVarShort :: Int16 -> VARIANT -> IO ()
readVarShort :: VARIANT
-> IO Int16
readVarShort p =
do
i <- allocBytes (fromIntegral sizeofInt16)
o_readVarShort <- prim_System_Win32_Com_Automation_Base_readVarShort p i
checkHR o_readVarShort
doThenFree free readInt16 i
foreign import ccall "readVarShort" prim_System_Win32_Com_Automation_Base_readVarShort :: VARIANT -> Ptr Int16 -> IO Int32
writeVarInt :: Int32
-> VARIANT
-> IO ()
writeVarInt i p =
prim_System_Win32_Com_Automation_Base_writeVarInt i
p
foreign import ccall "writeVarInt" prim_System_Win32_Com_Automation_Base_writeVarInt :: Int32 -> VARIANT -> IO ()
readVarInt :: VARIANT
-> IO Int32
readVarInt p =
do
i <- allocBytes (fromIntegral sizeofInt32)
o_readVarInt <- prim_System_Win32_Com_Automation_Base_readVarInt p i
checkHR o_readVarInt
doThenFree free readInt32 i
foreign import ccall "readVarInt" prim_System_Win32_Com_Automation_Base_readVarInt :: VARIANT -> Ptr Int32 -> IO Int32
writeVarWord :: Word32
-> VARIANT
-> IO ()
writeVarWord i p =
prim_System_Win32_Com_Automation_Base_writeVarWord i
p
foreign import ccall "writeVarWord" prim_System_Win32_Com_Automation_Base_writeVarWord :: Word32 -> VARIANT -> IO ()
readVarWord :: VARIANT
-> IO Word32
readVarWord p =
do
i <- allocBytes (fromIntegral sizeofWord32)
o_readVarWord <- prim_System_Win32_Com_Automation_Base_readVarWord p i
checkHR o_readVarWord
doThenFree free readWord32 i
foreign import ccall "readVarWord" prim_System_Win32_Com_Automation_Base_readVarWord :: VARIANT -> Ptr Word32 -> IO Int32
writeVarFloat :: Float
-> VARIANT
-> IO ()
writeVarFloat i p =
prim_System_Win32_Com_Automation_Base_writeVarFloat i
p
foreign import ccall "writeVarFloat" prim_System_Win32_Com_Automation_Base_writeVarFloat :: Float -> VARIANT -> IO ()
readVarFloat :: VARIANT
-> IO Float
readVarFloat p =
do
i <- allocBytes (fromIntegral sizeofFloat)
o_readVarFloat <- prim_System_Win32_Com_Automation_Base_readVarFloat p i
checkHR o_readVarFloat
doThenFree free readFloat i
foreign import ccall "readVarFloat" prim_System_Win32_Com_Automation_Base_readVarFloat :: VARIANT -> Ptr Float -> IO Int32
writeVarDouble :: Double
-> VARIANT
-> IO ()
writeVarDouble i p =
prim_System_Win32_Com_Automation_Base_writeVarDouble i
p
foreign import ccall "writeVarDouble" prim_System_Win32_Com_Automation_Base_writeVarDouble :: Double -> VARIANT -> IO ()
readVarDouble :: VARIANT
-> IO Double
readVarDouble p =
do
i <- allocBytes (fromIntegral sizeofDouble)
o_readVarDouble <- prim_System_Win32_Com_Automation_Base_readVarDouble p i
checkHR o_readVarDouble
doThenFree free readDouble i
foreign import ccall "readVarDouble" prim_System_Win32_Com_Automation_Base_readVarDouble :: VARIANT -> Ptr Double -> IO Int32
writeVarString :: Ptr Char
-> VARIANT
-> IO ()
writeVarString str p =
prim_System_Win32_Com_Automation_Base_writeVarString str
p
foreign import ccall "writeVarString" prim_System_Win32_Com_Automation_Base_writeVarString :: Ptr Char -> VARIANT -> IO ()
readVarString :: VARIANT
-> IO (Ptr (Ptr Char), Ptr VARIANT)
readVarString p =
do
pstr <- allocBytes (fromIntegral sizeofPtr)
w <- allocBytes (fromIntegral sizeofVARIANT)
o_readVarString <- prim_System_Win32_Com_Automation_Base_readVarString p pstr w
checkHR o_readVarString
return (pstr, w)
foreign import ccall "readVarString" prim_System_Win32_Com_Automation_Base_readVarString :: VARIANT -> Ptr (Ptr Char) -> Ptr VARIANT -> IO Int32
writeVarDispatch :: IDispatch a0
-> VARIANT
-> IO ()
writeVarDispatch ip p =
do
ip <- marshallIUnknown ip
withForeignPtr ip (\ ip -> prim_System_Win32_Com_Automation_Base_writeVarDispatch ip p)
foreign import ccall "writeVarDispatch" prim_System_Win32_Com_Automation_Base_writeVarDispatch :: Ptr (IDispatch a) -> VARIANT -> IO ()
readVarDispatch :: VARIANT
-> IO (Ptr (Ptr ()), Ptr VARIANT)
readVarDispatch p =
do
ip <- allocBytes (fromIntegral sizeofPtr)
w <- allocBytes (fromIntegral sizeofVARIANT)
o_readVarDispatch <- prim_System_Win32_Com_Automation_Base_readVarDispatch p ip w
checkHR o_readVarDispatch
return (ip, w)
foreign import ccall "readVarDispatch" prim_System_Win32_Com_Automation_Base_readVarDispatch :: VARIANT -> Ptr (Ptr ()) -> Ptr VARIANT -> IO Int32
writeVarOptional :: VARIANT
-> IO ()
writeVarOptional p =
prim_System_Win32_Com_Automation_Base_writeVarOptional p
foreign import ccall "writeVarOptional" prim_System_Win32_Com_Automation_Base_writeVarOptional :: VARIANT -> IO ()
writeVarError :: Int32
-> VARIANT
-> IO ()
writeVarError err p =
prim_System_Win32_Com_Automation_Base_writeVarError err
p
foreign import ccall "writeVarError" prim_System_Win32_Com_Automation_Base_writeVarError :: Int32 -> VARIANT -> IO ()
readVarError :: VARIANT
-> IO Int32
readVarError p =
do
perr <- allocBytes (fromIntegral sizeofInt32)
o_readVarError <- prim_System_Win32_Com_Automation_Base_readVarError p perr
checkHR o_readVarError
doThenFree free readInt32 perr
foreign import ccall "readVarError" prim_System_Win32_Com_Automation_Base_readVarError :: VARIANT -> Ptr Int32 -> IO Int32
writeVarBool :: Bool
-> VARIANT
-> IO ()
writeVarBool b p =
do
b <- marshallBool b
prim_System_Win32_Com_Automation_Base_writeVarBool b p
foreign import ccall "writeVarBool" prim_System_Win32_Com_Automation_Base_writeVarBool :: Int32 -> VARIANT -> IO ()
readVarBool :: VARIANT
-> IO Bool
readVarBool p =
do
pb <- allocBytes (fromIntegral sizeofInt32)
o_readVarBool <- prim_System_Win32_Com_Automation_Base_readVarBool p pb
checkHR o_readVarBool
doThenFree free readBool pb
foreign import ccall "readVarBool" prim_System_Win32_Com_Automation_Base_readVarBool :: VARIANT -> Ptr Int32 -> IO Int32
writeVarUnknown :: IUnknown a0
-> VARIANT
-> IO ()
writeVarUnknown ip p =
do
ip <- marshallIUnknown ip
withForeignPtr ip (\ ip -> prim_System_Win32_Com_Automation_Base_writeVarUnknown ip p)
foreign import ccall "writeVarUnknown" prim_System_Win32_Com_Automation_Base_writeVarUnknown :: Ptr (IUnknown a) -> VARIANT -> IO ()
readVarUnknown :: VARIANT
-> IO (Ptr (Ptr ()), Ptr VARIANT)
readVarUnknown p =
do
ip <- allocBytes (fromIntegral sizeofPtr)
w <- allocBytes (fromIntegral sizeofVARIANT)
o_readVarUnknown <- prim_System_Win32_Com_Automation_Base_readVarUnknown p ip w
checkHR o_readVarUnknown
return (ip, w)
foreign import ccall "readVarUnknown" prim_System_Win32_Com_Automation_Base_readVarUnknown :: VARIANT -> Ptr (Ptr ()) -> Ptr VARIANT -> IO Int32
writeVarByte :: Octet
-> VARIANT
-> IO ()
writeVarByte b p =
prim_System_Win32_Com_Automation_Base_writeVarByte b
p
foreign import ccall "writeVarByte" prim_System_Win32_Com_Automation_Base_writeVarByte :: Word8 -> VARIANT -> IO ()
readVarByte :: VARIANT
-> IO Octet
readVarByte p =
do
pb <- allocBytes (fromIntegral sizeofWord8)
o_readVarByte <- prim_System_Win32_Com_Automation_Base_readVarByte p pb
checkHR o_readVarByte
doThenFree free readWord8 pb
foreign import ccall "readVarByte" prim_System_Win32_Com_Automation_Base_readVarByte :: VARIANT -> Ptr Word8 -> IO Int32
writeVarEmpty :: VARIANT
-> IO ()
writeVarEmpty p =
prim_System_Win32_Com_Automation_Base_writeVarEmpty p
foreign import ccall "writeVarEmpty" prim_System_Win32_Com_Automation_Base_writeVarEmpty :: VARIANT -> IO ()
writeVarNull :: VARIANT
-> IO ()
writeVarNull p =
prim_System_Win32_Com_Automation_Base_writeVarNull p
foreign import ccall "writeVarNull" prim_System_Win32_Com_Automation_Base_writeVarNull :: VARIANT -> IO ()
readVarNull :: VARIANT
-> IO ()
readVarNull p =
do
o_readVarNull <- prim_System_Win32_Com_Automation_Base_readVarNull p
checkHR o_readVarNull
foreign import ccall "readVarNull" prim_System_Win32_Com_Automation_Base_readVarNull :: VARIANT -> IO Int32
writeVarCurrency :: Int32
-> Word32
-> VARIANT
-> IO ()
writeVarCurrency hi lo p =
prim_System_Win32_Com_Automation_Base_writeVarCurrency hi
lo
p
foreign import ccall "writeVarCurrency" prim_System_Win32_Com_Automation_Base_writeVarCurrency :: Int32 -> Word32 -> VARIANT -> IO ()
readVarCurrency :: VARIANT
-> IO (Int32, Word32)
readVarCurrency p =
do
hi <- allocBytes (fromIntegral sizeofInt32)
lo <- allocBytes (fromIntegral sizeofWord32)
o_readVarCurrency <- prim_System_Win32_Com_Automation_Base_readVarCurrency p hi lo
checkHR o_readVarCurrency
hi <- doThenFree free readInt32 hi
lo <- doThenFree free readWord32 lo
return (hi, lo)
foreign import ccall "readVarCurrency" prim_System_Win32_Com_Automation_Base_readVarCurrency :: VARIANT -> Ptr Int32 -> Ptr Word32 -> IO Int32
writeVarWord64 :: Word32
-> Word32
-> VARIANT
-> IO ()
writeVarWord64 hi lo p =
prim_System_Win32_Com_Automation_Base_writeVarWord64 hi
lo
p
foreign import ccall "writeVarWord64" prim_System_Win32_Com_Automation_Base_writeVarWord64 :: Word32 -> Word32 -> VARIANT -> IO ()
readVarWord64 :: VARIANT
-> IO (Word32, Word32)
readVarWord64 p =
do
hi <- allocBytes (fromIntegral sizeofWord32)
lo <- allocBytes (fromIntegral sizeofWord32)
o_readVarWord64 <- prim_System_Win32_Com_Automation_Base_readVarWord64 p hi lo
checkHR o_readVarWord64
hi <- doThenFree free readWord32 hi
lo <- doThenFree free readWord32 lo
return (hi, lo)
foreign import ccall "readVarWord64" prim_System_Win32_Com_Automation_Base_readVarWord64 :: VARIANT -> Ptr Word32 -> Ptr Word32 -> IO Int32
writeVarVariant :: VARIANT
-> VARIANT
-> IO ()
writeVarVariant p1 p2 =
prim_System_Win32_Com_Automation_Base_writeVarVariant p1
p2
foreign import ccall "writeVarVariant" prim_System_Win32_Com_Automation_Base_writeVarVariant :: VARIANT -> VARIANT -> IO ()
readVarVariant :: VARIANT
-> IO (Ptr VARIANT)
readVarVariant p1 =
do
p2 <- allocBytes (fromIntegral sizeofVARIANT)
o_readVarVariant <- prim_System_Win32_Com_Automation_Base_readVarVariant p1 p2
checkHR o_readVarVariant
return (p2)
foreign import ccall "readVarVariant" prim_System_Win32_Com_Automation_Base_readVarVariant :: VARIANT -> Ptr VARIANT -> IO Int32
writeVarSAFEARRAY :: VARIANT
-> SAFEARRAY
-> Int32
-> IO ()
writeVarSAFEARRAY p1 p2 vt =
do
p2 <- marshallSAFEARRAY p2
withForeignPtr p2 (\ p2 -> prim_System_Win32_Com_Automation_Base_writeVarSAFEARRAY p1 p2 vt)
foreign import ccall "writeVarSAFEARRAY" prim_System_Win32_Com_Automation_Base_writeVarSAFEARRAY :: VARIANT -> Ptr SAFEARRAY -> Int32 -> IO ()
readVarSAFEARRAY :: VARIANT
-> Int32
-> IO (Ptr ())
readVarSAFEARRAY p1 vt =
do
p2 <- allocBytes (fromIntegral sizeofPtr)
o_readVarSAFEARRAY <- prim_System_Win32_Com_Automation_Base_readVarSAFEARRAY p1 p2 vt
checkHR o_readVarSAFEARRAY
return (p2)
foreign import ccall "readVarSAFEARRAY" prim_System_Win32_Com_Automation_Base_readVarSAFEARRAY :: VARIANT -> Ptr () -> Int32 -> IO Int32
primCopyVARIANT :: VARIANT
-> VARIANT
-> IO ()
primCopyVARIANT p1 p2 =
do
o_primCopyVARIANT <- prim_System_Win32_Com_Automation_Base_primCopyVARIANT p1 p2
checkHR o_primCopyVARIANT
foreign import ccall "primCopyVARIANT" prim_System_Win32_Com_Automation_Base_primCopyVARIANT :: VARIANT -> VARIANT -> IO Int32
primVARIANTClear :: VARIANT
-> IO ()
primVARIANTClear p1 =
do
o_primVARIANTClear <- prim_System_Win32_Com_Automation_Base_primVARIANTClear p1
checkHR o_primVARIANTClear
foreign import ccall "primVARIANTClear" prim_System_Win32_Com_Automation_Base_primVARIANTClear :: VARIANT -> IO Int32
primClockToDate :: Int32
-> IO Double
primClockToDate ct =
do
pT <- allocBytes (fromIntegral sizeofDouble)
o_primClockToDate <- prim_System_Win32_Com_Automation_Base_primClockToDate ct pT
checkHR o_primClockToDate
doThenFree free readDouble pT
foreign import ccall "primClockToDate" prim_System_Win32_Com_Automation_Base_primClockToDate :: Int32 -> Ptr Double -> IO Int32