Glx.hs

module Graphics.XHB.Gen.Glx
       (extension, render, renderLarge, createContext, destroyContext,
        makeCurrent, isDirect, queryVersion, waitGL, waitX, copyContext,
        swapBuffers, useXFont, createGLXPixmap, getVisualConfigs,
        destroyGLXPixmap, vendorPrivate, vendorPrivateWithReply,
        queryExtensionsString, queryServerString, clientInfo, getFBConfigs,
        createPixmap, destroyPixmap, createNewContext, queryContext,
        makeContextCurrent, createPbuffer, destroyPbuffer,
        getDrawableAttributes, changeDrawableAttributes, createWindow,
        deleteWindow, newList, endList, deleteLists, genLists,
        feedbackBuffer, selectBuffer, renderMode, finish, pixelStoref,
        pixelStorei, readPixels, getBooleanv, getClipPlane, getDoublev,
        getError, getFloatv, getIntegerv, getLightfv, getLightiv, getMapdv,
        getMapfv, getMapiv, getMaterialfv, getMaterialiv, getPixelMapfv,
        getPixelMapuiv, getPixelMapusv, getPolygonStipple, getString,
        getTexEnvfv, getTexEnviv, getTexGendv, getTexGenfv, getTexGeniv,
        getTexImage, getTexParameterfv, getTexParameteriv,
        getTexLevelParameterfv, getTexLevelParameteriv, isList, flush,
        areTexturesResident, deleteTextures, genTextures, isTexture,
        getColorTable, getColorTableParameterfv, getColorTableParameteriv,
        getConvolutionFilter, getConvolutionParameterfv,
        getConvolutionParameteriv, getSeparableFilter, getHistogram,
        getHistogramParameterfv, getHistogramParameteriv, getMinmax,
        getMinmaxParameterfv, getMinmaxParameteriv,
        getCompressedTexImageARB, deleteQueriesARB, genQueriesARB,
        isQueryARB, getQueryivARB, getQueryObjectivARB,
        getQueryObjectuivARB, module Graphics.XHB.Gen.Glx.Types)
       where
import Graphics.XHB.Gen.Glx.Types
import Graphics.XHB.Connection.Internal
import Graphics.XHB.Connection.Extension
import Graphics.XHB.Connection.Types
import Control.Concurrent.STM
import Foreign.C.Types
import Data.Binary.Put (runPut)
import Graphics.XHB.Shared hiding (Event(..), Error(..))
import Graphics.XHB.Gen.Xproto.Types
       hiding (PIXMAP(..), WINDOW(..), DRAWABLE(..), GC(..),
               CreatePixmap(..), CreateWindow(..), deserializeError,
               deserializeEvent)
import qualified Graphics.XHB.Gen.Xproto.Types
 
extension :: ExtensionId
extension = "GLX"
 
render ::
         Graphics.XHB.Connection.Types.Connection ->
           CONTEXT_TAG -> [BYTE] -> IO ()
render c context_tag data_
  = do let req = MkRender context_tag data_
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
renderLarge ::
              Graphics.XHB.Connection.Types.Connection -> RenderLarge -> IO ()
renderLarge c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
createContext ::
                Graphics.XHB.Connection.Types.Connection -> CreateContext -> IO ()
createContext c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
destroyContext ::
                 Graphics.XHB.Connection.Types.Connection ->
                   Graphics.XHB.Gen.Glx.Types.CONTEXT -> IO ()
destroyContext c context
  = do let req = MkDestroyContext context
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
makeCurrent ::
              Graphics.XHB.Connection.Types.Connection ->
                MakeCurrent -> IO (Receipt MakeCurrentReply)
makeCurrent c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
isDirect ::
           Graphics.XHB.Connection.Types.Connection ->
             Graphics.XHB.Gen.Glx.Types.CONTEXT -> IO (Receipt IsDirectReply)
