System.Win32.Com.Automation

Accessing COM / OLE Automation objects from Haskell clients. This library provides a fairly high-level view of Automation objects and the data values that their methods support. Transparent marshalling of arguments and invocation over Automation objects is supported via the Variant class and a family of invoke methods. This is also extended to cover the properties/fields of such objects.

Documentation

module System.Win32.Com

data IDispatch_ a

Instances

Variant (IDispatch_ a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (IDispatch_ a)

inVarList :: ArgIn [IDispatch_ a]

inVarIUnknown :: ArgIn (IUnknown (IDispatch_ a))

vtEltType :: IDispatch_ a -> VARENUM

resVariant :: ArgRes (IDispatch_ a)

defaultVariant :: IDispatch_ a

resVarList :: ArgRes [IDispatch_ a]

resVarIUnknown :: ArgRes (IUnknown (IDispatch_ a))

resVarIDispatch :: ArgRes (IDispatch (IDispatch_ a))

type IDispatch a = IUnknown (IDispatch_ a)

iidIDispatch :: IID (IDispatch ())

queryIUnknown :: IID (IUnknown a) -> IUnknown () -> IO (IUnknown a)

queryIDispatch :: IID (IUnknown a) -> IDispatch () -> IO (IUnknown a)

createObject :: ProgID -> IO (IDispatch a)

createObject progid is the Haskell equivalent of VB's CreateObject, trying to instantiate a new Automation object via an IDispatch interfac pointer.

getObject :: String -> IO (IDispatch a)

getActiveObject :: ProgID -> IO (IDispatch a)

getFileObject :: String -> ProgID -> IO (IDispatch a)

type Member = String

Automation Member functions or properties are identified by either name or DISPID. The latter saving you from having to do a method name resolution for each invocation.

type DISPID = Int32

getMemberID :: Member -> IDispatch a -> IO DISPID

getMemberID memberName obj translates the memberName string into the unique DISPID representing that method/property. If unknown, a COM exception is raised.

type VARIANT = Ptr VARIANT_

sizeofVARIANT :: Word32

marshallVARIANT :: VARIANT -> IO VARIANT

unmarshallVARIANT :: Ptr a -> IO VARIANT

readVARIANT :: Ptr VARIANT -> IO VARIANT

writeVARIANT :: Ptr VARIANT -> VARIANT -> IO ()

copyVARIANT :: VARIANT -> VARIANT -> IO ()

allocVARIANT :: IO VARIANT

type VarIn = VARIANT -> IO ()

VarIn is the marshaller for Variant arguments; a function that takes (a pointer to) a VARIANT structure and fills it in with value it encodes.

type VarRes a = VARIANT -> IO a

VarRes is the unmarshaller for 'Variant results; a function that takes (a pointer to) the VARIANT result and unscrambles its contents into the Haskell value representing that Variant result.

type ArgIn a = a -> VarIn

ArgIn is the extension of VarIn, returning a VarIn marshaller for some Variant-supported value of type a.

type ArgInOut a b = a -> ArgOut b

ArgInOut a b is the general 'in-out' parameter marshaller and result unmarshaller.

type ArgOut a = (VarIn, ArgRes a)

ArgOut a represent an in-out Automation parameter, pairing a marshaller with an unmarshaller for some type. Notice that the input value being marshalled may not have the same type as the output/result value being unmarshalled.

type ArgRes a = VarRes a

ArgRes is the Variant unmarshaller for results of type a, where is one of the Variant supported types.

class Variant a where

Methods

inVariant :: ArgIn a

inVarList :: ArgIn [a]

inVarIUnknown :: ArgIn (IUnknown a)

vtEltType :: a -> VARENUM

resVariant :: ArgRes a

defaultVariant :: a

resVarList :: ArgRes [a]

resVarIUnknown :: ArgRes (IUnknown a)

resVarIDispatch :: ArgRes (IDispatch a)

Instances

Variant Bool

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Bool

inVarList :: ArgIn [Bool]

inVarIUnknown :: ArgIn (IUnknown Bool)

vtEltType :: Bool -> VARENUM

resVariant :: ArgRes Bool

defaultVariant :: Bool

resVarList :: ArgRes [Bool]

resVarIUnknown :: ArgRes (IUnknown Bool)

resVarIDispatch :: ArgRes (IDispatch Bool)

Variant Char

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Char

inVarList :: ArgIn [Char]

inVarIUnknown :: ArgIn (IUnknown Char)

vtEltType :: Char -> VARENUM

resVariant :: ArgRes Char

defaultVariant :: Char

resVarList :: ArgRes [Char]

resVarIUnknown :: ArgRes (IUnknown Char)

resVarIDispatch :: ArgRes (IDispatch Char)

Variant Double

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Double

inVarList :: ArgIn [Double]

inVarIUnknown :: ArgIn (IUnknown Double)

vtEltType :: Double -> VARENUM

resVariant :: ArgRes Double

defaultVariant :: Double

resVarList :: ArgRes [Double]

resVarIUnknown :: ArgRes (IUnknown Double)

resVarIDispatch :: ArgRes (IDispatch Double)

Variant Float

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Float

inVarList :: ArgIn [Float]

inVarIUnknown :: ArgIn (IUnknown Float)

vtEltType :: Float -> VARENUM

resVariant :: ArgRes Float

defaultVariant :: Float

resVarList :: ArgRes [Float]

resVarIUnknown :: ArgRes (IUnknown Float)

resVarIDispatch :: ArgRes (IDispatch Float)

Variant Int

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Int

inVarList :: ArgIn [Int]

inVarIUnknown :: ArgIn (IUnknown Int)

vtEltType :: Int -> VARENUM

resVariant :: ArgRes Int

defaultVariant :: Int

resVarList :: ArgRes [Int]

resVarIUnknown :: ArgRes (IUnknown Int)

resVarIDispatch :: ArgRes (IDispatch Int)

Variant Int8

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Int8

inVarList :: ArgIn [Int8]

inVarIUnknown :: ArgIn (IUnknown Int8)

vtEltType :: Int8 -> VARENUM

resVariant :: ArgRes Int8

defaultVariant :: Int8

resVarList :: ArgRes [Int8]

resVarIUnknown :: ArgRes (IUnknown Int8)

resVarIDispatch :: ArgRes (IDispatch Int8)

Variant Int16

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Int16

inVarList :: ArgIn [Int16]

inVarIUnknown :: ArgIn (IUnknown Int16)

vtEltType :: Int16 -> VARENUM

resVariant :: ArgRes Int16

defaultVariant :: Int16

resVarList :: ArgRes [Int16]

resVarIUnknown :: ArgRes (IUnknown Int16)

resVarIDispatch :: ArgRes (IDispatch Int16)

Variant Int32

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Int32

inVarList :: ArgIn [Int32]

inVarIUnknown :: ArgIn (IUnknown Int32)

vtEltType :: Int32 -> VARENUM

resVariant :: ArgRes Int32

defaultVariant :: Int32

resVarList :: ArgRes [Int32]

resVarIUnknown :: ArgRes (IUnknown Int32)

resVarIDispatch :: ArgRes (IDispatch Int32)

Variant Int64

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Int64

inVarList :: ArgIn [Int64]

inVarIUnknown :: ArgIn (IUnknown Int64)

vtEltType :: Int64 -> VARENUM

resVariant :: ArgRes Int64

defaultVariant :: Int64

resVarList :: ArgRes [Int64]

resVarIUnknown :: ArgRes (IUnknown Int64)

resVarIDispatch :: ArgRes (IDispatch Int64)

Variant Word8

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Word8

inVarList :: ArgIn [Word8]

inVarIUnknown :: ArgIn (IUnknown Word8)

vtEltType :: Word8 -> VARENUM

resVariant :: ArgRes Word8

defaultVariant :: Word8

resVarList :: ArgRes [Word8]

resVarIUnknown :: ArgRes (IUnknown Word8)

resVarIDispatch :: ArgRes (IDispatch Word8)

Variant Word16

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Word16

inVarList :: ArgIn [Word16]

inVarIUnknown :: ArgIn (IUnknown Word16)

vtEltType :: Word16 -> VARENUM

resVariant :: ArgRes Word16

defaultVariant :: Word16

resVarList :: ArgRes [Word16]

resVarIUnknown :: ArgRes (IUnknown Word16)

resVarIDispatch :: ArgRes (IDispatch Word16)

Variant Word32

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Word32

inVarList :: ArgIn [Word32]

inVarIUnknown :: ArgIn (IUnknown Word32)

vtEltType :: Word32 -> VARENUM

resVariant :: ArgRes Word32

defaultVariant :: Word32

resVarList :: ArgRes [Word32]

resVarIUnknown :: ArgRes (IUnknown Word32)

resVarIDispatch :: ArgRes (IDispatch Word32)

Variant Word64

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn Word64

inVarList :: ArgIn [Word64]

inVarIUnknown :: ArgIn (IUnknown Word64)

vtEltType :: Word64 -> VARENUM

resVariant :: ArgRes Word64

defaultVariant :: Word64

resVarList :: ArgRes [Word64]

resVarIUnknown :: ArgRes (IUnknown Word64)

resVarIDispatch :: ArgRes (IDispatch Word64)

Variant ()

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn ()

inVarList :: ArgIn [()]

inVarIUnknown :: ArgIn (IUnknown ())

vtEltType :: () -> VARENUM

resVariant :: ArgRes ()

defaultVariant :: ()

resVarList :: ArgRes [()]

resVarIUnknown :: ArgRes (IUnknown ())

resVarIDispatch :: ArgRes (IDispatch ())

Variant SAFEARRAY

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn SAFEARRAY

inVarList :: ArgIn [SAFEARRAY]

inVarIUnknown :: ArgIn (IUnknown SAFEARRAY)

vtEltType :: SAFEARRAY -> VARENUM

resVariant :: ArgRes SAFEARRAY

defaultVariant :: SAFEARRAY

resVarList :: ArgRes [SAFEARRAY]

resVarIUnknown :: ArgRes (IUnknown SAFEARRAY)

resVarIDispatch :: ArgRes (IDispatch SAFEARRAY)

Variant a => Variant [a]

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn [a]

inVarList :: ArgIn [[a]]

inVarIUnknown :: ArgIn (IUnknown [a])

vtEltType :: [a] -> VARENUM

resVariant :: ArgRes [a]

defaultVariant :: [a]

resVarList :: ArgRes [[a]]

resVarIUnknown :: ArgRes (IUnknown [a])

resVarIDispatch :: ArgRes (IDispatch [a])

Variant a => Variant (Maybe a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (Maybe a)

inVarList :: ArgIn [Maybe a]

inVarIUnknown :: ArgIn (IUnknown (Maybe a))

vtEltType :: Maybe a -> VARENUM

resVariant :: ArgRes (Maybe a)

defaultVariant :: Maybe a

resVarList :: ArgRes [Maybe a]

resVarIUnknown :: ArgRes (IUnknown (Maybe a))

resVarIDispatch :: ArgRes (IDispatch (Maybe a))

Variant (Ptr a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (Ptr a)

inVarList :: ArgIn [Ptr a]

inVarIUnknown :: ArgIn (IUnknown (Ptr a))

vtEltType :: Ptr a -> VARENUM

resVariant :: ArgRes (Ptr a)

defaultVariant :: Ptr a

resVarList :: ArgRes [Ptr a]

resVarIUnknown :: ArgRes (IUnknown (Ptr a))

resVarIDispatch :: ArgRes (IDispatch (Ptr a))

Variant a => Variant (IUnknown_ a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (IUnknown_ a)

inVarList :: ArgIn [IUnknown_ a]

inVarIUnknown :: ArgIn (IUnknown (IUnknown_ a))

vtEltType :: IUnknown_ a -> VARENUM

resVariant :: ArgRes (IUnknown_ a)

defaultVariant :: IUnknown_ a

resVarList :: ArgRes [IUnknown_ a]

resVarIUnknown :: ArgRes (IUnknown (IUnknown_ a))

resVarIDispatch :: ArgRes (IDispatch (IUnknown_ a))

Variant (IDispatch_ a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (IDispatch_ a)

inVarList :: ArgIn [IDispatch_ a]

inVarIUnknown :: ArgIn (IUnknown (IDispatch_ a))

vtEltType :: IDispatch_ a -> VARENUM

resVariant :: ArgRes (IDispatch_ a)

defaultVariant :: IDispatch_ a

resVarList :: ArgRes [IDispatch_ a]

resVarIUnknown :: ArgRes (IUnknown (IDispatch_ a))

resVarIDispatch :: ArgRes (IDispatch (IDispatch_ a))

Variant a => Variant (SafeArray a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (SafeArray a)

inVarList :: ArgIn [SafeArray a]

inVarIUnknown :: ArgIn (IUnknown (SafeArray a))

vtEltType :: SafeArray a -> VARENUM

resVariant :: ArgRes (SafeArray a)

defaultVariant :: SafeArray a

resVarList :: ArgRes [SafeArray a]

resVarIUnknown :: ArgRes (IUnknown (SafeArray a))

resVarIDispatch :: ArgRes (IDispatch (SafeArray a))

inoutVariant :: (Variant a, Variant b) => ArgInOut a b

outVariant :: Variant a => ArgOut a

defaultEmpty :: ()

inEmpty :: ArgIn ()

resEmpty :: ArgRes ()

inoutEmpty :: () -> (VarIn, ArgRes ())

outEmpty :: (VarIn, ArgRes ())

inNoArg :: ArgIn ()

defaultInt :: Int

inInt :: ArgIn Int

resInt :: ArgRes Int

inoutInt :: Int -> (VarIn, ArgRes Int)

outInt :: (VarIn, ArgRes Int)

defaultInt8 :: Int8

inInt8 :: ArgIn Int8

resInt8 :: ArgRes Int8

inoutInt8 :: Int8 -> (VarIn, ArgRes Int8)

outInt8 :: (VarIn, ArgRes Int8)

defaultInt16 :: Int16

inInt16 :: ArgIn Int16

resInt16 :: ArgRes Int16

inoutInt16 :: Int16 -> (VarIn, ArgRes Int16)

outInt16 :: (VarIn, ArgRes Int16)

defaultInt32 :: Int32

inInt32 :: ArgIn Int32

resInt32 :: ArgRes Int32

inoutInt32 :: Int32 -> (VarIn, ArgRes Int32)

outInt32 :: (VarIn, ArgRes Int32)

defaultInt64 :: Int64

inInt64 :: ArgIn Int64

resInt64 :: ArgRes Int64

inoutInt64 :: Int64 -> (VarIn, ArgRes Int64)

outInt64 :: (VarIn, ArgRes Int64)

defaultInteger :: Int64

inInteger :: ArgIn Int64

resInteger :: ArgRes Int64

inoutInteger :: Int64 -> (VarIn, ArgRes Int64)

outInteger :: (VarIn, ArgRes Int64)

defaultHRESULT :: Int32

inHRESULT :: ArgIn Int32

resHRESULT :: ArgRes Int32

inoutHRESULT :: Int32 -> (VarIn, ArgRes Int32)

outHRESULT :: (VarIn, ArgRes Int32)

defaultWord :: Int

inWord :: ArgIn Int

resWord :: ArgRes Int

inoutWord :: Int -> (VarIn, ArgRes Int)

outWord :: (VarIn, ArgRes Int)

defaultWord8 :: Word8

inWord8 :: ArgIn Word8

resWord8 :: ArgRes Word8

inoutWord8 :: Word8 -> (VarIn, ArgRes Word8)

outWord8 :: (VarIn, ArgRes Word8)

defaultWord16 :: Word16

inWord16 :: ArgIn Word16

resWord16 :: ArgRes Word16

inoutWord16 :: Word16 -> (VarIn, ArgRes Word16)

outWord16 :: (VarIn, ArgRes Word16)

defaultWord32 :: Word32

inWord32 :: ArgIn Word32

resWord32 :: ArgRes Word32

inoutWord32 :: Word32 -> (VarIn, ArgRes Word32)

outWord32 :: (VarIn, ArgRes Word32)

defaultWord64 :: Word64

inWord64 :: ArgIn Word64

resWord64 :: ArgRes Word64

inoutWord64 :: Word64 -> (VarIn, ArgRes Word64)

outWord64 :: (VarIn, ArgRes Word64)

defaultBool :: Bool

inBool :: ArgIn Bool

resBool :: ArgRes Bool

inoutBool :: Bool -> (VarIn, ArgRes Bool)

outBool :: (VarIn, ArgRes Bool)

defaultByte :: Byte

inByte :: ArgIn Byte

resByte :: ArgRes Byte

inoutByte :: Byte -> (VarIn, ArgRes Byte)

outByte :: (VarIn, ArgRes Byte)

defaultChar :: Char

inChar :: ArgIn Char

resChar :: ArgRes Char

inoutChar :: Char -> (VarIn, ArgRes Char)

outChar :: (VarIn, ArgRes Char)

defaultFloat :: Float

inFloat :: ArgIn Float

resFloat :: ArgRes Float

inoutFloat :: Float -> (VarIn, ArgRes Float)

outFloat :: (VarIn, ArgRes Float)

defaultDouble :: Double

inDouble :: ArgIn Double

resDouble :: ArgRes Double

inoutDouble :: Double -> (VarIn, ArgRes Double)

outDouble :: (VarIn, ArgRes Double)

defaultString :: String

inString :: ArgIn String

resString :: ArgRes String

inoutString :: String -> (VarIn, ArgRes String)

outString :: (VarIn, ArgRes String)

defaultIUnknown :: IUnknown a

inIUnknown :: ArgIn (IUnknown a)

resIUnknown :: ArgRes (IUnknown a)

inoutIUnknown :: IUnknown a1 -> (VarIn, ArgRes (IUnknown a2))

outIUnknown :: (VarIn, ArgRes (IUnknown a))

defaultIDispatch :: IDispatch a

inIDispatch :: ArgIn (IDispatch a)

resIDispatch :: ArgRes (IDispatch a)

inoutIDispatch :: IDispatch a1 -> (VarIn, ArgRes (IDispatch a2))

outIDispatch :: (VarIn, ArgRes (IDispatch a))

defaultDate :: Date

inDate :: ArgIn Date

resDate :: ArgRes Date

inoutDate :: Date -> (VarIn, ArgRes Date)

outDate :: (VarIn, ArgRes Date)

type Date = Double

defaultError :: Int32

inError :: ArgIn Int32

resError :: ArgRes Int32

inoutError :: Int32 -> (VarIn, ArgRes Int32)

outError :: (VarIn, ArgRes Int32)

defaultMaybe :: Variant a => Maybe a

inMaybe :: Variant a => ArgIn (Maybe a)

resMaybe :: Variant a => ArgRes (Maybe a)

inoutMaybe :: Variant a => ArgInOut (Maybe a) (Maybe a)

outMaybe :: Variant a => (VarIn, ArgRes (Maybe a))

inOptional :: VarIn -> ArgIn a -> ArgIn (Maybe a)

defaultCurrency :: Currency

inCurrency :: ArgIn Currency

resCurrency :: ArgRes Currency

inoutCurrency :: Currency -> (VarIn, ArgRes Currency)

outCurrency :: (VarIn, ArgRes Currency)

type Currency = Int64

defaultSafeArray :: Variant a => SafeArray a

inSafeArray :: Variant a => ArgIn (SafeArray a)

resSafeArray :: Variant a => ArgRes (SafeArray a)

inoutSafeArray :: Variant a => ArgInOut (SafeArray a) (SafeArray a)

outSafeArray :: Variant a => ArgOut (SafeArray a)

data SafeArray a

Instances

Variant a => Variant (SafeArray a)

Defined in System.Win32.Com.Automation

Methods

inVariant :: ArgIn (SafeArray a)

inVarList :: ArgIn [SafeArray a]

inVarIUnknown :: ArgIn (IUnknown (SafeArray a))

vtEltType :: SafeArray a -> VARENUM

resVariant :: ArgRes (SafeArray a)

defaultVariant :: SafeArray a

resVarList :: ArgRes [SafeArray a]

resVarIUnknown :: ArgRes (IUnknown (SafeArray a))

resVarIDispatch :: ArgRes (IDispatch (SafeArray a))

mkSafeArray :: Variant a => SAFEARRAY -> SafeArray a

defaultEnum :: Enum a => a

inEnum :: Enum a => ArgIn a

resEnum :: Enum a => ArgRes a

inoutEnum :: Enum a => ArgInOut a a

outEnum :: Enum a => ArgOut a

vtTypeEnum :: Enum a => a -> VARENUM

inHaskellValue :: ArgIn a

unsafeResHaskellValue :: ArgRes a

unsafeOutHaskellValue :: (Ptr (StablePtr a1) -> IO (), ArgRes a2)

defaultSqlNull :: SqlNull

inSqlNull :: ArgIn SqlNull

resSqlNull :: ArgRes SqlNull

inoutSqlNull :: SqlNull -> (VarIn, ArgRes SqlNull)

outSqlNull :: (VarIn, ArgRes SqlNull)

data SqlNull

Constructors

SqlNull

inGUID :: ArgIn GUID

outGUID :: (VarIn, ArgRes GUID)

inDefaultValue :: VarIn -> ArgIn a -> ArgIn a

noInArg :: VarIn

propertyGet :: Member -> [VarIn] -> ArgOut a -> IDispatch d -> IO a

propertySet :: Member -> [VarIn] -> IDispatch d -> IO ()

propertySetGet :: Member -> [VarIn] -> ArgOut a -> IDispatch d -> IO a

propertyGet2 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch d -> IO (a1, a2)

propertyGet3 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch d -> IO (a1, a2, a3)

propertyGet4 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch d -> IO (a1, a2, a3, a4)

propertyGetID :: DISPID -> [VarIn] -> ArgOut a -> IDispatch d -> IO a

propertySetID :: DISPID -> [VarIn] -> IDispatch d -> IO ()

propertySetGetID :: DISPID -> [VarIn] -> ArgOut a -> IDispatch d -> IO a

propertyGet2ID :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch d -> IO (a1, a2)

propertyGet3ID :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch d -> IO (a1, a2, a3)

propertyGet4ID :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch d -> IO (a1, a2, a3, a4)

function1 :: Member -> [VarIn] -> ArgOut a1 -> IDispatch i -> IO a1

function2 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch i -> IO (a1, a2)

function3 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch i -> IO (a1, a2, a3)

function4 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch i -> IO (a1, a2, a3, a4)

function5 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> IDispatch i -> IO (a1, a2, a3, a4, a5)

function6 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6)

functionID1 :: DISPID -> [VarIn] -> ArgOut a1 -> IDispatch i -> IO a1

functionID2 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch i -> IO (a1, a2)

functionID3 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch i -> IO (a1, a2, a3)

functionID4 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch i -> IO (a1, a2, a3, a4)

functionID5 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> IDispatch i -> IO (a1, a2, a3, a4, a5)

functionID6 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6)

method0 :: Member -> [VarIn] -> IDispatch i -> IO ()

method1 :: Member -> [VarIn] -> ArgOut a1 -> IDispatch i -> IO a1

method2 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch i -> IO (a1, a2)

method3 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch i -> IO (a1, a2, a3)

method4 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch i -> IO (a1, a2, a3, a4)

method5 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> IDispatch i -> IO (a1, a2, a3, a4, a5)

method6 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6)

method7 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> ArgOut a7 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6, a7)

method8 :: Member -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> ArgOut a7 -> ArgOut a8 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6, a7, a8)

methodID0 :: DISPID -> [VarIn] -> IDispatch i -> IO ()

methodID1 :: DISPID -> [VarIn] -> ArgOut a1 -> IDispatch i -> IO a1

methodID2 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> IDispatch i -> IO (a1, a2)

methodID3 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> IDispatch i -> IO (a1, a2, a3)

methodID4 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> IDispatch i -> IO (a1, a2, a3, a4)

methodID5 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> IDispatch i -> IO (a1, a2, a3, a4, a5)

methodID6 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6)

