hdirect-0.21.0: comlib/SafeArray.hs

{-# OPTIONS -#include <windows.h> #-}
{-# OPTIONS -#include "SafeArrayPrim.h" #-}
-- Automatically generated by HaskellDirect (ihc.exe), version 0.20
-- Created: 20:11 Pacific Standard Time, Tuesday 16 December, 2003
-- Command line: -fno-qualified-names -fhs-to-c -fno-export-lists --gen-headers -fout-pointers-are-not-refs --gen-headers -c SafeArray.idl -o SafeArray.hs

module SafeArray where

import Prelude
import Com (checkHR)
import Foreign.ForeignPtr (ForeignPtr, withForeignPtr)
import Foreign.Ptr (Ptr, FunPtr, castPtr)
import HDirect (nullFinaliser, writefptr, readPtr, sizeofPtr, 
                writeWord32, writeInt32, addNCastPtr, readWord32, readInt32, 
                allocBytes, free, doThenFree, sizeofForeignPtr, marshalllist, 
                trivialFree, freeref, sizeofInt32, marshallref)
import IOExts (unsafePerformIO)
import Int (Int32)
import Pointer (makeFO)
import StdTypes (VARTYPE)
import Word (Word32, Word16)

{- BEGIN_C_CODE
#if defined(__MINGW32__) || defined(__CYGWIN32__)
END_C_CODE-}
{- BEGIN_C_CODE
#include <w32api.h>
END_C_CODE-}
{- BEGIN_C_CODE
#endif
END_C_CODE-}
{- BEGIN_C_CODE
#if !defined(_MSC_VER) && __W32API_MAJOR_VERSION == 1
END_C_CODE-}
-- --------------------------------------------------
-- 
-- interface SAFEARRAY
-- 
-- --------------------------------------------------
newtype SAFEARRAY
 = SAFEARRAY (ForeignPtr SAFEARRAY)
 
foreign label "primSafeArrayDestroy" addrOf_SAFEARRAY_primSafeArrayDestroy :: FunPtr (Ptr SAFEARRAY -> IO ())
marshallSAFEARRAY :: SAFEARRAY
                  -> IO (ForeignPtr SAFEARRAY)
marshallSAFEARRAY (SAFEARRAY v) = return (v)

unmarshallSAFEARRAY :: Bool
                    -> Ptr SAFEARRAY
                    -> IO SAFEARRAY
unmarshallSAFEARRAY finaliseMe__ v =
  do
    v <- makeFO v (case finaliseMe__ of
                      False -> nullFinaliser
                      True -> addrOf_SAFEARRAY_primSafeArrayDestroy)
    return (SAFEARRAY v)

writeSAFEARRAY :: Ptr (Ptr SAFEARRAY)
               -> SAFEARRAY
               -> IO ()
writeSAFEARRAY ptr (SAFEARRAY v) =
  writefptr ptr
            v

readSAFEARRAY :: Bool
              -> Ptr SAFEARRAY
              -> IO SAFEARRAY
readSAFEARRAY finaliseMe__ ptr =
  do
    v <- readPtr ptr
    v <- makeFO v (case finaliseMe__ of
                      False -> nullFinaliser
                      True -> addrOf_SAFEARRAY_primSafeArrayDestroy)
    return (SAFEARRAY v)

sizeofSAFEARRAY :: Word32
sizeofSAFEARRAY = sizeofPtr

addrToSAFEARRAY :: Ptr a
                -> SAFEARRAY
addrToSAFEARRAY v =
  unsafePerformIO (makeFO (castPtr v) addrOf_SAFEARRAY_primSafeArrayDestroy >>= \ v ->
                   return (SAFEARRAY v))

data SAFEARRAYBOUND = TagSAFEARRAYBOUND {cElements :: Word32,
                                         lLbound :: Int32}
                        
writeSAFEARRAYBOUND :: Ptr SAFEARRAYBOUND
                    -> SAFEARRAYBOUND
                    -> IO ()
writeSAFEARRAYBOUND ptr (TagSAFEARRAYBOUND cElements lLbound) =
  let
   pf0 = ptr
   pf1 = addNCastPtr pf0 0
  in
  do
    writeWord32 pf1 cElements
    let pf2 = addNCastPtr pf1 4
    writeInt32 pf2 lLbound

readSAFEARRAYBOUND :: Ptr SAFEARRAYBOUND
                   -> IO SAFEARRAYBOUND
readSAFEARRAYBOUND ptr =
  let
   pf0 = ptr
   pf1 = addNCastPtr pf0 0
  in
  do
    cElements <- readWord32 pf1
    let pf2 = addNCastPtr pf1 4
    lLbound <- readInt32 pf2
    return (TagSAFEARRAYBOUND cElements lLbound)

sizeofSAFEARRAYBOUND :: Word32
sizeofSAFEARRAYBOUND = 8

safeArrayAccessData :: SAFEARRAY
                    -> IO (Ptr ())
safeArrayAccessData psa =
  do
    ppvData <- allocBytes (fromIntegral sizeofPtr)
    psa <- marshallSAFEARRAY psa
    o_safeArrayAccessData <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayAccessData psa ppvData)
    checkHR o_safeArrayAccessData
    doThenFree free readPtr ppvData

foreign import stdcall "SafeArrayAccessData" prim_SafeArray_safeArrayAccessData :: Ptr SAFEARRAY -> Ptr (Ptr ()) -> IO Int32
safeArrayAllocData :: SAFEARRAY
                   -> IO ()
safeArrayAllocData psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayAllocData <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayAllocData psa)
    checkHR o_safeArrayAllocData