isDirect c context
  = do receipt <- newEmptyReceiptIO
       let req = MkIsDirect context
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
queryVersion ::
               Graphics.XHB.Connection.Types.Connection ->
                 CARD32 -> CARD32 -> IO (Receipt QueryVersionReply)
queryVersion c major_version minor_version
  = do receipt <- newEmptyReceiptIO
       let req = MkQueryVersion major_version minor_version
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
waitGL ::
         Graphics.XHB.Connection.Types.Connection -> CONTEXT_TAG -> IO ()
waitGL c context_tag
  = do let req = MkWaitGL context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
waitX ::
        Graphics.XHB.Connection.Types.Connection -> CONTEXT_TAG -> IO ()
waitX c context_tag
  = do let req = MkWaitX context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
copyContext ::
              Graphics.XHB.Connection.Types.Connection -> CopyContext -> IO ()
copyContext c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
swapBuffers ::
              Graphics.XHB.Connection.Types.Connection ->
                CONTEXT_TAG -> Graphics.XHB.Gen.Glx.Types.DRAWABLE -> IO ()
swapBuffers c context_tag drawable
  = do let req = MkSwapBuffers context_tag drawable
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
useXFont ::
           Graphics.XHB.Connection.Types.Connection -> UseXFont -> IO ()
useXFont c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
createGLXPixmap ::
                  Graphics.XHB.Connection.Types.Connection ->
                    CreateGLXPixmap -> IO ()
createGLXPixmap c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
getVisualConfigs ::
                   Graphics.XHB.Connection.Types.Connection ->
                     CARD32 -> IO (Receipt GetVisualConfigsReply)
getVisualConfigs c screen
  = do receipt <- newEmptyReceiptIO
       let req = MkGetVisualConfigs screen
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
destroyGLXPixmap ::
                   Graphics.XHB.Connection.Types.Connection ->
                     Graphics.XHB.Gen.Glx.Types.PIXMAP -> IO ()
destroyGLXPixmap c glx_pixmap
  = do let req = MkDestroyGLXPixmap glx_pixmap
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
vendorPrivate ::
                Graphics.XHB.Connection.Types.Connection -> VendorPrivate -> IO ()
vendorPrivate c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
vendorPrivateWithReply ::
                         Graphics.XHB.Connection.Types.Connection ->
                           VendorPrivateWithReply -> IO (Receipt VendorPrivateWithReplyReply)
vendorPrivateWithReply c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
queryExtensionsString ::
                        Graphics.XHB.Connection.Types.Connection ->
                          CARD32 -> IO (Receipt QueryExtensionsStringReply)
queryExtensionsString c screen
  = do receipt <- newEmptyReceiptIO
       let req = MkQueryExtensionsString screen
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
queryServerString ::
                    Graphics.XHB.Connection.Types.Connection ->
                      CARD32 -> CARD32 -> IO (Receipt QueryServerStringReply)
queryServerString c screen name
  = do receipt <- newEmptyReceiptIO
       let req = MkQueryServerString screen name
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
clientInfo ::
             Graphics.XHB.Connection.Types.Connection -> ClientInfo -> IO ()
clientInfo c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
getFBConfigs ::
               Graphics.XHB.Connection.Types.Connection ->
                 CARD32 -> IO (Receipt GetFBConfigsReply)
getFBConfigs c screen
  = do receipt <- newEmptyReceiptIO
       let req = MkGetFBConfigs screen
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
createPixmap ::
               Graphics.XHB.Connection.Types.Connection -> CreatePixmap -> IO ()
createPixmap c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
destroyPixmap ::
                Graphics.XHB.Connection.Types.Connection ->
                  Graphics.XHB.Gen.Glx.Types.PIXMAP -> IO ()
destroyPixmap c glx_pixmap
  = do let req = MkDestroyPixmap glx_pixmap
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
createNewContext ::
                   Graphics.XHB.Connection.Types.Connection ->
                     CreateNewContext -> IO ()