methodID7 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> ArgOut a7 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6, a7)

methodID8 :: DISPID -> [VarIn] -> ArgOut a1 -> ArgOut a2 -> ArgOut a3 -> ArgOut a4 -> ArgOut a5 -> ArgOut a6 -> ArgOut a7 -> ArgOut a8 -> IDispatch i -> IO (a1, a2, a3, a4, a5, a6, a7, a8)

unmarshallVariants0 :: VARIANT -> IO ()

unmarshallVariants1 :: ArgRes a -> VARIANT -> IO a

unmarshallVariants2 :: ArgRes a -> ArgRes b -> VARIANT -> IO (a, b)

unmarshallVariants3 :: ArgRes a -> ArgRes b -> ArgRes c -> VARIANT -> IO (a, b, c)

unmarshallVariants4 :: ArgRes a -> ArgRes b -> ArgRes c -> ArgRes d -> VARIANT -> IO (a, b, c, d)

unmarshallVariants5 :: ArgRes a -> ArgRes b -> ArgRes c -> ArgRes d -> ArgRes e -> VARIANT -> IO (a, b, c, d, e)

unmarshallVariants6 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6)

unmarshallVariants7 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> ArgRes a7 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6, a7)

unmarshallVariants8 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> ArgRes a7 -> ArgRes a8 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6, a7, a8)