foreign import stdcall "SafeArrayAllocData" prim_SafeArray_safeArrayAllocData :: Ptr SAFEARRAY -> IO Int32
safeArrayAllocDescriptor :: Word32
                         -> IO SAFEARRAY
safeArrayAllocDescriptor cDims =
  do
    ppsaOut <- allocBytes (fromIntegral sizeofForeignPtr)
    o_safeArrayAllocDescriptor <- prim_SafeArray_safeArrayAllocDescriptor cDims ppsaOut
    checkHR o_safeArrayAllocDescriptor
    doThenFree free (readSAFEARRAY True) ppsaOut

foreign import stdcall "SafeArrayAllocDescriptor" prim_SafeArray_safeArrayAllocDescriptor :: Word32 -> Ptr (Ptr SAFEARRAY) -> IO Int32
safeArrayCopy :: SAFEARRAY
              -> IO SAFEARRAY
safeArrayCopy psa =
  do
    ppsaOut <- allocBytes (fromIntegral sizeofForeignPtr)
    psa <- marshallSAFEARRAY psa
    o_safeArrayCopy <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayCopy psa ppsaOut)
    checkHR o_safeArrayCopy
    doThenFree free (readSAFEARRAY True) ppsaOut

foreign import stdcall "SafeArrayCopy" prim_SafeArray_safeArrayCopy :: Ptr SAFEARRAY -> Ptr (Ptr SAFEARRAY) -> IO Int32
safeArrayCreate :: VARTYPE
                -> [SAFEARRAYBOUND]
                -> IO SAFEARRAY
safeArrayCreate vt rgsabound =
  let
   cDims = (fromIntegral (length rgsabound) :: Word32)
  in
  do
    rgsabound <- marshalllist sizeofSAFEARRAYBOUND writeSAFEARRAYBOUND rgsabound
    o_safeArrayCreate <- prim_SafeArray_safeArrayCreate vt cDims rgsabound
    freeref trivialFree rgsabound
    unmarshallSAFEARRAY True o_safeArrayCreate

foreign import stdcall "SafeArrayCreate" prim_SafeArray_safeArrayCreate :: Word16 -> Word32 -> Ptr SAFEARRAYBOUND -> IO (Ptr SAFEARRAY)
safeArrayDestroy :: SAFEARRAY
                 -> IO ()
safeArrayDestroy psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayDestroy <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayDestroy psa)
    checkHR o_safeArrayDestroy

foreign import stdcall "SafeArrayDestroy" prim_SafeArray_safeArrayDestroy :: Ptr SAFEARRAY -> IO Int32
safeArrayDestroyData :: SAFEARRAY
                     -> IO ()
safeArrayDestroyData psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayDestroyData <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayDestroyData psa)
    checkHR o_safeArrayDestroyData

foreign import stdcall "SafeArrayDestroyData" prim_SafeArray_safeArrayDestroyData :: Ptr SAFEARRAY -> IO Int32
safeArrayDestroyDescriptor :: SAFEARRAY
                           -> IO ()
safeArrayDestroyDescriptor psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayDestroyDescriptor <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayDestroyDescriptor psa)
    checkHR o_safeArrayDestroyDescriptor

foreign import stdcall "SafeArrayDestroyDescriptor" prim_SafeArray_safeArrayDestroyDescriptor :: Ptr SAFEARRAY -> IO Int32
safeArrayGetDim :: SAFEARRAY
                -> IO Word32
safeArrayGetDim psa =
  do
    psa <- marshallSAFEARRAY psa
    withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayGetDim psa)

foreign import stdcall "SafeArrayGetDim" prim_SafeArray_safeArrayGetDim :: Ptr SAFEARRAY -> IO Word32
safeArrayGetElement :: SAFEARRAY
                    -> Ptr Int32
                    -> Ptr ()
                    -> IO ()
safeArrayGetElement psa rgIndices pv =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayGetElement <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayGetElement psa rgIndices pv)
    checkHR o_safeArrayGetElement