createNewContext c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
queryContext ::
               Graphics.XHB.Connection.Types.Connection ->
                 Graphics.XHB.Gen.Glx.Types.CONTEXT ->
                   IO (Receipt QueryContextReply)
queryContext c context
  = do receipt <- newEmptyReceiptIO
       let req = MkQueryContext context
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
makeContextCurrent ::
                     Graphics.XHB.Connection.Types.Connection ->
                       MakeContextCurrent -> IO (Receipt MakeContextCurrentReply)
makeContextCurrent c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
createPbuffer ::
                Graphics.XHB.Connection.Types.Connection -> CreatePbuffer -> IO ()
createPbuffer c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
destroyPbuffer ::
                 Graphics.XHB.Connection.Types.Connection -> PBUFFER -> IO ()
destroyPbuffer c pbuffer
  = do let req = MkDestroyPbuffer pbuffer
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
getDrawableAttributes ::
                        Graphics.XHB.Connection.Types.Connection ->
                          Graphics.XHB.Gen.Glx.Types.DRAWABLE ->
                            IO (Receipt GetDrawableAttributesReply)
getDrawableAttributes c drawable
  = do receipt <- newEmptyReceiptIO
       let req = MkGetDrawableAttributes drawable
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
changeDrawableAttributes ::
                           Graphics.XHB.Connection.Types.Connection ->
                             ChangeDrawableAttributes -> IO ()
changeDrawableAttributes c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
createWindow ::
               Graphics.XHB.Connection.Types.Connection -> CreateWindow -> IO ()
createWindow c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
deleteWindow ::
               Graphics.XHB.Connection.Types.Connection ->
                 Graphics.XHB.Gen.Glx.Types.WINDOW -> IO ()
deleteWindow c glxwindow
  = do let req = MkDeleteWindow glxwindow
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
newList ::
          Graphics.XHB.Connection.Types.Connection -> NewList -> IO ()
newList c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
endList ::
          Graphics.XHB.Connection.Types.Connection -> CONTEXT_TAG -> IO ()
endList c context_tag
  = do let req = MkEndList context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
deleteLists ::
              Graphics.XHB.Connection.Types.Connection -> DeleteLists -> IO ()
deleteLists c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
genLists ::
           Graphics.XHB.Connection.Types.Connection ->
             CONTEXT_TAG -> INT32 -> IO (Receipt GenListsReply)
genLists c context_tag range
  = do receipt <- newEmptyReceiptIO
       let req = MkGenLists context_tag range
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
feedbackBuffer ::
                 Graphics.XHB.Connection.Types.Connection -> FeedbackBuffer -> IO ()
feedbackBuffer c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
selectBuffer ::
               Graphics.XHB.Connection.Types.Connection ->
                 CONTEXT_TAG -> INT32 -> IO ()
selectBuffer c context_tag size
  = do let req = MkSelectBuffer context_tag size
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
renderMode ::
             Graphics.XHB.Connection.Types.Connection ->
               CONTEXT_TAG -> CARD32 -> IO (Receipt RenderModeReply)
renderMode c context_tag mode
  = do receipt <- newEmptyReceiptIO
       let req = MkRenderMode context_tag mode
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
finish ::
         Graphics.XHB.Connection.Types.Connection ->
           CONTEXT_TAG -> IO (Receipt FinishReply)
finish c context_tag
  = do receipt <- newEmptyReceiptIO
       let req = MkFinish context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
pixelStoref ::
              Graphics.XHB.Connection.Types.Connection -> PixelStoref -> IO ()
pixelStoref c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
pixelStorei ::
              Graphics.XHB.Connection.Types.Connection -> PixelStorei -> IO ()
pixelStorei c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
readPixels ::
             Graphics.XHB.Connection.Types.Connection ->
               ReadPixels -> IO (Receipt ReadPixelsReply)
readPixels c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getBooleanv ::
              Graphics.XHB.Connection.Types.Connection ->
                CONTEXT_TAG -> INT32 -> IO (Receipt GetBooleanvReply)