readVariants0 :: VARIANT -> IO ()

readVariants1 :: ArgRes a -> VARIANT -> IO a

readVariants2 :: ArgRes a -> ArgRes b -> VARIANT -> IO (a, b)

readVariants3 :: ArgRes a -> ArgRes b -> ArgRes c -> VARIANT -> IO (a, b, c)

readVariants4 :: ArgRes a -> ArgRes b -> ArgRes c -> ArgRes d -> VARIANT -> IO (a, b, c, d)

readVariants5 :: ArgRes a -> ArgRes b -> ArgRes c -> ArgRes d -> ArgRes e -> VARIANT -> IO (a, b, c, d, e)

readVariants6 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6)

readVariants7 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> ArgRes a7 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6, a7)

readVariants8 :: ArgRes a1 -> ArgRes a2 -> ArgRes a3 -> ArgRes a4 -> ArgRes a5 -> ArgRes a6 -> ArgRes a7 -> ArgRes a8 -> VARIANT -> IO (a1, a2, a3, a4, a5, a6, a7, a8)

method_0_0 :: Member -> IDispatch i -> IO ()

method_1_0 :: Variant a => Member -> a -> IDispatch i -> IO ()

method_2_0 :: (Variant a1, Variant a2) => Member -> a1 -> a2 -> IDispatch i -> IO ()