foreign import stdcall "SafeArrayGetElement" prim_SafeArray_safeArrayGetElement :: Ptr SAFEARRAY -> Ptr Int32 -> Ptr () -> IO Int32
safeArrayGetElemsize :: SAFEARRAY
                     -> IO Word32
safeArrayGetElemsize psa =
  do
    psa <- marshallSAFEARRAY psa
    withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayGetElemsize psa)

foreign import stdcall "SafeArrayGetElemsize" prim_SafeArray_safeArrayGetElemsize :: Ptr SAFEARRAY -> IO Word32
safeArrayGetLBound :: SAFEARRAY
                   -> Word32
                   -> IO Int32
safeArrayGetLBound psa nDim =
  do
    plLbound <- allocBytes (fromIntegral sizeofInt32)
    psa <- marshallSAFEARRAY psa
    o_safeArrayGetLBound <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayGetLBound psa nDim plLbound)
    checkHR o_safeArrayGetLBound
    doThenFree free readInt32 plLbound

foreign import stdcall "SafeArrayGetLBound" prim_SafeArray_safeArrayGetLBound :: Ptr SAFEARRAY -> Word32 -> Ptr Int32 -> IO Int32
safeArrayGetUBound :: SAFEARRAY
                   -> Word32
                   -> IO Int32
safeArrayGetUBound psa nDim =
  do
    plLbound <- allocBytes (fromIntegral sizeofInt32)
    psa <- marshallSAFEARRAY psa
    o_safeArrayGetUBound <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayGetUBound psa nDim plLbound)
    checkHR o_safeArrayGetUBound
    doThenFree free readInt32 plLbound

foreign import stdcall "SafeArrayGetUBound" prim_SafeArray_safeArrayGetUBound :: Ptr SAFEARRAY -> Word32 -> Ptr Int32 -> IO Int32
safeArrayLock :: SAFEARRAY
              -> IO ()
safeArrayLock psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayLock <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayLock psa)
    checkHR o_safeArrayLock

foreign import stdcall "SafeArrayLock" prim_SafeArray_safeArrayLock :: Ptr SAFEARRAY -> IO Int32
safeArrayPtrOfIndex :: SAFEARRAY
                    -> Ptr Int32
                    -> IO (Ptr ())
safeArrayPtrOfIndex psa rgIndices =
  do
    ppvData <- allocBytes (fromIntegral sizeofPtr)
    psa <- marshallSAFEARRAY psa
    o_safeArrayPtrOfIndex <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayPtrOfIndex psa rgIndices ppvData)
    checkHR o_safeArrayPtrOfIndex
    doThenFree free readPtr ppvData

foreign import stdcall "SafeArrayPtrOfIndex" prim_SafeArray_safeArrayPtrOfIndex :: Ptr SAFEARRAY -> Ptr Int32 -> Ptr (Ptr ()) -> IO Int32
safeArrayPutElement :: SAFEARRAY
                    -> Ptr Int32
                    -> Ptr ()
                    -> IO ()
safeArrayPutElement psa rgIndices pv =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayPutElement <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayPutElement psa rgIndices pv)
    checkHR o_safeArrayPutElement

foreign import stdcall "SafeArrayPutElement" prim_SafeArray_safeArrayPutElement :: Ptr SAFEARRAY -> Ptr Int32 -> Ptr () -> IO Int32
safeArrayRedim :: SAFEARRAY
               -> SAFEARRAYBOUND
               -> IO ()
safeArrayRedim psa psaboundNew =
  do
    psa <- marshallSAFEARRAY psa
    psaboundNew <- marshallref (allocBytes (fromIntegral sizeofSAFEARRAYBOUND)) writeSAFEARRAYBOUND psaboundNew
    o_safeArrayRedim <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayRedim psa psaboundNew)
    free psaboundNew
    checkHR o_safeArrayRedim

foreign import stdcall "SafeArrayRedim" prim_SafeArray_safeArrayRedim :: Ptr SAFEARRAY -> Ptr SAFEARRAYBOUND -> IO Int32
safeArrayUnaccessData :: SAFEARRAY
                      -> IO ()
safeArrayUnaccessData psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayUnaccessData <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayUnaccessData psa)
    checkHR o_safeArrayUnaccessData

foreign import stdcall "SafeArrayUnaccessData" prim_SafeArray_safeArrayUnaccessData :: Ptr SAFEARRAY -> IO Int32
safeArrayUnlock :: SAFEARRAY
                -> IO ()
safeArrayUnlock psa =
  do
    psa <- marshallSAFEARRAY psa
    o_safeArrayUnlock <- withForeignPtr psa (\ psa -> prim_SafeArray_safeArrayUnlock psa)
    checkHR o_safeArrayUnlock

foreign import stdcall "SafeArrayUnlock" prim_SafeArray_safeArrayUnlock :: Ptr SAFEARRAY -> IO Int32
{- BEGIN_C_CODE
#endif
END_C_CODE-}