getBooleanv c context_tag pname
  = do receipt <- newEmptyReceiptIO
       let req = MkGetBooleanv context_tag pname
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getClipPlane ::
               Graphics.XHB.Connection.Types.Connection ->
                 CONTEXT_TAG -> INT32 -> IO (Receipt GetClipPlaneReply)
getClipPlane c context_tag plane
  = do receipt <- newEmptyReceiptIO
       let req = MkGetClipPlane context_tag plane
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getDoublev ::
             Graphics.XHB.Connection.Types.Connection ->
               CONTEXT_TAG -> CARD32 -> IO (Receipt GetDoublevReply)
getDoublev c context_tag pname
  = do receipt <- newEmptyReceiptIO
       let req = MkGetDoublev context_tag pname
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getError ::
           Graphics.XHB.Connection.Types.Connection ->
             CONTEXT_TAG -> IO (Receipt GetErrorReply)
getError c context_tag
  = do receipt <- newEmptyReceiptIO
       let req = MkGetError context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getFloatv ::
            Graphics.XHB.Connection.Types.Connection ->
              CONTEXT_TAG -> CARD32 -> IO (Receipt GetFloatvReply)
getFloatv c context_tag pname
  = do receipt <- newEmptyReceiptIO
       let req = MkGetFloatv context_tag pname
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getIntegerv ::
              Graphics.XHB.Connection.Types.Connection ->
                CONTEXT_TAG -> CARD32 -> IO (Receipt GetIntegervReply)
getIntegerv c context_tag pname
  = do receipt <- newEmptyReceiptIO
       let req = MkGetIntegerv context_tag pname
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getLightfv ::
             Graphics.XHB.Connection.Types.Connection ->
               GetLightfv -> IO (Receipt GetLightfvReply)
getLightfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getLightiv ::
             Graphics.XHB.Connection.Types.Connection ->
               GetLightiv -> IO (Receipt GetLightivReply)
getLightiv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMapdv ::
           Graphics.XHB.Connection.Types.Connection ->
             GetMapdv -> IO (Receipt GetMapdvReply)
getMapdv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMapfv ::
           Graphics.XHB.Connection.Types.Connection ->
             GetMapfv -> IO (Receipt GetMapfvReply)
getMapfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMapiv ::
           Graphics.XHB.Connection.Types.Connection ->
             GetMapiv -> IO (Receipt GetMapivReply)
getMapiv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMaterialfv ::
                Graphics.XHB.Connection.Types.Connection ->
                  GetMaterialfv -> IO (Receipt GetMaterialfvReply)
getMaterialfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMaterialiv ::
                Graphics.XHB.Connection.Types.Connection ->
                  GetMaterialiv -> IO (Receipt GetMaterialivReply)
getMaterialiv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getPixelMapfv ::
                Graphics.XHB.Connection.Types.Connection ->
                  CONTEXT_TAG -> CARD32 -> IO (Receipt GetPixelMapfvReply)
getPixelMapfv c context_tag map
  = do receipt <- newEmptyReceiptIO
       let req = MkGetPixelMapfv context_tag map
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getPixelMapuiv ::
                 Graphics.XHB.Connection.Types.Connection ->
                   CONTEXT_TAG -> CARD32 -> IO (Receipt GetPixelMapuivReply)
getPixelMapuiv c context_tag map
  = do receipt <- newEmptyReceiptIO
       let req = MkGetPixelMapuiv context_tag map
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getPixelMapusv ::
                 Graphics.XHB.Connection.Types.Connection ->
                   CONTEXT_TAG -> CARD32 -> IO (Receipt GetPixelMapusvReply)
getPixelMapusv c context_tag map
  = do receipt <- newEmptyReceiptIO
       let req = MkGetPixelMapusv context_tag map
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getPolygonStipple ::
                    Graphics.XHB.Connection.Types.Connection ->
                      CONTEXT_TAG -> BOOL -> IO (Receipt GetPolygonStippleReply)