method_3_0 :: (Variant a1, Variant a2, Variant a3) => Member -> a1 -> a2 -> a3 -> IDispatch i -> IO ()

method_4_0 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch i -> IO ()

method_0_1 :: Variant a1 => Member -> IDispatch i -> IO a1

method_1_1 :: (Variant a, Variant a1) => Member -> a -> IDispatch i -> IO a1

method_2_1 :: (Variant a1, Variant a2, Variant a3) => Member -> a1 -> a2 -> IDispatch i -> IO a3

method_3_1 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> a3 -> IDispatch i -> IO a4

method_4_1 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch i -> IO a5

method_0_2 :: (Variant a1, Variant a2) => Member -> IDispatch i -> IO (a1, a2)

method_1_2 :: (Variant a, Variant a1, Variant a2) => Member -> a -> IDispatch i -> IO (a1, a2)

method_2_2 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> IDispatch i -> IO (a3, a4)

method_3_2 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5) => Member -> a1 -> a2 -> a3 -> IDispatch i -> IO (a4, a5)

method_4_2 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5, Variant a6) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch i -> IO (a5, a6)

function_0_1 :: Variant a1 => Member -> IDispatch i -> IO a1

function_1_1 :: (Variant a, Variant a1) => Member -> a -> IDispatch i -> IO a1