getPolygonStipple c context_tag lsb_first
  = do receipt <- newEmptyReceiptIO
       let req = MkGetPolygonStipple context_tag lsb_first
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getString ::
            Graphics.XHB.Connection.Types.Connection ->
              CONTEXT_TAG -> CARD32 -> IO (Receipt GetStringReply)
getString c context_tag name
  = do receipt <- newEmptyReceiptIO
       let req = MkGetString context_tag name
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexEnvfv ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexEnvfv -> IO (Receipt GetTexEnvfvReply)
getTexEnvfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexEnviv ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexEnviv -> IO (Receipt GetTexEnvivReply)
getTexEnviv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexGendv ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexGendv -> IO (Receipt GetTexGendvReply)
getTexGendv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexGenfv ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexGenfv -> IO (Receipt GetTexGenfvReply)
getTexGenfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexGeniv ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexGeniv -> IO (Receipt GetTexGenivReply)
getTexGeniv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexImage ::
              Graphics.XHB.Connection.Types.Connection ->
                GetTexImage -> IO (Receipt GetTexImageReply)
getTexImage c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexParameterfv ::
                    Graphics.XHB.Connection.Types.Connection ->
                      GetTexParameterfv -> IO (Receipt GetTexParameterfvReply)
getTexParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexParameteriv ::
                    Graphics.XHB.Connection.Types.Connection ->
                      GetTexParameteriv -> IO (Receipt GetTexParameterivReply)
getTexParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexLevelParameterfv ::
                         Graphics.XHB.Connection.Types.Connection ->
                           GetTexLevelParameterfv -> IO (Receipt GetTexLevelParameterfvReply)
getTexLevelParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getTexLevelParameteriv ::
                         Graphics.XHB.Connection.Types.Connection ->
                           GetTexLevelParameteriv -> IO (Receipt GetTexLevelParameterivReply)
getTexLevelParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
isList ::
         Graphics.XHB.Connection.Types.Connection ->
           CONTEXT_TAG -> CARD32 -> IO (Receipt IsListReply)
isList c context_tag list
  = do receipt <- newEmptyReceiptIO
       let req = MkIsList context_tag list
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
flush ::
        Graphics.XHB.Connection.Types.Connection -> CONTEXT_TAG -> IO ()
flush c context_tag
  = do let req = MkFlush context_tag
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
areTexturesResident ::
                      Graphics.XHB.Connection.Types.Connection ->
                        AreTexturesResident -> IO (Receipt AreTexturesResidentReply)
areTexturesResident c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
deleteTextures ::
                 Graphics.XHB.Connection.Types.Connection -> DeleteTextures -> IO ()
deleteTextures c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
genTextures ::
              Graphics.XHB.Connection.Types.Connection ->
                CONTEXT_TAG -> INT32 -> IO (Receipt GenTexturesReply)
genTextures c context_tag n
  = do receipt <- newEmptyReceiptIO
       let req = MkGenTextures context_tag n
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
isTexture ::
            Graphics.XHB.Connection.Types.Connection ->
              CONTEXT_TAG -> CARD32 -> IO (Receipt IsTextureReply)
isTexture c context_tag texture
  = do receipt <- newEmptyReceiptIO
       let req = MkIsTexture context_tag texture
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getColorTable ::
                Graphics.XHB.Connection.Types.Connection ->
                  GetColorTable -> IO (Receipt GetColorTableReply)
getColorTable c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getColorTableParameterfv ::
                           Graphics.XHB.Connection.Types.Connection ->
                             GetColorTableParameterfv ->
                               IO (Receipt GetColorTableParameterfvReply)
getColorTableParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getColorTableParameteriv ::
                           Graphics.XHB.Connection.Types.Connection ->
                             GetColorTableParameteriv ->
                               IO (Receipt GetColorTableParameterivReply)
getColorTableParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getConvolutionFilter ::
                       Graphics.XHB.Connection.Types.Connection ->
                         GetConvolutionFilter -> IO (Receipt GetConvolutionFilterReply)
getConvolutionFilter c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getConvolutionParameterfv ::
                            Graphics.XHB.Connection.Types.Connection ->
                              GetConvolutionParameterfv ->
                                IO (Receipt GetConvolutionParameterfvReply)
getConvolutionParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getConvolutionParameteriv ::
                            Graphics.XHB.Connection.Types.Connection ->
                              GetConvolutionParameteriv ->
                                IO (Receipt GetConvolutionParameterivReply)
getConvolutionParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getSeparableFilter ::
                     Graphics.XHB.Connection.Types.Connection ->
                       GetSeparableFilter -> IO (Receipt GetSeparableFilterReply)
getSeparableFilter c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getHistogram ::
               Graphics.XHB.Connection.Types.Connection ->
                 GetHistogram -> IO (Receipt GetHistogramReply)
getHistogram c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getHistogramParameterfv ::
                          Graphics.XHB.Connection.Types.Connection ->
                            GetHistogramParameterfv ->
                              IO (Receipt GetHistogramParameterfvReply)
getHistogramParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getHistogramParameteriv ::
                          Graphics.XHB.Connection.Types.Connection ->
                            GetHistogramParameteriv ->
                              IO (Receipt GetHistogramParameterivReply)
getHistogramParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMinmax ::
            Graphics.XHB.Connection.Types.Connection ->
              GetMinmax -> IO (Receipt GetMinmaxReply)
getMinmax c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMinmaxParameterfv ::
                       Graphics.XHB.Connection.Types.Connection ->
                         GetMinmaxParameterfv -> IO (Receipt GetMinmaxParameterfvReply)
getMinmaxParameterfv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getMinmaxParameteriv ::
                       Graphics.XHB.Connection.Types.Connection ->
                         GetMinmaxParameteriv -> IO (Receipt GetMinmaxParameterivReply)
getMinmaxParameteriv c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getCompressedTexImageARB ::
                           Graphics.XHB.Connection.Types.Connection ->
                             GetCompressedTexImageARB ->
                               IO (Receipt GetCompressedTexImageARBReply)
getCompressedTexImageARB c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
deleteQueriesARB ::
                   Graphics.XHB.Connection.Types.Connection ->
                     DeleteQueriesARB -> IO ()
deleteQueriesARB c req
  = do putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequest c chunk
 
genQueriesARB ::
                Graphics.XHB.Connection.Types.Connection ->
                  CONTEXT_TAG -> INT32 -> IO (Receipt GenQueriesARBReply)
genQueriesARB c context_tag n
  = do receipt <- newEmptyReceiptIO
       let req = MkGenQueriesARB context_tag n
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
isQueryARB ::
             Graphics.XHB.Connection.Types.Connection ->
               CONTEXT_TAG -> CARD32 -> IO (Receipt IsQueryARBReply)
isQueryARB c context_tag id
  = do receipt <- newEmptyReceiptIO
       let req = MkIsQueryARB context_tag id
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getQueryivARB ::
                Graphics.XHB.Connection.Types.Connection ->
                  GetQueryivARB -> IO (Receipt GetQueryivARBReply)
getQueryivARB c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getQueryObjectivARB ::
                      Graphics.XHB.Connection.Types.Connection ->
                        GetQueryObjectivARB -> IO (Receipt GetQueryObjectivARBReply)
getQueryObjectivARB c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt
 
getQueryObjectuivARB ::
                       Graphics.XHB.Connection.Types.Connection ->
                         GetQueryObjectuivARB -> IO (Receipt GetQueryObjectuivARBReply)
getQueryObjectuivARB c req
  = do receipt <- newEmptyReceiptIO
       putAction <- serializeExtensionRequest c req
       let chunk = runPut putAction
       sendRequestWithReply c chunk receipt
       return receipt