function_2_1 :: (Variant a1, Variant a2, Variant a3) => Member -> a1 -> a2 -> IDispatch i -> IO a3

function_3_1 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> a3 -> IDispatch i -> IO a4

function_4_1 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch i -> IO a5

function_0_2 :: (Variant a1, Variant a2) => Member -> IDispatch i -> IO (a1, a2)

function_1_2 :: (Variant a, Variant a1, Variant a2) => Member -> a -> IDispatch i -> IO (a1, a2)

function_2_2 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> IDispatch i -> IO (a3, a4)

function_3_2 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5) => Member -> a1 -> a2 -> a3 -> IDispatch i -> IO (a4, a5)

function_4_2 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5, Variant a6) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch i -> IO (a5, a6)

propertyGet_0 :: Variant a => Member -> IDispatch d -> IO a

propertyGet_1 :: (Variant a1, Variant a2) => Member -> a1 -> IDispatch d -> IO a2

propertyGet_2 :: (Variant a1, Variant a2, Variant a3) => Member -> a1 -> a2 -> IDispatch d -> IO a3

propertyGet_3 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> a3 -> IDispatch d -> IO a4

propertyGet_4 :: (Variant a1, Variant a2, Variant a3, Variant a4, Variant a5) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch d -> IO a5

propertySet_1 :: Variant a => Member -> a -> IDispatch d -> IO ()

propertySet_2 :: (Variant a1, Variant a2) => Member -> a1 -> a2 -> IDispatch d -> IO ()

propertySet_3 :: (Variant a1, Variant a2, Variant a3) => Member -> a1 -> a2 -> a3 -> IDispatch d -> IO ()

propertySet_4 :: (Variant a1, Variant a2, Variant a3, Variant a4) => Member -> a1 -> a2 -> a3 -> a4 -> IDispatch d -> IO ()

invokePropertyGet :: DISPID -> [VarIn] -> [VarIn] -> IDispatch d -> IO VARIANT

invokePropertySet :: DISPID -> [VarIn] -> [VarIn] -> IDispatch d -> IO VARIANT

invokeMethod :: DISPID -> [VarIn] -> [VarIn] -> IDispatch d -> IO VARIANT

invokeFunction :: DISPID -> [VarIn] -> [VarIn] -> IDispatch d -> IO VARIANT

enumVariants :: Variant a => IDispatch b -> IO (Int, [a])

marshallCurrency :: Int64 -> IO Int64

unmarshallCurrency :: Int64 -> IO Int64

readCurrency :: Ptr Int64 -> IO Int64

writeCurrency :: Ptr Int64 -> Int64 -> IO ()

sizeofCurrency :: Word32

data VARENUM

Constructors

VT_EMPTY

VT_NULL

VT_I2

VT_I4

VT_R4

VT_R8

VT_CY

VT_DATE

VT_BSTR

VT_DISPATCH

VT_ERROR

VT_BOOL

VT_VARIANT

VT_UNKNOWN

VT_DECIMAL

VT_I1

VT_UI1

VT_UI2

VT_UI4

VT_I8

VT_UI8

VT_INT

VT_UINT

VT_VOID

VT_HRESULT

VT_PTR

VT_SAFEARRAY

VT_CARRAY

VT_USERDEFINED

VT_LPSTR

VT_LPWSTR

VT_FILETIME

VT_BLOB

VT_STREAM

VT_STORAGE

VT_STREAMED_OBJECT

VT_STORED_OBJECT

VT_BLOB_OBJECT

VT_CF

VT_CLSID

VT_BSTR_BLOB

VT_VECTOR

VT_ARRAY

VT_BYREF

VT_RESERVED

VT_ILLEGAL

VT_ILLEGALMASKED

VT_TYPEMASK

Instances

Enum VARENUM

Defined in System.Win32.Com.Automation

Methods

succ :: VARENUM -> VARENUM

pred :: VARENUM -> VARENUM

toEnum :: Int -> VARENUM

fromEnum :: VARENUM -> Int

enumFrom :: VARENUM -> [VARENUM]

enumFromThen :: VARENUM -> VARENUM -> [VARENUM]

enumFromTo :: VARENUM -> VARENUM -> [VARENUM]

enumFromThenTo :: VARENUM -> VARENUM -> VARENUM -> [VARENUM]

Eq VARENUM

Defined in System.Win32.Com.Automation

Methods

(==) :: VARENUM -> VARENUM -> Bool

(/=) :: VARENUM -> VARENUM -> Bool

Show VARENUM

Defined in System.Win32.Com.Automation

Methods

showsPrec :: Int -> VARENUM -> ShowS

show :: VARENUM -> String

showList :: [VARENUM] -> ShowS

marshallVARENUM :: VARENUM -> IO Int16

unmarshallVARENUM :: Int16 -> IO VARENUM

readVARENUM :: Ptr Int16 -> IO VARENUM

writeVARENUM :: Ptr Int16 -> VARENUM -> IO ()

sizeofVARENUM :: Word32

sizeofVARIANT_BOOL :: Word32

marshallVARIANT_BOOL :: Bool -> IO Int16

unmarshallVARIANT_BOOL :: Int16 -> IO Bool

readVARIANT_BOOL :: Ptr Int16 -> IO Bool

writeVARIANT_BOOL :: Ptr Int16 -> Bool -> IO ()

vARIANT_TRUE :: Int

vARIANT_FALSE :: Int

marshallVariant :: Variant a => a -> IO VARIANT

unmarshallVariant :: Variant a => VARIANT -> IO a

readVariant :: Variant a => VARIANT -> IO a

writeVariant :: Variant a => VARIANT -> a -> IO ()

readVarEnum :: VARIANT -> IO VARENUM

readVarInt :: VARIANT -> IO Int32

readVarFloat :: VARIANT -> IO Float

readVarDouble :: VARIANT -> IO Double

readVarString :: VARIANT -> IO (Ptr (Ptr Char), Ptr VARIANT)

readVarBool :: VARIANT -> IO Bool

marshallSafeArray :: SafeArray a -> IO (ForeignPtr SAFEARRAY)

unmarshallSafeArray :: Ptr a -> IO (SafeArray a)

writeSafeArray :: Ptr (SafeArray a) -> SafeArray a -> IO ()

readSafeArray :: Variant a => Bool -> Ptr (SafeArray a) -> IO (SafeArray a)

freeSafeArray :: SafeArray a -> IO ()

readSA :: Bool -> Ptr (SafeArray a) -> VARENUM -> IO SAFEARRAY

systemTimeToDate :: SystemTime -> IO Date